Simon Peyton-Jones: Escape from the ivory tower: the Haskell journey 

😂

Think I that's hilarious as well as being I the 69th like.

It occurred to me that the title might be deliberately chosen...fits well as a British humor

It gets worse! Before he even starts introducing Simon, there's a long segment about dinner arrangements, featuring all sorts of Oxbridge-isms. Great talk though.

how else are you gonna escape the ivory tower if you didn't set it up first?

Exactly

@@ianb7400 brother

Try: hello = "Hello World" hello

That code won't do anything. You want something like main = putStrLn "Hello World!"

Don't forget the type signature: main :: IO () main = putStrLn "Hello World!" (you may omit it if you want, but it is considered bad practice)

IO is learned a lot later in Haskell than other languages

It's one of the cleanest and easiest thing out of any languages. It's literary three words: print "hello world". So, if you're running it from shell, then and want to test it interactively, then: > ghci print "hello world" If you want to compile a file: # This writes 'main = print "hello world"' to a file. > echo 'main = print ""hello world" ' >> myFirstProgram.hs # This compiles the file > ghc myFirstProgram.hs # This runs the program > ./myFirstProgram hello world Writing IO in Haskell is very easy, way easier in fact than in most other languages if you don't bother understand abstractions about how it works (1). Easier because a) IO for concurrency and parallelism just works, while in other languages you'll quickly find yourself in trouble and having to transform most of your code b) there are abstractions that make it easier to reason about doing IO safely, like doing it in constant memory or making sure that all resources are released. (1): You don't, for example, go through Python internals to understand how it deals with the code you wrote. But in Haskell most things are actually implemented as abstractions and written in the language itself, rather than baked into some internals. You can actually not import `+` and `-` because even they are implemented in the language instead of being baked in. So you have that choice to go and read, and understand how anything is implemented, including how IO is done by checking the IO monad. Unlike looking at some compiler code where you would quickly be scared to do it, it will look not bulky or complex, but look elegant enough to be tempting to try and understand it. So people are tempted to learn everything and they get lost. It would be the same way if they were to try to understand how Python or C compiler works instead of just writing their apps using simple things they learned. Most languages don't give you the freedom to implement some abstraction that you want. You just write code using simple principles, and are fine for it sometimes getting a bit verbose. But in Haskell you have a choice to write very elegant code, so you can immediately get lost in abstractions and instead of writing useful code, get lost in trying to optimize everything and trying to implement a perfect abstraction for your code, whereas in other languages you would just bruteforce a verbose, potentially unsafe, solution, and go on living your life. This is the source for the myth that Haskell has a steep learning curve. It mostly (2) doesn't and it's pretty simple to write programs in it. But you can do the same thing in so many ways that if you want to learn how to do it in the best way, then you'll quickly find yourself learning infinitely many things, things that you would never learn because they are simply not possible in other languages. A simple list transformation can take you down a rabit hole if you want to "make it perfect" by putting length of the list as a type. But in other language you just wouldn't do it. You would just be fine with lists failing at runtime if somebody constructed a list with the wrong length. (2) One thing where it is indeed can be unavoidably difficult for beginners is if they come from objective or imperative programming and they got used to using mutation in their code by using `for` and `while` loops. It's still pretty easy to do the same thing in Haskell when using IO if you so desire, but it's rarely done in practice and thus you will not know how to do it in the beginning (and for right reasons) and you'll quickly have to adapt to use recursion. fold, and map, instead. This is one area where Haskell indeed forces you to learn how to do it its way from the very begging and you actually have to learn a couple of things before writing things you want. However, you have already written pure code before in the past in other languages, then it will look pretty familiar.

What do you mean? Forty six thousand people stopped in to listen to this talk.

I just demonstrated what a side effect is by clicking on the dislike button. :-)

Matlab is the language of gods.

Not on this RU-vid record though. )

The teaching approaches presented at media.ccc.de/v/35c3-9800-how_to_teach_programming_to_your_loved_ones do introduce a functional language as the first one and seem quite promising.

I've just started checking out FP and I was really thinking, I would have got this really easily when I was a teenager and now I am like wtf

@@zTJq40sl Developing software with the focus on what to do instead of how to do it will eventually become mainstream, it's inevitable. JavaScript gains more and more functional characteristics which is a really good sign.

If i were a freshman in CS and theyh tried to foist a functional langusge on me, I would refuse to learn it and hand in all my assignments in Python or Go or C or Pascal, even - anything but a functional language.

Because in a functional machine every variable has to be constantly passed over the stack. If you make a change to a variable, then there are two copies on the stack, the old value and the new value until the calling function overwrites the old value that's buried deeper on the stack and so on, until you are down on the lowest level. Now, if your called function throws an exception, then your stack is shot and you don't know which of the values on the stack (which you can't even retrieve easily because you don't know where they are) is valid. In other words, your global state is unrecoverable after every exception. This is not the case in machines that keep the state on the heap.

He said "Intel won". I assume a special FP microprocessor would have the need for its own instruction set and programming model. The cost per item of things like microprocessors goes down by a lot with the amount of items that are produced. So if there are only a few FP system users, the cost per machine becomes too high and it makes more sense to adapt to the mainstream architecture.

His remark about linear types at about 1:02:50 is relevant to that.

dawei liu import Data.Function first

hahahaha I actually had to check wether I had inherited the x1.5 speed from some previous video, and actually changed it to x0.75 and then x1 just to be sure :P

I guess I am a bit too late, but he later mentions it, as System F, which is polymorphic lambda calculus. According to my understanding this is exactly what flambda is.

Phil ipp me

me!

me too

Count me in!

White and mostly male? Majority still look like that.

Watched this at 1.25x being a non-native, on the contrary - he has a pretty clean pronunciation

@@user-tk2jy8xr8b hahaha. Good for you if you can follow at x1.25. Me, I will even miss his gestures at that rate 😁.

What’s wrong with Hoogle?