boothead

Must be pretty handy to be paid in $ around now :-)

Are you aware of http://postgrest.com/?

In SV (or there abouts) I know of:

https://www.frontrowed.com/

https://www.wagonhq.com/

https://github.com/alphaHeavy

I'm sure there are others too.

This is actually the other way round. Given:

1. People who learn Haskell put in a lot of effort for their own learning benefit - they're not usually learning Haskell to get a job.

2. Once you learn Haskell you really kind of want a Haskell job to put all this nice stuff into practice.

3. There aren't many Haskell jobs about (in part due to a perception that it's hard to hire Haskell developers).

As a company in the lucky position of hiring for a Haskell role you have a pool of people who have self selected to be above average in determination and smarts, but limited options in employment in their new tech of choice.

source Built a Haskell team at a startup, now work on a Haskell team in finance. Hiring has NEVER been a problem.

It was? I still can't see it...

AFAIR the problem with WriterT was the use of mappend within is always lazy, regardless of the strictness of the w in WriterT w m a.

could have been worse - it could have come out with "wash the cat", resulting in serious injury!

Excellent write up. One point though: watch out for WriterT and RWST leaking memory:

http://stackoverflow.com/questions/25280852/space-leak-in-pi...

It's often better to just include the writer part you need in a larder State type (lenses make this really seamless)/

Their tech is not incredibly advanced. Their tech is is shower of shit that lurches from one disaster to another. Source: have worked in a few investment banks.

It's one of my weird muscle memory glitches. (Had to type it in rather than link, because no twitter at work).

But a submarine is classified as a boat...

Nate Silver on twitter:

    No, I didn't predict the the Republican Party would lose it's fucking mind.

In finance, probably. Start ups and other industry, probably not so much.

Biggest thing for me: have a small number of fundamental, composable abstractions. Be able to reason about how their properties interact when you combine them.

This is the main reason that Haskell is such a force multiplier for me. All the small minutia is well defined and it frees you to think about the big picture. Sure, it's a big learning curve, but so worth it :-)

Well you could hardly call it Shippy McShipface could you? (Try saying it 5 time fast)

Any info on when this (or the XPS 15 with linux) will be available in the UK? I just had a look on Dell's website, and as expected it's still a shower of shit WRT finding what you want.

I bought one of the first or 2nd gen XPS 13s and loved it. However the experience of buying from Dell was awful and customer service was so intractable as to be useless too.

Hussien they didn't think of that?

It's really to do with the incubation of a very strong shared culture and shared experience. For example the Royal Marines has a history going back 350 years, a shared language (google jack speak), and the longest and arguably hardest basic training in the world.

I believe it is possible, albeit in a slightly different form: elite sports teams and groups of people tied together with a strong shared purpose can get there I think.

edit and yes, as marktangotango says - shared hardship and knowing you can count on the next guy because he's been through what you have and hasn't broken either is also key.

It seems to be an excerpt from Charles Duhig's (author of The Power of Habit) new book.

I'd be willing to bet that Sakaguchi has read "The 5 dysfunctions of a team" [1]. One of my favorite books about how people jell together in groups.

Like him I was also in a military setting before I became a programmer. I haven't yet experienced the same level of engagement and team cohesion outside of the military but I believe that the answers are to be found in the kinds of insights that studies like this uncover.

[1] http://www.tablegroup.com/books/dysfunctions

edit formatting

I'd be willing to bet that Sakaguchi has read "The 5 dysfunctions of a team" [1]. One of my favorite books about how people jell together in groups.

Like him I was also in a military setting before I became a programmer. I haven't yet experienced the same level of engagement and team cohesion outside of the military but I believe that the answers are to be found in the kinds of insights that studies like this uncover.

[1] http://www.tablegroup.com/books/dysfunctions

Isn't that a bit like hiring a sniper and then sending them into battle armed with a nerf gun? ;-)

I learned to program on a warship heading to Iraq in 2003. From a book, with no internet. It's amazing what constraint's will do for you - I'm not sure I'd achieve that feat now in the presence of constant distraction!

Got a link to the talk/slides? As someone who works in a bank I'd be really interested what a truly green field approach looks like!

I was talking about banks. I work for one where we build stuff on top of essentially this paper:

http://research.microsoft.com/en-us/um/people/simonpj/Papers...

We're even hiring: https://donsbot.wordpress.com/2016/01/18/haskell-developer-r...

This seems similar to the idea of a spark file?

http://lifehacker.com/5941997/defrag-your-brain-with-a-spark...

edit Also do you have anything written down about using org-mode for todos and ideas?

Whereabouts are you? If you're interested in PLT, DSLs and compilers, there are some small enclaves in finance that might interest you.

edit spelling

That sounds pretty amazing. Like a whole person, holistic tune up. You could call it the body and soul service :-)

What do you find impractical about Haskell out of interest?

It's this

  contramap :: (a -> b) -> f b -> f a

  http://hackage.haskell.org/package/contravariant-1.3.3/docs/Data-Functor-Contravariant.html#v:contramap

The code looks good. One thing you might want to consider is using applicative style for parsing. So

  taggedImage :: Parser BaseImage
  taggedImage = do
    name <- many (noneOf ":")
    reservedOp ":"
    tag <- many (noneOf "\n")
    return $ TaggedImage name tag

Would end up something like:

  taggedImage :: Parser BaseImage
  taggedImage = TaggedImage <$> (many (noneOf "\n") <* reservedOp ":")
                            <*> (many (noneOf "\n")