(Part 2) Best products from r/haskell

While LYAH is a fantastic book, I also felt a bit lost after reading it. You're still kinda useless as a Haskell programmer, all the practical things like 'drawing to the screen', 'calling a web API' are not included and bread & butter concepts like monad transformers, arrays/vectors, exceptions, any form of parallelism / concurrency, widely used language extensions etc., required to use/understand many libraries, are not discussed.

I can recommend Real World Haskell as a second book. Skip the basic early chapters and some of the outdated stuff, and you're still left with enough good parts. Also the Parallel and Concurrent Haskell book is truly excellent. It's written in a way that should make it accessible to someone with just LYAH under their belt. Both are available online for free, btw.

I haven't personally read it, but some people here recommend this book:
www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508/

Also, have you seen this great collection:

http://dev.stephendiehl.com/hask/

? That should give you a good introduction to many of the advanced concepts.

I would also recommend to check out 24 days of hackage to get a good idea of Haskell's library ecosystem:

https://ocharles.org.uk/blog/pages/2012-12-01-24-days-of-hackage.html
https://ocharles.org.uk/blog/pages/2013-12-01-24-days-of-hackage.html

Hope that helps, good luck! ;-)

That's fine, then. My main concern was that you might be putting your money on the line!

I am not sure that an automated momentum system can't work. In fact, many CTAs (commodity trading advisors... a kind of hedge fund) made consistent returns in 2000-2009 by following pretty simple momentum strategies - generally moving averages or moving average crossovers on a 100-300 day window. Note that the timescale is much longer than yours, and also note that most of those CTAs have been in drawdown since about 2010 (ie they've lost money or just about broken even for the last four years).

But I am pretty certain that an intraday trading system based on trashy, discredited technical analysis isn't going to yield consistent profits, especially when applied by someone who is trading for the first time.

One way to tell if a trader knows what they are doing is to listen to their language - if they talk about technical indicators, fibonacci retracement, elliott waves, entry and exit points, MACD etc then they are a quack. If they talk about regression, signal processing, traing and test sets, regularization, bias/variance etc then there's a chance that they know what they're talking about.

There is fifty years of history building mathematical tools for analysing random processes, making time series forecasts, building regression models, and analysing models out of sample, all of which is generally ignored by the quacks who rely on spurious "indicators" and "entry/exit points". A good place to start is this book -

http://www-bcf.usc.edu/~gareth/ISL/

and this is a good book for when you've progressed beyond the intermediate level

http://statweb.stanford.edu/~tibs/ElemStatLearn/

There are two books by Ernest Chan about quantitative trading that frankly don't tell you anything that will be immediately applicable to creating a strategy (there's no secret sauce) but they do give you a good high level overview of what building a quantitative trading system is all about

http://www.amazon.co.uk/Quantitative-Trading-Build-Algorithmic-Business/dp/0470284889/ref=sr_1_2?ie=UTF8&qid=1406963471&sr=8-2&keywords=ernest+chan
http://www.amazon.co.uk/Algorithmic-Trading-Winning-Strategies-Rationale/dp/1118460146/ref=sr_1_1?ie=UTF8&qid=1406963471&sr=8-1&keywords=ernest+chan

Hope that's helpful.

Thank you! Yeah, I'm reading a book on graphic shaders, this one: http://www.amazon.co.uk/Graphics-Shaders-Theory-Practice-Edition/dp/1568814348

The first approach is how I'm doing the rendering in direct mode, so I guess that's how I'd like to approach it. The whole point of the project is to have the functional API to enable a more functional way of writing programs.

I've had a dash at LambdaCube and even GPipe which might be possibilities. I figured it'd make sense to get as much information before I get too deep in the shaders and realise there's a much better way of doing it and it was because I didn't explore the possibilities.


Thank you very much, I really appreciate it!

I found the best way to think about relational data in general is to start with an old book, one that covers the subject in a pure way without reference to any particular system. Then you can translate the concepts into a nice modern system like PostgreSQL. http://www.amazon.com/Handbook-Relational-Database-Candace-Fleming/dp/0201114348

If you just want to jump in and try stuff out here are some tutorials and docs.

Here are some tutorials about triggers
http://www.postgresqltutorial.com/postgresql-triggers/

Managing roles (the "official" docs are actually pretty good)
http://www.postgresql.org/docs/9.4/static/user-manag.html
http://www.postgresql.org/docs/9.4/static/sql-grant.html
http://www.postgresqltutorial.com/postgresql-roles/

Creating schemas and using the search path
http://www.postgresql.org/docs/9.4/static/ddl-schemas.html

If you're trying to make functional programming a pariah, I can heartily recommend writing all your programs in Church encoded lambda calculus.

I mean that's what the author is ultimately advocating, right? That gets rid of all the Booleans and conditionals that make programming hard.

I get it. Ever since Dijkstra (his name is easy to spell if you remember it has the first three Fortran integers in it in order) did his "no gotos" thing, everybody has wanted to be that guy and explain how getting rid of another major programming feature will actually make programs better. Indeed functional programming does exactly that by considering programming with storage harmful.

But "no reification" is a bridge too far. That's what's being advocated here: never lift a decision into the domain of values. When you get beyond the whole mystic "just one bit" thing, Booleans aren't special. For example, anytime you pass an integer to say how many times to do something, you could instead have passed a lambda that does it the desired number of times. That's how Church encoding works: you literally pass the replicable thing to the function representing the integer, and voila.

The resulting mess is almost completely unreadable to most programmers, because reification is a reflection of how humans think about the real world. Counting is reification, for pity's sake: you replace some set with the number of elements precisely to throw away inessential information and retain only the part that is semantically meaningful in your situation. The same is true of Booleanization: you don't need to know or care about where the bit came from: you just care about true or false.

To make this more concrete, think about the cognitive burden on the programmer in the "good" and "bad" examples in the article. In the "bad" case, the programmer has to keep track of which of two Booleans means what. In the "good" case, she has to keep track of two arbitrary computations, and verify that they are appropriate for the use case in question.

I find myself writing less and less Haskell as I have to deal with more and more of other people's code that looks like this. I'm a not-too-dumb guy with an MS in programming languages and 30 years of functional programming experience. I was on a student's math dissertation committee last week. This coding style baffles me.

I've spent the last few days learning Rust, and the amount of this style of code in the standard libraries is close to making me give up. The overgenerality and confusion makes simple things really hard, and hard things impossible.

So if this is where everybody is headed, I'll go back to writing C. It's a horrible language for safety, but the code most people put into production stuff is comprehensible and maintainable. No one gets mad at me for writing an if or using a Boolean. Sorry, but I like that.

Edit: If you want to see how this approach looks in Java, I heartily recommend Felleisen et al's A Little Java, A Few Patterns. It's an amazing book...

> Problem one is ANSI control codes.

This isn't a problem at all, if your library is properly abstracted (and I haven't looked at Vty at all) then all you'd need to do is call the right Win32 API instead of just emitting ANSI control sequences. That is if you want compatibility with older OSes.

If you're only aiming for Windows 10 and higher it supports most if not all VT100 sequences fine https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences

If the library isn't then you can just re-interpret the control sequences back to Win32 api calls, It's not that hard at all, to the point where lots of compilers just do this. See projects like ANSICON that have existed for years https://github.com/adoxa/ansicon.

> Namely, instead of sending an escape sequence, ALT+{Key} escapes the console host entirely and talks to the OS instead, and you get similar behaviors with some CNTRL+{Key} combos. I am not sure if there is any way at all to bypass this behavior.

If you want low level controls, you need to look at the low level console apis instead of the high level ones https://docs.microsoft.com/en-us/windows/console/low-level-console-i-o

Particularly, the only signals I am aware of that the console host actually routes to the OS by default are Ctrl+C and Break. And if you don't this you can just turn off console input processing https://docs.microsoft.com/en-us/windows/console/low-level-console-modes (this is how you get mouse events in the input buffer as well).

Lastly you can even get access to the full underlying screen buffer and manipulate the entire buffer as a char* which allows you to do things not supported by the APIs if you want. (I've used this before to do things like screen scraping of console programs which use TUI like functionality so std redirection didn't work.).

In short, there is no technical reason why Vty shouldn't be able to achieve full feature parity with unix like OSes. The API is more than capable, it's just different, which is why historically you didn't have things like an ncurses port. It would essentially be a rewrite because it's not abstracted correctly.

> Basically, MS threw CMD.EXE in the dustbin about 20 years ago and only recently started to try pulling it out again -

CMD is just a layer on top of conhost which is the actual console host. The limitations of CMD in no way reflect the limitations of window's console host. ConEmu etc all use conhost because it's the only user facing console interface on Windows. https://blogs.technet.microsoft.com/askperf/2009/10/05/windows-7-windows-server-2008-r2-console-host/ explains the architecture behind it. and if you're interested in learning more https://www.amazon.co.uk/Inside-Windows-Debugging-Practical-Strategies/dp/0735662789

Conceptual Mathematics by Lawvere and Schanuel is a good low level introduction to category theory (and a bit of set theory) if you are feeling shaky on those grounds. From there lots of books open up to you.

The best books I know on how to "think" like a functional programmer are all written by Richard Bird. http://www.amazon.com/gp/product/1107452643/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=1944579842&pf_rd_s=lpo-top-stripe-1&pf_rd_t=201&pf_rd_i=0134843460&pf_rd_m=ATVPDKIKX0DER&pf_rd_r=090NKMWKY6078Z0WPCTW http://www.amazon.com/Pearls-Functional-Algorithm-Design-Richard/dp/0521513383

Not much is available in book form, especially that I can recommend on the FRP front.

Dependent types is a broad area, you're going to find yourself reading a lot of research papers. You might be able to get by with something more practical like Chlipala's Certified Programming with Dependent Types, but if you want a more theoretical treatment then perhaps Zhaohui Luo's Computation and Reasoning might be a better starting point.

An Introduction to Functional Programming Through Lambda Calculus by Greg Michaelson is a great intro book about both lambda calculus and functional programming that may be easier to digest: http://www.amazon.com/Introduction-Functional-Programming-Calculus-Mathematics/dp/0486478831. Also, it seems, available for free as a PDF: https://www.cs.rochester.edu/~brown/173/readings/LCBook.pdf

The Haskell Road to Logic, Maths and Programming

http://amzn.com/0954300696

I read only the first chapter or two a long time ago. I don't remember much, but I do remember I was able to progress through the book and learn new things about both math and Haskell from the text.

I didn't have any trouble getting the outdated examples to work. I had read LYAH previously though, so I wasn't a complete beginner.

I would really enjoy hearing what others have thought about this book.

I have a related notion of locality (albeit a bit more kludgy) in my pending numerical array Apis.
One thing I don't know if classical geometry addresses is what happens when your geometric structure is discrete.

Doesn't the turn into convex geometry? I'm actually spending a bit of time teaching myself convex geometry, and it's very very nce language for a lot of discrete arrangement stuff.

I'm actually start to explore how to mod "cloud Haskell" to admit better reasonig about locality and paths. Hope to have something to share after a few more weekends of hacking.

Edit:
I'm told that the works of Maurice herlihy such as http://www.amazon.com/gp/aw/d/0124045782/ref=redir_mdp_mobile?adid=11Q692XVB3PRZGKNS6PE&camp=14573&creative=327641&creativeASIN=0124045782&linkCode=as1&ref-refURL=http%3A%2F%2Fcs.brown.edu%2F~mph%2F&tag=mauriherli-20 cover this whole perspective in some depth!
His academic page is http://cs.brown.edu/~mph/

I liked TTFP for a start to functional programming. It covers lambda calculus and a type system that will help you get through about 90% of day to day software design. Now category theory is much harder to find. I read through a little bit of the introductory text by Simmons since the Kindle version is only $20 and my tablet can handle the math text, but I've also attempted to read through Category Theory for the Working Mathematician (Mac Lane) since it had excellent reviews. I've been meaning to also check out Category Theory for the Scientists but I think it's too introductory.

Haskell is a great starter language for your situation. Once you get into it, you might look at Ermine, as it's specifically developed for financial stuff. The main guy who develops it, Ed Kmett, is also a big Haskell developer. If I recall correctly, he's the head of the committee maintaining the Haskell standard library.

Chris Allen has a nice tutorial on GitHub. Learn You a Haskell is aimed at people who already know imperative programming (Python, Java, C, etc). There's another book aimed at complete newbies, called Programming in Haskell. I haven't looked at that book, but I've heard good things about it.

If you have any questions, you can always ask here, or in the #haskell channel on FreeNode. I'm pharpend in the channel, if you ever want to talk to me.

I've found Haskell: The Craft of Functional Programming to be great. RWH is naturally better for real-world examples though. That would be CoFP's main downfall.

I run NixOS on both a Jetson TK1 (armv7l) and a Jetson TX1 (aarch64). It works great on both of those boards. On the TX1, I use a Mailiya M.2 PCIe to PCIe 3.0 x4 adapter (https://www.amazon.com/gp/product/B01N78XZCH/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1) along with a Samsung EVO 960 NVMe board to host the entire NixOS filesystem, and it really flies.

Out of the box, Nixpkgs does not support GHC on any ARM architecture, because -- believe it or not -- the GHC bootstrap process on Nixpkgs starts by downloading the binary distributions for GHC 7.4.2, and there is no binary distribution of 7.4.2 for any ARM. (Even if there were, you would not want to wait for it to bootstrap through 3 or 4 versions of GHC on ARM! Building even a single version of GHC on the TK1 is brutally slow.)

However, I've created a Nixpkgs overlay that downloads the Debian package for 8.0.1 and use that to bootstrap a Nix derivation for 8.0.2. I posted links to a rough version of that overlay in the comments here: https://github.com/NixOS/nixpkgs/issues/31666. I've been using this overlay to build Haskell packages for armv7l on my TK1 for months now with great success. I thought it worked on aarch64 as well, but based on the feedback from a tester in that GitHub issue, it sounds like it doesn't work anymore for that platform. In any case, over the next week or so I'll try to post a working version of the overlay somewhere on GitHub.

Re: the Jetson TX2, I can't get NixOS to boot on it, which is odd given how similar the platform is to the TX1. It can't find the root filesystem from the initrd. I even tried the official linux-tegra kernel, which is maintained by Nvidia devs and has bleeding-edge support for Nvidia's Tegra platforms, but to no avail. I haven't tried the recently-released 4.14 kernel yet, but I will soon.

Great talk.

I'm wondering. Simon Marlow's book Parallel and Concurrent Programming in Haskell is from 2013 - before Haxl was released.

Those of you who have read this book, would you still recommend reading it today?

I have ordered Real World Haskell from Amazon hoping that it's a book that will close this gap. The table of contents looks very promising.

This might suffice

> Standard C++ and the design and programming styles it supports owe a debt to the functional languages, especially to ML. Early variants of ML's type deduction mechanisms were (together with much else) part of the inspiration of templates. Some of the more effective functional programming techniques were part of the inspiration of the STL and the use of function objects in C++. On the other hand, the functional community missed the boat with object-oriented programming, and few of the languages and tools from that community benefited from the maturing experience of large-scale industrial use.

I remember that he discussed the idea in the C++ programming lanugage book, but I cannot find the right passage on the interwebs.

There are some advanced Logo environments:

• NetLogo
  
• aUCBLogo
  
• FMS Logo
  
  ...and for those interested in more of a challenge, check out the table of contents for Turtle Geometry: The Computer as a Medium for Exploring Mathematics. And if you really want to bend your mind, try to find a copy of: Fractals, Visualization and J, which uses the J Language.
  

> I'm not aware of anything that covers ... lens in book form

Beginning haskell has an introduction to lens.

In addition, there are a few lens tutorials out there on the web; google for them.

An Introduction to Functional Programming Through Lambda Calculus

a beginner level book; helped me when i started looking into FP & Lambda calculus.

http://www.amazon.com/Introduction-Functional-Programming-Calculus-Mathematics/dp/0486478831

Thompson's book was updated in 2011, and the Apress book looks like a good learning resource generally but I haven't read beyond a few chapters. There's a few odd typos where Mena writes "Platform does something" and he means GHC.

(Also, how about Bird's Pearls book? Hudak, School of Music?)

http://www.haskellcraft.com/craft3e/Home.html

http://www.amazon.com/Beginning-Haskell-A-Project-Based-Approach/dp/1430262508