[Edu-sig] trails through the ecosystem: language sequence

[Mark Engelberg]

On Sun, Jul 26, 2015 at 1:36 PM, kirby urner <kirby.urner at gmail.com> wrote:

> I'd say:  leverage your Python to tackle a second
> OO language: Java (not JavaScript yet).  Then
> leverage your Java, which need not be super
> polished, to tackle Clojure.  That'll be a first
> LISP-family language and will start to formalize
> ground covered, making the concepts more
> clear.  Pick up concurrency concepts here.
>
>
I think there are a lot of good paths, and I see the logic of what you
propose.  But as someone who uses both Clojure and Python, I'd like to
remind you that Clojure introduces far more novelty than just the
concurrency constructs.  The biggest difference is that all the fundamental
data structures are immutable, which lends itself to a rather elegant
programming style that in most languages is only available for numbers and
maybe strings.  Once you embrace this, it really changes the way you code,
and going back to a programming language that doesn't support immutable
data well can feel painful.



> Finally:  back to Python i.e. take what you've
> learned on this circle tour to move into concurrency
> with Python if you wish, and with new fondness
> for a LISPish mindset.
>

Yeah, as I point out above, in my experience most students don't want to go
back to Python once they've embraced Clojure's way of doing things, because
they can't employ those techniques well in Python.  Also, Clojure is fairly
opinionated about being anti-OO (at least, in the sense of the way people
usually think about OO).  So once you've drunk that Koolade, OO starts to
feel kind of clunky and limiting as a way to organize programs.  But that's
probably a good thing. Even among mainstream programmers, OO is "on the way
out", getting replaced by things like component entity systems,
inheritance-less interfaces, traits, multimethods, etc.



>
>
> Python first
> Bridge to Java
> Tackle concurrency in Clojure (runs on JVM)
> back to Python, add more layers and polish
>

Right.  My path for students looks more like:
Racket first
Bridge to Python and/or Java as a way to understand mainstream languages
and paradigms and gain the ability to interact with the vast majority of
code out there.  With these three languages under their belt, they can
probably read and write code in most languages reasonably well.
Clojure as a language that fuses this all together: functional goodness
similar to, and in some respects better than Racket, interoperation with
Java and Javascript ecosystems.

Other languages worth "dipping one's toe into" could be:
C++ for low-level programming
Javascript for mainstream client-side web programming
Haskell for pure functional
Scala for a functional/OO hybrid with an intricate type system and a robust
dataflow
ML to understand the style of pattern matching over abstract data types
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20150730/d5f34754/attachment.html>