notes-computer-programming-programmingLanguageDesign-prosAndCons-martinTheLastProgrammingLanguage

notes on -- https://docs.google.com/file/d/0B7ZmlZgOfG3KUkpWQVpud0N2dWs/edit CleanCode?-E0-TheLastProgrammingLanguage?-540p.mp4 :

"we still write sequence statements, selection statements, iteration statements, assignment, if and while"

dijkstra encouraged the structured programming paradigm in "goto considered harmful", encouraging people to only use sequence statements, selection statements (e.g. if), iteration statements (e.g. while), partially because he wanted to prove the correctness of algorithms and he noticed it was hard to prove things if goto is allowed, but tractable if only sequencing, selection, and iteration are allowed. later people found that even if we aren't doing proofs, the same thing that makes things easier to prove makes things easier to understand. discipline imposed on goto, on direct transfer of control.

OOP is basically polymorphism

OOP is discipline on indirect transfer of control; e.g. you could do polymorphism in C but C++ hides all the stuff with function pointers in the vtable from you with its syntax. What you get in return for this discipline is the ability to have dependencies in the source code flow in the opposite direction to the flow of control.

the functional paradigm is old but is becoming more important because of increasing parallelism, so we are looking for paradigms that are robust to concurrency.

the functional paradigm is discipline imposed on assignment. we can initialize variables but we can't re-assign to them again. sometimes we allow ourselves to assign but only with a lot of discipline, e.g. using transactional memory

SICP doesn't give you an assignment statement until you're halfway thru, and then they apologize for it. if you want to understand the functional paradigm, read that book.

so note that all of these paradigms are constraints, not additions, to expressiveness in programming

in this sense multiparadigm languages are not any paradigm, because they let you do anything (no constraints)

AOP adds expressiveness, rather than constraining it. and it failed.

he's skeptical that we'll see any more paradigms

why dont graphical programming languages take off? maybe b/c time is linear/1-D

the last big syntax revolution was prolog or fourth

his criteria for a language:

• VM
• light syntax (like lisp, smalltalk, or fourth)
• polymorphism
• OOP (no jumping to function pointers) + structured programming (no goto) + functional (no assignments)
• should be able to interoperate with other languages and libraries in other languages well, esp. JVM and .NET (e.g. ruby, python, clojure)
• garbage collected
• fast
• high level (e.g. you shouldn't know how many bits are in an integer; C is too close to the metal, smalltalk, clojure and ruby are not)
• textual, not graphical
• homeoiconic (lisps have this)
• dynamically change the language while its running (lisp, ruby and java)
• problems with C: not garbage collected, polymorphism is possible but too hard, no VM, cannot modify it while it's running, not homeoiconic
• problems with C++: same problems as C, and way too much syntax
• problems with Java: not functional, a little syntax heavy
• problems with C#: same as Java

--

other criteria that many people demand that he omits:

• static typing
  • various criteria about the expressivness of static typing, e.g.:
  • generics
• true multithreading (e.g. no GIL)