On 03/02/2017 10:32 AM, bachmeier wrote:
I too learned to program using BASIC sometime in the mid-80's. The
Ditto here (well, late 80's). AppleSoft Basic on Apple IIc.
"enterprise" side of things has created a completely unnecessary
learning curve. Java being used to teach intro to computing was
successful at exactly one thing - it drove people away from programming.
Oh, it was a disaster in so many ways, it even wound up warping the
whole process of teaching programming basics into a total ineffective
mess. Case in point:
Back around the height of Java schools, I was a tutor for CS 101 (Intro
to programming, using Java) students at a university around here (John
Carroll University). There were two instructors who taught the course: A
prof who'd been teaching it since well before the Java craze, and a
Java-zealout who was constantly bragging how she'd come direct from a
real software dev studio and had real-world experience with the right
way of doing things.
The two approached their classes very differently:
The first one, the one who had been teaching code since before Java,
started out by teaching basic flow-of-execution. "This statement runs,
then the next one, then the next one." Conditions, loops, functions, etc.
The second teacher, the one who was kneck-deep in the "Java/OOP is our
god, we must not question" madness that was common in that time
period...didn't teach it that way. Those students were instead dropped
straight into object-oriented modeling. Because, of course, OOP is "the
right way to do everything", as most programmers believed circa early
2000's. (Hell, even I believed it - but I hadn't drank enough of the
kool-aid to think it was more fundamental than basic execution flow.
But, OOP was such a craze back then, that it was widely seen as an
alternative to imperative programming, rather than merely a way of
structuring imperative code, as was the real dirty little truth of Java.
So the imperative execution-flow was thought of as "dirty", something to
discourage and sweep under the rug instead teach as a basic fundamental.)
So, literally with ZERO exceptions: EVERY student I got from the first
teacher's class pretty much knew what they were doing and were only
coming to me for confirmation that they were on the right track.
Invariably they were. And EVERY (again, zero exceptions) student I got
from the second teacher's class was *completely* and utterly lost, and
didn't even have enough grasp of the basics of basics that I was able to
help them get a working program - at ALL.
Java definitely had good points (especially compared to the C++ that was
so predominant before Java stole its thunder), but it also lead to some
real major blunders and corrupted a lot of minds.
Do we have such a thing with D? Unfortunately we are moving in the wrong
direction. New users are told to write configuration files for Hello World.
Lot of truth to that: I'm a big fan of using D instead of bash for
scripting purposes, and about a couple months ago I found myself
promoting that approach to a guy who writes a lot of bash scripts and
python. It was embarrassing to show this as the "hello world" for
replacing bash scripts with D:
-------------------------
#!/usr/bin/env dub
/+ dub.sdl:
// This is the config file for the DUB package manager,
// but it can be embedded into your main .d file like this.
name "myscript"
dependency "scriptlike" version="~>0.9.6"
+/
import scriptlike;
void main(string[] args) {
run("echo Foobar > stuff.txt");
}
-------------------------
I don't think I won him over.
