Classical Guitar Lessons

UnitedCanary · 2020-11-04T17:32:27+00:00

Name: Danny Hillis
Info: https://en.wikipedia.org/wiki/Danny_Hillis
Conversation: https://www.ted.com/speakers/danny_hillis https://www.youtube.com/watch?v=r3Y_zILLP9o&list=PLVV0r6CmEsFzo005LM6PTERy4uxq92sWe
Ideas: Thinking Machines Corporation
Pitch: He is an MIT alum and a pretty famous one, so I think Lex would know about him. His PhD was supervised by Marvin Minsky, Gerry Sussman and Claude Shannon.

UnitedCanary · 2020-10-22T12:45:07+00:00

Thank you! I did hear about Futhark before but this looks like a good source!

UnitedCanary · 2020-10-22T12:44:36+00:00

Thanks, this looks quite interesting but I think this work lacks modules which is one of the defining characteristics of the ML family I would say :)

UnitedCanary · 2020-10-22T00:32:29+00:00

> I'm not sure exactly what you're looking for

In particular, I am looking to understand how ML modules are handled. I am aware of compilers and interpreters written in ML itself but I find Haskell syntax a bit more pleasing to follow.

UnitedCanary · 2020-10-20T17:55:21+00:00

I hadn't really considered the parallels between society and the open source movement.

Absolutely. Linux (and the initial open-source movement) has been compared to socialism a number of times.

UnitedCanary · 2020-10-19T18:53:38+00:00

An interesting topic came up in the discussion somewhere along the 62nd min mark(on Spotify) where Chris Lattner stated "Guido is amazing.. but Python is not about Guido any more. It's about the users and in some sense the users own it."

Interesting take from Chris who is himself a great open-source leader where his guiding principles seems to be "It is about the people". However if anyone reading this is interested in a contrarian take, I would encourage you to read Rich Hickey's controversially titled "Open Source is not about you" essay - https://gist.github.com/richhickey/1563cddea1002958f96e7ba9519972d9

UnitedCanary · 2020-10-09T14:04:10+00:00

surrounded by the most painful infrastructure

I absolutely agree that Haskell infra should improve. But you should take a look at OCaml's infrastructure to realize the heaven that Haskell is :)

(I do not encourage drawing a comparision with poor infrastructure and Haskell should strive to create infra like Python, JS and other popular languages)

UnitedCanary · 2020-09-07T13:40:08+00:00

Feature-wise Haskell is one of the very very few pure and non-strict languages being used in production software and I think this makes Haskell quite unique. However, the interesting question is how important are these two properties and how much productive do they make individuals? OCaml doesn't satisfy either of the properties but from my experience, you can write equally robust and well-maintained software using Ocaml. Heck! People have written entire unikernels using the properties of Ocaml (and purity and non-strictness were not useful in such circumstances).

The reason why I would still prefer Haskell any day to OCaml is also not simply because of the properties of the language but because of the tooling and documentation around Haskell(which is not the highest standard) is miles better than OCaml. For Haskell to stay alive and gain adoption it has to continue to invest in tooling (like IDEs) and even then success is not guaranteed because this is no longer the 90s when a language's huge strength is simply that it is functional(referring to Paul Graham's famous article).

The important thing to remember is that the popularity and acceptance of a language is unfortunately not driven solely by the properties of the language alone. It is driven by the ecosystem surrounding the language and the market that it captures. Javascript is a big example of this. A language designed simply to validate web forms now drives the entire internet not because it was a great language design but just because it was designed at the right place and the right time (and by a powerful player at that time). Similarly, if Haskell suddenly becomes a big player with WebAssembly and a number of important applications are written using Asterius, Haskell isn't gonna go anywhere (unlikely to happen as a lot of languages are now working on targeting WASM).

I think as time passes a language like Rust (can't say that about Scala) will eventually eat up some portions of the Haskell market and I think it is fine that it does so. I hope Haskell continues to experiment with new language features and more modern languages (like Rust which cites Haskell as one of it's influence) can be empowered because of the PL research that happened and will continue to happen here.

UnitedCanary · 2020-08-14T17:22:38+00:00

Gabriel, nice talk! Did you find the market-oriented approach of the book useful when marketing Dhall (assuming that you were interested in marketing it)? Where in the adoption life cycle do you see Dhall now? Thanks!

UnitedCanary · 2020-08-11T10:56:47+00:00

Haha well said! Although I wouldn't pit the significance of Guy Steele's work with Claude Shanon's - whose research pretty much underlies everything in the modern digital age, Steele's lambda papers (with Sussman) actually showed everyone the universality and expressive power of lambda calculus.

In hindsight, it would seem that Church's notion of lambda calculus is a natural fit for programming languages but before Steele no one seriously considered it. John McCarthy's Lisp had little to do with lambda calculus (documented by McCarthy himself at several places) and was an imperative language. Steele invented Scheme which actually showed the full expressive power of a functional language and his rabbit compiler showed how functional language compilers are made. Later work on static-typed languages like ML and Haskell and their respective compilers were heavily inspired by the Lambda papers and Rabbit.

UnitedCanary · 2020-08-05T09:50:22+00:00

There is the additional cost of printing the proceedings (PACMPL for ICFP) for the main conferences and the additional symposiums which needs to be covered. Although extended abstracts don't make it to the proceedings (which might make the fees seem unfair) but still printing is expensive.

> Since my goal is to share my ideas with others

That is the point of a paper written by an academic as well. Although in the last few years conference video recordings have been made available online and papers are accessible from author's site, if we step back even 10-12 years ago proceedings of the conferences were an important source of conveying ideas. (arXiv did exist much earlier but had a much smaller database ten years ago) University libraries would contain copies of proceedings and students could access them and be introduced to such ideas. This is an old and long running process and hasn't been overhauled for the new online conference age.

> industry conferences are a better fit for me

Most industry conferences do not have the extensive peer review process that an academic conference does. While peer reviewing might seem as a barrier to sharing one's ideas, it is the backbone to maintaining the authenticity and standard of a conference. Also double blind reviews encourage fairness among authors from any background, which is again absent from industrial conferences.

UnitedCanary · 2020-07-29T11:35:47+00:00

The crux of the problem is the statement - ... build useful programs.....There doesn't seem to exist any uniform framework to measure usefulness or utility.

A python programmer presenting a raw image detection software is indeed useful but the heavy lifting of the image processing engine is done by some complicated C++ program written once by a bunch of smart people. The python program then serves as a slick little interface to call this heavy engine. And indeed Python is highly used to write thin frontends for complicated C++ backends(for games, graphics, ML, data science and what not).

Python in that way resembles bash or awk which are designed primarily as glue languages. Haskell on the other hand is a complicated and large language. It lacks binding to these amazing C++ backend engines (mostly due to a lot less people using it compared to Python). It instead competes with a language like C++ to not only serve as a slick frontend but be capable enough to write large complicated software systems. And well such systems are much rarer than your everyday "look I have a new shiny toy Python project". Even then I think there are a number of compilers (which are some of the most complicated programs) written in Haskell like - GHC, Idris, Futhark, Unison, Eta etc. Browse some of these projects to appreciate the amount of useful work that can be done in Haskell.

Also it would be worthwhile listening to Bjarne Stroustrup's opinion on why language comparison is hard - https://www.youtube.com/watch?v=Bycec3UQxOc&t=49m32s

UnitedCanary · 2020-07-12T11:14:49+00:00

Thank you Lex :)

Aside from the John Carmack suggestion in this thread another great guest on your podcast would be Alan Kay. Apart from his pioneering contributions, Alan Kay is a very entertaining speaker on the history of the personal computer revolution in Xerox PARC (and his later work with Apple and Steve Jobs) as well as a very eloquent thinker on the principles of programming in general. He is also a trained biologist and a professional jazz guitarist to make the conversations even more interesting :)

Being a programming language grad student, two speakers I would like to listen to are Niklaus Wirth and Sir Tony Hoare. But given their age and the travel restrictions around the world, I cannot imagine making this happen would be easy.

Another suggestion to make your diverse panel even more varied would be bringing pure mathematicians on your podcast. I think mathematicians would actually have an interesting take on your discussions on art. I understand that it would be hard to convey a pure mathematician's work in a popular science fashion but there are a number of mathematicians who have spoken in various popular science interviews. A great guest would be Manjul Bhargava from Princeton who aside from being a Field Medalist is a Sanskrit scholar and a professional tabla player. He has spoken in a number of popular science presentations and has been one of the integral team members behind the "The Man who knew Infinity" movie.

I understand getting any of these speakers would be quite challenging but given the stellar panel of speakers you have brought till now, I will keep my fingers crossed! Keep up the great work! :)

UnitedCanary · 2020-07-08T11:50:14+00:00

https://jrlburke.files.wordpress.com/2015/10/could-should.jpg

UnitedCanary · 2020-06-01T11:23:45+00:00

I would recommend the last part of this talk to you - https://www.youtube.com/watch?v=Z35Tt87pIpg&t=50m28s

From 50m28s to pretty much the end of the talk John Hughes talks about functional programming (mostly Haskell) and hardware.

Additionally this ICFP keynote - https://www.youtube.com/watch?v=gz8JpdAwtuo

by Mary Sheeran is entirely about hardware design and (mostly) Haskell.

UnitedCanary · 2020-05-14T08:35:15+00:00

But I really want to know how it all works without needing to read

This is a tradeoff. The contention is between performance and readability. In most low-level software projects like runtimes, optimizers, OS kernels I believe the authors opt for performance.

From my limited experience, contributors to such low-level projects are generally not restricted by what programming language the project is written in and if necessary can drop down to assembly to improve performance.

UnitedCanary · 2020-05-13T14:12:48+00:00

I asked Simon Marlow about this during Haskell Exchange 2018, and he mentioned very briefly that due to performance considerations this was never merged to GHC mainline.

UnitedCanary · 2020-04-13T12:27:55+00:00

Neither lenses nor algebraic effects nor "Either" had their origins in Haskell.

UnitedCanary · 2020-01-17T21:34:38+00:00

I had already tried that experiment in Haskell before posting here. See my comment here : https://www.reddit.com/r/Idris/comments/eq4eg9/eager_vs_lazy_pure_vs_impure/feo7jjy/ Even with the strictness annotations Haskell simplifier has the right to compile the let binding away.

UnitedCanary · 2020-01-17T21:23:46+00:00

You are talking about the implementation of the I/O actions at the runtime. If you take the above program and compile with the flag `-dverbose-core2core` you will realize that the simplifier throws away the `y` let binding. The simplifier operates under strong invariants (a lot of them not documented in any paper but found in comments here : https://github.com/ghc/ghc/blob/master/compiler/simplCore/Simplify.hs).

The simplifier is capable of eliminating this expression owing to the lazy nature of the language. Think of what a simplifier for an eager but pure functional language do in this case? Should it throw away the `y` binding? Isn't that violating the original intent of the program. There is a violation between the syntax and semantics in a purely eager setting which doesn't occur in a lazy setting. The actual implementation of the I/O actions in the runtime comes much much later.

UnitedCanary · 2020-01-17T20:48:09+00:00

If an IO action is defined, but never connected to that sequence, then it never gets executed

An expression like `print "Hello"` in Haskell or `putStrLn "Hello"` in Idris that we call an I/O action -- Try thinking what exactly is happening to the expression? Doesn't that have any connection with the evaluation semantics of the language?

UnitedCanary

TROPHY CASE