text:
IF the Galaxy polling results are mirrored on election day, Colin Barnett's Liberal Party could win a majority in its own right, no longer needing to rely on the Nationals for support.
It would be a case of King Colin ruling WA all on his own.
Without a breakdown of seat-by-seat results, predictions are always dangerous and the Nationals have increased their vote, chasing seats in the state's north.
But a primary vote rise for the Liberals from 38.4 per cent at the last election to 43 per cent now suggests Mr Barnett won't need to pander to the Nationals the way he was forced to 4 1/2 years ago.
The reason for the Government's strong polling is management of the economy: 54 per cent regard the Liberals as the better economic managers, only 37 per cent selected Labor.
A large swath of voters claim Troy Buswell's presence makes them less likely to vote Liberal (37 per cent). But the economic management percentages report voters trust his competence as Treasurer.
Economic dominance permeates perceptions of how the major parties handle other issues, too. Remarkably, the Liberals lead Labor on which party is better at handling health as well as education issues, which are traditional strong suits for Labor.
All in all, while Mark McGowan is a viable alternative premier in the eyes of voters, on the issues that count voters just aren't ready to hand him control of the state.
Peter van Onselen is a professor at UWA

subset: commoncrawl


text:
IBBY Canada (International Board on Books for Young People, Canadian section) has named A Pattern for Pepper (Tundra Books), written and illustrated by Julie Kraulis, the winner of the 2018 Elizabeth Mrazik-Cleaver Canadian Picture Book Award.
The jury called the Toronto author-illustrator's fourth picture book "a delicate and delightful confection." They found the story of a girl and her mother visiting a tailor shop to choose the right fabric for a dress "original," "nostalgic," and "endearing."
The jury also named two Honour Books: Town Is by the Sea, illustrated by Sydney Smith (who won the award in 2016) and written by Joanne Schwartz (Groundwood Books), and When the Moon Comes, illustrated by Matt James and written by Paul Harbridge (Tundra Books).
The award, which was established in 1985 and honours one of Canada's pre-eminent book illustrators, comes with a $1,000 prize.


text: I hid a sticky note under my computer mouse when I left work yesterday. When I found it this morning, it really brightened my day. This made me want to write something I like about all my coworkers on sticky notes and put them around the office so that I can see everyone smile! Kindness matters!


text:
λ> cons 'a' (1::Int, 2::Word, 3::Double) :: (Char, Int, Word, Double)
Or how about this?
λ> unsnoc ('a',1::Int,2::Word,3.0::Double) :: ((Char, Int, Word), Double)
Let me try to completely confuse you (and potentially give a hint as to what I'm doing):
λ> transmogrify ('H', 'a', 's', 'k', 'e', 'l', 'l') :: ((Char, Char), Char, (Char, Char, (Char, Char)))
One more hint:
λ> data Foo = Bar Char Char Char deriving (Show, Generic)
λ> transmogrify ('a', 'b', 'c') :: Foo
Bar 'a' 'b' 'c'
I've suddenly become really interested in GHC Generics, and it occurred to me the other day that – since it basically decomposes more interesting types to products and sums with lots of associated metadata – that it should be possible to get two different types that are fundamentally the same shape but lots of different pesky metadata.
Turns out, it is possible. I've got a prototype of a little library that implements this on GitHub, and that's what I used for those examples above.
Basically, all metadata (constructor names, record aliases, strictness annotations, etc.) is stripped out. This is done recursively throughout the entire type, stopping at fundamental types like
Int and
Char. To cap it all off, products and converted from a tree-like implementation into an explicit list (this is even done recursively for any products contained within products, like the nested tuples above).
I doubt it will be.
The approach is a bit hacky, with various type-classes required including type aliases, etc. That's not too bad, but there is pretty much no type safety or inference available (hence all the explicit annotations above).
The performance is also not great: it's fundamentally
O(n), and there's no way to really fix this (at least that I can see).
There are also currently two limitations with the implementation:
This second limitation is the biggest fundamental problem with how to get this to a production-ready library. Ideally you could specify "this type should not be examined". Even better: if a component type doesn't have a
Generic instance then don't bother trying to split it apart.
Well, the code is there. If there's enough interest I might try and clean it up and put it on Hackage regardless.
But if you think this will somehow solve all your problems, then maybe you should re-think what you're doing
There are lies, damn lies and benchmarks.
— Old Jungle saying
testbench is a new library designed to make it easier to write comparison benchmarks, ensure that they return the correct value and thus help prevent unintentional bias in benchmarks.
About a year ago, I was working on some Haskell code that I wanted to compare to existing implementations. In Haskell, we of course have the wonderful criterion library to write benchmarks with, but whilst I've found it really helpful before to help me tell whether a particular function has been improving in performance as I work on it, I felt that it was a bit clunky for directly comparing implementations against each other (there used to be a
[bcompare] function, but it hasn't existed since version 184.108.40.206 which came out in August 2014).
When I tried looking at how others have approached this problem, I found that they did so by just directly using the
bench and
bgroup functions. From my point of view, there are two problems with this approach:
[ bench "f1" $ nf f1 a
, bench "f2" $ nf f2 a
Because of this duplication, it is too easy to have benchmarks nominally comparing two (or more) functions/values, but accidentally end up comparing apples to oranges (e.g. using
whnf instead of
Whilst I kept looking at existing comparison benchmarks, I even came across an example where a comparison ended up nominally showing that
f1 was faster than
f2… except that the result of
f1 was a value with an
O(1) implementation of
[rnf], whereas
f2 has an
O(n) definition. I don't know if this is intentional (I think it probably wasn't) and even if this is rectified
f1 was still faster… but the difference in runtimes – whilst minor in comparison to performance between the two functions – is non-negligible.
This to me demonstrated the desirability of not only having a wrapper around criterion to reduce the verbosity of comparison benchmarks, but to only be able to produce unit tests to ensure criteria are satisfied.
It's taken me longer than I wished to produce a syntax that I was both happy with and would actually work (with lots of fighting against GHC in the form of "Why won't you accept this? Oh, wait, now I get it; that makes sense… but can't you accept it anyway? Pretty please?"), but I've now finally gotten it to a usable form and am hence releasing it.
testbench is now available on Hackage with the source on GitHub.
As extremely simple and contrived examples, consider the following:
main :: IO ()
main = testBench $ do
-- Monomorphic comparisons
compareFunc "List length"
(\n -> length (replicate n ()) == n)
(testWith (@? "Not as long as specified")
<> benchNormalForm)
(mapM_ (\n -> comp ("len == " ++ show n) n) [1..5])
-- Polymorphic comparisons.
-- Currently it isn't possible to use a Proxy as the argument to the
-- function, so we're using 'undefined' to specify the type.
compareFuncConstraint (Proxy :: Proxy (CUnion Eq Num))
"Number type equality"
(join (==) . (0`asTypeOf`))
(baseline "Integer" (undefined :: Integer)
<> benchNormalForm)
$ do comp "Int" (undefined :: Int)
comp "Rational" (undefined :: Rational)
comp "Float" (undefined :: Float)
comp "Double" (undefined :: Double)
When this is run, the result on the console is:
Cases: 9 Tried: 9 Errors: 0 Failures: 0
Mean MeanLB MeanUB Stddev StddevLB StddevUB OutlierVariance
List length
len == 1 22.15 ns 21.86 ns 22.88 ns 1.505 ns 742.2 ps 2.826 ns 83%
len == 2 22.64 ns 22.49 ns 22.87 ns 602.0 ps 449.5 ps 825.7 ps 43%
len == 3 23.39 ns 23.16 ns 23.78 ns 1.057 ns 632.6 ps 1.553 ns 68%
len == 4 23.70 ns 23.51 ns 23.95 ns 773.3 ps 567.9 ps 1.050 ns 53%
len == 5 24.14 ns 23.96 ns 24.71 ns 962.4 ps 307.5 ps 1.886 ns 63%
Number type equality
Integer 12.59 ns 12.48 ns 12.80 ns 538.0 ps 312.4 ps 944.2 ps 67%
Int 12.79 ns 12.69 ns 12.98 ns 463.6 ps 320.0 ps 665.2 ps 59%
Rational 12.77 ns 12.67 ns 12.93 ns 395.1 ps 290.0 ps 535.9 ps 51%
Float 13.13 ns 12.88 ns 13.42 ns 869.7 ps 667.3 ps 1.212 ns 83%
Double 12.74 ns 12.57 ns 13.02 ns 704.6 ps 456.5 ps 1.047 ns 78%
You can see on the top line we've had nine tests (run using HUnit):
Integer case.
Since all the tests passed, the benchmarks are run. The output for these is a tabular format to make it easier to do vertical comparisons (though in this case the variances are all high so we should take them with a grain of salt).
Whilst I'm quite pleased with the API for defining the actual tests/benchmarks (subject to what GHC will let me write), there's still scope for more functionality (e.g. support for
IO-based benchmarks).
However, the default output (as soon above) isn't configurable. It's possible to get the individual tests and benchmarks out to feed them explicitly to HUnit and criterion respectively, but if you're after this particular output then you have to wait until all the benchmarks are complete before the results are printed. There is no support for saving results to file (either as a CSV of all the results or an HTML report), or even to control how the benchmarks are run (minimum time spent on each benchmark, etc.) or any other option currently offered by criterion.
If there is enough interest I can look at adding these in; but this satisfies my itch for now whilst getting this library out there for people to start trying out.]]>
There are quite a few libraries that try and provide more convenient ways of dealing with monad transformers (typically using those defined in transformers so as to avoid re-defining them all the time and to provide inter-compatibility): the old standard of mtl, the type-family variant found in monads-tf, the more ambitious layers package and Roman Cheplyaka's monad-classes work.
However, I found that none of the libraries I could find really satisfied me. Even
layers and
monad-classes – that aim to simplify/remove the quadratic instance problem still require a "catch-all" default instance for all other monad transformers. Ideally for me, if I want to define a new transformer class, then I should only need to define instances for transformers that directly implement it's functionality.
As such, I'm pleased to announce the first (alpha-level) release of my new library: monad-levels.
Originally, all I wanted was to be able to lift operations in a base monad up through any transformers I might stack on top of it.
We already have MonadIO; I just need to generalise it to work on any monad, right?
Except that I didn't want to just lift up a single monad up through the stack: I wanted to be able to convert a function on my base monad up to whatever set of transformers I had stacked up on top of it. So I resigned myself to writing out instances for every existing transformer in the
transformers library.
As I started doing so though, I noticed a common pattern: for each method in the instance, I would be using a combination of the following operations (using
StateT as an example):
wrap: apply the monad transformer (e.g.
m (a,s) → StateT s m a)
unwrap: remove the monad transformer (e.g.
StateT s m a → m (a,s))
addInternal: adds the internal per-transformer specific state (e.g.
m a → m (a,s))
In particular,
wrap is used everywhere,
unwrap is used when lowering existing monads down so that they can (eventually) be used in the base monad and
addInternal is used when lifting monadic values.
Thus, if I define this as a type class for monad transformers, then I could use the wonderful
DefaultSignatures extension to simplify defining all the instances, and what's more such a class would be re-usable.
Generally, the definition of
unwrap and
addInternal require information from within the scope of the transformer (e.g. the
s parameter within
StateT); as such,
wrap ends up being a continuation function. I thus came up with the following class:
class (Monad m) => MonadLevel m where type LowerMonad m :: * -> * type InnerValue m a :: * -- A continuation-based approach for how to lift/lower a monadic value. wrap :: ( (m a -> LowerMonad m (InnerValue m a) -- unwrap -> (LowerMonad m a -> LowerMonad m (InnerValue m a)) -- addInternal -> LowerMonad m (InnerValue m a) ) -> m a
(Note that I'm not using
MonadTrans for this as I also wanted to be able to use this with newtype wrappers.)
So I define this class, use
DefaultSignatures and my instances – whilst still needing to be explicitly defined – become much simpler (and in many/most cases empty)!
Whilst I was looking to see if any existing libraries had something similar (
layers came the closest, but it uses multiple classes and requires being able to specify function inverses when using it), I came across Roman Cheplyaka's blog post on how
monad-control uses closed type families to automatically recursively lift monads down to a monad that satisfies the required constraint. I became intrigued with this, and wondered if it would be possible to achieve this for any constraint (more specifically something of kind
(* → *) → Constraint) rather than using something that was almost identical for every possible monad transformer class.
So I wrote a prototype that made it seem as if this would indeed work (note that I used the term "lower" rather than "lift", as I saw it as lowering operations on the overall monadic stack down to where the constraint would be satisfied):
data Nat = Zero | Suc Nat class SatisfyConstraint (n :: Nat) (m :: * -> *) (c :: (* -> *) -> Constraint) where _lower :: Proxy c -> Proxy n -> (forall m'. (c m') => m' a) -> m a instance (ConstraintSatisfied c m ~ True, c m) => SatisfyConstraint Zero m c where _lower _ _ m = m instance (MonadLevel m, SatisfyConstraint n (LowerMonad m) c) => SatisfyConstraint (Suc n) m c where _lower _ _ m = wrap (\ _unwrap addI -> addI (_lower (Proxy :: Proxy c) (Proxy :: Proxy n) m))
(This is a simplified snippet: for more information – including where the
ConstraintSatisfied definition comes from – see here.)
With this, you also get
liftBase for free! However, if all I wanted was a function just to lift a value in the base monad up the stack, then I could have used a much simpler definition. For this to actually be useful, I have to be able to write (semi-)arbitrary functions and lift/lower them as well.
I could just go back to my original plan and use
MonadLevel combined with
DefaultSignatures and not bother with this automatic lifting/lowering business… but I've already started, and in for a penny in for a pound. So full steam ahead!
It took a while to sort out it would work (dealing with
State and
Reader was easy; having to extend how this worked for
Cont took quite a while and then even more for
Writer) but
monad-levels is now able to deal with arbitrary monadic functions.
Well… I say arbitrary…
To be able to deal with functions, you first need to use the provided sub-language to be able to specify the type of the function. For example, a basic function of type
m a → m a is specified as
Func MonadicValue (MkVarFnFrom MonadicValue)) (or more simply as just
MkVarFn MonadicValue, using the inbuilt simplification that most such functions will return a value of type
m a); something more complicated like
CallCC becomes
MkVarFn (Func (Func ValueOnly (MonadicOther b)) MonadicValue).
This language of lower-able functions is used to be able to know how to convert arguments and results up and down the monadic stack.
I'm finally releasing this library after being able to successfully replicate all the existing monad transformer classes in
mtl (with the exception of the deprecated
MonadError class). As an example, here is the equivalent to
import Control.Monad.Levels import Control.Monad.Levels.Constraints import Control.Monad.Trans.Cont (ContT (..)) import qualified Control.Monad.Trans.Cont as C import Control.Monad.Trans.List (ListT) -- | A simple class just to match up with the 'ContT' monad -- transformer. class (MonadLevel m) => IsCont m where -- Defined just to have it based upon the constraint _callCC :: CallCC m a b instance (MonadTower m) => IsCont (ContT r m) where _callCC = C.callCC instance ValidConstraint IsCont where type ConstraintSatisfied IsCont m = IsContT m type family IsContT m where IsContT (ContT r m) = True IsContT m = False -- | Represents monad stacks that can successfully pass 'callCC' down -- to a 'ContT' transformer. type HasCont m a b = SatisfyConstraintF IsCont m a (ContFn b) -- | This corresponds to @CallCC@ in @transformers@. type ContFn b = MkVarFn (Func (Func ValueOnly (MonadicOther b)) MonadicValue) -- This is defined solely as an extra check on 'ContFn' matching the -- type of 'C.callCC'. type CallCC m a b = VarFunction (ContFn b) m a -- Not using CallCC here to avoid having to export it. -- | @callCC@ (call-with-current-continuation) calls a function with -- the current continuation as its argument. callCC :: forall m a b. (HasCont m a b) => ((a -> m b) -> m a) -> m a callCC = lowerSat c vf m a _callCC where c :: Proxy IsCont c = Proxy vf :: Proxy (ContFn b) vf = Proxy m :: Proxy m m = Proxy a :: Proxy a a = Proxy -- By default, ListT doesn't allow arbitrary constraints through; -- with this definition it is now possible to use 'callCC' on @ListT (ContT r m) a@. instance (MonadTower m) => ConstraintPassThrough IsCont (ListT m) True
One thing that should be obvious is that the constraint is a tad more complicated than that required for
MonadCont. Specifically, it requires the
a and
b parameters as well; this is because not all instances of
MonadLevel allow dealing with arbitrary other monadic values (that is, we're dealing with
m a over all, but we also need to consider
m b in this case). In practice, however, the only existing monad transformer with this constraint is
ContT itself, and you can't pass through a call to
callCC from one
ContT transformer to another (as there's no way to distinguish between the two).
(Something that might not be obvious is that the interaction between
StateT – both lazy and strict – and how I've defined
callCC differs from how it's defined in
mtl. Hence why I started this thread on Haskell Cafe.)
But, any monad transformer in the
transformers library that is an instance of
MonadCont also satisfies the requirements for the
HasCont constraint, and furthermore just by making it an instance of
MonadLevel any new transformer (including a newtype wrapper over a monadic stack) will also automatically satisfy the constraint!
There are two main sources of problems currently with
I have no idea how it compares speed- and memory-wise to
mtl; as it uses a lot of type families, explicit dictionary passing, etc. I expect it to be slower, but I haven't compared it or investigated if there's anywhere I can improve it.
I'm not sure of all the names (e.g.
MkVarFn and
MkVarFnFrom for dealing with variadic functions probably could be improved); not to mention that there's probably also room for improvement in terms of what is exported (e.g. should the actual type classes for dealing with variadic arguments be fully exported in case people think of more possible argument types?).
It could also do with a lot more documentation.
These, however, are for the most part just a matter of time (though it might be that the performance one should actually belong to the next category).
The biggest noticeable problem is one of discovery: if you look at
mtl, it's obvious to tell when a transformer is an instance of a particular class; in contrast, with
monad-levels there's no obvious way of looking at Haddock documentation to tell whether or not this is the case. The best you can do for a specific constraint
c and monad
m (without trying it in ghci) is that if it's
MonadLevel_ definition has
AllowOtherValues m ~ True and
DefaultAllowConstraints m ~ True (both of which are the defaults) and the latter hasn't been overriden with
instance ConstraintPassThrough c m ~ False then it is allowed. (Assuming that the constraint and its functions are sound, and something screwy hasn't been done like having the monad actually being a loop.)
Something that might also be a problem for some is the complexity: lots of language extensions are used, not to mention using a lot of things like
Proxy and explicit dictionary passing.
As part of this, this means things like type errors sometimes being difficult to resolve due to the large usage of associated types and constraint kinds. Furthermore, as you probably saw in the
HasCont definition shown above, you typically need to use
ScopedTypeVariables with proxies.
Whilst it most definitely isn't perfect, I think
monad-levels is now at a usable state. As such, I'd appreciate any attempts people make at using it and giving me any feedback you might have.
This is also the first time I've used git and Github for my own project. I missed the simplicity and discoverability of darcs, but magit for Emacs makes using it a bit easier, and in-place branches and re-basing turned out to be quite nice.]]>
I realise that this might not be exactly a much-sought-after library, but I've been using this as a test-bed for various ideas I've been having for a "normal" graph library. I'm going to discuss various aspects of the design of this library and some ideas I've had for an extensible graph library.
The standard definition of a graph is as follows:
a graph is an ordered pair G = (V, E) comprising a set V of vertices or nodes together with a set E of edges or lines, which are 2-element subsets of V (i.e., an edge is related with two vertices, and the relation is represented as unordered pair of the vertices with respect to the particular edge).
However, this definition is rather limiting: by assuming that an edge is comprised of a two-element subset of the vertices, we make it harder for us to consider it computationally: in practice we don't have a data-structure that represents a two-element set. In practice, we instead tend to use something like
(Node,Node). However, this isn't ideal:
Using this representation implicitly makes graphs directed rather than undirected, unless you do a lot more bookkeeping by checking both elements of the tuple. In practice this may not be too much of a problem, as people want directed graphs, but this doesn't make it perfect.
The directionality of an edge is now part of its definition rather than being a property of the edge: that is, whether the edge is meant to be directed or not should be a value that can be determined from the edge; currently all edges are directed and undirected graphs are simulated with two inverse edges.
Multiple edges become difficult to handle: if you want to delete an edge between node
n1 and node
n2 and there are three edges there, how do you know which one to delete? In practice, the answer seems to be "all of them".
A more preferable definition was stated by W. T. Tutte in a 1961 paper:
A graph G consists of a set E(G) of edges and a (disjoint) set V(G) of vertices, together with a relation of incidence which associates with each edge two vertices, not necessarily distinct, called its ends. An edge is a loop if its ends coincide and a link otherwise.
Note that no indication is given of E being a set of two-sets: instead, a mapping exists between every e ∈ E to the two endpoints of that edge.
A planar graph is a graph that can be drawn on a specified surface (usually a plane or a sphere) such that no edges intersect/cross except at their endpoints.
When considering a planar graph programmatically, we also want to take into account their embedding (i.e. where all the edges adjacent to a node are in relation to each other). As such, just using an approach of identifying edges solely by their end points fails completely if there are multiple edges. As such, using a unique identifier for each edge is preferable.
But the difficulty of endpoint identification (i.e. distinguishing between
(n1,n2)) remains. As such, several implementations of planar graphs use two identifiers for each edge. More about this later.
As I said earlier, I've been using the development of this library as a way to experiment with various approaches to how to design a graph library, all of which I intend to use in a non-planar graph library.
Most existing graph libraries (e.g. Data.Graph and fgl) use a type alias on
Int values to represent vertices/nodes. Furthermore, when considering how to create a graph, it requires that you:
Explicitly come up with new node identifier for each new node;
Make sure you don't re-use an existing identifier.
Whilst this isn't a big problem if considering a bulk creation of a graph (i.e. you have some arbitrary
[a] representing the nodes and edges represented as
[(a,a)], in which case a
zip-based solution can be used to assign node identifiers, etc. though it would be a tad messy), it isn't ideal for adding new nodes on after the fact and it is also open to abuse.
As such,
planar-graph does not permit users to create node identifiers: the constructor isn't exported, it isn't an instance of
Enum or
Bounded, etc. Instead, you provide the label for the new node you want to add and the function returns the updated graph and the identifier for the new node. When the node identifiers are changed for some reason (e.g. merging two graphs), a function is returned that allows you to update the values of any node identifiers you've been storing elsewhere.
Show and
Read instances are available and leak some of the internals out, but you have to really be persistent to try and abuse them to create your own identifier values: you need to explicitly call
read on the
String to get it to parse as the result isn't valid Haskell code (as the instances exist solely for debugging).
As intimated earlier, each edge is actually represented by two half-edges: an edge from
n1 to
n2 is "stored" twice: one half-edge
n1 -> n2 and its inverse
n2 -> n1 (this also includes loops). Each half-edge has its unique identifier (which is abstract, just as with nodes) and mapping function exists that lets you determine a half-edge's inverse.
Most graph implementations are something like a newtyped version of:
type Graph = Map Node [Node]
where each node has information on its adjacent nodes. Or, if we consider a graph with labels, we have:
type LabelledGraph n e = Map Node (n, [(Node,e)])
Instead, the definition of planar-graph looks more like (just considering the labelled version):
type PlanarGraph n e = ( Map Node (n, [Edge]) , Map Edge (Node, e, Node, Edge) )
where a mapping exists between a half-edge identifier and the corresponding node that it comes from, the label of that half-edge, the node that it is going to and its inverse half-edge. This definition matches the mathematical ones stated earlier much more closely.
Now, this half-edge usage might be a requirement for a planar graph data structure, but it is also viable for non-planar graphs. First of all, if we wished to allow multiple edges between two nodes, then the traditional representation must be altered slightly:
type LabelledGraph' n e = Map Node (n, [(Node,[e])])
Each edge representation now keeps a list of edge labels, one per edge between the two nodes. Extra bookkeeping is required about what to do when that list becomes empty (and in fact previous fgl versions had an implementation where this list wasn't considered at all and thus multiple edges would silently fail).
Also, consider how fgl-style graphs are implemented:
type FGLGraph n e = Map Node ([(Node,e)], n, [(Node,e)])
Here, each node stores not only the outgoing edges but also the incoming edges for efficiency reasons (otherwise we'd need to traverse all edges in the graph to determine what the incoming edges are). This also leads to possible data corruption issues as each edge label is stored twice.
However, with our half-edge implementation, neither of these points need any change: each multiple edge has its own unique identifier, and to obtain the incoming edges we just determine the inverse of all the outgoing edges (though technically this point isn't quite valid when considering directed graphs, as planar-graph treats them differently; see the next section).
Most graph implementations conflate the structure of the graph (i.e. which nodes and edges there are) with the information that graph is representing. One example is the question of graph orientation: in fgl, a graph can be considered to be undirected if each edge is represented twice; however, it is quite possible that such a graph is not undirected but just happens to have each directed edge having an inverse (e.g. some kind of flow algorithm).
Whilst it is not fully formalised as yet, in planar-graph the orientation of a graph is dictated by its half-edge labels: in my use case that prompted the development of this library, I had a need for mixed-orientation of a graph: one half-edge pairing might have had a fixed direction on one half-edge whilst its inverse had a label of "
InverseEdge"; other pairings might both have some kind of partial edge label.
But the actual edge identifiers didn't change: I could apply a mapping function to transform all edge labels to
() and thus make the graph "undirected", but I didn't need to change the actual structure of the graph to do so.
I believe this is a much more useful way of considering graphs, where the information that the graph represents can be found in the node and edge labels, not the identifiers.
I needed to be able to encode my planar graphs using various binary encodings (e.g.
PLANAR_CODE, described in Appendix A here). Now, I could have written custom encoding functions from a
PlanarGraph to a
ByteString for every possible encoding; however, since they all follow the same basic underlying structure, I decide to utilise an intermediary list-based representation.
However, I then realised that this representation could also be used for
Show and
Read instances for the graphs as well as pretty-printing functions. The definition of the representation is:
[( node index , node label , [( edge index , node index that this edge points to , edge label , inverse edge index )] )]
Read, etc. this is basically a raw dump of the graph (which means it is technically open to abuse as the internals of the abstract identifiers are accessible this way, but I had to draw the line somewhere); the
deserialise function that is utilised by
Read also ended up being useful for an internal function rather than manually trying to construct a graph!
For encoding/decoding of binary representations, a re-numbering of the identifiers according to a breadth-first traversal is first undertaken (as many require that the identifiers be
0 ... n-1 and for decoding the order of edges for each node is important) and then the same structure is used. A class is then used to convert the graph into this representation and then convert it to the encoding of your choice.
However, not all of the encodings require that the graph be planar: whilst a breadth-first traversal doesn't make as much sense for non-planar graphs, the same framework could be used for other graph types.
I haven't even started to prototype this, as some of the ideas I'm listing below I only started to mentally flesh out over the past few days. However, I think that it should work and will provide a useful approach to dealing with graphs in Haskell.
The root of my idea is that we often have different properties that we want graphs to hold: should it be a directed graph? What should the identifier types be? Is there any way to automatically determine all nodes with a certain label (e.g. for graph colouring)? What kind should the graph have?
The current methods of dealing with such a thing is to have a graph implementation, and just live with it. This "solution" clearly has problems, not least of which is that if you try to do anything else you have to re-implement everything yourself.
However, consider this: we have a method of generalising monads via monad transformers: why not do the same thing with graphs?
Now, I'm not the first person to think of this; Edward Kmett has already released a library that has this kind of characteristic (though his classes differ from how I'm planning on structure/distinguish them by having them more implementation-based than property-based IMO).
What my plans entail is this:
Define a
GraphTransformer class. Not only will graph transformers be instances of this class, but so will the actual graph types (with identities for the different lift/unlift functions):
class (Graph (SubGraph gt)) => GraphTransformer gt where type SubGraph gt :: * .....
Graph class then requires that the instance type also be an instance of
GraphTransformer, and has default definitions of all methods using the lift/unlift functions. These default definitions will resolve down to
f = f definitions for actual graph types, but for transformers will just apply the function down the stack.
This class only defines "getters": e.g. determine the size of the graph, get all its nodes or edges, etc.
Other classes are defined as sub-classes of
Graph, again using lift/unlift functions from
GraphTransformer for default definitions of the methods.
Most classes (except for where it's necessary, e.g. a class defining mapping functions) will assume that the graph is of kind
Most transformers will assume that the underlying graph is of kind
* -> * -> * (i.e. that you can specify node and edge labels) so that you can make the transformer an instance of any class that requires kind
* -> * -> *, but it should be possible to make transformers that take in a graph of kind
Because of the default definitions using lift/unlift functions, most class instances for the graph transformers will be of the form
instance Graph (MyTransformer ExistingGraph a b); this means that if you want to newtype your graph transformer stack, writing the instances will be trivial (albeit rather repetitive and boring).
As such, if a transformer only effects one small aspect of graph manipulation (e.g. a transformer that keeps a
Map of node labels to node IDs so you can more efficiently look up all nodes that have a particular label), then you only need to provide explicit definitions for those classes and methods (in this case, adding and deleting nodes and looking up node identifiers based upon labels rather than filtering on the entire list of nodes).
However, this does mean that any kind of unique operation you can think of (e.g. in the example above the ability to find all identifiers for nodes that have a particular label), you will need to create a new class and make appropriate instances for underlying types (if possible) and existing transformers (so that if you put extra transformers on the stack you can still use the improved definitions for this transformer).
Usage of the serialisation and encoding functionality for all graphs. This will provide
Read instances for graphs, pretty-printing, easy
Binary instances (using the serialised form) and any available encodings specified.
The actual method of this may change from what I've described above, as whilst a breadth-first traversal of a planar graph is unique up to the first edge chosen, for non-planar graphs this isn't the case. However, for encodings that don't assume a planar graph this shouldn't be a problem.
Whilst the provided underlying graph types might use abstract node identifiers, it will not be required for instances of
Graph to do so (and a transformer will be provided to let you specify your own type, that under-the-hood maps to the generated abstract identifiers). However, I can't see a way around having edges using some kind of abstract edge identifier, as it isn't as common to attach a unique label to each edge.
Generally, transformers will utilise the node and edge labels of the underlying graph stack to store extra metadata (e.g. directionality of the edges); this is why the transformers will typically require that the underlying type is of kind
* -> * -> *. However, the question then arises: should users be aware of these underlying type transformations? For example, should this information leak out with a
Show instance?
My current thinking is that it shouldn't: the output from
prettyPrint, etc. should be as if there were no transformers being used. The main counter-example I can think of is to have some kind of indicator whether each listed half-edge is the "real" one or not, especially when using a transformer that makes it a directed edge (though in this case it can be solved by only listing the "primary" half-edges and not their inverses; this again works for most graph types but not planar ones, as all half-edges need to be listed for the graph to be re-created due to the embedding of edge orders).
Assuming this all works (I plan on starting playing with it next week), I think this approach will do quite well. As you're writing your code, if you use a newtype/type alias for your graph type, you can just add or remove a transformer from your stack without affecting usage (in most cases: some transformers might change which classes a stack can be used in; e.g. a transformer that lets you specify node identifiers will require using a different class for adding nodes than one that generates and returns identifiers for you). Then at the end if you want to try and tweak performance, you can always go and write custom transformers (or indeed your own graph type if you want to merge all the functionality in to the actual type without using transformers) without having to change your code.
If this all works as I think/hope it will…]]>
I decided to take the opportunity to replace the current explicit
String-based (well, actually
Doc-based) mangling used to create Dot graphs for use with Graphviz from vacuum with usage of my graphviz library. I've just sent Conrad a pull request on his GitHub repo, and I decided that this would make a suitable "intro" tutorial on how to use
First of all, have a look at the current implementation of the
GHC.Vacuum.Pretty.Dot module. If you read through it, it's pretty straight-forward: convert a graph in an adjacency-list format into Dot code by mapping a transformation function over it, then attach the required header and footer.
Note though that this way, the layout/printing aspects are mixed in with the actual conversion part: rather than separating the creation of the Dot code from how it actually appears, it's all done together.
There's also a mistake in there that probably isn't obvious: the "
arrowname=onormal" part of the definition of
gStyle is completely useless: there is no such attribute as "arrowname"; what is probably meant there is "arrowhead" or "arrowtail".
Let's now consider the implementation using version
2999.12.* of
graphviz (the version is important because even whilst doing this I spotted some changes I'm likely to make in the next version for usability purposes):
{-# LANGUAGE OverloadedStrings #-} module GHC.Vacuum.Pretty.Dot ( graphToDot ,graphToDotParams ,vacuumParams ) where import Data.GraphViz hiding (graphToDot) import Data.GraphViz.Attributes.Complete( Attribute(RankDir, Splines, FontName) , RankDir(FromLeft), EdgeType(SplineEdges)) import Control.Arrow(second) ------------------------------------------------ graphToDot :: (Ord a) => [(a, [a])] -> DotGraph a graphToDot = graphToDotParams vacuumParams graphToDotParams :: (Ord a, Ord cl) => GraphvizParams a () () cl l -> [(a, [a])] -> DotGraph a graphToDotParams params nes = graphElemsToDot params ns es where ns = map (second $ const ()) nes es = concatMap mkEs nes mkEs (f,ts) = map (\t -> (f,t,())) ts ------------------------------------------------ vacuumParams :: GraphvizParams a () () () () vacuumParams = defaultParams { globalAttributes = gStyle } gStyle :: [GlobalAttributes] gStyle = [ GraphAttrs [RankDir FromLeft, Splines SplineEdges, FontName "courier"] , NodeAttrs [textLabel "\\N", shape PlainText, fontColor Blue] , EdgeAttrs [color Black, style dotted] ]
OverloadedStrings extension is needed for the
FontName attribute.)
First of all, note that there is no mention or concept of the overall printing/structure of the Dot code: this is all done behind the scenes. It's also simpler this way to choose custom attributes: Don Stewart's vacuum-cairo package ends up copying all of this and extra functions from vacuum just to have different attributes; here, you merely need to provide a custom
GraphvizParams value!
So let's have a look more at what's being done here. In
graphToDotParams, the provided adjacency list representation
[(a,[a])] is converted to explicit node and edge lists; the addition of
() to each node/edge is because in many cases you would have some additional label attached to each node/edge, but for vacuum we don't. There is a slight possible error in this, in that there may be nodes present in an edge list but not specified directly (e.g.
[(1,[2])] doesn't specify the "2" node). However, Graphviz doesn't require explicit listing of every node if it's also present in an edge, and we're not specifying custom attributes for each node, so it doesn't matter. The actual grunt work of converting these node and edge lists is then done by
graphElemsToDot in graphviz.
The type signature of
graphToDotParams has been left loose enough so that if someone wants to specify clusters, it is possible to do so. However, by default,
graphToDot uses the specified
vacuumParams which have no clusters, no specific attributes for each node or edge but does have top-level global attributes. Rather than using
Strings, we have a list of
GlobalAttributes, with one entry for each of top-level graph, node and edge attributes (the latter two applying to every node/edge respectively). I've just converted over the attributes specified in the original (though dropping off the useless "arrowname" one). Some of these attributes have more user-friendly wrappers that are re-exported by
Data.GraphViz; the other three need to be explicitly imported from the complete list of attributes (for these cases I prefer to do explicit named imports rather than importing the entire module so I know which actual attributes I'm using). I am adding more attributes to the "user-friendly" module all the time;
RankDir will probably make it's way over there for the next release, with a better name and documentation (and thus not requiring any more imports).
Now, you might be wondering how I've managed to avoid a
(a -> String) or similar function like the original implementation had. That's because the actual conversion uses the PrintDot class (which is going to have a nicer export location in the next version of graphviz). As such, as long as a type has an instance – and ones like
Int, etc. all do – then it will be printed when the actual Dot code is created from the
DotGraph a value.
So how to actually use this? In the original source, there's a commented out function to produce a
png image file. This is achieved by saving the Dot code to a file, then explicitly calling the
dot command and saving the output as an image. Here's the version using
{-# LANGUAGE ScopedTypeVariables #-} import GHC.Vacuum.Pretty.Dot import Data.GraphViz.Exception graphToDotPng :: FilePath -> [(String,[String])] -> IO Bool graphToDotPng fpre g = handle (\(e::GraphvizException) -> return False) $ addExtension (runGraphviz (graphToDot g)) Png fpre >> return True
(Note: The exception-handling stuff is just used to provide the same
IO Bool result as the original.)
I hope you've seen how convenient graphviz can be rather than manually trying to produce Dot code and calling the Graphviz tools to visualise it. There are still some cludgy spots in the API (e.g. I would be more tempted now to have the graph to visualise be the last parameter; at the time I was considering more about using different image outputs for the same graph), so I appreciate people telling me how the API can be improved (including which attributes are commonly used).]]>
Now, one of the packages I maintain is graphviz which suffices at what it does: use Graphviz to visualise graphs using static images. Despite its various problems, I keep using Graphviz because – unlike most of the flashier graph visualisation programs that I've found – it doesn't require a fancy GUI just to convert a pre-existing graph into an image (admittedly, others may have library versions, but most seem to be written in Java and Python, which do not seem as useful in terms of writing Haskell bindings). However, one thing that Graphviz cannot do is let you dynamically visualise graphs, which is especially useful for extremely large graphs (e.g. call graphs).
One of the visualisation toolkits that Adam talked about was the JavaScript InfoVis Toolkit, which seemed quite nice in how you can dynamically interact with the graphs. The graphs are represented using JSON, and the format looks relatively straightforward.
So here's my possibly crazy idea: does it make sense to create a companion library for graphviz to convert its DotRepr values into JIT-compatible JSON, possibly with some extensions to assist with the visualisation? We already have various libraries for interacting with JavaScript and JSON on HackageDB, so it may be possible to abstract most of the pain of visualising and interacting with graphs on the web into our preferred language. I'm not quite sure how to deal with incompatible/differing attribute values for Dot vs JIT's JSON, but is this type of avenue worth considering? Such a conversion library would save having to doubly-convert graphs (in case you want static image versions of the visualisations as well).
So, how crazy am I?]]>
For the last several months, a small group of people in Canberra including myself have been preparing a bid for LCA 2013. This is not just to give us more time to make the conference the most awesome, froody LCA you've ever been to. No – 2013 is also the centenary of the founding of Canberra as the nation's capital. It's a very significant year for us and we'd all be thrilled if we could show the attendees of LCA our great city and Canberrans the great work the FOSS community does to improve everyone's lives.
So we're really stoked that the bidding process is going to be opened early, and I think it'll lead to a really interesting competition that will result, whoever wins, in the best LCA ever!
If you're interested in getting involved, join the mailing list!]]>
The overall thing I want to do with these generic graph classes is to be able to deal with the vast majority of graph-like data structures in as common a way as possible. Note that I say graph-like: I'm distinguishing here between data structures that match the mathematic definition of a graph (that is, a collection of distinguished objects, where pairs of these objects may be connected in some fashion) from what is usually considered as a graph data structure: the difference mainly arises in that we have notions of expected operations on graph data structures that may not be applicable on our graph-like data types. These operations can either be ones that are forbidden (e.g. adding a node to a static type) or partially forbidden (e.g. adding a cycle to a tree).
As such, the classes as they currently stand are mainly informational: what can we determine from this graph-like type? Do we know specific properties about it (e.g. is it an instance of the class that specifies whether or not the graph is meant to be directed)? There will, of course, be classes for graph manipulation, but I see those as secondary components: for example, it doesn't make sense to consider using standard graph manipulation functions to add or delete values from a
PackageIndex as we can't arbitrarily add values to it.
Such a collection of classes will by necessity be subject to compromise: it is not possible to have a fully-featured set of classes that comprehensively covers every single possible type of graph-like data structure whilst also being small and easy enough to use. After all, there's no point in writing such classes if no-one uses them because they're too difficult!
In my previous post, I said that the best way of dealing with labels is similar to the way that FGL currently does: force all graph-like types to have both node and edge labels (but not require types to have kind
* -> * -> * like FGL does). A few people objected, notably Sjoerd Visscher said that labels should be optional for both nodes and edges, and ideally be part of the overall node and edge types.
In theory, this solution is great (and I actually worked for a while trying to get something like it to work). However, as I stated in the comments, it fails one notable requirement: we now have to specialise functions on graphs to whether or not the graph has labels or not, and if so which ones. Specifically, if the behaviour of a function may change depending upon whether or not labels are present, such a solution may require four implementations:
Probably the best example I can think of for this is from my graphviz library: consider the
preview function as it is currently defined for FGL graphs:
preview :: (Ord el, Graph gr, Labellable nl, Labellable el) => gr nl el -> IO () preview g = ign $ forkIO (ign $ runGraphvizCanvas' dg Xlib) where dg = setDirectedness graphToDot params g params = nonClusteredParams { fmtNode = \ (_,l) -> [toLabel l] , fmtEdge = \ (_, _, l) -> [toLabel l] } ign = (>> return ())
This is a relatively simple function, that just sets some defaults for the main functions in graphviz. To change this to my proposed layout of compulsory labels mainly requires changes to the type signature (the only implementation change would be the way edges are defined). But with optional labels, then either four variants of this function will be required or else the user will have to specify how to distinguish the node/edge identifiers from the labels (if they exist); this latter solution is not satisfactory as the whole point of this function is to provide defaults to quickly visualise a graph, and as such should not take any other parameters apart from the graph itself.
If an "
isInstanceOf" function was available (to determine whether or not the graph type is an instance of the appropriate label classes without needing to specify them as explicit type constraints), then this wouldn't be a problem: implementers of functions would just need to take into account the four possible label groupings in their code. But as it stands, the implementation of having optional labels breaks the simplicity requirement that I'm taking into account when writing these classes.
Note that I would actually prefer to have distinct/abstract node and edge types that optionally contain labels: for the planar graph library that I'm working on all operations on edges are done via unique identifiers rather than a data-type isomorphic to a tuple of node identifiers (so as to avoid problems with multiple edges). However, for most graph types such explicit differentiation between edges won't be required, and in general it will be simpler to both instantiate and use classes when a more simple edge type is used rather than requiring in effect a new data type for each graph (as required when using data families).
One thing I'm still not sure about: how shall I deal with the naming of functions when I have both labelled and unlabelled variants of them? Should I take the FGL route of prepending "
lab" to them (e.g.
nodes vs
labNodes)? I'm not sure I like this solution, as I want to try and shift focus to making the labelled versions the defaults (or at least not as clumsy to use): does it make sense to adopt a policy of priming functions to distinguish between labelled and unlabelled (e.g.
nodes vs
nodes')? Or should some other naming policy be used?
One of the first things I've been considering how to deal with in the new graph classes that I'm working on is how to deal with node and edge labels in graphs. My point of view is that graphs contain two separate but related types of information:
As an example, consider graph colouring: we have the actual structure of the graph and then the colours attached to individual vertices (or edges, depending how you're doing the colouring). Another example is a flow graph, where the distances/weights are not an actual "physical" part of the graph structure yet nevertheless form an important part of the overall graph.
Yet there are times when the extra labelling/information is an inherent part of the structure: either we are concerning ourselves solely with some graph structural problem (e.g. connected components) or – more commonly when programming – the information about the structure is embedded within the structure (for example, Cabal's
PackageIndex type: this is simplistically equivalent to an unlabelled graph with
PackageIndexID as the node type).
As such, I've come up with at least three different ways of dealing with graph labels:
Something along the lines of the first two options is very tempting: there is no requirement to force graphs that don't have or need labels to pretend to have them just to fit the constraints of some class. Furthermore, different graph types can thus be more specific in terms of which graph classes they are instances of.
However, there is a problem here: duplication. Let us consider a simplified set of graph classes that fit the second criteria:
class Graph g where type Node g nodes :: g -> [Node g] edges :: g -> [Edge g] type Edge g = (Node g, Node g) class (Graph g) => LabelledGraph g where type NLabel g type ELabel g labNodes :: g -> [(Node g, NLabel g)] labEdges :: g -> [(Edge g, ELabel g)]
So if some graph type wants to be an instance of
LabelledGraph, it must specify two ways of getting all of the nodes available (admittedly, it will probably have something along the lines of
nodes = map fst labNodes, but wouldn't it be nice if this could be done automatically?).
But OK, writing a set of classes and then instances for those classes is a one-off cost. Let's say we accept that cost: the problems don't stop there. First of all, consider something as simple as adding a node to the graph. There is no way (in general) that the two classifications (labelled and unlabelled) can share in the slightest a method to add a node, etc. Furthermore, this segregation would spread to other aspects of using a graph: almost all algorithms/functions on graphs would thus need to be duplicated (if possible). Since one of the main criteria I have for designing this library is that it should be possible to use graphviz to visualise the
PackageIndex type, this kind of split is not something I think would be beneficial.
As such, the only real viable choice is to enforce usage of labels for all graphs. This might be to the detriment of graphs without labels, but I'm planning on adding various functions that let you ignore labels (e.g. a variant of
addNode that uses
mempty for the graph label, which means it's usable by graphs that have
() as the label type). The distinction between
nodes and
labNodes above could also be made automatic, with only the latter being a class method and the former being a top-level function.
This solution isn't perfect: to ensure it works for all suitable graph types, it has to be kind
*. But this means that no
Functor-like mapping ability will be available, at least without really ugly type signatures (which the current experimental definition uses) at least until superclass constraints become available (or possibly some kind of kind polymorphism, no pun intended). However, this is still the best available solution that I can come up with at this stage.
However, several package maintainers seem to be unaware of a minor subtlety of how Cabal parses dependencies.
Let us consider a simple example: we have a package
foo which is primarily a library but also contains a testing executable which uses QuickCheck. The relevant parts of the
.cabal file look something like this:
... Flag test Description: Build the test suite, including an executable to run it. Default: False Library Build-Depends: base == 4.*, containers == 0.3.* Exposed-Modules: Data.Foo Executable foo-tester if flag(test) Buildable: True else Buildable: False Main-Is: FooTester.hs Build-Depends: QuickCheck >= 2.1 && < 2.1.2
So, we have an optional testing executable called
foo-tester and bonus points for defaulting the testing of this executable to
However, this doesn't quite behave as expected: if we try to build it as-is without enabling the
test flag, then Cabal will still make
foo depend upon
QuickCheck. Why? Because the dependency is not optional (I'm not saying that this behaviour is correct, just that this is how Cabal acts). This became noticeable when QuickCheck-2.2 came out, I upgraded to it and then
ghc-pkg check complained that some packages were now broken.
I've pointed out the correct way of doing this to individual maintainers in the past when I noticed it in their packages; now I'm doing it in this blog post in the hope that maintainers of all affected packages will remedy this. To ensure that testing dependencies are only considered when we are indeed building the testing executable, just shift it inside the if-statement:
... Executable foo-tester if flag(test) Buildable: True Build-Depends: QuickCheck >= 2.1 && < 2.1.2 else Buildable: False Main-Is: FooTester.hs
QuickCheck will only be brought in when you're building tests.
This doesn't also apply to testing executables, but to any conditional dependencies. See for example how I have testing modules built and exported in graphviz's
.cabal file.


text:
Full Series:
Hit with Hurricane Irma, and hit with identity theft.
Southwest Florida residents tell NBC2 that they tried to apply for FEMA assistance, but when they submitted their person information, a pop up window told them that they already applied.
"That day we saw your news report, we realized this was a lot more serious than we had thought," said Paul Mazurkewitz, of Fort Myers.
On Tuesday, the NBC2 Investigators exposed dozens of Southwest Florida residents were victims of identity theft related to FEMA, after Hurricane Irma.
On Friday, we learned that number is growing by leaps and bounds. In our original story, identity theft victims found out their identities were compromised when they applied for FEMA assistance.
These new victims never even sought FEMA's help, but they all received the same legitimate letter from the U.S. Small Business Administration that said, "You recently registered with FEMA for assistance with your disaster losses. You were referred to the U.S. Small Business Administration for possible disaster loan assistance."
Here's the strange thing: None of the people ever applied for FEMA assistance.
One month after the NBC2 Investigators exposed a major scheme involving criminals stealing local identities to defraud the federal government, the NBC2 Investigators get answers from FEMA.
"In the early days of the investigation, there wasn't a public announcement in part to protect the integrity of the investigation and in part, because investigators were still trying to determine the scope and nature of these fraudulent registrations," said Lynn Kimbrough, FEMA spokesperson. "NBC2 was the first in this area to make that connection and to see that the large number of fraudulent SBA letters coming in could be a signal that there was something more going on."


text:
Where to begin? [ENDORSED]
Any general non-science questions (software questions/problems, etc.,) and class announcements.
Moderators: Chem_Mod, Chem_Admin
9 posts • Page 1 of 1
- Posts: 9
- Joined: Fri Jul 15, 2016 3:00 am
Where to begin?
I haven't taken Chemistry since my sophomore year of high school and am now a first year in 14A. I started looking at the fundamentals section of the textbook because reading chapter 1 just confused me. I also looked at the first 4 modules. This class has so many resources to help that I don't really know where to begin. Anyone have any tips of what resources are best?
Re: Where to begin?
Focus on the online modules (high-school and Chapter 1) and related Chapter 1 homework problems.
- Posts: 24
- Joined: Wed Sep 21, 2016 2:58 pm
Re: Where to begin? [ENDORSED]
After watching some of Dr. Lavelle's videos, try working on some problems from the Fundamentals section of the textbook (odd numbers). That way you can compare your process with the process and answers that are shown in the solutions manual.
Re: Where to begin?
Great suggestion Samantha.
- Posts: 8
- Joined: Wed Sep 21, 2016 2:59 pm
Re: Where to begin?
I agree with Samantha. I didn't do Chemistry during my A-Levels so that adds up to almost 3 years without studying Chem, but Professor Lavelle's videos and pre-assessments really helped me get back on track. Also try to read ahead every week! For me it makes the transition a whole lot better.
- Posts: 26
- Joined: Wed Sep 21, 2016 2:59 pm
Re: Where to begin?
The video modules have been an amazing review tool both before the class began and after the lectures during the week (I 100% recommend using them), but do the topics posted on the class website stretch for the entire quarter? Or are there chapters later on that won't be accompanied by those videos? I'd love to keep using them if possible!
- Posts: 38
- Joined: Fri Jul 15, 2016 3:00 am
- Been upvoted: 1 time
Re: Where to begin?
I completely agree with Helena! I was looking ahead and noticed that online there are only videos posted through Chemical Equilibrium. I find these videos very helpful because they allow me to pause and rewatch as many times as I need while taking notes. Will you keep adding more videos as the quarter goes on?
- Posts: 10
- Joined: Sat Sep 24, 2016 3:01 am
Re: Where to begin?
I am in a similar situation and I have been watching some of the modules. Should I be taking notes on something other than the course reader so I can look back at it or does anyone have another suggestion? Thanks for the pointers!
- Posts: 22
- Joined: Wed Sep 21, 2016 2:58 pm
Re: Where to begin?
When you guys are taking notes, are you doing it off of the book (while using the topics introduced in the very beginning of each chapter in the Course Reader), the Audio-Visual Focus topics, or both? I'm so overwhelmed and I don't know where to start... thanks in advance!
9 posts • Page 1 of 1
Return to "Administrative Questions and Class Announcements"
Who is online
Users browsing this forum: No registered users and 1 guest


text:
Can you name this band or musician? Send your answer by noon on Monday following publication to email@example.com or call your answer in to 570-2227. We will draw from the correct answers and you will receive a piece of Spotlight swag (a CD or book we've been sent.) Woohoo!
A native of LaCrosse, Wis., (with masters degrees in both music education and clarinet performance), he's quite a player. He's been guest soloist at high schools, universities, and Boston area jazz clubs. Among other titles, he is currently director of jazz studies and professor of clarinet at the University of New Hampshire. This sketch shows a mere sampling of his 21-piece Seacoast Big Band as they brought their wonderful 'big band sounds' to Prescott Park.*
Name the musician/director.
*They've also performed on the SSNorway Jazz Cruise.
The answer to last week's Guess Who is Melvern Taylor and his Fabulous Meltones. (Band members: Dave Livingston, Melvern Taylor, Bob Nash and Matt Murphy.


text:
Your Name
Comment Title
Your Comments (10000 characters max, no HTML please)
Changed your mind? Decided not to comment right now?
Return to SHAPI FIGH'S Draw Knife.
Join in and write your own page! It's easy to do. How? Simply click here to return to Antique Draw Knife.
Copyright © 2011 EdMedia. All rights reserved.


text:
The National Attorneys General Training & Research Institute
Center for Consumer Protection Monthly May 2018
Consumer Chief of the Month: Sonny Jones, South Carolina
I thank you for the recognition of being selected as May's Consumer Chief of the Month. It is truly an honor to follow the previous Chiefs that were recognized. I joined the Office of the South Carolina Attorney General over 40 years ago and have had the pleasure of working under the leadership of five Attorneys General.
Article of the Month:
Spotting Government Assessment Scams
Cindy Franklin, Assistant Attorney General - Consumer Protection Unit, Alaska Department of Law
Consumer protection attorneys in attorney general offices nationwide face an increasing array of scams and deceptive marketing ploys aimed at separating consumers from their money. One such scam tries to trick consumers by mimicking government assessments. An effective way to fight against such scams is to identify their common elements and then educate the public.
Scam Alert:
A Scam Story: Secret Shopping and Fake Checks?
Federal Consumer Protection News
Commodity Futures Trading Commission:
- The CFTC has approved a proposed rule to reduce regulatory burdens for U.S. market participants, in order to promote economic growth and job creation, by bringing certain CFTC requirements in line with other U.S. regulators and is seeking public comments on the proposal.
- CFTC Chairman J. Christopher Giancarlo and North American Securities Administrators Association NASAA President Joseph P. Borg signed a mutual cooperation agreement to establish a closer working relationship between the federal commodity regulator and individual state securities agencies.
- The CFTC filed a civil enforcement action in the U.S. District Court for the Central District of California, Western Division, charging Defendants Jin Choi of Los Angeles, California, and his companies, Apuro Holdings Ltd. d/b/a ApuroFX and JCI Holdings USA d/b/a JCI Trading Group, LLC, with off-exchange retail foreign currency fraud and failure to register with the CFTC as a Commodity Trading Advisor and Associated Person of a Commodity Trading Advisor, as required.
Federal Trade Commission:
- The FTC has given final approval to a settlement with PayPal, Inc., over allegations that its Venmo peer-to-peer payment service misled consumers about their ability to transfer funds to external bank accounts and control the privacy of their Venmo transactions.
- As part of ongoing efforts to protect youth from the dangers of nicotine and tobacco products, the FTC and the FDA jointly issued 13 warning letters to manufacturers, distributors, and retailers for selling e-liquids used in e-cigarettes with labeling and/or advertising that resemble kid-friendly food products, such as juice boxes, candies, or cookies, some of them with cartoon-like imagery.
- The FTC has charged a mortgage relief operation with deceiving distressed homeowners by falsely promising to make their mortgages more affordable and prevent foreclosure. A federal court temporarily halted the scheme and froze the defendants' assets at the FTC's request.
- A New Jersey-based company and its owners have agreed to settle FTC charges that they used deceptive claims to sell purportedly mosquito-repelling perfume sprays and scented candles.
- The FTC has charged two Utah individuals and their telemarketing operation with deceptively claiming their business coaching services can help consumers start home-based businesses that earn thousands of dollars a month.
Securities and Exchange Commission:
- The SEC announced it has obtained a court order halting an ongoing fraud involving an initial coin offering that raised as much as $21 million from investors in and outside the U.S.
- The SEC announced the launch of an additional online search feature that enables investors to research whether the person trying to sell them investments has a judgment or order entered against him or her in an enforcement action. The new tool is intended to assist the public in making informed investment decisions and avoiding financial fraud.
- The SEC announced settled charges against broker-dealers Chardan Capital Markets LLC and Industrial and Commercial Bank of China Financial Services LLC for failing to report suspicious sales of billions of penny stock shares.
In other federal news:
- The CFPB warns consumers to guard their Medicare ID card to avoid fraud.
- The FBI's Internet Crime Complaint Center (IC3) released the IC3 Annual Report along with state reports.
- The FCC fined Adrian Abramovich $120 million for malicious spoofing that was part of his massive robocalling operation aimed at selling timeshares and other travel packages.
- The Department of Justice announced that a federal grand jury returned an indictment against Christopher Lischewski, the President and Chief Executive Officer of Bumble Bee Foods LLC, for participating in a conspiracy to fix prices for packaged seafood sold in the United States.
- To address youth use of e-cigarettes, the FDA sent official requests for information to four e-cigarette manufacturers requiring them to submit important documents to better understand the youth appeal of these products.
- The Department of Justice announced that a federal court issued an order to prevent a California individual from preparing, processing, and distributing adulterated fish or fishery products without first taking required remedial action.
Attorney General Consumer Protection News and Other Items of Interest
Arizona Attorney General Mark Brnovich obtained a consent judgment against Compliance Filings Service for allegedly sending government look-alike "Annual Minutes" mailers to Arizona businesses.
Arkansas Attorney General Leslie Rutledge and Treatsie LLC of Little Rock have reached a settlement to resolve allegations that Treatsie continued to sell and advertise subscriptions for their gourmet candy boxes, but failed to deliver hundreds of the boxes, and, in some cases, delivered the orders months late.
Colorado Attorney General Cynthia H. Coffman issued a warning to Colorado consumers to be on the lookout for scammers calling, emailing, or texting and claiming to be officials from Medicare.
Florida Attorney General Pam Bondi filed an action in state court against some of the nation's largest opioid manufacturers and distributors for their roles in the national opioid crisis.
Georgia Attorney General Chris Carr announced the release of a new resource for Georgians: The Georgia Consumer Protection Guide for Older Adults.
Kansas Attorney General Derek Schmidt announced that a recent filing by Equifax disclosed additional details relating to its massive 2017 data breach.
Maryland Attorney General Brian E. Frosh announced that his Consumer Protection Division and the Commissioner of Financial Regulation entered into settlement agreements with Nationstar Mortgage LLC to resolve allegations that it charged homeowners illegal inspection fees. In other Maryland news, General Frosh announced that his office's Securities Division has taken an enforcement action as part of an international crackdown on fraudulent Initial Coin Offerings and cryptocurrency-related investment products.
Michigan Attorney General Bill Schuette cautioned Michigan drivers searching for a new vehicle to be on the lookout for flood damaged cars, trucks, and SUVs.
Mississippi Attorney General Jim Hood warns about computer scams that could be used to steal consumers' personal information.
Missouri Attorney General Josh Hawley obtained a $372,561.04 judgment on behalf of 54 Missouri consumers who were defrauded by Herbert Miller, Kathleen Miller, and Miller Family Funeral Home. The Attorney General's investigation revealed that Herbert and Kathleen Miller failed to deposit or retain consumer funds in trust accounts or joint accounts as required by their contracts with consumers.
Nebraska Attorney General Doug Peterson provides tips on stopping unwanted robocalls.
Nevada Attorney General Adam Paul Laxalt filed a lawsuit against pharmaceutical company Purdue Pharma L.P. and its affiliates, which manufacture OxyContin and other opioids. The lawsuit alleges that Purdue engaged in deceptive marketing regarding the risks and benefits of prescription opioids, fueling Nevada's opioid epidemic and leading to the opioid overdose death of Nevadans.
New Jersey Attorney General Gurbir S. Grewal announced a lawsuit against luxury used auto dealership 21st Century Auto Group, Inc., and its owner Dmitry Zeldin, for allegedly violating consumer protection laws and regulations by engaging in a pattern of deceptive practices that include failing to disclose prior damage to used motor vehicles, continuing to advertise motor vehicles after they had been sold in an attempt to "bait-and-switch" customers, and failing to honor advertised and negotiated prices of used motor vehicles.
New Mexico Attorney General Hector Balderas issued a Scam Alert because New Mexicans who use "messenger" services or "apps" to communicate with friends are facing a new criminal hacking scheme.
New York Attorney General Barbara Underwood is preparing a lawsuit against Purdue Pharma for its alleged deception and reckless disregard for the health and wellbeing of New Yorkers.
North Carolina Attorney General Josh Stein filed a lawsuit against drug manufacturer Purdue Pharma over its marketing practices for prescription opioids. The lawsuit alleges that Purdue made deceptive and misleading statements to overcome prescribers' and patients' concerns and objections.
North Dakota Attorney General Wayne Stenehjem announced that he has filed a lawsuit against Purdue Pharma, the nation's leading manufacturer of prescription opioids, for allegedly mispresenting the risk of addiction from prolonged use of opioids.
Ohio Attorney General Mike DeWine filed a consumer protection lawsuit against Discovery Tours, a tour company accused of taking money for services it never provided to families and schools across Ohio.
Pennsylvania Attorney General Josh Shapiro announced restitution for 13 Pennsylvania consumers, including senior citizens, after reaching a settlement with a personal care home that closed unexpectedly and had failed to provide refunds to residents who prepaid for room and board.
Tennessee Attorney General Herbert H. Slatery III, along with a bipartisan group of attorneys general, sued Purdue Pharma for its alleged unlawful marketing and promotion of Oxycontin and other drugs and its role in causing and prolonging the opioid epidemic in Tennessee.
Texas Attorney General Ken Paxton announced that his office filed a consumer protection lawsuit against Purdue Pharma for allegedly violating the Texas Deceptive Trade Practices Act involving the company's prescription opioids, including OxyContin. In other Texas news, General Paxton's Consumer Protection Division announced that it secured Assurances of Voluntary Compliance with 37 store owners and wholesale distribution companies to stop selling alleged unlawful and potentially dangerous contact lenses in Texas.
Virginia Attorney General Mark R. Herring announced that he has filed a lawsuit against Service Dogs by Warren Retrievers, Inc., a Virginia-based company that sells purported service dogs to consumers nationwide, and its CEO, Charles D. Warren, Jr., for alleged violations of the Virginia Consumer Protection Act and the Virginia Solicitation of Contributions law.
Washington Attorney General Bob Ferguson filed a consumer protection lawsuit against Kirkland- and Portland-based Real Estate Investment Network, LLC, accusing the company of scamming foreclosed homeowners out of equity in the form of surplus funds from the sale. In other Washington news, General Ferguson announced that Toshiba Corporation, a multinational conglomerate headquartered in Japan, will pay $1.3 million as part of the Attorney General's price-fixing lawsuit against manufacturers of a component used in television and computer screens called cathode ray tube, or CRT.
New York Attorney General Barbara Underwood announced a settlement resolving an investigation into the Richenthal Foundation, a grant-making organization that focuses on funding not-for-profit theater groups. In other New York news, General Underwood announced a settlement agreement with the Wounded Warriors Foundation of Orange County, Inc., for allegedly illegally collecting thousands of dollars in raffle tickets without ever conducting a raffle.
The Colorado Legislature passed HB 1128 which would require entities maintaining documents that contain personal identifying information to develop a written policy for the destruction or proper disposal of those documents when no longer needed. It also requires those entities to implement and maintain reasonable security procedures and practices.
Utah Attorney General Sean Reyes announced that the Utah Consumer Credit Protection Act will make it easier for Utahns to obtain credit report security freezes.
Vermont Attorney General TJ Donovan applauded Vermont lawmakers for passage of a new law that protects consumers from credit freeze fees, fraudulent acquisition of Vermonters' data, and establishes a registry and security standards for the "data broker" industry. Vermont is the first state in the nation to successfully pass data broker legislation.
Veterans and Military News
The Department of Justice announced that it has reached a settlement with the Puerto Rico Police Bureau (PRPB) that resolves allegations that the PRPB violated the employment rights of three Puerto Rico Army National Guard Members under the Uniformed Services Employment and Reemployment Rights Act.
Blake Bee, Program Counsel for the Center for Consumer Protection, is the editor of Center for Consumer Protection Monthly, a compendium of information that may be of interest to the attorney general community and others interested in consumer protection. Neither the National Association of Attorneys General (NAAG) nor the National Attorneys General Training & Research Institute expresses a view as to the accuracy of the matters, nor as to the position expounded by the authors of the hyperlinked materials. Any use and/or copies of this newsletter in whole or part must include the customary bibliographic citation. NAAG retains copyright and all other intellectual property rights in the material presented in this publication. For content submissions or to contact the editor directly, please email email@example.com or call (202) 326-6263.
Faculty Spotlight
NAGTRI's faculty are top-rated experts in their field. Read about them.
Course Schedule
NAGTRI offers high-quality, responsive and innovative trainings.
Research & Newsletters
NAGTRI produces comprehensive research and newsletters on topical legal issues.


text:
This is necessary to divest the tragedy of its myth and propaganda
The Kashmir Civil Society has demanded an impartial international probe into the Kashmiri Pandit exodus. The demand carries weight especially in the light of different narratives put forth by different quarters about the migration.
The Muslims by and large believe that the then governor Jagmohan triggered the exodus. The Pandits hold the militants and the majority community responsible for their displacement.
On June 29, 2012 while honouring noted Kashmiri singer, Kailash Mehra Sadhu a resolution was passed at California. The clause of the resolution that merits special mention here reads: "Whereas, On January 19, 1990, 500,000 Kashmiri Pandits were internally displaced and dislodged by acts of terrorism, many of whom immigrated to the united States and whereas, today, 22 years later, a majority of the Kashmiri Pandits have not, due to fear, returned to their places of birth, not even as tourists."
The figures given above are not substantiated by the 1981 census. Kashmir never had 500,000 Pandits especially around 1990. The Pandits better check the document. January 19 is observed by the Kashmiri pundits as holocaust day. They believe that the exodus commenced on January 19, 1990. There is no denying the fact that January 19 was a tense day for all the Kashmiris. Revolutionary slogans were chanted across Kashmir. Processions were taken out amid strict curfew restrictions and people irrespective of the faith they professed were scared. But, there is no proof of the exodus having commenced on that day.
Sanjay Tikoo, who heads the Kashmiri Pandit Sangrash Samithi (KPSS) preferred to stay back in the Valley. He agrees that the exodus was not triggered by the happenings of January 19, 1990. "I was in Mumbai with my colleagues. All of us wanted to reach Kashmir to celebrate Heerath (Shivratri) in Kashmir in last week of February. We reached Jammu. Somebody told me that migrants were getting registered at Geeta Bhawan. I went to the Bhawan and got myself registered as a migrant. My serial number on the migrant register was either 36 or 37. Soon after, I came to Kashmir and celebrated Heerath with my family."
This proves that a handful of Pandits, around 37 had migrated up to last week of February and there was no mass exodus till then. Sanjay further says: "As usual we went to Habba Kadal to buy earthen ware needed for the festival. There was traditional hustle and bustle in the market. Pandits were making purchases."
Sanjay sees a conspiracy in the exodus. On Jan, 04, 1990, a local Urdu newspaper, Aftab, published a press release issued by Hizb-ul-Mujahideen, asking all Pandits to leave the Valley immediately. Al Safa, another local daily repeated the warning. Surprisingly, the outfit did not own the statement and a clarification was accordingly issued. Even if the authenticity of the statement is accepted for the sake of arguments, why did the Pandits wait for a fortnight. It makes no sense that a community that has been threatened with dire consequences stays back for fifteen days and then suddenly decides to flee on January 19.
According to Tikoo something happened in New Delhi around March 15. "Haday Nath Jattu, a Pandit leader called on my father telling him to leave Srinagar by March 17. He further said that the Jawahar tunnel shall be closed after the said date."
Jatoo met Ghulam Muhammad Bakshi, Sheikh Abdul Kabir and Late Mr Dugga at Qazigund while fleeing. They tried to stop the fleeing pandits but all in vain. Jattu told them he was going to Jammu to attend a marriage and would be back soon.
"Most of the Pandits migrated in April and May," maintains Sanjay. He says hundreds of Pandits were killed from June 1 to October 1990. "This means a good number of Pandits were still in the Valley up to October," he says.
Here an attempt is not being made to trivialise a tragedy. Exodus has taken place and it is a reality. But what triggered it? A thorough probe can bring facts to the fore. But who will probe it. Sanjay says a team comprising members of both the communities must revisit 1990 and unveil the conspiracy.
A noted medical practitioner returned from his holidays on February 28, 1990 and rushed to his clinic near erstwhile Hazuri Bagh. He saw his Pandit attendant in distress. "He (Jagmohan) is offering Rs 1500 to those pandits who leave the valley," he said. The learned doctor advised him to receive the amount and go to Jammu for a fortnight. He never returned. The doctor lost a faithful staffer.
The fascist government at New Delhi has been using the migrants as experimental animals. It has tried to pit them against the majority community by `rehabilitating' them in `composite townships'. Some of them have fallen prey to the machinations of the government and accuse the majority community of killing pandits. However, Sanjay and others admit it that the Muslims saved many precious lives during the fateful days of 1990. And, till the truth about the exodus is found, both the communities have to exercise caution. No provocative statements must be issued, he suggested. It has to be borne in mind that the government of India with all its military might has failed to bring the migrants back to Kashmir. It is the people of Kashmir who alone can ensure an honourable and dignified return of the migrants to the Valley.
The record of Jammu Kashmir government and the government of India for the past twenty-five years has created mistrust so much so that the people see government hand behind every act of violence. This record justifies the demand for a probe.
Some mysteries have already been solved. An investigation by foreign authors found involvement of government and its gunmen in the disappearance of foreign hostages who were abducted in 1995 by Al Faran. Pathribal, Machil are some of gruesome acts that convey it in clear terms. The Chittisinghpora massacre is still shrouded in mystery and the government is reluctant to probe it. The government has also barred State Human Rights Commission (SHRC) from probing the unmarked/mass graved. The government is not ready to probe enforced disappearances.
The demand for probing the Pandit exodus will not be accepted and the two communities will continue to hold rancor against each other notwithstanding the past bonhomie between them.
(Feedback at email@example.com)


text:
Glucosamine is a dietary supplement that is typically produced from chitin, a compound found in the hard outer shell of crabs, lobsters, shrimp and other shellfish. This popular dietary supplement is also available in a vegetarian form. Although such corn-derived supplements may be more suitable for your diet, they present issues that are both unique to vegetarian sources and common to all forms of glucosamine.
Vegetarian Glucosamine
Glucosamine is a naturally occurring sugar in the human body that serves as one of the building blocks of joint cartilage. As a result, glucosamine supplements are typically used to help rebuild cartilage and treat arthritis. Despite mixed evidence for its effectiveness, glucosamine is one of the most commonly used dietary supplements in the U.S. These supplements typically contain shellfish, thus making them unsuitable for vegetarians and unsafe for those with allergies. Although corn-derived sources do not present such issues, the use of vegetarian glucosamine can potentially result in numerous adverse side effects.
General Side Effects
Vegetarian sources of glucosamine share numerous side effects with those derived from shellfish. As drowsiness is among the most common, you should avoid driving, operating heavy machinery or doing anything else that might be dangerous while drowsy. Other common side effects of both sources of glucosamine include constipation, diarrhea, heartburn, nausea, headaches, upset stomach and vomiting. Although these do not commonly become major issues, you should stop taking glucosamine and seek medical attention if these side effects become severe and persistent. In addition, you should avoid glucosamine entirely if you are pregnant or breast-feeding.
Despite being less allergenic than shellfish, corn is increasingly being recognized as a source of food allergies. In fact, approximately 2 percent of people report experiencing some form of allergic reaction to corn. Common symptoms of a corn allergy are similar to those of other food allergies, including hives, rashes, nausea, sinus problems, headaches, vomiting, diarrhea and breathing difficulties. As an allergic reaction to corn can result in life-threatening anaphylaxis, you should avoid vegetarian glucosamine if you have any reason to suspect that you have a corn allergy.
Other Issues
Glucosamine supplements are not regulated by the U.S. Food and Drug Administration. As a result, many glucosamine supplements do not accurately list their ingredients. In fact, research into their contents indicates that such products contain anywhere from no glucosamine to over 100 percent of the amount listed on the package. With no clear indication of the contents of such products, you should consult with a health professional before starting glucosamine supplementation to discuss the most effective and safest option for you.
- Human Metabolome Database: Showing Metabocard for Glucosamine (HMDB01514)
- National Health Statistics Reports: Complementary and Alternative Medicine Use Among Adults and Children: United States, 2007
- Advancing Medicine With Food and Nutrients, Second Edition; Ingrid Kohlstadt
- MedlinePlus: Glucosamine Sulfate
- American College of Allergy, Asthma & Immunology: Corn Allergy


text:
Simon James
I'm running logic pro x and have some waves plugins that I was using with another computer and did a migration assistant over to the new computer. I have the licenses all transferred over. My plug in manager can see the plugins but it says that they could not be opened. I'm not sure when else I need to do. Do I need to download all the plugins again? Not sure what route to take.
Thx in advance,
Thx in advance,


text:
Are you suffering from the problem of Achilles tendonitis? Do you have knowledge with respect to treatment for Achilles tendonitis? Here, we shall throw light on some effective ways to treat Achilles tendonitis.
However, before we discuss about treatment options for Achilles tendonitis, we would first discuss what Achilles tendonitis is. Achilles tendonitis refers to a health condition associated with inflammation and pain in the ankle. The problem occurs due to an injury in ankle, which is very common among recreational athletes.
The pain and inflammation in the Achilles tendon basically arises due to excessive use of the tendon. An individual may also see some welling in the ankle as a result of the inflammation. The microscopic and degenerative tears inside the tendon result in ankle pain, inflammation and swelling, with the condition known as Achilles tendonitis. There are various ways to treat Achilles tendonitis, which have been discussed as under.
6 Effective Treatments For Achilles Tendonitis
Achilles tendonitis can be treated in an effective way with the help of below discussed remedies:
First of all, it is very important to allow the tendon to rest for a day or two, so that the inflammation in the ankle does not aggravate. In case the problem is very severe, immobilization of ankle may be required during the resting phase.
Ice pack
Cold pack of ice is regarded to be a very good treatment for Achilles tendonitis. The inflammation in the ankle would be reduced with the help of application of cold pack on the ankle twice or thrice in a day. The pack should not be extended for more than twenty minutes at a particular time, to prevent the tissues from getting damaged.
Wrapping an ace bandage on and around the ankle would help in reducing the inflammation in the ankle in a considerable way.
Exercises like maintaining balance on toes, wall stretching, calf stretching and toe raising are regarded to be quite useful in treating Achilles tendonitis. The strength and flexibility of the ankle would be improved and an individual would be able to get rid of the inflammation and pain in the ankle with the help of these exercises.
There are several anti inflammatory drugs, pain relievers and injections which help in dealing with the problem of Achilles tendonitis. An individual would find great level of relief with the help of the prescribed drugs, thus helping to recover soon.
In rare cases, surgery of the ankle may be required to treat Achilles tendonitis. However, this should be opted as the last alternative only. Proper examination of the ankle is done before the surgery.
All the aforementioned tips to treat Achilles tendonitis would help in improving the condition of the ankle in an effective way. Of all the tips given above, it is advised to opt for natural methods as far as possible.
Medical treatments should be opted only if natural methods do not work. The drugs and pills would surely give instant results; but in the long run, they may have side effects, as they contain lot of harmful chemicals.


text:
Over the weekend, the US Coast Guard performed two rescue operations to save the lives of a total of five rowers participating in The Great Pacific Race to Hawaii from the Central California coastline.
From the Los Angeles Times:
The first rescue came early Saturday, when a group of four rowers issued a distress call after their 24-foot English rowboat began taking on water, according to the U.S. Coast Guard. The team was participating in the 2,400-mile race, which started in Monterey on June 7 and ends 30 to 90 days later in Honolulu. Rescuers tried reaching the rowers, but high winds and rough seas made the mission impossible. A Coast Guard helicopter from San Francisco and C-130 plane from Sacramento found the rowers 75 miles west of San Luis Obispo. The rowers were taken to a local hospital, where they received medical aid and appeared to be in "good condition," the Coast Guard said.
The second rescue took place on Sunday, when Coast Guard crews assisted a solo rower some 52 miles west of Morro Bay. He reported capsizing several times in rough seas in the middle of the night. More at AP.
The Monterey Herald has an image gallery.


text:
diversity report
Uber finally sets diversity, inclusion and equity goals
Within the sphere of diversity, inclusion and equity, it's common knowledge that companies are unlikely to achieve meaningful progress unless they put goals in place. Uber has finally gotten the
Twitter wants workforce to be at least 5% black, 5% Latinx by the end of this year
Twitter unveiled its latest diversity report and announced a new vice president of people experience and head of diversity and inclusion. In order to "unify I&D with critical People function
Facebook's diversity efforts show little progress after five years
Facebook has released its fifth diversity report, and it's fine. Unless companies fire everyone and start over, we're not going to see drastic improvements anytime soon. "A critical
Google releases first diversity report since the infamous anti-diversity memo
Google has released its first diversity report since the infamous James Damore memo and the fallout that resulted from it. Those are both long stories but the TL;DR is that Damore said some sexist thi
Uber's first diversity report under new CEO shows slight progress
Under the leadership of Travis Kalanick, Uber was late to the game in producing its first diversity report. Now, under the leadership of new CEO Dara Khosrowshahi, things are starting to look a bit di
Slack CEO Stewart Butterfield details approach to sustaining an inclusive workforce
In light of the tech industry's last year of one sexual harassment scandal after another, Slack CEO Stewart Butterfield says the company has had active conversations about the issues. However, S
Pinterest beat hiring goals for women in engineering, missed for underrepresented minorities
Pinterest has unveiled its latest diversity report, showing progress in some areas while missing goals in others. Pinterest hit its goals for women in engineering roles but failed to reach its goal fo
Interviewing.io hopes to close the engineer diversity gap with anonymous interviews
Take out your name, resume and any other identifying information then hop on the internet and show your skills to a recruiting manager. That's the way Interviewing.io does it to ensure a truly b
Facebook's black employee representation has increased for the first time since 2014
Facebook is continuing to pick away at its diversity problem, which it shares with most companies in Silicon Valley. For the first time since 2014, Facebook has increased the overall representation o
A look at Square's first diversity report and ally training for employees
Square, led by CEO Jack Dorsey, has released its first diversity report, which, not surprisingly, looks very similar to the below-par numbers of other tech companies. But, unlike other tech companies,
Lyft finally releases a diversity report
Lyft just released its first-ever diversity report, a couple of months after Uber released its first one. Lyft, which committed to releasing a report last June, says it will continue to release report
Beyond the diversity report
There was once a time when everyone knew in their hearts that the tech industry was super white and male-dominated, but didn't have the stats to back it up. Now that the likes of Facebook, Apple, Tw
Slack's diversity report reveals how many people with disabilities it employs
Tech companies rarely, if ever, include information about how many people with disabilities they employ. Today, Slack is changing things up.
Intel's diversity efforts are somewhat paying off
It became clear in last year's mid-year diversity report that Intel had a leaky bucket, meaning that even though it had increased the number of underrepresented minorities it was bringing in, its ov
Twitter doesn't have quite as many white employees as it did last year
But there are still a lot. Twitter just released its first diversity report since hiring Jeffrey Siminoff, the former director of worldwide inclusion and diversity at Apple, in December 2015. Overall
Grace Hopper organizers finally release their own diversity report
After years of advocating for diversity and inclusion, and telling tech companies how to improve in that area, the Anita Borg Institute has released a diversity report of its own. The Anita Borg Insti
Pinterest has lowered its hiring goals for women in engineering roles
Pinterest found that the 30% hiring rate it set for women in engineering roles was doing too much, so it's lowering its 2017 goal to 25%, Pinterest disclosed on its blog today. "We still a
Dropbox is slightly more diverse than it was last year
Dropbox today released its latest diversity report, showing a slight increase in overall representation of underrepresented minorities at the company. Dropbox is now 3% black, up from 2% black last ye
Airbnb's female employee representation down since last diversity report
Airbnb recently released its 2016 diversity report, showing a 57% white workforce (last year, Airbnb was 63% white) and 43% female workforce — a 3% decline from last year. Although Airbnb lost s
Intel has a leaky bucket
This apparently bears repeating: putting resources toward attracting and hiring diverse candidates is useless if you can't retain them. I'm looking at you, Intel. Intel, which last year m