4 ms·

If you enjoyed this paper than I highly encourage you to read Wadler's 'Why calculating is better than scheming' where in he critiques SICP for it's choice of u

If you enjoyed this paper than I highly encourage you to read Wadler's 'Why calculating is better than scheming' where in he critiques SICP for it's choice of using Scheme, arguing that Miranda would have been a better language to go with. https://www.cs.kent.ac.uk/people/staff/dat/miranda/wadler87.pdf https://www.cs.kent.ac.uk/people/staff/dat/miranda/wadler87....

Jtsummers 9y ago
Interesting, I've read this before but it connects to some things I've been thinking about and discussing with people recently. A comment I made earlier today was about the value of static/expressive type systems, and how that can let you quickly go from specification -> code. My point being the relatively short semantic distance between many specification languages and the type systems in Ada/Haskell/others. You get a similar effect in connecting between intent and code when using a more algebraic language versus the Algol-lineage and Lisp-lineage languages. You reduce the semantic distance (especially paired with a good type system from above) from your specification to your executable code.
- dmix 9y ago
  I agree in terms of pure utility that that makes a lot of sense. You basically spec it out via setting up types. But in the context on SICP I'm not sure that would be ideal. As that book is about teaching 101 programming by introducing you to the idea of black box abstraction and building a program through layers of abstraction. Starting with types would be an entirely different approach to go at it. So personally, in my ideal university, I'd prefer to learn Scheme/LISP as the 101 course introduction to programming and learn a Haskell-esque language the following term and thereafter. Although that being said, I used a practical language as my introduction to programming (Ruby) before diving into SICP - which really taught me programming. So maybe it's worth going with practical first, then diving into the theoretical underpinning so you fully appreciate and grasp what you are doing.

Jtsummers 9y ago

Interesting, I've read this before but it connects to some things I've been thinking about and discussing with people recently. A comment I made earlier today was about the value of static/expressive type systems, and how that can let you quickly go from specification -> code. My point being the relatively short semantic distance between many specification languages and the type systems in Ada/Haskell/others. You get a similar effect in connecting between intent and code when using a more algebraic language versus the Algol-lineage and Lisp-lineage languages. You reduce the semantic distance (especially paired with a good type system from above) from your specification to your executable code.

dmix 9y ago
I agree in terms of pure utility that that makes a lot of sense. You basically spec it out via setting up types. But in the context on SICP I'm not sure that would be ideal. As that book is about teaching 101 programming by introducing you to the idea of black box abstraction and building a program through layers of abstraction. Starting with types would be an entirely different approach to go at it. So personally, in my ideal university, I'd prefer to learn Scheme/LISP as the 101 course introduction to programming and learn a Haskell-esque language the following term and thereafter. Although that being said, I used a practical language as my introduction to programming (Ruby) before diving into SICP - which really taught me programming. So maybe it's worth going with practical first, then diving into the theoretical underpinning so you fully appreciate and grasp what you are doing.