FP Complete Blog

there's lots of books, and a couple recent ones, listed here, depending on what you're looking for: http://www.reddit.com/r/haskell/comments/2cpr4z/recommended_reading_ma… and FP complete have put a huge effort into putting up tutorials that you can run through interactively https://www.fpcomplete.com/

Since no one have pointed out yet, I take the opportunity to recommend FPComplete. It's a new company focusing on this exact problem. They offer tools like an IDE and deployment model. You can just sign-up on their website and start coding directly, you don't need to mess with setting things up. They also got School of Haskell which is a central place of really great tutorials ranging from tutorials on developing web apps to category theory stuff. Check them out: https://www.fpcomplete.com/

I strongly recommend that you learn Haskell. I have some reasons to back up my endorsement of Haskell. First and foremost, Haskell is the best language to learn if you want to learn about functional programming. Why? Because Haskell is the quintessential functional programming language. It is approaching 30 years of age and was originally developed back when functional programming was nowhere to be found in production settings. A bunch of academics who were all working on separate functional programming languages got together and said, “hey, how about we all work together and make the ultimate FP language rather than reinventing the wheel on our own?” And that’s exactly what they did. The result today is a very mature, feature rich and programmer-friendly language. If you really want to delve into the history of Haskell, check out this paper or watch the video based on it: https://www.microsoft.com/en-us/research/publication/a-history-of-hask… The second reason to learn Haskell is that it is a great language for doing the things you want to do. A prominent Haskeller, Gabriel Gonzalez, estimates that Haskell is mature in the domain of server-side web development. Check out his view on the state of the Haskell ecosystem: https://github.com/Gabriel439/post-rfc/blob/master/sotu.md#server-side… Writing CLI programs is also rated…

The problem with packages and Haskell is well known; there are a few camps currently trying to solve the issue. Personally, (although the author went about things in a rather roundabout way) I can feel for the author. I LOVE Haskell, I cannot think of a better language for prototyping crazy ideas in and I work in it every chance that I get; that being said, its awful to get up and running with cabal. The suggestion which has been posed to me is "simply use cabal-dev", when I do this, I wind up with crazy huge project files because of repeat installs. I sincerely hope that someone much smarter than myself can come up with a solution for this; I think it is a primary reason why Haskell is not being more widely adopted. References(for those who are interested) http://www.yesodweb.com/blog/2012/04/replacing-cabal http://www.yesodweb.com/blog/2012/03/cabal-nirvana Hopefully the guys at FP complete will redirect some of their focus onto this (please oh please). http://fpcomplete.com/

It's worth noting that using Either style monadic error handling in IO code in Haskell is arguably an antipattern, as the Haskell runtime has its own built in exception handling (which actually works in a pretty conventional way). Some more info on this under 'Exceptions best practices ' here: https://tech.fpcomplete.com/haskell/tutorial/exceptions/

You're asserting properties, so IMO this meets the definition of PBTs ("every node of level greater than one has two children"). However, depending on the lib, you can get some nice quality of life improvements. One "nice to have" is shrinking. See the "Shrinking" section here https://tech.fpcomplete.com/blog/quickcheck-hedgehog-validity/ Having combinators to compose generators is also great. Libs may also have a known set of "bad" values that cause exceptional behavior.

Looking at https://www.fpcomplete.com/ FP Complete appears to be downplaying "Functional Programming" and "Haskell", perhaps because they found it scares off customers. At the same time, they are drowning themselves in generic buzzwords. Haskell is below Rust on their website, despite being later alphabetically. I suspect they are pivoting away from Haskell toward Rust.

Some resources: - https://www.fpcomplete.com - https://haskellweekly.news - https://wiki.haskell.org/Jobs - https://angel.co/haskell/jobs (if you're into startups) - r/haskell on reddit I do not work in haskell at my day job but I've found writing side projects with it has done wonders for my understanding -- I've been able to work through the trends in how people are being productive with haskell (mtl, readert, free monads, vinyl, datakinds shenanigans), just by trying to make stuff with haskell.

For people that have gotten into Haskell, but struggle to get over the intermediate level, I would warmly recommend checking out https://www.fpcomplete.com/haskell-syllabus. As for good tips, I've come to like the ReaderT "design pattern"[0]. For newcomers, I would recommend the Haskell Book[1], which covers everything quite extensively. [0] https://www.fpcomplete.com/blog/2017/06/readert-design-pattern [1] http://haskellbook.com

Mostly I just read various people's blog posts and follow links (for example, I think I first found Stack on [1]). I also spend occasional time in the IRC, which can be useful but isn't a comprehensive news source by any means. I hear some of the mailings lists are informative - iirc there's a haskell-beginners one which will probably cover major updates in tooling, feature releases, and so on. Good luck! [1]: https://www.fpcomplete.com/blog/2015/08/new-in-depth-guide-stack

> I'll use Haskell as an example, since it's the most widely-known strict static type system. Hindley-Milner type systems like Haskell often don't allow dependent types, which means that a 2D vector and 3D vector are the same type unless their dimensions are known at compile-time (which is oftentimes not the case). Implementation of dependent types in Haskell, with the specific example of dimension-parameterized vectors, is addressed in [0]. [0] https://www.fpcomplete.com/user/konn/prove-your-haskell-for-great-safe…

Nice article, i've been learning Haskell for about a month solving kata on http://www.codeswars.com/ using https://www.fpcomplete.com/ as my IDE. I'm finding it quite a learning curve understanding what library functions there are and how to use them. The code I write often ends up being quite different to the other solutions on codewars. I'm missing Visual Studio, are there any realy good Haskell IDEs out there? for example ones which allow debugging.

San Francisco, CA – Telecommute Haskell Test Software Engineer – Scientific Simulation FP Complete is looking for creative software engineers to build our test and delivery capabilities. You will be working as a member of the development team (with those brilliant people listed above). Your mission is to innovate on the test infrastructure enabling and implementing automated tests and test suites across multiple product components. More details here https://www.fpcomplete.com/business/software-engineer-test/

Here https://www.facebook.com/ Here https://galois.com/ And Here https://www.fpcomplete.com/ To name a few.

Actually, the ideas for LTS Haskell came out of conversations I had with Duncan and Mark at ICFP. The original idea was to create a GPS Haskell that would encompass a "best of both worlds." LTS Haskell is a first step towards that, and I'm hoping that Haskell Platform and Hackage ultimately fold this stuff back in. I went into more detail on this history in the previous blog post: https://www.fpcomplete.com/blog/2014/12/backporting-bug-fixes

This is pretty old. Bryan O'Sullivan is currently at Facebook and he's not running a startup on Haskell. One well known company that is actually running a company on Haskell is Galois, Inc. Another one is FPComplete (https://www.fpcomplete.com/).

I have really been enjoying the tutorials and online IDE at http://fpcomplete.com

Somehow related: For those who (like me) were searching for a long time for a quick and complete Haskell tutorial (but were left with very introductory guides for non-programmers like Learn You a Haskell for the Great Good), look at this tutorial: https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-w… Haskell Fast & Hard.

Learn You a Haskell for Great Good! has already been recommended, which I would have said if it had not yet been. There is also Real World Haskell [0]. It's a lot less long winded than LYaH, which is good or bad depending on how you like to digest information. Also, check out FP Complete's FP Haskell Center [1]. It contains community written tutorials with inline runnable code examples, so you can really get a feel for Haskell by manipulating and playing with the examples right on the site. [0] http://book.realworldhaskell.org/read/ [1] https://www.fpcomplete.com/business/fp-haskell-center/

http://fpcomplete.com free Community edition online dev environment.

Sort of off-topic, but wow, this is a really neat presentation format for tutorials. Love the markdown source[0] and the "open snippet in IDE" features. [0]: https://www.fpcomplete.com/tutorial-raw/5133/cf0de9edd526ea54e3b793580…

I think that's basically it. You can check out a great example of prisms in the lens-aeson article on FPComplete: https://www.fpcomplete.com/user/tel/lens-aeson-traversals-prisms

I tried dipping my hands into Haskell over the summer. I fell in love with two resources: 1. Yann Esposito's Haskell Fast and Hard (on FPcomplete -- https://www.fpcomplete.com/user/yogsototh/haskell-fast-hard) 2. Learn you a Haskell by Miran Lipovaca http://learnyouahaskell.com/ The latter author decided to write the book based on his experience in learning Haskell. It's definitely one of the simplest and clearest programming books I've read.

Not sure, but it might be turning into an IDE. They've got a good part of it in place. Something like FP Complete: https://www.fpcomplete.com/

I'm writing up a tutorial on F-algebras and compositional data types. I'd love if you read along and helped me to make it better. https://www.fpcomplete.com/user/tel/from-zero-to-comp-data

That's assuming people are rational and willing to put up with large up-front costs on the promise of future returns. Haskell is different, and learning Haskell is closer to learning programming all over again than just picking up another algolish language. Most programmers don't even seem willing to do the latter, much less learn something truly novel. The people who do use Haskell professionally (e.g. Standard Charter or some number of hedge funds) seem to be very happy with it. Now, there are some core problems--largely with education and ecosystem maturity--that make Haskell harder to adopt. Recently, people have actually started working on both of these[1]. But neither is a quality of the language itself. [1]: http://fpcomplete.com/

> https://tech.fpcomplete.com/haskell/tutorial/operators/ You're a prime example of a person who reads a page on the Internet and takes it at a face value without understanding the meaning and the context behind the words: > One of the most common operators, and source of initial confusion, is the $ operator. All this does is apply a function. Did you miss the part that says "All this does is apply a function"? Here's how you define (+) among other things: https://hackage.haskell.org/package/ghc-internal-9.1201.0/docs/src/GHC… instance Num Int where I# x + I# y = I# (x +# y) whereas (+#) is defined as a bridge from unboxed ints provided by the runtime to their efficient low-level machine representation, accomodating all instances of a data type defined as `Int = I# Int#` (the left-hand side is the name of the type, the right-hand side is the name of a constructor that accepts a single value of type Int# - the low-level primitive provided by the GHC implementation). The (+) in `I# x + I# y =` is a function definition in infix form. That's the same form you can use for any other infix function if you wish so: ghci> a `iAmHelping` b = a b + b ghci> :t iAmHelping iAmHelping :: Num a => (a -> a) -> a -> a > Oh you mean the things that look like operator, behave like operators Let me see your regular operators do the following, then we talk: plus = (+) a = (2 +) c = (2 `plus`) c' = plus 2 d =…

Amazing survey. Big fan of property testing. A particularly big fan of Hedgehog. I tried writing a Hedgehog-inspired library in Rust and realized how complex the underlying domain is. For example, the RNG is "splittable" [1][2] which means you can take a deterministic seed and split it in two, e.g. for parallel generators to work independently but still deterministically. The effort that has gone into this feature level is a little numbing. I have an awe similar to that of the "fast inverse square root" hack when I see code like this: -- | A predefined gamma value's needed for initializing the "root" instances of -- 'Seed'. That is, instances not produced by splitting an already existing -- instance. -- -- We choose: the odd integer closest to @2^64/φ@, where @φ = (1 + √5)/2@ is -- the golden ratio. -- goldenGamma :: Word64 goldenGamma = 0x9e3779b97f4a7c15 when realizing that those numbers don't come easily. [3] [1]: https://hackage.haskell.org/package/hedgehog-1.4/docs/src/Hedgehog.Int… [2]: https://gee.cs.oswego.edu/dl/papers/oopsla14.pdf [3]: https://github.com/hedgehogqa/haskell-hedgehog/issues/191 Wonder why most property-testing libaries don't have features like this? The libraries require training to use. And they're not that easy to write. > the current state-of-the-art when it comes to property-based testing is stateful testing via a state machine model and reusing the same sequential state machine model…

Even with Haskell you can still have deadlocks [1]. They give you the tools to write code that you can prove won't have them, but restricting the kinds of programs you can write. But it's an opt-in thing, it's not a promise of the language that you can't do it. Rust is trying to do a similar thing, but it's still also possible to write yourself into a corner with deadlocks if you work against the feature. Another language I saw recently that has this promise was Pony which uses an actor and message passing model to try to accomplish this but it doesn't actually prevent you from hitting the case, instead it'll just kill a random actor until the deadlock is gone [2]. This can work but it needs to be up front that you MUST write your software to be ready to be killed at any time and continue to function. It's really an impossible situation to completely "solve", given that doing so would require a solution to the halting problem. So it's always a fun place for me to start looking at any new language if they talk about locks and dead-locks. So far I think Haskell and Rust (and probably other ML family) have the best balance being struck since you can opt in to statically proving this if you restrict those parts of your program but you're not required to do so by the language itself. [1] https://www.fpcomplete.com/blog/2018/05/pinpointing-deadlocks-in-haske… [2] https://news.ycombinator.com/item?id=9485333

It's not just people at FP Complete `et al` who were frustrated with cabal-install. Cabal-hell was the number one problem with using Haskell for commercial projects, as a majority of people responded who took part in a FP Complete Haskell organized survey (this was before stack was officially released), https://www.fpcomplete.com/blog/2015/05/thousand-user-haskell-survey. I wrote that survey, if you want to discuss methodology I would be happy to. Anecdotally, after contacting by email most of the respondents, very few complained of a fragmentation the community by virtue of stack being released. We could argue all day over about arguments on reddit, but data suggests otherwise. FP Complete is a commercial consulting firm now targeting life science companies. We use Haskell because we believe it is the best modern language for robust high-performance software. It is not our goal to own the Haskell ecosystem. It is our goal to promote Haskell use and to develop reliable tooling. Do people feel the same way about continuum analytics for releasing Anaconda and special versions of numpy?