[Hidden-tech] SUMMARY: Help me rewrite an old Programming / Web Development Curriculum?

Bram Moreinis bram at greenfielddigital.com
Mon Sep 11 21:46:33 EDT 2017


Hi, Folks.

I am SO glad I asked you all!  I got great advice... this is an awesome 
list and I am so grateful to Rich for keeping it live and kicking.  I 
bet there will be more, so please don't hold off responding if you have 
thoughts.

To recap, I asked for a recommendation of a "Cluster":

  * a *server-side coding language* - either PHP (because Wordpress),
    Node.js (because Javascript), Java (because AP Computer Science) or
    Python (because Python)
  * a *database* to connect the language to - MySQL (because Wordpress)
    or PostgreSQL (because Python)
  * an *associated framework* to get comfy with - Symfony (because
    Drupal and Laravel), etc.
  * a *CMS* to get them started - Wordpress (because jobs) ...

I would summarize the responses thus:

 1. PHP / MySQL / Symfony / Wordpress: *NO WAY JOSE - IT'S PHP!!!:
    *enough PHP to make templates and theme files. Many folks want to
    hire Wordpress developers. But Codecademy says PHP is so unpopular
    now that they won't update their course in it.  I can't find
    anything on the web about what php framework Wordpress was developed
    from, but http://www.hongkiat.com/blog/best-php-frameworks says
    Drupal used components from Symfony, and that Laravel is based on
    Symfony

 2. Java / MySQL / SpringMVC / dotCMS: *NO - JAVA IS TOO HARD: *only two
    dotCMS developer jobs on Glassdoor makes me think that won't help
    them get jobs... but maybe that doesn't matter.  SpringMVC seems to
    be the most popular Java framework.

 3. NodeJS / MySQL / Meteor / [Apostrophe]: *YES - THIS IS WEB CODING
    AND MOST JOBS HERE: *nobody is looking for Apostrophe.  But since
    we're parlaying Javascript into Node.js and everyone wants to hire
    mobile app developers, maybe I should push them and leap off the
    Wordpress bandwagon, leaving Apostrophe for students who can't hack
    the coding?   Meteor seems to be the most popular Node.js framework.

 4. Python / PostgreSQL / Django / Wagtail: *YES - THIS IS PURE CODING
    AND MOST TRANSFERABLE:* The problem is that none of these connect to
    the Javascript or Java that we know have to be part of the course,
    and that unlike Wordpress, Wagtail is not a way to get jobs.

Folks seem to lean towards 4, but because I want to prepare the students 
for mobile app development (and because Node.js is like Javascript), I 
am tending towards 3 - but gradually, as the students move through the 
four years with the new curriculum.

Because it's what I know (old fart that I am) this year will likely be 
1, and next year will probably be 1 as well unless the students want to 
cram for the AP Computer Science exam, which means 2.

We'll bring on a new computer science teacher next year, and do proper 
planning then to move towards 3 or 4, depending on what else I find out 
from the other VoTech schools and from Westfield.

Anyhow, much more advice below which I'll be digesting.

-Bram

Here are the full responses:

Noah Paessel <knowuh at gmail.com>: *Option 4*
> My main thought: remove as much friction and ceremony as possible, and 
> get them publishing things and having fun quickly.
>
> Focusing on front end development might give the students the most 
> bang for their buck.  The landscape of CSS / HTML / JS is overwhelming 
> enough.  (You might not remember how confusing it was to get relative 
> links to work for the first time).  I recommend finding a simple and 
> disposable deployment strategy. Something like https://surge.sh/  
>  Advanced students could move on to exploring javascript view 
> frameworks, connecting to hosted database solutions like firebase, or 
> using local file storage.
>
> If your curriculum spans several courses, and you are committed to 
> addressing the full stack then *option 4* makes the most sense to me. 
> Python has been heralded as a great introductory language, with many 
> applications.
Michael Muller <tech at montaguewebworks.com>: *Option 1*
>
>   * Start with the simplest, most foundational level possible, so they
>     understand what it's all about
>       o Intro to HTTP, FTP, etc
>       o SimpleHTML
>       o Simple CSS
>       o Simple programming (PHP? ASP? Python?)
>       o Connecting to a database
>       o SELECT records in a bare-bones page
>           + Simple li page navigation w/ content below
>           + Button to create new page (INSERT)
>           + Form to edit text on page and UPDATE to DB (the "aha" lesson)
>           + Uploading files through HTML
>   * Introduction to simplest CMS to compareto above
>   * Intro to Wordpress, Drupal, Joomla, etc
>   * Work you way into JavaScript
>   * Cover simple server management and how all components connect
>   * Review popular control panels like Plesk, etc
>   * Return to HTML with code libraries for fun interactivity
>   * Tack on Bootstrap or FlexBox for good measure
>
Chaim Peck <chaimpeck at gmail.com>: *Option 4 or 3*
> I think that either Python/Django or Node/Meteor will leave the 
> students with the most possibilities in terms of employment 
> opportunities, as well as opportunities to expand upon their knowledge 
> into other areas.
>
> And, I think if between Python and NodeJS, Python wins, especially for 
> high school students. NodeJS requires the ability to grasp an event 
> driven architecture, and might feel frustrating and turn students away 
> from programming if it is not understood well at first. Whereas, with 
> a simple introduction to Python, the students (especially those new to 
> it) will really feel the power of programming.
>
> Definitely not PHP. It may still be popular today, but it is not the 
> future. And Java can be left for a Computer Science class - no need to 
> introduce the concepts of classes and static methods just to print 
> "hello world".
>
> So, my vote goes to Python/Django, or... Node/Meteor if you think that 
> you can teach Node with little frustration.
>
> Regarding the database, teach an ORM (i.e. SqlAlchemy if you go with 
> Python) and don't worry about Postgres/MySQL/SQLite/etc. No database 
> is tied to any particular language (i.e. where you wrote that Python 
> goes with Postgres...). Just teach the concepts of constructing a 
> database within the application that you are building. Outside of 
> production use-cases and special situations, the difference between 
> MySQL and Postgres is negligible. But, setting up and interacting with 
> an abstraction layer (such as SqlAlchemy) will be much more beneficial 
> in teaching the use of a database, in my opinion.
Rich Roth <webmaster at hidden-tech.net>: *Option 3*
>
> Given that, I'd recommend:
> - Javascript using HTML5 concepts within the browser
>   - (which includes the built-in NoSQL database)
>   - can introduce classes and libraries
>
> - Database - SQLite -- can do basic SQL introduction without requiring 
> major server details
>
> - Server side programming,  Node.js
>
> You can introduce all programming concepts with these tools
>
> IF the course is moving into more professional programming:
>    - then move into Python (personally hate the indent syntax) however 
> that teaches flexibility with programming
> and a very common professional tool, with libraries and repositories.
>
> If the web is the key direction, then Wordpress and PHP to write 
> plugins might be interesting, it introduces APIs programming also.
>
> As for ORM/Framework - I think that is for a next level course, not 
> really Voc school material unless an advanced group that already knows 
> programming - that you might well have in today's HS world.
>
Daniel Fried <frieddan at gmail.com>: *Option 2 then 4*
> From my perspective, one of the greatest things you can teach them is 
> good programming habits.  A good programmer can adapt to any 
> language... if they have a good foundation.
>
> Because of that, I would tend to argue in favor of languages that 
> impose more structure, object-oriented development and strongly typed 
> variables.  It's far easier to learn those concepts and then move to 
> languages that don't require them than the other way around.  From 
> your list, that would lead me to say Java first with Python next 
> (please avoid PHP).
Tim Boudreau <niftiness at gmail.com>: *Option 3 then 4*
> My two cents, having done this stuff for years, and now as the CTO 
> (read: only developer) of an embryonic startup, and facing framework 
> and tech choices myself (and being a framework author in addition):
>
> I'd lean towards NodeJS + Meteor/Apostrophe, then Python + Django - 
> same choices Chaim suggested, just with reversed order.  Other thoughts:
>
>  - PHP is a ghetto.  A very big ghetto, but a hard one to get out of.  
> It's not going to give someone real programming skills, and will 
> probably leave them with a bunch of stuff to unlearn if they want to 
> go on to do something real. 
> https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/
>
>  - Consider MongoDB as an alternative in that NodeJS stack (you've got 
> it if you're doing Meteor).
>
>  - Consider Postgres as an alternative to MySQL.  There's a pathology 
> in open source software that, if you have something that barely works, 
> people blog and crow about it when they get it to work - so 
> technologies that kind of work but not quite wind up looking more 
> popular and attractive than ones that quietly just work.  Somewhere I 
> have MySQL a t-shirt from a conference with "[x] TRANSACTIONS" on the 
> back - as in "woo hoo, we've finally got transactions!" (yes, it's an 
> old t-shirt).  I know, I know, Facebook uses MySQL - yes, but they rip 
> the SQL front end off of it completely and just use the storage back 
> end as a giant shared hard drive.
>
>  - If you want to start them simpler in NodeJS, take a look at 
> https://hapijs.com/ as a sane, straightforward application framework 
> for basic HTTP stuff
>
>  - Java - there are some good, modern async frameworks out there - but 
> I wouldn't start with Java - it's not going to provide instant 
> gratification, and it's too easy to wind up veering into Java EE land, 
> which is a slightly less squalid ghetto than PHP - but similar in its 
> ability to handicap people into not being able to think outside its box.
>
> I'll disagree with Chaim about event driven architecture (and thus 
> Node) being too hard, vehemently:
>
> There is no simpler expression of how just about any piece of software 
> works than "when this happens, do that".  When an http request comes, 
> call to this function.
>
> We might think of that as hard because /we/ were raised in a paradigm 
> of writing sequential, synchronous programs that ran on a single-core, 
> single-threaded 8086.  And some time in the 90s, with multicore 
> processors and server-writing becoming mainstream, languages and 
> frameworks started libraries through hoops to preserve the fiction 
> that you're running on an 8086 at all costs, and of course, if you're 
> doing I/O, nothing else could possibly be happening - in a world that 
> was increasingly diverging from that.  Thus you get the 
> thread-per-socket paradigm - all to cosset you away from reality - at 
> enormous cost in resources and scalability.
>
> So in short, evented architecture is /only/ only hard to reason about 
> if you've been handicapped by being weaned on sequential, synchronous 
> programming. /Our/ generation has that handicap or has had to work to 
> overcome it.  There's no reason to inflict that on another generation.
>
> There's nothing intrinsically harder about "when this happens, do 
> that" - human brains are well adapted to that kind of reasoning - if 
> we weren't, we wouldn't be able to do things like drive cars.  The 
> idea that this stuff is difficult is a handicap that we don't have to 
> pass to the next generation.
>
> I'd start them on NodeJS, with something really, really simple - just 
> create a hello world HTTP server (about 8 lines). Then pick it apart, 
> and come up with more things you'd like it to do.  When it needs to do 
> more than one thing, start breaking out functions to do those things - 
> actually introduce the concept there.  I.e. you start with:
>
> const http = require('http');
> http.createServer(function (req, res) {
>     res.writeHead(200, {
>         'Content-Type': 'text/plain; charset=UTF-8'
>     });
>
>     res.end('Hello world');
>
> }).listen(8080, "");
>
> Then show how you can use the request's uri to decide what to say - 
> start with letting someone go to /Joe and have it say "Hello Joe".  
> Once you have a few things in there (hint: use the URL query string) - 
> let it get messy, so students can see /why/ you'd want to do that - 
> show how you could move each piece out into a function and just add a 
> switch(req.uri) to choose what to call.
>
> The point is, what's happening in here is simple, low on boilerplate, 
> easy to write - but it's not hiding the reality of what a server 
> actually does behind some artifice.  You can then teach frameworks 
> that make this or that easy, but start with something that gives an 
> understanding of the reality behind it all - which is really just 
> "when this happens, do that".
>
> Then look at some other things you could use that for - for example, 
> here's a tiny Node project that simply takes the image-to-svg 
> conversion program Potrace and turns it into a web service: 
> https://timboudreau.com/files/trace-service.js - (an older version of 
> that actually running here - https://timboudreau.com/trace if you want 
> to see what it does).
>
> If you want some help working up a few initial lessons on this stuff, 
> let me know.
>
> -Tim
Andy Klapper <atk at AndyKlapper.com>: General Advice
>
> I second Daniel’s statement that a good base is more important than 
> particular languages or tools in the long term.  I also agree with the 
> statement that it’s better to start with a highly typed language and 
> if necessary slip to more laxed languages later.
>
> That all being said I don’t know if learning a solid programming base 
> is what this class is about.  So my recommendation is to not design 
> this class in a vacuum but look at what other classes are required and 
> what students learn in those classes.  In fact I’d recommend that the 
> entire CS program be built together to some extent.  You can have a 
> single class that talks about different coding techniques like 
> OOP/recursion/state based/data driven/event 
> driven/multi-threading/etc. or these things can be spread over a few 
> different courses.  Ditto for everything else that covers the 
> definition of “a good base”.  Testing, IMHO, should be part of all 
> classes, but which class teaches the basics of how to design a good 
> test suite and which classes just including testing as the normal 
> process of making good code?  Also, if this course is part of a 
> well-defined sequence then presumably the students already know at 
> least one language (Java?) and already know SQL and at least one 
> database which means that is something you don’t have to cover as long 
> as you stick to that language and that database.
>
> As far as the specifics for this particular class – look to others but 
> what I can tell you as somebody that took a class on web development 
> once long ago – try to keep the number of technologies you need to 
> learn down to a minimum.  The class I took have at least seven 
> different technologies, each a separate open source project, that had 
> to work together to get anything to work.  While this may have been 
> realistic if one is doing complex work with open source tools only, it 
> meant that we didn’t learn any of them to any depth and more time then 
> I would have liked was spent making sure we had the right versions of 
> each configured in the specific way they needed to play (mostly) well 
> with each other.  All of that configuration knowledge was useless a 
> couple of years later to boot.  (or the goal could have been to give 
> an example of how parts of the gui could be determined/modified at 
> every single point it was possible to effect the gui – and that was 
> more than the course should have contained).
>
> Of course I’m assuming a professional level class, if the goal is 
> simply to expose kids to the wonders of programming and get them 
> excited about programming as a career choice then a course that is 
> high on visible results and low on structure might be a better way to go.
>

-- 

Martin Bram Moreinis, Designer/Developer
http://myinstructionaldesigns.com
(413) 829-0355

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.hidden-tech.net/pipermail/hidden-discuss/attachments/20170911/51d61929/attachment-0001.html 


Google

More information about the Hidden-discuss mailing list