
Learning to program is getting harder - henrik_w
http://allendowney.blogspot.com/2018/02/learning-to-program-is-getting-harder.html
======
socialist_coder
Anecdotally, what I've seen is that older programmers, in addition to being
programmers, also have the skills of a computer helpdesk technician. They can
debug Windows problems, hardware problems, know how to mess with the BIOS, and
have no problem installing or configuring any piece of software. This helps
_immensely_ when setting up your IDE or debugging weird problems with
compiling.

Younger programmers seem to commonly have zero knowledge in this area. If they
run into some problem with their environment, they are completely stuck. Oh,
they're asked to install a VPN client but it doesn't work and they have to
debug it? They're completely blocked. They have no idea how to continue.

For me, I learned these basic computer skills first (because I was _obsessed_
with computers as a child). Then I learned to program.

I think this is a side effect of teaching programming as a career skill. You
have people that want to be programmers but don't include "computing" as one
of their hobbies. So of course they don't know anything about how to debug
computer problems. This is totally expected.

Teaching these skills in CS curriculum would probably be a good idea.

~~~
userbinator
I agree completely --- being one of the "older programmers" \--- and think it
could be phrased thus: a new generation of "coders" is being forced to learn
how to write instructions for the machine, when they are barely computer-
literate.

Having taught some introductory CS courses a few years ago, the amount of
struggling with basic things like file naming, directory hierarchies, and even
simple hardware use was a constant distraction.

On one memorable occasion, I had to help a student by _turning on the monitor_
: he would sit down at a workstation, move the mouse and tap the keyboard, and
seeing nothing show up on the monitor after a moment, go to another unoccupied
one. I watched, without intervention, him try this with all the unoccupied
workstations in the lab until he finally came to me and said, in an
exasperated tone, "all the computers left are broken!" I lead him over to one,
and upon pressing the power button on the monitor, the expression he made was
quite unforgettable...

~~~
skookumchuck
There aren't really any clues as to how a computer works on an iphone. There
isn't even a visible filesystem. It's no wonder students today have no idea
how a computer works.

~~~
tartrate
Wait, the previous generation had no phones at all. Do you mean that today's
generation use phones instead of computers? In that case, I understand your
point.

~~~
j45
This reminds me of a story I recently heard where a student at a digital arts
college reported they were saving their file inside photoshop instead of a
folder.

It sounds bizarre - because they were using an iPad/iPhone instead of a
computer.

------
sametmax
I disagree.

Creating a program that meets todays' users expectations is what's harder.

But learning programming by itself, is way easier.

We have Python, Ruby, Javascript... We have the Web as a platform and as
documentation. We have communities and cheap, fast computers.

The hello world has never been easier to do.

What's hard is to make a real time offline first SPA with a beautiful
responsive design that uses the same API backend as the mobile app while
integrating with third party Saas and leveraging social medias.

~~~
rconti
But the learning curve of getting an environment setup to do that is steeper.

~~~
user5994461
It's not. Installing a C++ tool chain two decades ago is much harder than any
current environment.

~~~
groovy2shoes
Really? I remember it being rather easy circa 2003. On Windows, you could
download an installer for Dev-C++ or the Borland compiler, install it like any
other program, and you were done. On virtually every other platform, you
didn't have to do anything at all: the system came with a C++ toolchain ready
to go.

I'd say it's still just as easy to get going with those sorts of tools now,
and the same goes for many other languages, like Java and C# for example.

That said, I think the question of whether it was easier to start programming
then versus now has a more nuanced answer. The kinds of programs people are
likely going to want to write—like mobile apps, web apps, and games—are a lot
more complex these days than their equivalents were back then. On the other
hand, there are boatloads of free tooling and information readily-available to
help people through it. On the third hand, there could perhaps be issues of
information overload if you go looking without a guide.

So, getting started is one thing, and I can't say for sure whether it's harder
now versus then. Of course, that's a slightly different question than whether
it was easier to _learn_ programming then versus now. _This_ question is easy
for me to answer: of course not, learning it now is just as easy[1] as it's
ever been!

[1]: Or hard, if you're of the glass-half-empty persuasion ;)

~~~
user5994461
You had to install Visual Studio then the Windows SDK then probably other
libraries. Then spend an afternoon to set environment variables and project
settings until it can compile anything.

Dev C++ and code blocks had a an easier start, although they were bugged to
death and only used for hello world projects.

Borland is paid software. There was a free edition was very challenging to
obtain. That certainly contributed to the death of the company.

If we talk about two decades strictly. There was no internet so you couldn't
find any tutorial or help page. Books were selling for $50 each and you
couldn't Ctrl+F them.

On Linux a newbie can "gcc -o helloworld.c" to compile his first C file. Then
there is a massive gap until he will be able to compile multiple files with
make, auto tools, manage external libraries and package anything to run on
another computer. Now it's 2018 and Linux still doesn't have a C++ debugger.

------
sien
This is presenting a wildly rosy view of the past.

In Commodore 64 days you got some book that was all you had. You couldn't
email the author of the book or look online.

If you got through the huge filter of the initial steps being much harder than
today then you were doing well and would go on.

However, the endless set ups and downloading every library that is used is
going to make maintenance of programs in 5, 10 or 20 years a nightmare.

~~~
bitwize
Not just some book, usually lots of books, from the fundamentals of BASIC to
technical references with complete schematics for the entire machine. I had a
Commodore VIC-20 and it certainly came with all these.

And even then, experts and resources were available online, for suitably
primitive values of "online". Think CompuServe.

Another thing we had back then but less so today was magazines, full of
programming and technical tips and info, usually tailored to a particular
computer family. (So, Commodore magazines, Tandy magazines, Apple magazines,
etc.) Once business computing took off, the dominant players (PCMag, MacWorld,
etc.) became more productivity-oriented -- but I still learned Windows
programming from the free utility and programming columns in early 90s PCMag.
And then once the Web hit, the dead tree publishers were fighting over scraps.

~~~
astrodust
The manual didn't tell you anything. The books didn't tell you anything. They
scratched the surface, which if you knew nothing might have seemed profound,
even mind-blowing, but if you were trying to do anything non-trivial you were
left grasping for answers.

I tried to build games on the C64 using BASIC and, while I had some success,
the results were always limited by the fact that it was in BASIC, it was going
to be slow, and that planning and editing your code was extremely painful, you
didn't even have a proper text editor.

The real way to develop on the C64 was with assembly. Unfortunately, finding
information on how to do this was virtually impossible. Almost no books
existed, and those that did were rare and expensive. Even when you got the
book you were missing huge chunks of knowledge: The CPU itself is just 10% of
the problem, the rest is knowing the memory layout, the supporting chips, and
so on, stuff that wasn't well known.

The methods employed by actual production games were dark and mysterious,
often close to protected secrets. You were welcome to painfully disassemble
these games, but you also had no tools, not even a basic assembler, unless you
went out and bought one.

Today it's easier than ever to build games for vintage hardware because
everything, every little thing, is lovingly documented. This was absolutely
not the case in the 1980s.

~~~
jonathankoren
Why didn't you just buy the Commodore Programmers Reference Guide[0]? It had
an entire guide to C64 machine language, and _circuit schematics_. The book
even tells you to buy the 64MON cartridge if you're serious about programming
in assembly. This book wasn't rare. A friend of mine had it, we lived in the
middle of nowhere. These programs and cartridges were not rare. I had multiple
catalogs for buying these things as kid. The best programming books had code
listings on page, and line by line explanations on the facing page.

[0]
[https://www.c64-wiki.com/wiki/Commodore_64_Programmer%27s_Re...](https://www.c64-wiki.com/wiki/Commodore_64_Programmer%27s_Reference_Guide)

~~~
ryandrake
Funny... I didn't even know that book existed until I was a few years into
learning how to program my C64. I honestly thought you were supposed to figure
things out by randomly PEEKing and POKEing addresses to see what they did. I
had complete tech illiterate parents and no mentors existed to point me in the
right direction.

I remember visiting some other kid who had a C64, and his dad had given him
the Programmer's Reference Manual. He never opened it and didn't care about
programming at all (he just used the thing to play games). I cracked that book
open and my mind was blown!

~~~
u801e
I thought the guide that came with the C64 mentioned the Programmer's
Reference Manual. I remember asking my dad to get a copy and he told me that I
had to finish the first book before we could get it.

> I cracked that book open and my mind was blown!

I really wish I had had the opportunity to read through one when I was
younger.

~~~
jonathankoren
It did. The last page of the User's Guide[0] that came packaged with every C64
says:

> Commodore hopes you've enjoyed the COMMODORE 64 USER'S GUIDE. Although this
> manual contains some programming information and tips, it is NOT intended to
> be a Programmer's Reference Manual. For those of you who are advanced
> programmers and computer hobbyists Commodore suggests that you consider
> purchasing the COMMODORE 64 PROGRAMMER'S REFERENCE GUIDE available through
> your local Commodore dealer.

Honestly, until I checked the PDF just now, I thought the User's Guide came
with a card to order it through the mail.

[0]
[http://www.commodore.ca/manuals/c64_users_guide/c64-users_gu...](http://www.commodore.ca/manuals/c64_users_guide/c64-users_guide.htm)

~~~
astrodust
My "local dealer" was a Radio Shack and they didn't sell anything Commodore
related. If you wanted to know about Tandy, though, did they ever have you
covered!

------
ewjordan
I remember when I was first learning Java, whacking my head repeatedly against
all these sorts of problems - WTF is a JRE vs. a JDK, why is it asking to
install a browser toolbar, WTF is Eclipse and why doesn't it just let me _run_
the file that I'm working on without going through half an hour of researching
"Run configurations" and classpath BS first, etc. It was doable, but as a new
person to the whole ecosystem, it was seriously painful to even get to the
point where "Hello, world!" would run. Then I tried to get OpenGL working (I
wanted to do games), and I probably blew an entire week futzing with
configuration just to draw a rectangle on the screen. TBH it was harder than
getting the same thing done in C++.

And compiling it all into a Real Executable that would run on Windows like a
normal program? Forget about it...not even to get into Web Start, applets,
Maven and JavaFX (remember that disaster?), oh my!

Then I discovered Processing, which bundled everything (Java runtimes,
libraries, etc.) together in a nice tidy package, and its own IDE where you
could just open up the thing, type in some code, and hit the big obvious "Run"
button. Want a library? Download it from the nicely curated set that are
guaranteed to work! Wanted to create an executable, click "Export", and it
just works! All the nastiness of linking native dependencies, bundling the
JRE, handling classpaths and linker flags, it was handled once by the devs
working on that project, and end users could just focus on code.

Things are getting better with other technologies these days, but it's still
rare that I see an environment as zero-config as Processing, apart from web-
based Javascript playgrounds. All it takes is a pure focus on usability, which
I think is something that as devs we often overlook because once _we 've_
gotten over the installation problems that we're familiar with ("well of
_course_ brew is better than MacPorts, and you'll need to install nvm and pick
the right version before this library will work, except for this one
dependency that's only available through RubyGems, and this other one that")
we forget that they can be confusing and really off-putting to newbies.

Python environments are particularly bad, IMO because of screwy webs of
dependencies that more often than not fail to install cleanly and the Python 2
vs 3 split.

~~~
icebraining
On the other hand, Python's "batteries included" means you can go a long way
without installing anything. Sometimes I think people forget to look in the
stdlib:

[https://docs.python.org/3/library/index.html](https://docs.python.org/3/library/index.html)

------
edmundhuber
I don't understand this viewpoint at all. There's a breathtaking amount of
tutorials, Q/A (stackoverflow), forums, chats, that can get someone started
with a fraction of the effort it took for me to learn programming 20 years
ago. There are one-click installers for programming languages and for IDEs.
There are entire free books online to learn specific languages or frameworks.

I think people have gotten lazier and they expect to be taught, rather than
seeking out materials. Or perhaps the people wishing to learn, are not as
interested in programming as they think they are.

That being said, yes, learning "cloud" is an enormous sink of time that
requires some exposure to lots of different silos of information. Doesn't that
make sense though? It's a complicated subject.

~~~
racl101
As relatively young person I agree. Many people my age and/or younger expect
quick results and don't really have the patience to see something through. But
like with any other facet in life, if people take shortcuts they totally
deprive themselves of vital experiences that are necessary for them in the
long run if they want to experience any decent amount of success. Especially
if they are wishing to learn something for their career.

In other words, if your objective is to learn programming, how can you
possibly hope to create or do anything more meaningful than trivial examples
without challenging yourself to learn the environment nor learning howto
import 3rd party software libraries so that you don't have to recreate the
wheel?

It's part and parcel of not doing anything trivial. Learning to be resourceful
by visiting Q/A websites, forums, chats and asking questions, and trying
things and failing and getting up and trying again just makes you better.

You learn more by failure and experimentation than by following an example to
a T but never venturing outside the sandbox.

~~~
edmundhuber
I'm not that old, 33, but I think I recognize that I wasted a lot of my youth
being paralyzed by the thought of failing, when really it is the most
successful people who start out by failing. A lot. It is important to get
comfortable with failing, and to separate one's failure in trying something
from the thought of personal failure. That is "I failed because I need to
learn more," versus "I failed because I'm not good enough."

~~~
racl101
> I'm not that old, 33, but I think I recognize that I wasted a lot of my
> youth being paralyzed by the thought of failing, when really it is the most
> successful people who start out by failing

Well said. Describes me as well.

------
ericmcer
I got my CS degree in 2012. It was kinda scary how many students were on the
verge of graduation, and were unable to use a terminal, use SSH, or tell you
what git is (not that I know exactly o_o).

Those aren't particularly complex concepts. It is definitely partially the
schools fault, but CS is also a field where you have to have some interest in
what you do. You can't just go through the motions.

~~~
aidenn0
I wasn't able to use version control at all when I graduated; I didn't even
realize it was an option. I just every now and then would make a tar of my
project in case I lost something.

I suppose I had copy/pasted some cvs commands from sourceforge in order to
download the source of some open-source projects, but that was the full extent
of my interactions with source control.

~~~
Retra
I know how to write some software before I went to school, but learning
version control there was an eye-opening experience. It's the kind of thing I
think they should teach in school to non-programmers. Anybody who writes
anything, collaborative or not, is advantaged in some way by using it.

------
PacketPaul
The author is making an excuse for not including an intro chapter and tool in
his book to get the reader to a place where they can start using the book. My
sixth grader checked-out a Python game programming book from the school
library. He was able to install all the tools necessary to follow along and
learn from the book.

Today you have Google, Youtube and every programming language available from
scratch to assembler at your fingertips. There is no way it is "harder".

Yea the C64 dropped you into basic. But this was my first experience on a
Commodore 64:

"Play A Game" -Syntax Error

"Play a Game of Chess" -Syntax Error

"Let's play Global Thermonuclear War" -Syntax Error

------
zubspace
Well programming is one piece of the puzzle. I also miss the days when qbasic
was preinstalled and easily accessible.

But what worries me more is the actual deployment of the application you
write, which is getting more and more complex quite fast.

It seems, I'm in a rare place, where deployment consists of installing a
database and extracting an zip file. There's a script you run and the
(intranet) service is ready. Updates work exactly the same.

Sometimes I feel a bit ashamed, when clients watch me extracting a zip file,
but then I experience deployments and updates of other so called enterprise
systems and am completely baffled by their complexity.

Server provisioning and orchestration. Container managment. In memory caches.
Sharded databases with master slave setups. Load balancing with health
monitoring and what not... And to manage this mess you need a mix of bash
scripts, fiddle with permissions, run terraform which itself runs ansible
which deploys some docker containers... And when there's a tiny problem the
guys in charge are completely roadblocked for weeks.

I have no idea how some people can live with so many layers of complexity and
I fear the day, when I need to dig into this mess, eventually...

------
amasad
To add to this, one other way programming is getting harder is that there is
no incremental path to becoming a developer. In the past, you could easily
become a programmer by accident. You wanted to edit your MySpace page, google
around, learn some HTML and do it. You wanted to mod a game, you started
messing around with the game, download other mods, and change them.

I think this incrementally is gone in two ways. One is that programming is so
abstracted away from how we use computers that it's almost in a different
world. But even if you figured out what programming is, when you actually
attempt to do it, the sophistication of our tools make it a lot harder to get
started. Everything that makes us programmers more productive: compilers,
build systems, package managers, etc make programming less accessible. There
is a lack of coherence between all these tools, no one person designed them,
they're the product of bottom-up innovation (the bazaar) which has the problem
of making things messier.

I think open-source/bottom-up innovation is great, but eschewing "the
cathedral" for a wholly bazaar-based approach is making it a lot harder to
learn to program.

What I'm working on now (I'm the founder of Repl.it) is taking a lot of these
awesome tools and putting a nicely designed experience on top of them. We want
to bring back the welcoming cursor that invites you to program the computer
and bring back incrementality to programming, you start from a repl, and from
there you can move on to web-dev or what have you. You'd be surprised how fun
it is for kids to build CLI programs before moving on to build other things.
We put together a page where kids can post about what they're building with
Repl.it and it's really inspiring to see:
[https://repl.it/ibuiltthis](https://repl.it/ibuiltthis)

I've written more about what I call a "Holistic development service" here:
[http://repl.it/site/blog/holistic](http://repl.it/site/blog/holistic) And
also here I describe how we went wrong with "Disintegrated Development
Environments — How Did We Get Here?":
[https://amasad.me/disintegrated](https://amasad.me/disintegrated)

~~~
bomb199
I guess it depends on what you mean by "become a developer".

I think a lot of the increased difficulty is the skill of developers. At one
point, knowing how to edit HTML would get you an interview. Now, I feel like I
might need a successful Python library so I can get an interview...

Not sure if it's a bad thing or not, since the art is just becoming better.

------
always_good
We like to think programming is hard and that there's a barrier to entry that
we somehow surmounted because we're oh so smart.

But does anyone here actually know people who learned to program within the
last couple years?

My co-founder's girlfriend taught herself enough Javascript and React to help
out on our front-end in a couple months. Had no experience except for dabbling
in Wordpress. Now closes issues for us.

My buddy learned enough Python to create a GUI for an old card game. Built it
to completion enough to challenge himself against the computer player. Hasn't
programmed since.

Neither of them had any experience before. These posts really underrate the
resourcefulness and intelligence of beginners. And my suspicion is because we
like to think it's hard.

People here act like installing Homebrew to download python3 is somehow hard
for a beginner when there are hundreds of tutorials online telling them how to
do it. Hundreds of tutorials are exactly what I didn't have when I started
programming Basic even though the hello-world was a little simpler.

~~~
smt88
I actually think programming is pretty easy. Programming _well_ or in
constrained environments is hard. It's easy to learn and hard to master.

I've been coding for 22 years, and each year I feel like I can look back to
the year before and say, "Wow, I sucked at programming then."

------
linguae
One of the consequences of the transition from command-line interfaces such as
DOS and Unix to contemporary GUIs such as macOS and Windows is we have moved
from environments that do not make a sharp distinction between programmer and
user to environments that make a sharp distinction. One of the nice things
about command-line interfaces is being able to make powerful tools that are
composed of smaller tools. Unix has a powerful collection of tools, and if
those tools aren't powerful enough even with combined by pipes, there's awk
and sed, and then there are scripting languages. Contemporary GUI
applications, however, work very differently. Instead of being composed from
smaller programs, many contemporary GUI applications such as Microsoft Word,
Adobe Photoshop, and iTunes are large monoliths that are expensive to write
(just consider how large the teams engineering these products are, and
consider how much effort it would take to write a clone of these programs from
scratch), difficult to combine, and are difficult to script unless they are
specially designed to support scripting (e.g., AppleScript, Microsoft Visual
Basic for Applications, etc.). Web applications are even harder to write than
native GUI applications, and they are even more difficult to deal with in
regards to interoperability and scriptability.

It didn't have to be this way, and there's room for a future where it doesn't
have to be this way. The Smalltalk-76 environment demonstrated that it is
possible to construct composable and interoperable GUI applications. The
Genera operating system for LISP machines worked similarly. Apple's OpenDoc
initiative would have introduced the wider world to the concept of composable
GUIs, although it was canned as a consequence of Apple adopting the tried-and-
true OpenStep platform as the basis of future Mac development. An operating
system environment inspired by the Smalltalk environment and LISP machines
that provides both a REPL for tasks that are equivalent the Unix command line
and an OpenDoc-like API for designing composable GUI or even web applications
would create an environment that is both easy to use and programmable. I've
been growing more and more excited about the possibility of such an operating
system for workstation users that could one day serve as an alternative to
contemporary desktop operating systems and environments such as Windows,
macOS, and the Linux desktop.

~~~
scroot
I want a machine like that.

------
ozim
For me it looks like inverted survivorship bias. You won't hear from people
that succeed so you don't have way to count them. People that nag or email
author might be even in some special group of 'someone please make it work for
me', I cannot imagine mailing author of a book. I do not believe that such
group to be really big, maybe it just visible more than others. Like 'plz give
codez' on StackOverflow.

Buying a book or reading blogpost does not entitle you to anything more, like
wasting author time. Time is most valuable asset and he already spent it on
writing book. If that book is crap you can rate it on Amazon or something but
directly contacting author?

------
solomatov
I work at JetBrains on [https://datalore.io/](https://datalore.io/) It's an
interactive computational notebook for data science, which automatically
recalculates code as you change it. We believe that such an interface lowers
the barrier for entry into data science (and programming).

~~~
askvictor
Looks great, though I can't find anything about pricing or pricing plans
(looks like it's in open beta?)

While I've dabbled with using jupyter for teaching programming to high school
students, on the whole its usually too difficult to get up and running for
someone who's not already moderately tech savvy. Interface is everything when
starting off; this looks quite promising if the pricing is affordable for
schools

~~~
solomatov
We don't have billing yet, but we have gift codes. If you want to try larger
instances or run out of allotted time, let me know.

------
majormajor
I agree that it's harder to learn to program now than in 1982 (in terms of
"hello world" level simple stuff - but not for advanced stuff), but I believe
that it's way easier now than in 1992 or 2002.

AppleScript might be an exception in the 1992 case, but it was a fairly
specialized case and only for Macs. Otherwise, today you can google stuff
easily (vs needing books and such) and even Windows supports installing Linux
tools out of the box.

The danger, though, is that in the future we could have fewer and fewer
general-purpose computers -- iOS is not as dev friendly as OS X.

However, even on general-purpose computers, don't seem _that_ interested in
making it easier, which is sad from a professional pride point of view if
nothing else. I set up Android Studio on Linux recently. It wasn't terrible,
but even that wasn't a seamless experience - the emulator stuff had a few
problems, including included libs that were incompatible with Intel graphics
drivers, that I had to work around.

Any time you join a company and have to browse a long dev environment setup
wiki or readme, you've seen us all fail. We're bandaging it as fast as we can
with stuff like Docker, but that's just delaying the problem until you have to
debug your container in prod. ;)

------
henrik_w
My first computer was a VIC-20 (I later got a Commodore 64), where you also
start with a BASIC prompt. I too have been thinking about to the barriers to
starting to code.

Last fall, I helped in my son's grade 8 class to teach them python
programming. There we wanted the students to be able to start coding with
minimal effort, and minimal magic. They already had MacBook Airs, which had
python 2.7 already installed, so there was nothing to install. Then we
concentrated on a few core programming constructs (no classes for example),
and no libraries. This was an attempt to recreate the environment I had when I
learnt to program on the VIC-20.

I think it worked really well. The students were able to write fairly advanced
(a few pages full of code) with that set-up. If you want to do more advanced
programming, you'll need to install more, but for a start it was really good.
I've written more about it here:

[https://henrikwarne.com/2017/12/17/programming-for-
grade-8/](https://henrikwarne.com/2017/12/17/programming-for-grade-8/)

------
gxs
I'll be honest with you. Programming is actually pretty easy to learn.

As long as you have a vague idea of how logic works and are eager to learn
with the right approach, you can pick it up pretty quickly.

A lot of the concepts floated around in programming have crazy sounding names
but are actually not that bad.

What's really hard to learn, however, is full on software engineering.

Knowing how something works end to end. Sure, you can learn to program well in
JS, but that won't translate right away to knowing how to build an awesome
website.

You can be an excellent java programmer, but that won't translate right away
into architecting a nice Android app.

For me at least, when I was an up and comer, these were the things that were
hard to put together.

Every tutorial site wants to jump into a lot of details right away - I wish
they started with a high level overview of where you'd need the language,
where it fits in in the larger "app" picture (where app can be a site, an app,
etc.) and then dive into the specifics.

~~~
cchubitunes
Hi, I completely agree you. I am currently learning how to code. I am at that
point where I know the syntax of of a few language pretty well and can code up
small programs.

However, I do have difficulties in architecting and developing a fully
functional application.

How did you solve this problem?

~~~
gxs
Not sure you'll see this but honestly man, if you have friends in the field
just ask them, plain and simple. Not saying this is you, but often people
don't go this route because pride, etc.

If you don't know people in the field, chances are there are software people
where you work - some are douchy to people just learning (pfft, you think you
can learn this craft in months?) but others are willing and eager to help
others. Find them and again, just ask them to point you in the right
direction.

Lastly, find a class. Nothing crazy like a 25k bootcamp or anything, but find
something like building a site end to end in 2 days or something like that.

A lot of this stuff is tribal knowledge and not captured well in tutorials.
There are excellent tutorials for learning the technical things, but not
necessarily for putting everything together into a working app.

Hope that helps!

------
dahart
> Computer retailers stopped installing development environments by default

This is true, but somewhat ignores web browsers. The big ones (Chrome,
Firefox, IE & Safari) all have complete and high quality dev environments.

The article is Python-centric, and so the best answer for that right now is:
install Anaconda!

Otherwise, the general argument being made here is solved by JavaScript at the
moment.

If you use JS to write code, there’s nothing to install, distribution is built
in, it comes with the dev environment. All language and feature comparisons
aside, this is the strongest reason to use JS, because it makes sharing
programs with other people so insanely easy compared to any other language.

~~~
DanBC
BASIC is easy to understand. Javascript is incomprehensible in comparison.

[https://news.ycombinator.com/item?id=11637866](https://news.ycombinator.com/item?id=11637866)

    
    
        var drawing = document.createElement('canvas');
        document.body.appendChild(drawing);
        var ctx = drawing.getContext('2d');
        ctx.beginPath();
        ctx.moveTo(0, 0);
        ctx.lineTo(100, 100);
        ctx.stroke();
    

VS

    
    
        SCREEN 13
        LINE (X1, Y1) - (X2, Y2), COLOUR
    

I'm not claiming BASIC is a good language, or that it teaches good
programming. But it is very easy to use.

~~~
dahart
That's true for drawing one straight line, sure!

The question here wasn't whether the language is easy to use, the issue raised
in the article was whether the language & dev environment are pre-installed,
how hard they are to install, and then how hard the programs are to share
after you're written them.

No version of BASIC is being shipped with any OS today. You still have to
download the language and a dev environment on a brand new (Windows) computer.
And when you share a BASIC program, you either have to build an executable
that will run on someone else's machine, or the recipient has to install BASIC
on their own. (The article was about sharing code & learning to code, so a
binary isn't ideal.)

JavaScript and the dev environment, on the other hand, comes with every new
computer, on every OS, because browsers are pre-installed.

BTW, is this modern basic? That looks like what I remember from DOS 2.0 in
1980. :P

To be fair, you're comparing HTML canvas API to BASIC's native line drawing,
this example doesn't actually say much about the JavaScript or BASIC
languages. And it doesn't compare BASIC's graphics to canvas's... with canvas
you can draw curves and bitmaps and do transforms. I'm not familiar with
whether BASIC can do that these days.

In my experience, canvas is quite easy to use, even compared to BASIC. I know
you were joking, but incomprehensible is what I'd use for, say, Vulkan or
DX12. JS+canvas is _very_ comprehensible and easy, at all times, in my
opinion.

------
hedora
Honestly, if I were teaching someone to program now, I’d just tell them to buy
a raspberry pi. For $50 for the nice kit, plus a surplus monitor + keyboard +
mouse, you get a fully working toy dev environment preinstalled. You also get
piles of programming tutorials written for that _exact_ environment.

------
tyingq
I personally know otherwise competent Java backend devs that have no idea how
http works at all. Pipelining, gzip/deflate, Cache-control headers, XSS, uri
concepts, bandwidth consumption, proxies, etc...not even the foggiest clue.
There's just so much breadth, abstraction, inversion-of-control, and pressure
to deliver in corporate environments. There's little incentive to be a big
picture person when you're rewarded solely for closing out stories and pushing
out change requests. The resulting hit in quality is atrocious.

------
jakelazaroff
There's another option the author doesn't consider: _Change programming_ , or
create fundamentally different programming paradigms that entirely obviate
some of the requirements we have now.

One idea that's a fairly natural progression from where we are now is Luna, a
WYSIWYG data processing language: [http://www.luna-lang.org](http://www.luna-
lang.org)

A loftier re-imagining is Dynamicland, co-founded by Alan Kay and Bret Victor:
[https://dynamicland.org](https://dynamicland.org)

------
drenvuk
This is why I recommend people learn how to program using javascript at first.
There are no downloads, there is no setup and given some simple instructions
you can mess around with fully formed pages just by typing into the console
what you want to do. The modern browser has all the tools for a programming
course that takes place almost entirely in the console.

I lean more towards the python/C++ side of things but for just diving in and
seeing something cool for quick, colorful motivation to learn, javascript
fills that need better than anything else.

~~~
zbentley
> There are no downloads, there is no setup...

For a REPL/solving an algorithms problem? Sure. And the first time they want
to use some code from StackOverflow that uses a _library_ , god forbid, it's
off to the races. Require? Script tag? Webpack? Transpile? Minify?

All of those things are important tools, but their use (and presumption of
their use, a la "just import 'map' from underscore.js; you know the drill") is
so widespread as to present a major stumbling block for first-time programming
explorers.

------
fizixer
I'm afraid a very important point was missed.

What is it that's being programmed?

Commodore 64 programmers were never interested in "Bayesian Statistics" and
"Digital Signal Processing". Their main interest was pretty much related to
systems programming in one way or another.

Today's "programmers" expect to do crazy things like carry out statistical
analysis on megabytes of data, in a matter of minutes, with all kinds of
insightful plots, and animations and what not. (Same goes with DSP).

Today's programmers are NOT asking for what Commodore 64 programmers were
asking for. They're asking for way way more.

Not that there is anything wrong with that. But who's is to provide such shiny
interfaces to future Bayesian-statisticians and Digital-signal-processors?

\- System programmers do massive research to automate for today's programming
demands, workflows, and activities. And a lot of people are working in this
space. But it's full of information overload without a clear winner.

\- Or one of their own takes a hit for the team, transitions into system level
programming, and uses his past experience to create usable interfaces,
processes, workflows, and associated software. It's not an easy task.

I think now we're talking about something I've been struggling with for many
years, a computational science workflow software. Again there are hundreds of
projects in this space but that makes it even worse. How do you chose between
them? Someone says he/she uses Sumatra and it works for him/her. But it may
not work for someone else. Someone else says you should follow Cookiesutter
Data Science guidelines. But that's also addresses on a small aspect of the
overall problem. Etc, etc. The there are the emacs diehards who claim you can
do everything in emacs so why leave emacs. Well I can do everything in linux +
shell + C so why leave linux + shell + C? (point being emacs only let's you do
everything by becoming an OS in itself).

I don't have a solution.

I'm working on this problem in my spare time from a very very different meta
level angle. But that is a massive research project and cannot be finished in
a matter of a couple years, much less without funding.

------
lucidguppy
I find this difficult to understand.

Computers in 1979 would be 500 dollars in equivalent today money for something
like a sinclair zx-80.

Now computers are cheaper than lunch.

Computers of long ago couldn't do much... the raspi zero wireless can do a
lot.

We're looking for treasure - but there's diamonds on the soles of our feet. We
just need some curriculum worked out - like the article indicates computer
usage + computer programming.

We assume a lot is just absorbed by kids - but it isn't it must be taught.

~~~
sydd
yeah, nowadays you can get a PC which you can use to develop anything under
$300.

Nowadays there are millions of prime quality materials on the web for free -
audiobooks, videos, books, whatever suits you.

Nowadays the best IDEs in the industry are free - a few years ago you needed
to shell out hundreds of dollars.

The only thing that got worse is the confusing amount of choices that you need
to make.

------
SZJX
Isn't what he said the natural consequence of technology being available to a
wider and wider segment of the public, reaching ubiquity? This is to be
expected when what was originally something only known in a small circle is
now having to be used by essentially everybody then. One thing that can
definitely help is to incorporate programming as mandatory into national/state
school curricula as soon as possible. Programming literacy could become
something like writing literacy, though of course we're not quite there, yet.

Everybody having a solid grasp on programming principles would also protect
the democratic society in the sense that people would have an idea on how the
software they're using daily actually work, what is being done to their data,
etc. Leaving such a fundamental fabric of the society in the hands of few is
self-evidently dangerous.

------
vinceguidry
I love Ruby the language, but I absolutely hate Ruby the platform. I've never
run across a more hostile landmine-ridden terrain for new developers. Every
time I have to ramp up a new dev, I just resign myself to the fact that it's
going to take anywhere from an hour to three or four to get everything
installed. God forbid they've actually tried to use Ruby before on their
machines.

I've dipped on job prospects which involved code challenges that require me to
get their codebase working on my machine. I inevitably wind up having to
troubleshoot their broken setup and that takes way more time than doing the
actual challenge.

Ruby desperately needs innovation in this space. Bundler and rbenv / chruby /
rvm just isn't good enough. Vagrant / Chef just isn't good enough. I
understand that dependency management is a hard problem, but other languages
aren't half the headache that Ruby is.

~~~
thesmallestcat
Before the tire fire that is rvm became "standard", it was normal to just
download the version you needed and build it from source. There's nothing
forcing us to use crappy, obscure tools like rvm and rbenv. And I agree with
you on all points.

~~~
vinceguidry
It's a total shitshow. But since ruby manages everything with environment
variables, you need some kind of tooling to manage multiple versions.
Horrendous.

Ruby should just standardize on a way to point projects to rubies. Instead of
a zillion environment variables, just a shebang. It's how everything else
works.

~~~
zbentley
> Instead of a zillion environment variables, just a shebang. It's how
> everything else works.

I would like to tell you about an environment variable called PATH...

------
loup-vaillant
The fourth option, developing on the cloud and stay there, looks like a good
way to lose whatever freedom we had left.

Would the cloud provider let me write pen testing tools? Would it let me put
profanities in my comments? Would it give reports of my work sessions to my
boss? Would it get a licence to my code?

I'd rather go dinosaur.

------
saagarjha
> Computer retailers stopped installing development environments by default.
> As a result, anyone learning to program has to start by installing an SDE --
> and that's a bigger barrier than you might expect. Many users have never
> installed anything, don't know how to, or might not be allowed to.
> Installing software is easier now than it used to be, but it is still error
> prone and can be frustrating. If someone just wants to learn to program,
> they shouldn't have to learn system administration first.

I'm not sure I agree with this statement. macOS provides Python, Java, Ruby,
etc. out of the box, and a C compiler is one button click away. On Linux a C
compiler is provided. For web languages, every browser comes with a full suite
of development tools.

~~~
mamon
By leaving MS Windows out of the equation you've just ignored 90% of computer
sales worldwide...

------
frankc
There is a certain amount of systems administration knowledge you need to have
if you are going to be an effective programmer. No, you don't need to be a
sysadmin, but but source code doesn't live in a vacuum. I vote for face the
pain.

------
worker840234
"If someone just wants to learn to program, they shouldn't have to learn
system administration first."

I may disagree. Even though that's maybe an old school opinion I think every
developer should at least understand his own development environment
(including the OS), potentially also aspects of the target environment. The
reason is because (1) the abstraction between the OS and an(y) (sofisticated)
SDE is still leaky (sometimes for a reason) and (2) because a developer that
cannot support operations when things turn bad at runtime is just a fair-
weather captain.

~~~
Const-me
Every good developer should understand these things, but I don’t think it’s
reasonable to demand them from beginners.

I learned to program in Borland Turbo C on DOS, and later in Visual Studio 97.
Both were full-featured IDEs, at least by 90’s standards. I’ve only started to
learn Windows internals & system administration on my first job in 2000. If
knowing system administration would be a prerequisite, I’m not sure I’d become
a professional programmer.

------
alex_young
The point about cloud IDEs being the future is excellent I think. I worked for
a bit over a year on a chromebook with no local storage - only a cloud IDE.

It was a lot to get used to at first, but once you have made the context
switch, it's great to have everything in one consistent place with tools you
can use from literally anywhere.

Similarly, working on a small display pays the same kind of dividend. When you
can't put windows of code all over the place you enforce a kind of mental
order that's hard to achieve otherwise.

I guess I just want a portable WYSE terminal :)

------
justinhj
A couple of things bother me about this. First the idea that someone would be
a data scientist and not want to first learn how to do the most basic things
with their computer. Second the idea that it's hard to do anything on a
computer when you can literally type into Google what you want to do, and
seconds later can be watching someone else do it on YouTube or reading
detailed curated answers on StackOverflow.

------
nickjj
As someone who makes developer courses / training material I think it's a
really bad idea to use online services like PythonAnywhere or Cloud9IDE.

It's really important to learn how to set up your own development environment
as a developer and if you're making this content, I believe it's our
responsibility as teachers to show people how to do this.

Personally I use Docker in my courses (because it's what I use for my own
stuff) and it's been a smashing success. I do get occasional people
questioning "why" but after I explain what the process would be like to set up
a proper Python dev environment without Docker they immediately see the wins.

Of course I do get Docker related installation questions but it's a small
percent compared to questions on the course content. One of my courses is
building real world web apps with Flask and it's probably 80% Flask / 20%
Docker related questions.

That's much better than punting a local development environment off to a third
party service / pre-built VM and then leaving people stuck in the dark for
getting anything done on their own.

~~~
prawks
I think I'm in the group that doesn't immediately see the obvious gain of
teaching in a Docker container vs. teaching how to install pyenv/virtualenv.

Is it mainly cutting out troubleshooting differences between host OS's while
also getting isolated python environments?

Maybe I do see the win there, after all?

~~~
nickjj
I think you're starting to see it.

By the way, everything isn't just thrown into a single container. We use
Docker to set up the whole app over a series of containers.

So postgres, redis, the flask app and celery all run in their own containers.

Without Docker, you're responsible for getting not only virtualenv set up, but
also installing postgres and redis on your box, which is wildly different on
Windows, MacOS and Linux.

From a teaching POV, it's easier to level everyone off with Docker, but from a
student's POV, it's also easier because now they don't need to worry about any
of that. It lets them get to the important material faster. They can just
install Docker and run a simple `docker-compose up --build` and they are good
to go.

Compare that to listing out a million steps to install python, setup
virtualenv, write special clauses for people on Windows or MacOS, etc.. It's a
huge burden for everyone, and it's the main reason why I started using Docker
for my own projects years ago.

We haven't even talked about installing multiple versions of postgres or redis
without Docker too (because apps tend to be developed at different points in
time), or deploying an app to production. All of the steps you do to set up a
typical real world Flask app on Windows and MacOS are thrown out the window
without Docker because your production box is likely running Linux, but with
Docker, it's pretty much the same.

~~~
prawks
Ah yes, makes total sense if you're setting up not just a Python environment,
but an entire stack. Very cool.

------
codazoda
The problem described is exactly why I wrote a short "How to Code" primer a
couple years ago. It teaches some basics of Javascript. Javascript, at least
in the browser, can be run with no extra dependencies. Everyone has a web
browser these days.

[https://www.joeldare.com/blog/post/how-to-
code/](https://www.joeldare.com/blog/post/how-to-code/)

------
gaius
The question of “where to begin” is certainly a lot harder now. Learning to
program the way my generation did, the programming itself was obviously harder
- assembly vs Python for example - but the path and the progression was laid
out for you.

For me it was BBC Basic, then 6502, then 68k with DevPac on the ST... myself
and a friend wrote our own driver for a modem we found in a skip and that is
how we first got online... good times

------
_trampeltier
I also think learning to program is getting harder, but at least you can start
easy today. When I started to program in the early/mid 90s it was very
difficult for me to start as teenager. I didn't know anybody who did and had a
(copy) of a compiler for me. At least I found QBasic (was in DOS included). It
was very easy to program and debug something. The program could be as just one
line of code. Just hit F5 (as far I remember) and the thing did run. But it
was just an interpreter and slow. The included help was pretty good. Later I
tryed to program Assembler under DOS. But again, no compiler, I had just the
DEBUG function from DOS. With that it was possible to write Assembler direct
in memory (but not save to a file). Also no marks for jumps .. you had always
to calculate the address by yourself.

My QBasic book had (still has) 416 pages. It included EVERYTHING you could do
in QBASIC. My Assembler book was a bit more slim (XT-486, before MMX). A
"complete" book today would need over 10000 pages. There are sooo many things
you can do. There are almost a infinite number of librarys on github.

------
ohiovr
I get along pretty good on blind trust, issuing commands provided in tutorials
or setup guides sometimes having little understanding of what the heck it is
that I'm doing. There is always an end point that I'm highly interested in and
I spend my time learning the ins and outs of. I spend my time learning what I
need to learn when I'm stuck. Sure this attitude can be disasterous. I keep
current and offline backups at all times and not nuking the production code is
a standing order. I know enough to install Gogs, but I am by no means an
expert on all things git quite yet. If it weren't for stack overflow and
search engines I'd still be writing inconsequencial stuff in Director Lingo.
No one can afford the time to really understand the stack, its tens or
hundreds of millions of interconnected lines of thought. When I take time to
learn something I intend to do something useful with it. At this time my mind
is like a buffer. For every new thing I learn, stuff from 10 years ago is
fading fast. There is a lot to learn sure. There is even more that is
forgetable.

------
BuckRogers
I enjoyed the article, the author has some good points. I started on the
Commodore 128 and I'd have to disagree with the author's conclusion. I think
the filter is far less for self-motivated, truly interested users today than
it was in the Commodore's heyday.

None of the issues presented are really issues, it's just that there's a
larger swath of people who have accepted computers as mainstream devices and
can now afford one. Or are simply too young and missed the heyday of the truly
"personal" computer.

If I were to write a response, it would be titled The Great Filter. I was a
computer nerd most of my life, by the advent of the smartphone and the
majority of people realized how much the career paid, that whole stigma blew
out the window. Unfortunately, the Great Filter is gone, people who would've
been filtered out in the 80s are only visible by observing the students who
aren't even computer literate enough to have bothered to investigating
figuring out how a filesystem works before trying to program.

------
bthornbury
This is a REAL problem. The information overload for becoming a coder is going
way up with all these "great" new tools we're getting.

Try messing with the build of a React.js app, and I'll come see how you're
doing next week.

Things should be getting easier, and the information overload less. For all
scenarios, not just the easy ones. I think more advanced developer tools will
be the main driver of this.

------
Pica_soO
Its not getting harder, the old systems just forced the users to learn- today,
its just magic who works or wont.

Windows, MacOS, Chromebooks - none of them have a compiler and a ide by
default. Even the "bash-scripting" is not introduced to new users.

So if you do not choose this occupation, you will never grow into it now a
days.

------
steve_taylor
I would pay $99 for an Apple TV app that recreates the experience of
programming a computer connected to a TV, in BASIC. Something like the Amstrad
CPC series computers with lots of built-in commands for drawing graphics,
making sounds, etc. I’m trying to get my 8-year-old interested in programming,
but there’s just too much shit on the computer that gets in the way and too
many unrelated parts (text editor, terminal, compiler/interpreter, etc.) for
him to think about. I can’t use parental controls to stop him from switching
to YouTube the moment I walk away, because just about every piece of software
has a long list of websites it needs to connect to.

He’s used to playing games on the iPad and none of those would be simple
enough to inspire him to think that maybe he could make games too.

------
emilfihlman
The issue is with annoying, irrelevant and complete-but-not-quite-you-must-
tinker-actually-quite-a-lot-first frameworks and build systems.

Not to mention inadequate documentation.

You can learn to program easily still, say with Python or C but learning to
use the all the time progressing tools is a completely different thing.

------
bpicolo
While it could be easier, there are few languages I've ever felt I had to go
through extraordinary lengths to get running.

Having the patience to set them up is probably a good indicator for having the
patience to learn them. (Or rather, the reverse is probably more true)

------
Lerc
I seem to spend a lot of my time attacking this problem from one direction or
another.

I'm currently writing a browser based editor/assembler/emulator for 8-bit AVR.
I've made code-running MediaWiki plugins. I even got to the point where I made
an entire client-side browser desktop environment.

At the same time as making tools to ease the entry cost, I'm also wary of
making tools to conceal the complexity. Helper tools are beneficial, but once
complexity is hidden it can grow unchecked. Being able to get a project set-up
with ./configure or npm is great, but you have black-box that over time
becomes more and more onerous to open up and have a peek.

------
Houshalter
I think it's just a matter that most people use Windows, and programming
software is optimized for linux. I once wrote up all the steps required to get
youtube-dl working on windows.
[https://news.ycombinator.com/item?id=11453506](https://news.ycombinator.com/item?id=11453506)
Which is quite similar to what you need to do to install a programming
language. Nontechnical people will get stuck on things like changing path
variables, because they have no idea what that is. Let alone compiling
something which is frequently required.

~~~
cheschire
Programming certain software is optimized for Linux, but with VS Code and VS
Community Edition, and the robust project templates that come out of the box,
users can easily get basic C# programs working for free in console apps or
even windows store apps with powerful debugging and intellisense tools. When
someone is learning to code, C# can get them there quickly and easily once
they discover the correct docs.

If you feel programming is optimized for Linux, that’s because it’s your
preference. And a valid one at that! Its just going to tint your view a bit.

~~~
Houshalter
C# was made by microsoft for windows specifically. The majority of programming
languages were not. When I started programming I got very frustrated getting
stuff to work right. I remember it used to be near impossible to get pip on
windows and eventually found some weird unofficial installer.

------
lbotos
This is what glitch is looking to solve:
[https://glitch.com/](https://glitch.com/)

To add my take here, this was a problem in 2003 too when I wanted to learn,
but C++ was such a hard starting point.

The big takeaway is modern commercial programming is so far from "learning to
program". That's a hard gap to bridge when a newbie is learning "making a
terminal based calculator and wondering how do I build an 'app' or 'web
app'?". One Month a YC company tried to solve this but the market is hard to
reach because education is hard.

------
heurist
> Some of them send me email. They often express frustration, because they are
> trying to learn Python, or Bayesian Statistics, or Digital Signal
> Processing. They are not interested in installing software, cloning
> repositories, or setting the Python search path!

None of that is new. Setting up an environment that is conducive to coding
takes effort if you don't have someone to set it up for you, which describes
most new coders. I had a hell of a time learning to code on cheap hardware
running Windows 15 years ago.

------
_pdp_
This article lacks any depth! It is easier than ever to program and get
started. 5 minute tutorials are available on almost anything and sometimes
delivered by 8-9 year old kids.

Even low-level stuff are easier to pick up thanks to the explosion of readily
available information and IDEs. No one is using Arduino? Perhaps it is true
that newer generation is just less keen to put an effort to study anything
outside of the norm of but learning old and new technologies has never been
easier.

------
seandougall
My mother-in-law, who learned to program in the ‘60s by carrying her boxes of
punch cards across campus while getting tear gassed by Berkeley PD, would
probably beg to differ.

------
meuk
"For beginners, and especially for people working on their own, I recommend
delaying the pain."

No, no, no, no, no! This is exactly what caused the problem in the first
place.

That you need an IDE is one of the biggest lies in programming. From the
terminal on most Linux systems, you can download and install everything in a
single line. Then compiling is another line.

------
soniman
I had this same problem as the OP describes and my solution after a lot of
frustration was taking some tutorials on Linux from Youtube. That actually
might not be a bad place to start because bash is a programming language
(right?). Teaching some simple bash scripts plus navigating the file system
wouldn't be the worst intro to programming and it can now be done in Windows.

~~~
veddox
Yes, bash technically _is_ a programming language - but it's a pretty horrible
one in terms of usability, and _not_ the first that I would teach a newbie.
Plus, you really don't need it unless your deep into sysadmin stuff.

------
alant
As many others, I also disagree. Back in the day, laptops are more expensive
and less capable. Now you can program everywhere with laptop and wifi. More
importantly, sites like SO makes learning to program so much easier than
before. Back then, if you don’t know somebody you might be stuck with some
silly issues for a long time. Not to mention Windows had frequent blue screen
of death.

------
conradk
Recently, I've experienced working on a remote server. It was a real pain. You
need a crazy fast connection to be productive. Otherwise, you're stuck waiting
for changes to save, for pages to load, etc. Of course, you can only hope the
network doesn't break down or the cloud IDE company makes a buggy deploy.

As a remote developer, I like working in different places. These places don't
always have nice internet. Working with a local environment and 4g connection
is fine, because 4g is more than enough to look up docs. But working with a
distant environment and 4g connection is very slow and unreliable.

Nowadays, a lot of people praise the "cloud" or everything. Use APIs for
everything, Use public CDNs to load up bootstrap and jquery. Use an online
IDE. Make a hosted Git service an essential part of your workflow. The thing
is, not only do these services occassionally break, but some might get
compromised ([https://techcrunch.com/2018/02/12/browsealoud-coinhive-
moner...](https://techcrunch.com/2018/02/12/browsealoud-coinhive-monero-
mining-hack/)) and some even ask you to install closed source binaries to your
system without any idea of what's in it (keylogger, ransomware, anything is
possible).

Given all that, when I read that using a local environment is "anachronistic",
I can't help but cringe.

~~~
figgis
This really just sounds like issues with whatever web IDE you are using.
Remote development does not need to be a huge pain like that.

~~~
conradk
I wasn't using a web IDE, but the dev server was remote. While I suppose
remote environments do not have to be a huge pain, I'd be interested to know
how to mitigate all of the issues I mentioned in my previous comment. The only
solution I've been able to setup is a local environment with minimal set of
dependencies calling the network.

~~~
figgis
For testing there are quite a few good remote solutions. Here are a couple I'm
familiar with.

[https://developer.github.com/v3/guides/building-a-ci-
server/](https://developer.github.com/v3/guides/building-a-ci-server/)
[https://docs.gitlab.com/ee/ci/examples/README.html](https://docs.gitlab.com/ee/ci/examples/README.html)

My simplified workflow is: do work locally using whatever IDE I desire ->
create a pull request -> server runs the tests and puts the results in the
pull request. Much faster than running the same tests on my local machine as
well.

With the tests being done remote you will also likely not need to commit such
large amounts of data that it becomes a problem.

> Working with a local environment and 4g connection is fine, because 4g is
> more than enough to look up docs. But working with a distant environment and
> 4g connection is very slow and unreliable.

Normally even if you are working remote it's expected that you have a stable,
decent, connection. But even without one there are plenty of great options.

For documentation I actually keep that local using
[https://devdocs.io/](https://devdocs.io/).

Without internet you don't have sites like stackoverflow and that's a downside
that really can't be fixed without some serious work.

~~~
conradk
> Much faster than running the same tests on my local machine as well.

That sounds odd. Usually, while developing, running the whole test suite is
unnecessary. So running tests is very fast, as long as you only run the tests
that may fail after recent changes. At least that's my experience.

> not need to commit such large amounts of data that it becomes a problem

Not sure what you mean here. Mind clarifying ?

> if you are working remote it's expected that you have a stable, decent,
> connection

Definitely ! And 90% of the time I do have a stable connection. But that 10%
where I don't (because the wifi breaks down, or I'm on a train to a nearby
town), having a remote environment would not work. That's my use case for
having a local environment.

> For documentation I actually keep that local using
> [https://devdocs.io/](https://devdocs.io/).

Wow, that's cool ! I wasn't aware it worked offline ! Will definitely have a
look at this. Thanks :)

------
0xBA5ED
Personally, I feel it's vastly easier these days. The sheer volume of learning
material at your fingertips is staggering. I mean, you can just turn on
youtube tutorials and soak it in with barely any effort. Most of the time, you
can copy/paste whatever error you're getting into a search engine and get
instant answers. It's a walk in the park!

------
emmelaich
There was a great blog article on all the non-programming "stuff" you have to
do get productive in programming.

Everyone resents doing it but it is very hard to avoid. And it's unclear
whether it's inessential to programming.

Does anyone remember this blog article?

The author's name might have been Paul, and he might have been a Coursera
teacher.

------
bsaul
I’m amazed to see that the reaction of many people including the op author,
don’t think that this is simply the symptom of a field (ide) that haven’t
evolved in thirty years.

Whenever i open a terminal to type some esoteric command line i don’t feel
like a tech genius. I feel like someone living in the stone age.

------
dba7dba
When I tried to learn Java years ago, I got stuck with setting path on my
Windows computer. Afraid to break it somehow, I gave up on learning Java.

I picked up Shell scripting and html/css years later but I think the logistics
of anything is the really hard part. Not the actual activity.

------
TimJYoung
It's getting harder because it's become fashionable to shun IDEs that make
most of these issues obsolete, and have done so since at least the 90's. It's
ridiculous to expect newcomers to a language and/or programming in general to
slog through a 20 or 30-step environment setup process. This idea that using
an IDE will discourage someone from finding out the more detailed workings of
the language, compiler, etc. is nonsense. If anything, immediate progress and
reward will _encourage_ new developers to keep going and exploring further,
whereas an overly-complicated, tangled mess of setup instructions will just
make many people throw their hands up and quit.

Case in point: my first experience with the Delphi IDE in 1996 had me
immediately writing a basic text editor _without knowing anything about Delphi
/Object Pascal at all_ prior to sitting down with it. Drag, drop, consult the
context-sensitive help, write some code, and compile/run, all in the same IDE.
It also helped that Delphi shipped with the entire source code to it's RTL and
the VCL (Visual Component Library), but that's more important as you get
deeper into the language/product.

~~~
switchbak
Surprisingly I think I'm the first to disagree.

I find a modern IDE comes with so much implied mental baggage that new users
can get completely overwhelmed. Sure, languages which require complex build
environments almost demand one, but in simpler environments it can be a lot
easier to reduce the cognitive load in a simplified environment.

One can do a lot of programming and learning with just a simple editor (Nano?)
and a Python-like environment (repl, interpreter). With quality online
notebook-style environments, we can now accomplish an outrageous amount with
very little time or cognitive overhead devoted to build tooling.

As professionals, we ought to be familiar with the underpinnings of our tools
though. It can be really painful trying to work with a colleague who's afraid
of getting low level to really understand their build issues. I've worked with
people who actually become visually agitated when I open up a command line.

What's worse (I see less of this these days) are those who are so coupled to
their IDEs that they don't use proper build tools - limiting reproducability,
CI integration, etc. This was a real problem back in the earlier Java days
before Ant/Maven/etc came around.

No need to shun an IDE - I certainly don't, but one needs to understand how it
works otherwise you risk having incorrect (overly simplified) mental models
about how your programs are built and run.

~~~
dan_mctree
For me it's the opposite. A modern IDE is significantly easier to understand,
with far less mental baggage than some hacked together combination of several
CLI based tools. The mental drain of clicking some nice green play arrow on
screen when you want to execute code is non-existent. The baggage of
remembering which tool does what, what weird flag you have to keep adding to
one of the commands you need, what keyboard shortcut you needed again to exit
your CLI based text editor, all of that takes far more baggage for me.
Especially when you have 10 different setups like it, and may not return to
some of them for months.

And even if you do somehow remember how all of your CLI tools fit together,
you're still missing out on an incredible amount of power and clarity that
IDEs provide. A CLI just doesn't have the ability to show information nearly
as well as a GUI, it doesn't even come close in terms of the amount of bits
worth of information you can show simultaneously, nor in its ability to use
positioning and formatting to clarify what's important and related. Add that
GUIs provide constant in your face hints that tell you what your options are,
and it's no wonder almost everyone finds them significantly more pleasant to
use. You don't have to remember anything, it shows you.

Yes, people end up developing bad habits and will run into some problems
later. But these issues aren't as significant as people giving up early
because of learning curves that are too steep on software which is only
vaguely connected to what they actually want to do. "I want to build an app"
is what drives people, not "I want to learn all the flags for javac".

~~~
kd5bjo
CLI tools are all about codeveloping the build environment with the project.
Instead of you trying to remember the weird flags, write a one-line shell
script and save it with the project.

For example, my current side project is built on C+SQLite. The larger chunks
of SQL are plain text files so that I don't have to worry about C string
escaping. Instead of trying to read them at runtime, I have the build process
wrap them in a .o file that gets linked into the executable.

This is relatively simple because it's just a slight variant on what's already
happening (.sql files are "compiled" with objcopy instead of gcc), but I've
utterly failed whenever I've tried to do something similar in an IDE-based
project.

On the other hand, the standard build process is generic enough these days
that most projects don't need to do this sort of customization. For those
projects, being locked into the IDE's process isn't really a drawback and you
may as well take advantage of the benefits it provides.

~~~
TimJYoung
Just to give you an idea of how you would do that in Delphi (even in 1996):

1) Drop an instance of your database-specific query class (or a generic
database API query class, such as ODBC, ADO, etc.) on a form or data module.

2) Click on the property editor button next to the SQL property for the class
instance in the object inspector.

3) Input your SQL in the provided window (or load/save to/from a file,
whatever the property editor allows for).

4) Compile your application.

That's it. The SQL is now automatically included as a resource in your
executable and is available to you at runtime as if it were assigned at
application startup. And this isn't just limited to SQL - you can do this with
any text or binary file. It's all only limited by the imagination of the
developer of the component(s) that you're using in the IDE.

Visual Studio has always been a bit more obtuse in how it handles
datasets/databases, so it's probably more of an example of how _not_ to do
something like this in an IDE.

The point is that a beginner can do the above, whereas I'm not sure that a
beginner would even know where to begin when it comes to implementing what
you've done (which is very well done, putting all of this aside).

~~~
kd5bjo
I'm glad that at least one IDE gets this particular case right, but I think I
missed my broader point.

As a programmer, my job is to produce a set of instructions that a computer
can understand. The Unix shell is quirkier than most, but it is a real
programming language that I can bring all of my profession's skills to bear
on. IDEs, on the other hand, are opaque boxes that work great until you need
something they didn't anticipate.

I'll readily admit that my needs are no longer those of a beginner, but my
learning path was a pretty steady climb of copy/pasting boilerplate, to making
a few small changes, to just starting with an empty file and writing
everything from scratch.

I worry[1] that, by hiding complexity from beginners, we may be hindering
eventual mastery in the name of making it easy to start learning. Are modern
intermediate-level developers asking questions like:

\- I've been told to always do X; what happens if I don't? \- This thing I
usually ignore seems vaguely related to my current problem; what does it
actually do?

[1] Without any real foundation or evidence

------
commandlinefan
Not only that, but the perception is going in the opposite direction - as
learning to (or actually practice) programming gets harder - non-programmers
seem to think that the proliferation of graphical tools ought to have made
programming easier.

------
brandonmenc
> Computer retailers stopped installing development environments by default.
> As a result, anyone learning to program has to start by installing an SDE

What?

Notepad and a browser is all you need to get started learning the most popular
programming language in the world.

------
fnord77
You don't need a computer to program. Paper and pencil will get you pretty
far. Anyone take CS106X at stanford? Most everything was written by hand, only
the labs or homework were actually done on a computer.

------
st1ck
For Python, just try Anaconda/miniconda [https://conda.io/docs/user-
guide/index.html](https://conda.io/docs/user-guide/index.html)

------
naveen99
I started with autohotkey. Still think it's the best gateway from user to
programmer. keyboard and mouse macros. It's the first thing you learn on emacs
and vim also.

~~~
willhslade
I'd say Excel, but potato, potato.

------
wolco
Things are so much easier to program these days. Compare c or asm or cobol to
php,ruby, python or modern javascript things are much easier at a higher level
of abstraction.

~~~
kbwt
> php,ruby, python or modern javascript

But do you really understand those? Do you have a complete mental model of how
they work down to the fundamentals?

For C and even C++, I can confidently say YES.

------
glorkk
Please don’t hijack the horizontal swipe. It is for going back/forward in
navigation histoey, not switching between articles on your website.

------
pdfernhout
I've been programming for about forty years -- starting as a teenager on a
KIM-1 with 1K of RAM. I was playing with digital electronics for years before
that which is also a good foundation for understanding the basic logic of some
programming operations like AND, OR, and NOT. What I feel is also often
missing in the programming community today -- as well as computing education
-- is people who have the experience of computers from the wires up.

Nand2Tetris is a course that provides some help in that direction -- but it is
still not the same as having been there:
[http://nand2tetris.org/](http://nand2tetris.org/)

Back then, programming was one of the most interesting things you could do
with a computer. One of the biggest challenge for programmers starting out now
is that, frankly, much of what you can do with computers is so darn
interesting (e.g. Kerbal Space Program, Minecraft, or just browsing the Web).
So, those distractions are often more interesting-seeming than the computer
basics of logic circuits, machine language, and fumbling around in confusion
(maybe for years in some areas) until things click.

I see that challenge with my own kid learning programming.

Still, there is Redstone in Minecraft -- and even a Forth computer mod for
Minecraft. There are lots of programming game-like things like the Smalltalk-
derived Scratch now. And great software libraries. And there are places like
GitHub and GitLab for sharing code. And even board games like RoboRally.

And Arduinos and Raspberry Pis are very cheap. And you can so so much even on
just a cheap Chromebook. I'm writing this on a cheap Acer Chrombook 15 running
GalliumOS Linux when I now do most of my personal coding and writing -- both
to save money and also to keep thinking about what is possible with the
current low-end of personal computing.

JavaScript is still no Smalltalk -- which was a much easier language to learn
and use when it is installed and supported, especially since it was designed
for kids and went through many years of refinements to make it easier to
learn, use, and debug. But JavaScript these days (especially ES6/ES7) is not
that bad -- and it is almost everywhere and almost anybody can start
programming in it in their web browser. Here is a browser-based playground I
wrote recently for JavaScript using Mithril and Tachyons:
[http://rawgit.com/pdfernhout/Twirlip7/master/src/ui/twirlip7...](http://rawgit.com/pdfernhout/Twirlip7/master/src/ui/twirlip7.html)

So programming has never been cheaper or more accessible. And the original
article goes into that some, like with the suggestion of starting with a
Cloud-based IDE (e.g. [https://c9.io](https://c9.io) ) or simulators (e.g.
[http://www.visual6502.org/JSSim/](http://www.visual6502.org/JSSim/) ).

------
HIPisTheAnswer
Seems to me the author wants nix, the functional build system, with an easy to
use ' browser' of nix configurations.

------
rbongers
There's a big green download button on github repository pages with an option
to download the code as a zip file.

------
stephenblum
specializing is getting harder. DevOps, BigData, AI/ML, Blockchain, Full stack
/ MEAM, Front-end, Mobile Android Studio, XCode

------
Havoc
idk assembly looked pretty damn hard to me so I stuck to modern languages.

------
jordiburgos
I has never been easy...

------
iamleppert
Programming is not getting harder, these are just the reactions of people who
probably shouldn't be in this discipline in the first place.

A great deal of any programming, technical, what have you job is just getting
stuff to work. A lot of it has nothing to do with the actual core task at hand
or your specialization but still needs to happen one way or another. This
means using critical thinking skills, deductive reasoning, the scientific
method. It means scouring Google, _trying things_ until you have a clear
mental model of whatever insane legacy you're working in.

Back in the day, I'd spend my time at home trying random things, looking at
files in a hex editor, disassembling software to figure out how it worked
because there was simply no other way. There was no Internet, and the only
documentation I had was at my library, which was limited to whatever they had
and usually was out of date or incorrect. Sometimes they wouldn't even let me
bring stuff home, because I was a kid and why on earth is this weird kid
wanting some giant technical reference manual? There were no laptops (that I
could afford) so I had to read it there, and then go back home and try more
things with my hopefully newfound knowledge.

Today, we have Google, we have groups, the Internet, mobile devices, tons of
high quality blogs, books, free online courses, and the industry itself is
infinitely larger with resources that still boggle my mind to this day. As
long as I have the time, I'm usually able to tackle most any problem. I
couldn't really say that as a kid growing up in the early 90's, trying to
learn programming. Those were the literal stone ages. No internship programs,
most people thought of tech jobs as vocational IT help desk related (at least
in my hometown). There were times when I was legitimately stuck with no
resources or recourse.

So please, excuse me if I don't find sympathy of these people who cannot be
bothered to setup their python envrionment with the aid of stackoverflow.

------
RawData
I don't know...if you can't figure out how to install python on a local
machine...maybe you don't have any business being a coder to begin with. I
mean, come on...

edit: the downvotes from the delicate snowflakes crack me up...

~~~
plusone111
Agreed sort of. Especially when the solution is often easily searchable.

I’ve hired interns and junior folks who have trouble with the command line
(special circumstances for FT hire). I offer help, but also tell them that
it’s their responsibility to understand any extant skill gap and learn. I’ve
worked with at least one older boot camper who threw fits when they had to
learn something new on their own to debug a problem. I’ve worked with much
older career programmers who’ve done the same.

I don’t think it’s a matter of being a coder or not, rather some people aren’t
problem solvers, and some people are lazy, and some people dumb, and some
people want to be somewhere else. If I had my pick, I’d never work with these
people. However, sometimes the people doing the hiring shouldn’t be managers,
you could say, and sometimes the people making the decisions have incentives
to hire bad people. Then you end with experienced newbies, and have to fill a
position eventually.

A better articulated post would posit the problem is not inherit to people not
knowing things, but people not having to.

