[Edu-sig] Python + JS == more than their sum()

[kirby urner]

On Sun, Nov 27, 2016 at 2:24 AM, Mark Engelberg <mark.engelberg at gmail.com>
wrote:

> I'm going to play devil's advocate and say that I don't think it is wise
> to introduce multiple programming languages until fairly late in a
> student's programming education.
>
>
Yeah, I agree you sketch a believable way in which a "many languages"
approach could also be time-wasting.  Good anthropology.

One hopes for a world in which students cater to their own appetites,
cafeteria style.  I remember being glad for the survey overview course at
Princeton, where engineering, computer science more specifically, were the
constant siren call.  This way I got hands on with APL, SNOBOL, some
virtual assembler, FORTRAN, PL/1 and who knows what all else (a voluntarily
took on whatever I could get my hands on).

"This is so cool!" I was thinking, especially the APL (Iverson: A
Programming Language -- I knew you'd know, so for other readers...).
Thanks to early exposure to APL, I was very curious about J (jsoftware.com)
later.

I'm more working backwards from the bootcamp code school economy, where you
either do full stack JavaScript, or some hybrid, with a server language
like a P language, Ruby or a lower level system type-rigid language (C#,
Java...).  I'm somewhat locked into that matrix right now and need to make
the best of it.

PDX Code Guild is Python + JS + HTML + CSS and then of course there's
persisting data with SQL / noSQL.  That's a lot to cover in a few months.
So why is (Python + JS) a viable combo again? You see where that takes me.

I want to reassure people that (Python + JS) is more than the mere sum of
the parts; new synergies will emerge.

The thought process required to compare and contrast these two languages,
appreciate their similarities, as well as their differences, is a kind of
discrimination that also helps with learning either / both.  You gain more
traction with that minimum twoness of two general purpose programming
languages (JS newly qualifies, since node at least -- let out of its
browser cage).

At the meta level, we could say, there's a generic problem of coupling
chunks of software together by passing pointers or containers or objects or
whatever metaphor.  We call them subprocedures or as in Python, "callables"
with functions and types both callable objects. Functions comprise their
own type.

When we do this, segue code, splice execution sequences, we typically think
of "arguments" getting passed, with "parameters" on the other shoreline,
all set to "match and catch" on the other side, in the territory of the
callable, the other's scope.  Then comes the problem of returning back,
once work is done.  JS has a generator function now too, same keyword yield.

Each language solves this challenge its own way.  Having at least a couple
languages to showcase, examples of how it's done, clarifies what the
generalization was in the first place, at the meta level, just as many
examples of groups in a group theory book, brings forward what's in common
across all these groups (closure etc.).  Family resemblance and all that.

JavaScript in the incarnation of ES6 is adding what we in Python World we
call the sequence parameter (builds a tuple), and they call it their "rest"
parameter, as in "absorbing or taking the rest".  Their "object" (their
thing with a Prototype) is like our dict with embedded lambda (function)
values and intra-element shared bindings, but now they're getting a Map()
more like our dict, in addition to a "class" keyword.

In a presentation by a code school mentor, having these two languages on
our plate provides an opportunity to draw attention to the generic problem
being addressed, of argument-passing (with JS more of a moving target,
adopting features of the more-slowly-changing Python).

That's the other point I want to make in my courses:  that with a language
comes a story, of its inception and evolution, an unfolding scenario.
Having at least two examples of such a narrative, even without diving in to
the syntax too deeply, is another angle on "leaning to code" that makes
sense to people, helps them retain what they've learned.

"Oh, you mean like Python is an actor on some kind of world stage, with
other languages also actors, and I'll be able to follow the action, like
it's some kid of television".  Yes, that's right.

I need to devote more time tracking down Wes's links, a great resource of
edu-sig readers.

Another focus right now, in addition to the Python course I'm teaching, is
this whole Polymer phenomenon and the web components chapter, ala
Shadow-DOM and such as <template> and <element> tags.

What that means in my case is a lot of butt time watching Youtubes,
sometimes doing the OST thing (O'Reilly School) and coding right along,
maybe not verbatim but on related material. We didn't use Safari / video,
but might have in time.  As a learning mode, that works for me.

http://controlroom.blogspot.com/2016/11/web-components.html  (I've singled
out Monica as seriously talented but have since watched more by her peers,
quite the subculture, another story...).  On Safari I'm reading that
JavaScript Ninja book which another Youtube JavaScript teacher touted as
well worth the time.

Kirby
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20161127/d4480ce1/attachment.html>