Hacker Cinema
Erlang: The Movie
1990 · Film · short · 12 min
From: mike@erix.ericsson.se (Mike Williams) To: erlang-questions@erlang.org [...] As one of the main "actors" in "Erlang the Movie", I absolutely and categorically forbid its showing *anywhere*. If there was a competition for "turkey" short movies, I think we would win hands down. So, please, please, please, forget we made that retched film in 1990!
14 positive8 neutralfrom 22 commenters
Where to watch
No streaming data for this title.
Videos commenters linked
From YouTube links in the comments below. Most are clips and trailers; “Full” means the uploader says so.
24 comments on Hacker News
It isn't entirely true though. The original Erlang guys made Erlang: The Movie https://www.youtube.com/watch?v=xrIjfIjssLE and the sadly missed Joe Armstong made plenty of blog posts https://joearms.github.io/ and public appearances and expressed a number of strong opinions (though genially) https://www.youtube.com/watch?v=lKXe3HUG2l4 . Robert Virding's public profile is not as high, but he's by no means in hiding either. https://www.youtube.com/watch?v=naTisAcey5Q — or indeed https://news.ycombinator.com/user?id=rvirding )
If we to wedge how Erlang does hot code swapping into a container metaphor, then to get what Erlang does, you'd need to have a container per function call.
Given that it would be absurdly wasteful to use OS processes in containers to clone Erlang's code reload system, AnotherGoodName might take ten minute to watch Erlang: The Movie to get a better sense of the capabilities of that system. The movie is available from many places, including archive.org.
The talking on the phone bit at the beginning reminds me of Erlang, The Movie: https://youtu.be/xrIjfIjssLE?t=205
Erlang: The Movie shows how it's done (RIP Joe Armstrong): https://www.youtube.com/watch?v=xrIjfIjssLE
This is almost certainly a reference to Erlang: The Movie [1] which is the most glorious 11 minutes of some programmers explaining how their creation works you will ever see. In the video, the three call each other to demonstrate what happens real-time in an Erlang system. For the impatient, the telephone conversation starts at about minute 3.
[1]: https://www.youtube.com/watch?v=BXmOlCy0oBM
Just in case anyone hasn't seen the old classic, Erlang: The Movie
https://www.youtube.com/watch?v=uKfKtXYLG78
It doesn't provide much detail but "Erlang: The Movie" is definitely worth a watch. It's only 10 minutes long, made by the creators, and is very 80s.
At least we have this "Erlang: The Movie" demo to reverse engineer some bits: https://m.youtube.com/watch?v=BXmOlCy0oBM
Spawning a process for each call / endpoint is how almost every large phone switchboard does it. See also: Erlang The Movie:
https://www.youtube.com/watch?v=uKfKtXYLG78
> Erlang can even do a harder thing, which is update the code handling a given socket connection or something live, in a principled manner, while never dropping the connection.
That's what I meant. :) Hot reloading when nothing is "in flight" isn't so hard. The Erlang the Movie example, hot-fixing a PBX without disturbing phone calls in progress (real time requirements!), is really hard.
Fred probably forgot to mention it, but Joe, Mike, and Robert starred in a short film Erlang: The Movie, a very fine and concise demonstration of fault-tolerance of Erlang.
The film has some magic power that I cannot describe but made me watching it over and over again.
YouTube link to the film with fixed audio: https://www.youtube.com/watch?v=BXmOlCy0oBM
I only recently came across his Twitter account and started following him (he had some interesting ideas about and experiments with TiddlyWiki). He seemed like a passionate and enthusiastic technology lover, which was a good enough reason to follow him.
And it is only just a few minutes ago that I discovered that Joe is the guy with the moustache from the famous Erlang: The Movie video…. I had not pieced those two things together.
So I knew nothing about his history, just one little thing he was working on/interested in. That may make me seem ignorant, but I share this because it goes to show that the light that shines in people like Joe was a genuine light of curiosity and sharing. Bright enough to attract people like me.
I first learnt about Joe from this music video (based on Erlang: The Movie, I believe): https://www.youtube.com/watch?v=p1LjmDCOM-8
Afterwards looked up talks by him and was fascinated by Erlang, sad to see him pass away.
Lol, this reminds me of Erlang: The Movie
https://www.youtube.com/watch?v=xrIjfIjssLE
It is not that common. Erlang has a famous one "erlang the movie". This one feels more like a hat tip to the awesome erlang one.
I use Erlang the Movie and its Sequel https://www.youtube.com/watch?v=rRbY3TMUcgQ&t=9s whenever I teach my classes at Oxford Uni. #studentlife :-)
I had never watched Erlang the Movie before, this is truly a gem:
https://www.youtube.com/watch?v=uKfKtXYLG78
This is a great way to explain the benefits of Erlang. Anyone who has tried to write robust, distributed systems should immediately see the benefits. Even all of these years later.
It is one of the core features of Erlang (a language developed by Ericsson), being able to rewrite code in production, with errors/crashes that break one thread not affecting another.
Obligatory link to Erlang: The Movie (10min)- https://www.youtube.com/watch?v=xrIjfIjssLE
Note that they start crashing things in Erlang around minute 7, and fix them shortly thereafter. Meanwhile, their setup keeps calls that weren't directly involved in the crash alive and running unaffected.
Virding's First Rule of Programming:
Any sufficiently complicated concurrent program in another language contains an ad hoc informally-specified bug-ridden slow implementation of half of Erlang.
https://rvirding.blogspot.com/2008/01/virdings-first-rule-of-programming.html
(he is one of the creators of erlang / stars in Erlang the Movie)
I discovered Erlang in the late 2000s via its kinda weird and iconic video "Erlang the Movie" https://www.youtube.com/watch?v=xrIjfIjssLE that prompted me to dig further. I was at the time an average developer. Erlang, and Joe Armstrong books and videos, made me understand things that other web-oriented languages ( Ruby, PHP... ) never really dug into at the time. Because the Erlang ecosystem is more than distribution. Distribution is a consequence of its design around concurrency and message passing and let-it-crash/auto-healing philosophy. Erlang, and after that Elixir, made me think differently about code and made me a better programmer.
The author doesn't talk a lot about preemptive scheduling, which is probably the best thing about the Erlang virtual machine. This video explains what preemptive scheduling is and why it is extremely useful: https://www.youtube.com/watch?v=5SbWapbXhKo
First, the speaker creates an application endpoint that runs into an infinite loop on invalid input. Then, he shows how that doesn't block the rest of the requests. Using native BEAM (EDIT: BEAM = EVM = Erlang Virtual Machine) tools, he looks for the misbehaving process (the one running the infinite loop), prints some debug information and kills it. It's pretty impressive.
Another great (and lighter) resource, is "Erlang the Movie" (https://www.youtube.com/watch?v=xrIjfIjssLE). It shows the power of concurrency through independent processes, the default debug tools, and the power of hot code reloading. Don't miss the twist at the end.
Not a book but you should definitely watch Erlang the movie. It's on YouTube. Then watch erlang the movie 2, it's hilarious.
The original “Erlang: The Movie” https://www.youtube.com/watch?v=xrIjfIjssLE (with a good demonstration of what a reliability means)
And if you haven't seen it, here is some classic. “Erlang: the Movie”:
— http://www.youtube.com/watch?v=xrIjfIjssLE
And sequel “Erlang: the Movie II”:
— http://www.youtube.com/watch?v=rRbY3TMUcgQ
Don't think wtf. Just watch.