From Commodore 64 to the Cloud — Lessons from 30 years of programming


Published on

Lessons about programming, programming languages, distributed systems, and operating systems from the perspective of a professional programmer with 30 years of programming experience.

Published in: Technology
  • Be the first to comment

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

From Commodore 64 to the Cloud — Lessons from 30 years of programming

  1. 1. From Commodore 64 to the Cloud Lessons from 30 years of programming
  2. 2. Early 1980s • Dick Smith Wizzard • Commodore 64 • BASIC, peek/poke, machine code, assembly, graphics, games, electronic music, compilers.
  3. 3. Lesson - Fun! Tell your kids to program games in JavaScript with HTML5/Canvas/WebGL but ensure they understand that JavaScript is a low-level assembly language of modern machines
  4. 4. Late 1980s / Early 1990s • QUT • Modula-2 > Pascal • VAX/VMS DCL • Unix & C • Gardens Point Beers Club
  5. 5. Lesson - Modules are important Modula-2 modules are simple but useful. Sooo much better than C “header files” and preprocessor directives!
  6. 6. Lesson Beer kills brain cells and lowers grades :)
  7. 7. Early 2000s Python Ruby Smalltalk Scheme Common Lisp Scheme Dylan
  8. 8. Lesson - Macros Macros are very useful for building extensible languages
  9. 9. Lesson - Continuations Scheme’s first-class continuations tickle your brain TODO: Read Oleg on why delimited continuations are the thing
  10. 10. Mid 2000s Xavier Leroy on compilers, Caml Light, Caml, Objective Caml, OCaml
  11. 11. Lesson - High-level Programming Languages can be very efficient i.e. OCaml is fast but nag them about multicore ;)
  12. 12. Lesson - Pattern Matching Algebraic datatypes are great for compilers
  13. 13. Lesson - Macros in ML family languages camlp4 shows that macros aren’t just for Lispers
  14. 14. Lesson - Better Modules Modula-2 modules are great and simple. ML modules have yet to be improved upon (but check out MixML).
  15. 15. Late 2000s Haskell, Laziness, Template Haskell
  16. 16. Lesson - Laziness for Modularity John Hughes on “Why FP” is “Why Laziness”
  17. 17. Lesson - ad-hoc overloading Can use type classes for CLOS style ad-hoc overloading
  18. 18. Early 2010s • Proofs are programs • Coq, Agda, Epigram, Idris, Cayenne, Ur • Inductive datatypes • Dependent types • Module Systems
  19. 19. Lesson - The future of programming is dependently typed • No longer need to statically analyse (aka infer or guess) the properties of your programs. Instead state them. • TDD: Test Driven Development → Type Driven Development. • Manuel Chakravarty calls for Property Driven Development. Yes, that would be mathematical properties.
  20. 20. Cloud (aka “Cloud”) i.e. Distributed Systems, Software Defined Infrastructure
  21. 21. Lesson - Reduce network hops • A key lesson from distributed computing. • Also applies to optimising the user-space to kernel-space interactions. Consider how the c10k problem is solved with libevent, libuv, NIO/NIO.2, over epoll, kqueue, AIO etc. This kind of efficient I/O system is baked into the runtime systems of Erlang, Haskell (via the Glorious GHC), Go, Rust, Java, Scala ε̷ Node.js. • Single address-space Operating Systems help solve a similar problem when switching between threads/processes after a time-slice. • L4 microkernel implements efficient inter-process message passing using hardware memory remapping techniques. • Operating Systems as libraries (aka exokernels): • Mirage is OCaml on virtual metal • HaLVM is Haskell (via the Glorious GHC) on virtual metal
  22. 22. Lesson - Everything fails, deal with it! … and everything will be fine 😃 These may help: • replicas and redundancy • app containers and PaaS, Docker, Kubernetes • Raft, Zookeeper, etcd • Erlang OTP
  23. 23. Questions?