From Commodore 64 to the Cloud — Lessons from 30 years of programming
2 likes•873 views
The document outlines key programming lessons learned over 30 years, from early coding practices on platforms like Commodore 64 to contemporary concepts like cloud computing and distributed systems. It highlights the evolution of programming languages and methodologies, emphasizing the importance of modules, macros, and dependently typed programming. Additional insights include handling failures in systems design and the role of efficient I/O in modern programming environments.
From Commodore 64 to the Cloud — Lessons from 30 years of programming
- 1. From Commodore 64 to the Cloud Lessons from 30 years of programming
- 2. Early 1980s • Dick Smith Wizzard • Commodore 64 • BASIC, peek/poke, machine code, assembly, graphics, games, electronic music, compilers.
- 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. Late 1980s / Early 1990s • QUT • Modula-2 > Pascal • VAX/VMS DCL • Unix & C • Gardens Point Beers Club
- 5. Lesson - Modules are important Modula-2 modules are simple but useful. Sooo much better than C “header files” and preprocessor directives!
- 6. Lesson Beer kills brain cells and lowers grades :)
- 8. Lesson - Macros Macros are very useful for building extensible languages
- 9. Lesson - Continuations Scheme’s first-class continuations tickle your brain TODO: Read Oleg on why delimited continuations are the thing
- 10. Mid 2000s Xavier Leroy on compilers, Caml Light, Caml, Objective Caml, OCaml
- 11. Lesson - High-level Programming Languages can be very efficient i.e. OCaml is fast but nag them about multicore ;)
- 12. Lesson - Pattern Matching Algebraic datatypes are great for compilers
- 13. Lesson - Macros in ML family languages camlp4 shows that macros aren’t just for Lispers
- 14. Lesson - Better Modules Modula-2 modules are great and simple. ML modules have yet to be improved upon (but check out MixML).
- 15. Late 2000s Haskell, Laziness, Template Haskell
- 16. Lesson - Laziness for Modularity John Hughes on “Why FP” is “Why Laziness”
- 17. Lesson - ad-hoc overloading Can use type classes for CLOS style ad-hoc overloading
- 18. Early 2010s • Proofs are programs • Coq, Agda, Epigram, Idris, Cayenne, Ur • Inductive datatypes • Dependent types • Module Systems
- 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. Cloud (aka “Cloud”) i.e. Distributed Systems, Software Defined Infrastructure
- 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. 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. Questions?