[Haskell-cafe] Haskell Weekly News

[Kim-Ee Yeoh]

Folks:

Recall the quote from the May Day 2015 issue:
<http://haskell.1045720.n5.nabble.com/Haskell-Weekly-News-td5808226.html>

The MLs and Haskell remind me of Brian Eno's line about how the first
Velvet Underground album only sold 30,000 copies, but "everyone who bought
one of those 30,000 copies started a band".

This issue spotlights Elm and Idris, two languages implemented in Haskell.
Enjoy!


*Top Picks:*

   - Evan Czaplicki of the Elm web-front-end language leaves Prezi for
   NoRedInk <http://elm-lang.org/blog/new-adventures-for-elm>. A startup
   dedicated to improving high-school English grammar, NoRedInk already
   employs 5 engineers writing Elm full-time. A HN comment hyperbolizes
   that Elm <https://news.ycombinator.com/item?id=10837278#up_10838052> "is
   Clojure without parens, it's Haskell without academy, it's Redux without
   facebook, it's duck-typing without quacks, it's MVC without objects, and
   last but not least Evan Czaplicki (the creator) is the new Aaron Patterson
   (bright and fun!)." [Ed. Aaron is a Ruby and also Rails core dev.]

   - Janos Dobronszki, a self-described "Haskell addict, latent Idris
fan", introduces
   Idris
   <http://crufter.com/2015/01/01/idris-a-language-which-will-change-the-way-you-think-about-programming/>
   as "a language that will change the way you think about programming
   <https://news.ycombinator.com/from?site=crufter.com>." He motivates
   dependent types using the classic list vector example. The Hacker News
   community enthuses over the article
   <https://news.ycombinator.com/item?id=10850205> with healthy signs of
   grassroots static-typing evangelism. Elsewhere, a haskell redditor obtains
   valuable answers about the tradeoffs that dependently typed programming
   incurs
   <https://www.reddit.com/r/haskell/comments/3zc81v/tradeoffs_of_dependent_types_xpost_from_ridris/>
   .

   - In "Monads to Machine Code (Part 1)"
   <http://www.stephendiehl.com/posts/monads_machine_code.html>, Stephen
   Diehl walks his readers through an LLVM-like runtime machine code
   generation while introducing the x86 architecture all at the same time. No
   mean feat, what more x86 as opposed to a RISC architecture. Much-loved
   on HN <https://news.ycombinator.com/item?id=10842988>. Also on haskell
   reddit
   <https://www.reddit.com/r/haskell/comments/3zfca3/monads_to_machine_code_part_1/>.
   Compare to Lennart Augustsson's older series on code generation
   <http://augustss.blogspot.com/search/Label/Code%20generation>. Quality
   packages on hackage for runtime code generation include harpy
   <https://hackage.haskell.org/package/harpy> and llvm-general
   <https://hackage.haskell.org/package/llvm-general>.

   - A redditor wonders whether 3 nested loops written as a list
   comprehension
   <https://www.reddit.com/r/haskell/comments/3zcjn7/optimizing_list_comprehensions/>
   compiles into the tight machine code version of 3 nested loops.
   Conspicuously absent in the discussion is mention of the Vector package
   <https://hackage.haskell.org/package/vector> and Don Stewart's 2010
   achievements of tight loop optimization
   <https://donsbot.wordpress.com/2010/02/21/smoking-fast-haskell-code-using-ghcs-new-llvm-codegen/>
   .



*Quotes of the Week:*

   - ReinH: thanks puregreen for Lens over Tea series
   puregreen: is grinning all around
   ReinH: also thanks for not titling it "You could have written lens"
   johnw:
   <http://ircbrowse.net/day/haskell/today?id=22057773&timestamp=1451949277#t1451949277>
   ReinH, just skip to, "You could have been edwardk", it answer all other
   questions
   (Thanks to Gesh for the link.)

   - From HN: <https://news.ycombinator.com/item?id=10832576#up_10836690>
   One thing I've learned from using immutable, functional languages (Elixir)
   is: "Don't tell your computer what to do, tell it how to transform data."
   While it may seem obvious, it's been a revelation for me and it has totally
   transformed how I write code, and especially how I test it.

   - From HN: <https://news.ycombinator.com/item?id=10833240#up_10837893>
   FP people are nailing composability and reusability to never seen levels
   just in front of your eyes. You just have to keep them open to see. OOP did
   it at its time too, it just hit a ceiling; but there's one reason every
   imperative language is OOP nowadays.

   - From HN: <https://news.ycombinator.com/item?id=10850205#up_10855934>
   As someone who learned Haskell and subsequently have been writing a lot of
   Python, I keep a mental tally of how many of my bugs (some of which took
   ages to track down) would have been caught immediately by a type system
   like Haskell's or Idris'. I'd say it's well over half.

   - From HN: <https://news.ycombinator.com/item?id=10850205#up_10856141>
Haskell
   syntax is the lingua franca when discussing anything related to data types
   and functional programming these days.



*Videos of the Week:*

   - Watch LambdaConf 2015
   <https://www.youtube.com/playlist?list=PLE7tQUdRKcybh21_zOg8_y4f2oMKDHpUS>,
   organized by John A. De Goes and professionally recorded by Confreaks
   <http://www.confreaks.com/>. Richard Eisenberg presented on "A practical
   Introduction to GADTs" <https://www.youtube.com/watch?v=6snteFntvjM>.
   The video recording gets love over at haskell reddit
   <https://www.reddit.com/r/haskell/comments/3yw2mg/lambdaconf_2015_videos/>
   and even a talk summary.


-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20160108/2931ce64/attachment.html>