0
From Commodore 64
to the Cloud
Lessons from 30 years of programming
Early 1980s
• Dick Smith Wizzard
• Commodore 64
• BASIC, peek/poke, machine
code, assembly, graphics,
games, electronic mu...
Lesson - Fun!
Tell your kids to program games in JavaScript with
HTML5/Canvas/WebGL
but ensure they understand that JavaSc...
Late 1980s / Early 1990s
• QUT
• Modula-2 > Pascal
• VAX/VMS DCL
• Unix & C
• Gardens Point Beers
Club
Lesson - Modules are
important
Modula-2 modules are simple but useful. Sooo much
better than C “header files” and preproces...
Lesson
Beer kills brain cells and lowers grades :)
Early 2000s
Python
Ruby
Smalltalk
Scheme
Common Lisp
Scheme
Dylan
Lesson - Macros
Macros are very useful for building extensible languages
Lesson -
Continuations
Scheme’s first-class continuations tickle your brain
TODO: Read Oleg on why delimited continuations ...
Mid 2000s
Xavier Leroy on compilers, Caml Light, Caml, Objective
Caml, OCaml
Lesson - High-level
Programming Languages
can be very efficient
i.e. OCaml is fast
but nag them about multicore ;)
Lesson - Pattern
Matching
Algebraic datatypes are great for compilers
Lesson - Macros in ML
family languages
camlp4 shows that macros aren’t just for Lispers
Lesson - Better
Modules
Modula-2 modules are great and simple. ML modules
have yet to be improved upon (but check out MixM...
Late 2000s
Haskell, Laziness, Template Haskell
Lesson - Laziness for
Modularity
John Hughes on “Why FP” is “Why Laziness”
Lesson - ad-hoc
overloading
Can use type classes for CLOS style ad-hoc overloading
Early 2010s
• Proofs are programs
• Coq, Agda, Epigram, Idris,
Cayenne, Ur
• Inductive datatypes
• Dependent types
• Modul...
Lesson - The future of
programming is
dependently typed
• No longer need to statically analyse (aka infer or guess) the pr...
Cloud
(aka “Cloud”)
i.e. Distributed Systems, Software Defined Infrastructure
Lesson - Reduce
network hops
• A key lesson from distributed computing.
• Also applies to optimising the user-space to ker...
Lesson - Everything
fails, deal with it!
… and everything will be fine 😃
These may help:
• replicas and redundancy
• app co...
Questions?
Upcoming SlideShare
Loading in...5
×

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

286

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
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
286
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
1
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Transcript of "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?
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×