Yann Esposito

When I was new to Haskell (and also not an experienced programmer), the following example on “functional style” had a huge positive impact on me -- where the same program is re-written in ten different ways, each time making it more modular & composable: http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/ (section 3.1... Feel free to ignore everything before/after that) It feels so much easier to both understand and modify the evolved version of the code.

I like the "Learn Vim Progressively" guide. It starts with just a few commands, and introduces new ones in small batches when you feel comfortable with the ones you're using. http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/ I'd add windows to your list of things to take a look at once you feel comfortable with the editor. You can split your workspace with ctrl+w followed by 'v' (vertical) or 's' (split). Then you can switch between those panes by pressing ctrl+w twice, or ctrl+w followed by hjkl or an arrow key. You can also resize the windows and stuff, it's great for things like viewing a header and source file at the same time.

The only thing you need to read about Vim to get started is here: http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/, the rest is learned pretty much by the following principle: 1. Detect inefficiency for a particular task 2. Find a faster way to do it 3. Make it a habit You can learn more about this approach in this video: https://www.youtube.com/watch?v=p6K4iIMlouI

Try this: http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/ This is how I learned Vim, so as far as I know it's the best resource out there.

Also, I can't resist but to mention hakyll[1]. I switched from nanoc to hakyll[2]. The two of them are great to use. [1] - http://jaspervdj.be/hakyll/ [2] - http://yannesposito.com/Scratch/en/blog/Hakyll-setup/

From the Learn More link at the bottom [1]: > Note the awesome Shakespearean inspired name convention. Another good reason to use yesod. Lol. > Until here I believe it goes in the right direction. Even if I believe the real future is by generating HTML pages from the client (using javascript) and server limited to serve JSON (or XML, or any object representation system). This is a little unclear. Do you mean, prior to Yesod you thought web development was heading in the right direction, but Yesod made you realize there was a much better way, even if the future is HTML5 rich web apps with the app server as a JSON/XML API endpoint? 1. http://yannesposito.com/Scratch/en/blog/Yesod-excellent-ideas/

Try RubyMine from JetBrains, a very slick product, and worth paying for (I don't pay for much but JetBrains IDEs I make an exception for). In true HN tradition, I must urge you to try Vim. I found this very helpful when I first start: http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/

I mastered most of the more commonly known motions, including most of the ones on this page (http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/) and some that aren't on it. It didn't seem to be delivering the promised efficiency improvements, so now I only use it for git commit messages, line editing in zsh, and file processing with macros (which are pretty nice--best way I know of to reformat data; much easier than writing a script). I don't think it was worth it--should have shipped product instead and used nano for my command line editing needs.

I sincerely recommend against LYAH! It takes sooooooooo loooooong to get to the interesting bits that actually make Haskell worth learning an has so many try-to-be-funny examples that it makes you run away screaming... I tried going through it but it was literally oscillating between putting my mind to sleep and making wish to grab a chainsaw :) And the "humor" and "pretty pictures" don't help either... they were more like poignant guide to ruby, something that you either love or they annoy the hel out of you (this was for me), but either way they don't help the learning experience at all. I suggest HFH ("Haskell Fast & Hard") as the introductory tutorial to start with instead. You can pick from 2 formats: - http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/ - static all-in-one-page format with pretty pictures - https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-w… - split version, but with the ability to open snippets in their web based IDE ...after this, Real World Haskell is probably the next step: http://book.realworldhaskell.org/read/ (I'm still at this step).

The Yesod method does seem interesting (best explanation I could find of it is at [1]. Perhaps that would be a better plan, although you could look at the encoding syntax as strongly typed strings. If you look at the 'boldheart' example once the <strong>&lt;3</strong> is saved as an "type html" string, it is not re-encoded when placed inside another "type html" string. As for the "yet-another" argument - I know. Convincing developers to switch to a language that is not leaps-and-bounds ahead of their choice language is hard to impossible. The reality is that I'm simply not happy with any of my options and decided it would be an interesting experiment to write my own. I'm not planning on writing any serious applications in it myself -- unless somehow it can pick up a community. The remixing though I find interesting. This is simply an attempt at making something "better" than the other options. Languages get stuck with broken features in order to maintain backwards compatibility. I see this as a way to take the good parts of any languages and turn it into something I would like to use. I'd rather stick with what works. [1] http://yannesposito.com/Scratch/en/blog/Yesod-tutorial-for-newbies/

Unrelated to Vim but reminds me of https://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

You may be looking for "Learn Vim Progressively" by Yann Esposito. It's also how I got into Vim almost 10 years ago. https://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/

https://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/ This article got me from scared of of VIM to feeling crippled without it.

I am currently going through https://www.seas.upenn.edu/~cis194/spring13/ to learn about Haskell (my goal is to use it for Nand2Tetris's compiler assignments). There are also other resources that I used before cis194: - https://typeclasses.com/beginner-crash-course - https://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

You don’t learn Vim that way. Once you get the Vim grammar, you just flow. Verb-adverb-noun. This helped me back in the day: http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/

Doctests are often useful to briefly demonstrate how something works: http://hackage.haskell.org/package/doctest They are a bit finicky to set up though. Another good resource: http://yannesposito.com/Scratch/en/blog/Haskell-Tutorials--a-tutorial/

I am very much the same way. What I eventually did to get a foothold on the language was power through the first few chapters of 'learn you a haskell', and read 'haskell the hard way' and then sat down and typed out a tutorial implementing the Kaleidoscope teaching language in Haskell [2]. It was slow at first, and there was a lot of "now what's this arrow doing here?", but I would go back to the books when I had questions and eventually things started making sense. That won't work for everyone, but maybe it will work for you too? The folks in #haskell are generally pretty helpful, and delightfully easy to troll. [2]: http://www.stephendiehl.com/llvm/ [1]: http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

For those who missed it, there's a newish project called the holy haskell project starter. It generates a skeleton project with cabal sandbox, tests and a Foo/Bar module example: http://yannesposito.com/Scratch/en/blog/Holy-Haskell-Starter/

It is, you won't have to download the entire stack. You might want to try this tutorial out: http://yannesposito.com/Scratch/en/blog/Holy-Haskell-Starter/

http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/ I wasn't crazy about LYAH or RWH. They're both spreading too little butter over too much dry toast. Haskell the Hard Way is small, dense, efficient, and enjoyable. I think one of the more popular, but fundamental, mistakes in teaching Haskell is in thinking that the more important "revelations" are easier to convey if you hide them in a sea of noise and that doing so is the only alternative to impenetrable white papers.

While I've heard good things about LYAH, I personally found its approach to be too wordy with too many not-illustrative-enough examples for each concept, and ultimately confusing. I felt like I gained a much better understanding from 2 hours spent reading "Learn Haskell Fast And Hard"(1) which is more concise, pragmatic, and presents a better logical build up of explanation and examples. 1.) http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/

This website is really good for vim beginners http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/