
Basics of Haskell – Code and exercises - raviksharma
https://github.com/raviksharma/bartosz-basics-of-haskell
======
moralestapia
Bartosz truly deserves to be more widely known.

His Category Theory for Programmers book is an _excellent_ introduction to the
CT world if you come from a Computer Science background (well ... duh it says
it right there in the title) and know very little math.

Highly recommended to give it a try, even if the topic doesn't seem to fit
you. This is one of those books that will make you a better programmer
regardless of what you do.

------
siraben
Writing interpreters in Haskell (which is what some of the lessons seem to be
about) is a great way to learn the language. It naturally motivates recursion,
algebraic data types, strong types, higher-order functions and later, when
effects such as state and errors are needed, monads arise naturally.

The best part? It takes a ridiculously small amount of code to do all that,
maybe around a hundred or less. Languages without ADTs and higher-order
functions bend over backwards to recover them[0] via design patterns.

[0]
[http://www.cs.ox.ac.uk/jeremy.gibbons/publications/hodgp.pdf](http://www.cs.ox.ac.uk/jeremy.gibbons/publications/hodgp.pdf)

~~~
mason55
It also introduces you to the expression problem pretty quickly and
organically :)

I agree with the comment though. I learned Haskell and how to write an
interpreter at the same time by working through the book Crafting
Interpreters. It was a great match.

------
guerrilla
Bartosz is always doing great stuff. Check out is Category Theory lectures for
people who know Haskell:
[https://www.youtube.com/user/DrBartosz](https://www.youtube.com/user/DrBartosz)

~~~
vrnvu
Also I personally recommend to take a look to this series before diving into
his great introductory book about category theory [1]. Seeing the application
of the theoretical concepts and deriving the code yourself makes it more
approachable for completly begginers from my experience.

1\. [https://github.com/hmemcpy/milewski-ctfp-
pdf](https://github.com/hmemcpy/milewski-ctfp-pdf)

~~~
ajarmst
I liked his introduction to Category Theory enough to buy the extremely well-
done hardcover edition:

[https://www.blurb.com/b/9621951-category-theory-for-
programm...](https://www.blurb.com/b/9621951-category-theory-for-programmers-
new-edition-hardco)

The only introductory treatment of Category Theory for non-specialists that
I’ve encountered that even competes with it is Spivak’s “Category Theory for
the Sciences.” For the curious, Eugenia Cheng’s books for lay audiences are
excellent for getting a feel of the power and value of the Category
Theoretical approach.

Category Theory is somewhat unique in being a recently developed area of
advanced maths that is nevertheless approachable with only modest formal
training. Because it maps so well to much of the theory and practice of
functional programming, most programmers with even a little interest and
familiarity with that will be able to engage with the fundamentals, and
Milewski does a masterful job of introducing it to that audience.

------
vajrabum
Here is the tutorial that goes with that code. Unfortunately the School of
Haskell is now read only so they aren't dynamic in the browser anymore.
[https://www.schoolofhaskell.com/school/starting-with-
haskell...](https://www.schoolofhaskell.com/school/starting-with-
haskell/basics-of-haskell)

------
buddhiajuke
Milewski has the best video lectures on category theory that I know of.

Thanks for your contributions, Bartosz!

------
bobbyz
My university teaches the intro CS course in Racket (lisp), and I know another
that teaches in Haskell. If decades of priority exposure to young programmers
is not enough to spur widespread adoption, then I'm not hopeful.

~~~
rowanG077
I think most programmers aren't actually coming from university currently.

~~~
grogenaut
I did my interpreter class in Scheme in university. The main thing it taught
me was I never wanted to use scheme (or lisp) and put me off of functional
programming for many years.

I re-did the interpreter from that class in C++ and it made insanely more
sense to me than the scheme version. I could see where scheme was going and
why it was a good fit but just hated it.

That same professor taught our C++ class (while learning it, they had someone
quit) the next semester and they had to actually do a do-over he was so bad at
C++. To his credit he knew as much half way through the semester (he had
students getting ahead of him). He basically nop'd out of C++ like I did out
of Scheme. It just didn't fit his brain.

~~~
mateioprea
We learned Scheme, Haskell, Prolog and Clips in one semester for Programming
Paradigms course.

I can still remember the homework for each programming language (this was 6
years ago):

\- Something with genetic algorithms in Scheme

\- 2048 implementation in Haskell

\- Searching in an infinite space in Prolog

\- Phutball in Clips

Pretty dope if you ask me. :)

~~~
grogenaut
Glad it was good for you. It was not for me.

~~~
agumonkey
It's interesting to have intense negative reactions to a language. Could you
give details what annoyed you with scheme ?

I hope it goes beside the syntax.

~~~
grogenaut
Many people who like scheme and functional languages have an averse reaction
to more procedural or OOP languages. It's interesting that people don't grok
it can go the other way. But this is HN so I guess I'll explain.

A few things (and for context this was 1996).

With the class I disliked they were trying to teach me a language and a
complex concept at the same time. In a 4 month semester, half of it was spent
just getting basically proficient in the language. So instead of learning one
concept I'm learning 2. We were essentially using scheme to build a
interpreter for a simplified scheme. I understand why we were implementing
scheme, it's one of the simplest languages to implement and maps well to many
concepts in CS. this is actually why the game studio I worked at used it, not
that it was the right language, in fact it's caused a lot of trouble and they
have a lot of c/python like in the language now

Scheme seemed like a pretty useless language as well. The book for it listed
(in the forward) out how amazing it was and showed all the amazing projects
done with lisp-like languages. That list started with emacs and then the rest
was academic things I'd never heard of, which seemed like a joke. If I recall
scheme had some pretty weak language library functions at the time as well.
Also at the time I cared about drawing triangles on the screen.

[I will lose points for this but it's my POV] I tend to find people who
strongly like functional languages a bit insufferable, especially academics. I
tend to learn by getting a real world project done, and I like tools that let
you build real world things. I don't care anywhere near as much about form of
the solution. . Functional languages seem to gel better with people who care
about the beauty of a simple proof. I hate proofs. Also in much of the work
I've done, the folks who really pushed for functional languages didn't really
understand that most of their coworkers were juts not capable of understanding
those languages or thinking that logically. There's a reason (imho) that
they're not as popular of languages.

I have written stuff in these languages since then. I did work in the (gp
reference) scripting language and on its implementation in the engine. This
got me real features (like a mission in an AAA game, and features for my
mission designers in the engine). This seemed useful to me.

I spent about 3 months trying to use Clojure to do a highly parallel data
processing work. It seemed to map well to the problem. However it was
insufferably slow, and with required type hinting was essentially complicated
java (lost the benefit). I re-wrote it in C++ in about a week and brought the
processing time from 15 minutes to 32 seconds by leveraging the deeper parts
of the machine (buffers, disk cache, physical cores) which were not as
available inside the abstraction.

So it also comes down to I haven't found a problem that maps well to something
like scheme that I need to solve. When I do stuff with interpreters I just
grab ANTLR and java/go/c++. This is more maintainable for everyone I work
with.

~~~
agumonkey
I think some points are unfair. I have physical anger when I use java prior 8,
but I do appreciate smalltalk a lot more, it tickles my sense of curiosity,
joy.

While I do admit that lisp/scheme/fp seek beauty.. it's also one thing I want
in coding. Beautiful code. Not at the expense of practicality.. but still,
look at how easy it is to be confused and make a mess trying to write a
flatmap like procedure, while in lisp it's so trivial you never even think
about it.

Thanks for the honesty and good job on making things fast.

~~~
grogenaut
Oh I never said it's fair, just laying it out there for you to take however
you wish. It's pretty obvious to me I've got an inherent bias towards
functional programming. I see people who love it and are successful with it so
it obviously works. I've never had cause to work it out though. Just like I
never owned a Sega Saturn nor a X-Box One. It's my personal opinion and
thoughts on a language. You don't have to agree with it! In fact I'm very sure
you don't. But for every preferential opinion you have, someone else will have
a different one.

For flatmap, looked up
[https://rosettacode.org/wiki/Flatten_a_list#Common_Lisp](https://rosettacode.org/wiki/Flatten_a_list#Common_Lisp),
this is just gibberish to me currently. Is this simple, or am I missing
something?

I once had an discussion with someone who was a huge relational guy who could
not understand dynamo (many have this issue). I asked him how to do a global
postal address in a relational db. He proceeded to put out a ~5 table layout
on the whiteboard from memory. Finished by saying of course there are other
situations and you can handle them with X or Y. We went and grabbed a drink
and I had him grab get a sde1 and explain that layout to the SDE1. I cut it
off after 15 minutes. While it was OBVIOUS to him in his experience, it was in
no way simple and the SDE1 (who was just starting multi-table joins) was
taking a while to catch up. The sr eng was just used to relational. The model
he had on the board was at least 30 years of iteration and best practices,
practically it's own microservice. I drew it in dynamo where it's just
PK:UserId, and then a bunch of optional columns. SDE1 grokked this right away.

I would love to know what types of apps / code / work you do that you really
appreciate in lisp. As I said I'm always looking for a language to solve a
problem. What class of applications do you use it for?

For instance I use C++ when I need to be near the metal (game engines,
shaders, arduino). We use go at work but Scheme or Clojure might be better for
the business logic we do (tho it'd be slower). Always wanted to use Erlang but
I never got on the distributed chat program projects (I killed 2 acutally).

~~~
agumonkey
Wow if you consider flatten gibberish I have nothing to say to you that can
convince you..

Talking about bare metal and video games, take a peek at
[https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp](https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp)

Mind you this guys are far above average, but you can't get more perf + low
level than this.

I think in time you'll realize how nice other paradigms can be, even if they
look alien for quite some time.

------
somewhereoutth
Would it not be great if instead of a programming language being handed down
to us as if made of stone, it was seen as a particular expression of a set of
ideas (some good, some bad), much as music is, that we could relate and
respond to in the same spirit?

~~~
doomjunky
The programming course at my university taught us the fundamental paradigmens.
The languages were chosen only as examples.

Imperativ / OOP => Java

Functional => Haskell

Logic => Prolgo

------
doomjunky
Haskell is actually very easy.

This is just my heuristic but Haskell has just 25 keywords. For comparison: C
32, Java 53, C++ 83 and C# 102. What makes Haskell confusing are the 115 GHC
language extensions. Each is basically a new concept to learn. Every time i
join a new and sufficiently large project, I stumble across an extension that
I am not familiar with.

[https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html)

~~~
tome
Often extensions make the language _easier_ to understand, by removing
arbitrary restrictions that you wouldn't have expected to be there in the
first place.

------
mateioprea
I also recommend [http://learnyouahaskell.com/](http://learnyouahaskell.com/).
Super cool and easy to understand

~~~
chillee
I think that a lot of people find that LYAH makes you _feel_ like you're
learning, but have difficulty actually applying/using the concepts. This is
compounded by the lack of exercises.

I definitely agree with this review: [https://bitemyapp.com/blog/functional-
education/](https://bitemyapp.com/blog/functional-education/)

> The material often bores learners and leaves them feeling like they're not
> "getting" it. This is because they're being "talked at" and demo'd to.
> They're not engaging with and solving problems.

