
Don't Make Students Use Eclipse - NoraCodes
https://nora.codes/post/stop-making-students-use-eclipse/
======
0_gravitas
I think a better alternative would be "Don't Make Students Use Java", I
seriously can't think of a worse language for training beginner/intermediate
programmers, I certainly wish my schooling experience consisted of something
else. From day one you're introduced to magic on top of magic: "Open up <IDE>
and click 'new project' and name it 'MyProj' and now click on the file in the
side menu that says 'MyProj' and inside `public static void main(String
args[]){}` inside the `public class MyProj{}` write `System.out.println("Hello
World")` and go to the top bar and hit 'Run' and then 'Hello World' will
appear in the integrated console, ah, programming!"

And you don't even begin to grasp what all those steps you just took in the
IDE did until you're at least 1+ years in, and you don't learn what all of
those magic words even remotely mean by at least halfway into your second
semester.

I felt like every single thing I ever did was magic, never having a clue why
it ever actually worked the way it did, and as a result nearly dropped out.
The only time things _finally_ started to make sense is when I got to Computer
Architecture/Organization with MIPS followed by some work in C.

~~~
ardit33
for very beginners, yes... Java is not the right programing language to teach.
(I'd say Python is).

But for intermediate/advanced classes I think Java is a must learn for every
CS graduate.

1\. While it is bloated, it has so many modern and not so modern concepts into
it, that learning it makes you understand those concepts better. (eg: It is
hard to understand Generics if your favorite language doesn't have them)

2\. A lot of enterprises (and major tech) backends still run on Java. I thin
knowing it is a must to be competitive in the job market as a fresh grad

3\. Learning Java (and probably disliking it) it will make you appreciate and
perhaps make you better at learning other more nimble languages (aka. GoLang
and friends)

~~~
bokwoon
It’s kind of embarrassing but I didn’t understand generics from my beginner CS
course (taught in Java). It wasn’t actively tested on either. I only began to
appreciate it when I took an online MOOC in OCaml on a whim.

~~~
kick
Generics in Java were poorly-handled and almost universally considered to be a
mistake.

~~~
djsavvy
Why is that? And how so?

~~~
nitrogen
I'm not the OP, but look up "type erasure" for one criticism.

~~~
lazulicurio
Type erasure gets an unfairly bad rap. Yes, it makes reflection difficult
sometimes. Yes, it doesn't play well with value types. But other than that,
erasure is a very powerful concept.

~~~
MereInterest
My understanding is that the only value in type erasure is that it maintains
compatibility with libraries compiled in ancient versions of Java. Are there
language-level benefits to type erasure?

~~~
lazulicurio
Absolutely. Erasure lets you write code that's actually generic, instead of
code that appears to be generic.

For example, in C# IList<Foo> and IList<Bar> are two different interfaces that
happen to have similar methods. Whereas in Java, List<Foo> and List<Bar> are
the same interface. This means you can do things like this in Java:

    
    
        List<?> list = ...
        Object o = list.get(0);
    

To do something similar in C# is significantly more effort. You either have to
duplicate all of your interfaces (IList + IList<T>), use `dynamic`, or use
reflection to compile delegates at runtime.

A common complaint is "but erasure lets you add an integer to a list of
strings". But as long as you follow PECS[1] rules you can avoid most of those
situations.

[1] Producer: extends. Consumer: super

~~~
jdmichal
I don't think either of your points has anything to do with type erasure, and
everything to do with allowing generics to take value types. This was an easy
decision in Java, since it doesn't (yet?) allow user-defined value types. But
C# has had `struct` since the beginning.

C# creates one instance of a generic for all reference types. The general
consideration in instantiating multiple versions is object size. All reference
types are the same size, so not a concern. Value types, however, range wildly
in size and so generally get their own specialized versions during code
generation.

The same choice effects the ability to wildcard. C# probably could implement
wildcards over reference types, but it would feel inconsistent without value
types. And, honestly, a good portion of wildcarding in my experience is to
handwave away the compiler when you know what you're doing without reified
types. Simply not an issue in C# -- its stronger guarantees around generic
types means I can make that same code generic over the type I'm wildcarding in
Java.

~~~
lazulicurio
Code generation is definitely important to talk about, but that really wasn't
the focus of my first example. Even if Foo and Bar were both reference types,
the same reasoning would apply.

In C#, you can do:

    
    
        class MyClass : IList<Foo>, IList<Bar> { ... }
    

In Java, you can't do:

    
    
        class MyClass implements List<Foo>, List<Bar> { ... }
    

I know this is commonly viewed as an annoying restriction, but, IMO, it's
rather an indication that you're writing code that doesn't respect the
contract of the generic interface. For example, what should the `Count`
property return if you're implementing IList<T> twice? (C# wiggles around this
with explicit interface implementations, but I think it's fair to argue that
that's not a strictly superior approach to Java's).

------
dvt
> ... it insulates the student from the javac command line program, and the
> command line environment itself

Such a misguided article. The Java _language_ has (quite literally) nothing to
do with `javac`. In fact, there's a lot of _other_ compilers out there. Taking
a Java class should not focus on the intricacies and weirdness of Java
compiler command line interfaces. It seems pretty amateurish to argue in favor
of it. Case in point: back in high school, I learned C++ using a Borland
compiler (and I haven't touched `bcc` in the 15 years since then, even though
I've written plenty of C++ in the meantime).

> ... imports and file naming requirements.

These, again, are (compiler) implementation details and should not be part of
a generalized Java curriculum.

> And of course, mathematics is the foundation of computer science.

Stuff like this can be misleading and even though not _completely_ wrong
(discrete math, logic, metalogic, mathematical logic are sorta' kinda'
similar), it's just wrong _enough_ [1] to lead people astray.

[1] [https://www.scott-a-s.com/cs-is-not-math/](https://www.scott-a-s.com/cs-
is-not-math/)

~~~
dahfizz
I strongly disagree.

A lot of my peers in college were very bright and could write great code, but
they were absolutely useless as developers because they didn't know any
tooling. They couldn't compile, run, test, or source control their code if the
professor didn't set it up for them.

Yes, tools change, but the knowledge from one tool is almost always
transferable. Once you're comfortable on the CLI and understand the concept
that Java source is compiled to bytecode and then run on a VM, it's easy to
switch to a new compiler.

If you only want to know the absolute bare minimum, go to a boot camp. People
go to college to learn, and being comfortable with tools is an essential part
of being a developer that students need to learn.

~~~
cle
Agreed. The least effective developers I’ve had the displeasure of working
with never understand how their code executes end-to-end. And the best ones
have a deep knowledge of it.

This is no fluke! If you don’t know how a classloader works with the Java
classpath, how to set various JVM flags for operating the JVM, etc., then I’d
argue that you’re an amateur, and I wouldn’t trust you to write correct code
in a production setting. It’s critical knowledge to know _how_ your code runs,
and if you don’t know that, then stay away from production systems. If the
goal of these courses is to teach students enough about Java to use it in a
professional setting, then knowing how classfiles are produced, bundled,
distributed, loaded, and executed by a JVM is critical knowledge.

More succinctly, if you don’t know how your code makes it to a production
server and gets executed, you’re not ready to work on it.

(And if the goal _isn 't_ to teach students how to use Java in a professional
setting, then why are they learning it at all? Use a teaching language so
students can focus on the concepts instead of Java's idiosyncracies.)

~~~
siphor
eh, I understand the sentiment - but it's a little overkill. Junior
programmers can be code reviewed and taught these things over time, and also
be wildly productive in a production setting.

~~~
cle
Sure you can teach junior programmers all kinds of stuff that they should have
already learned or should know how to learn, I do it all the time. I'm arguing
that this is crucial information that even entry-level engineers should know.
If they don't, then I give them a link to the relevant documentation and
politely ask them to read it. It's a prerequisite.

------
cutchin
I'm not sure I agree much with this. When I first started learning Java I had
six or seven years of programming experience and I still found dealing with
matters of classpath and javac remarkably complicated. I had things down well
enough with the tools I used before, but it all seemed so foreign in the Java
world.

And to this day I find junior devs struggle with the same things unless they
have a maven/gradle project all set up for them.

I'm all for folks learning these skills eventually, but in a first-year CS
class I'd really rather students worry about the language and general concepts
of writing software.

Lots of javascript tutorials start off with opening and browser's javascript
console and typing out some simple stuff and I don't think people would tell
them they need to jump straight into node.js and webpack.

All the other intricacies of writing systems will come to them but I find
something uniquely wonderful about sitting and writing code, and if we're
lucky we'll find students who can have that same experience. I'd rather meet
them where they are and talk purely of the language and core concepts, and
introduce them to the ugly details as their progress dictates.

~~~
therealmarv
Actually I agree for the Java world here. Thanks to the design of Java and
many Java libraries you cannot write a little more complex Java code from your
mind. Even importing all this nested OOP libraries is complicated without an
IDE. For me Java is really a language which is impossible or too time
consuming to master without a good IDE.

Working for many years in the python world professionally some people are
still amazed that I'm essentially using more or less a normal text editor. IDE
is optional for many languages but for some languages it's a strong
requirement.

~~~
bernawil
Java is special since the whole compile/link/run loop is relatively slow and
there's no REPL. In Nodejs or python you are expected to just run your code.
Any error like a bad import/require statement you can correct quickly and re-
run. Maybe even add/remove print statements while at it. And it's not just
dynamic languages! You can have the same experience in Haskell.

~~~
oftenwrong
There is a REPL as of JDK 9:
[https://en.wikipedia.org/wiki/JShell](https://en.wikipedia.org/wiki/JShell)

------
ngngngng
I completely agree. IDEs obscure the behavior of tools and languages. It's the
last thing a student needs. I've been talking for a while about writing a
course that teaches programming in 2 or 3 languages side by side to basically
so the opposite of this. The specific quirks of languages or the things they
obscure with magic melt away when you look at languages side by side. I wish
university would teach in this way.

~~~
takeda
UCLA has a class that does this, you have 10 weeks to learn 5 languages and
write a non trivial assignment in each:
[http://web.cs.ucla.edu/classes/spring20/cs131/syllabus.html](http://web.cs.ucla.edu/classes/spring20/cs131/syllabus.html)

[http://web.cs.ucla.edu/classes/spring20/cs131/homework.html](http://web.cs.ucla.edu/classes/spring20/cs131/homework.html)

The languages change over the years, but the goal is to have them touch
different programming paradigms.

~~~
afarrell
Thats a different argument, and a much stronger one.

"Universities should offer a class on comparative programming languages and
language tooling." is much different than "Intro-to-programming classes should
not have a strongly-recommended IDE"

~~~
NoraCodes
I actually think that would mostly confuse a lot of new undergrads.
Fundamentals first, variety later (but it's definitely important!)

~~~
afarrell
I agree. The intro class should use whatever IDE & config will most enable
them to teach the fundamentals.

Understanding the details of packages and javac and other things should be
left for a later class which can put them in the context of other languages.

------
jcrawfordor
I can't help but feel like this article is less a condemnation of IDEs in
introductory teaching and more a condemnation of _java_ in introductory
teaching.

It feels like the use of Eclipse or IntelliJ in intro CS courses is so common
in large part because Java has such relatively complex tooling and language
conventions. I've never seen someone intro Python with an IDE, because it's
extremely easy to use Python without one. The same goes for C, and indeed all
of the intro C classes I've seen have gone without an IDE. Java, though... you
really could spend an extended part of the course just getting everyone
setting up their first file and using the compiler correctly, if it's the
first language.

~~~
vips7L
I don't see how java tooling is any more complex than any other language, they
all have learning curves. Even Python has complexities around venv,
requirements, pipfile etc. C's tooling in particular is probably the worst.
You have to learn the compiler, the linker, or a 3rd party tool like cmake or
meson.

Using an IDE in Java is a choice just like picking PyCharm is for python.

~~~
NoraCodes
I agree with you in general, but here I am discussing introductory CS
programs. It's very hard for an intro CS student to build and run a Java
program without an IDE, even with help from the professor. It's completely
trivial for that same student to write and run most of the Python programs
they'll be doing in their intro class after having installed _just Python_.

------
jimbob45
This can fuck right off. My elitist university decided that if it wasn’t pure
C built on a Linux box, then it wasn’t worth using. Consequently, I never
learned how much more enjoyable and quick programming could be until I used VS
at my first job. Even worse, I was a VS novice, struggling to perform even the
most rudimentary of debugging techniques, despite being fairly fluent in
GDB/Valgrind.

~~~
qppo
I had the opposite experience. My university decided that they would
standardize student development environments on vanilla Visual Studio, put
everything that students would ever want into a single header (i swear it was
something like "header.h") that you copy/pasted into your project folder and
that was it. We didn't even use the terminal.

It was tedious as hell to learn everything else in real world development,
like static versus dynamic linking, include/linker paths, make, system
libraries, and so on. Like as in myself nor my classmates would have any idea
those things existed after two semesters of C++ programming courses.

The moral here is that education needs a degree of breadth. Teaching CS
students involves three concepts - Computer Science, Writing Code, and Writing
Software. The dependency graph between those topics on what knowledge and
tools are needed contains cycles.

------
kixiQu
I'm laughing right now because ... I mean, I really thought this was going to
be saying "Don't make students use Eclipse (because it's so inferior to the
JetBrains tooling they'll use as professionals". My university had us in the
command line plenty for C--that's no reason to pretend that that world has
anything to do with how Java is written. It's the same "up by the bootstraps"
70s LARPing fantasy that makes people think that assembly will Teach
Computational Thinking Skills that will somehow confer ability to handle
distributed systems. If you want students to be able to come out able to
effectively use tools, they have to come up using them.

------
lxe
> The issue is, as Kevlin Henney is fond of saying, “Software is nothing but
> the details.” When students don’t understand what a file is, or haven’t ever
> edited text in anything but Microsoft Word and don’t realize they can edit
> code outside of an IDE3, they will not be able to do the crucial work of
> self-directed learning that is a hallmark of all computer science success.

Not sure why the aggressive comments here, but I agree with this. IDE for
learning programming ends up shielding you from reality that you should
probably understand before you use an IDE.

~~~
ativzzz
People who don't know what a file is need to take a computer literacy class
before they can jump into something like programming.

An IDE is fine to hide programming related magic for a beginner, but if it
needs to hide things like a filesystem, file extensions, navigating through
advanced options in simple software like word and internet browsers, or how to
use google to help diagnose technical issues, that person is in way over their
heads.

------
afarrell
> Most importantly, though, it limits the ability of their peers to learn. If
> a 300-level software engineering class which budgeted a week to teach basic
> version control skills has to take a two-day detour to teach the Windows
> users how to get rid of the CRLFs in their commits, and teach the Mac users
> to remove the .DS_Store files from their repositories, and get everyone set
> up in Eclipse EGIT, that’s wasted time. If the professor has to schedule
> time with students outside of class to demonstrate their code because so
> many students aren’t able to submit their code in a form that successfully
> runs on the professor’s computer, that’s wasted time for both professors and
> students, and it undermines important lessons about portability and good
> practices.

This is might be an argument against a particular IDE setup for a class, but
it isn't an argument against IDEs in general. Instead it is an argument for
providing a config file to make these problems go away.

> When students have only ever programmed in Java using some bespoke learning
> library provided by their professor, it will take them much longer than
> necessary to figure out other languages, other libraries, and other
> approaches.

The article doesn't support the case that an intro class using an IDE
_prevents_ students from learning anything else. The class doesn't set people
back--it merely fails to move them forward in that way. I agree that it is
important to teach this eventually. But it should be through teaching it
_deliberately_. (EDIT: Someone else posted a link to a class which compares
different languages and their tooling side-by-side. That sounds _fantastic_.)

I have yet to see a class which can do a good job of teaching how package
management works to a degree that the student can then confidently debug weird
setuptools errors.

I've been looking for such a class since 2009.

------
smitty1e
Related classic rant: "Does Visual Studio Rot the Mind? Ruminations on the
Psychology and Aesthetics of Coding"

[http://charlespetzold.com/etc/DoesVisualStudioRotTheMind.htm...](http://charlespetzold.com/etc/DoesVisualStudioRotTheMind.html)

------
ashton314
The author brings this up as a reason for using an IDE:

> This is valuable in an introductory course, as it avoids wasting class time
> and lowers the barrier to entry

and then proceeds to argue why other things are more important than that.

I don't like Eclipse or other IDEs, having watched my fellow students get
stymied by basic issues that I could resolve with one or two relatively simple
instructions on the command line. I think IDEs can be a crutch that
programmers ought to learn to do without. Learning what the "real" tools are
will pay dividends—quickly too.

That being said, I think it's important that the barrier to entry be low. Java
almost necessitates the use of an IDE. There's so much "enterprise" cruft
involved in doing the simplest things that, unless you have an IDE to hide it,
you're going to confuse beginners.

A better choice of language and tooling can help here. I think starting off
with something like Racket would be best. Those who _need_ an IDE (out of
laziness, familiarity, whatever) can use DrRacket, and then switch to running
their programs from the command line shortly thereafter with next to no
transition overhead.

~~~
dionian
i agree with everyone saying you shouldnt use IDE as a crutch.. but as a
seasoned Java dev, it is probably my main exception to the rule as well. I
would just recommend intellij over eclipse for beginners, but its better than
nothing.

------
hota_mazi
> Ultimately, my core belief is this: Students need to know how to use
> computers before they can program them in a serious way.

Nonsense.

If we went this way, young people would get completely turned off from
programming in the first hours.

Show them Python, Javascript, Scratch. Get them to display something on the
screen, anything.

Get that spark.

And once they're hooked, now you can start showing them more details about the
wonderful world they have just uncovered.

The author of this article needs to spend a solid five more years thinking
about computer science and education because right now, her writing is just
dangerously naive.

------
1f60c
Suggestion: in the submission title, replace "Eclipse" with "An IDE".

~~~
barnaclejive
yep.. I came here to read why Eclipse sucks compared to IntelliJ or something.
Turns out, he hates _all_ IDEs.

~~~
1f60c
> he

she[0], but yeah.

[0]: [https://twitter.com/noradotcodes](https://twitter.com/noradotcodes)

------
joppy
I think that this is mixing up two different skills.

The first skill is learning to program, and in particular learning to program
data structures, or algorithms, or whatever. For this you don't care at all
how your code builds, you care about correctness and easy to use testing
infrastructure, and an IDE like IntelliJ or Eclipse is going to be almost
frictionless for that. Teaching command line necessities together with this
provides nothing of value _for this skill_. If I'm trying to get an algorithm
right, I don't care at all about how my code builds, I care that it is easy to
hit the "recompile and run tests" button. I also think that Java is a decent
choice of language for this.

The second skill is learning how to build, version control, package and
distribute software, and for this you really need to learn the common tools
used in the industry. Which in addition to the IDE, is use of the Unix/Windows
command line, git, compilers, Makefiles and build systems, and so on. Here you
really need to care about the details - for example, such a project could be
to take a previous project and package it so that it runs on a computer
without Java/Python/etc installed.

I think the problem is that many universities never have a course on this
second skillset, and so while for teaching the first skillset they choose
appropriate tools (in my opinion), they leave this second skillset behind
completely. But I think the debate is more nuanced than IDE = Good or IDE =
Bad, I think we should carefully figure out what skills should be taught, and
what the best way to teach those skills are, keeping in mind that for a lot of
first-year university students this may be their first introduction to using
anything other than a web browser, office programs, and video games on a
computer.

~~~
NoraCodes
> I think we should carefully figure out what skills should be taught, and
> what the best way to teach those skills are, keeping in mind that for a lot
> of first-year university students this may be their first introduction to
> using anything other than a web browser, office programs, and video games on
> a computer.

This is absolutely spot on. I used IDE Good/IDE Bad mostly as a way to get
people to think about this, and clearly it worked :)

~~~
joppy
Yes, I’ve thought about it before, since at my university they started on an
entirely-eclipse sort of syllabus, and then overcorrected massively to command
line. A bunch of new CS undergrads were driven off because they thought that
programming was mostly memorising arcane command line invocations just to get
simple code to run, and that just doesn’t seem right to me.

Out of interest, your original article pointed out the potential use of
repl.it as an alternative to Eclipse and friends, but isn’t it still the whole
build-in-a-box experience?

------
indymike
The "stop using IDE _____ so that students can learn how the computer works"
has been around since at least Turbo Pascal and Turbo C. In my own career, my
toolchain seems to change radically every 3 years, and the transition time is
measured in days to weeks. It's not that deep. Neither is bringing a new grad
or new hire up to speed on whatever tools we're using.

I've worked with enough really good developers who were lost when not given an
IDE. Most of the time, it takes a few days to teach "here's how to build at
the command line" and here's how to use git (followed by the eventual day lost
to finding a way to break git completely). The IDE centrism seems especially
common in Windows and Java shops (and every Java shop I've worked with was
using Windows).

------
bdcravens
I tend to agree, but I wonder how many in the "IDE bad" camp would agree that
in order to obtain your drivers license, you must pass the drivers test on a
manual transmission?

~~~
mech422
Gotta admit - that appeals to me :-P

U.S. drivers licenses are too easy to get as it is... I don't think my sister
even had to parallel park on hers.

~~~
lordalch
Since I got my driver's license over a decade ago, I've had to parallel-park
less than ten times. I've probably changed a flat tire more often.

I think you would find that the vast majority of drivers in the US don't
parallel park even once per year. Furthermore, an increasing fraction of new
cars can park automatically.

The chief value of having a road test, in my mind, is to force most teens to
learn to drive in a structured program that introduces rules of the road and
safe habits. Parallel parking is rare and not dangerous, so we shouldn't waste
the limited hours that teens spend with professional driving educators on it.

~~~
stordoff
> I think you would find that the vast majority of drivers in the US don't
> parallel park even once per year.

In the UK, I had the exact opposite experience. Immediately after passing my
test, I was parallel parking daily, and I've frequently been in situations
where parallel parking is the only way to find a parking space. IMO it _would_
have been dangerous had I not learnt how to do it and was confident doing it.
I'd have likely have been too distracted thinking about what I'm trying to do
rather than paying sufficient attention to my surroundings. I know I was when
I was first learning, and I failed my first driving test because I didn't
adequately check my surroundings before starting to reverse.

------
enhdless
I agree that the file system is not emphasized enough anymore, and I've met a
fair share of students who struggle with file paths.

Also, in the last section:

> or UC Berkeley (oh, I’m sorry, “Cal”)

A bit off-topic, but as a Berkeley student, I was a bit amused/confused here,
what's the sarcasm in the parenthetical about? According to our official
branding guidelines[1] both are acceptable, though Cal is mostly used in
athletic contexts.

[1] pg34-35, [https://brand.berkeley.edu/wp-
content/uploads/2019/07/Berkel...](https://brand.berkeley.edu/wp-
content/uploads/2019/07/Berkeley-Brand-Manual-accessible.pdf)

~~~
NoraCodes
> as a Berkeley student, I was a bit amused/confused here, what's the sarcasm
> in the parenthetical about?

Mostly a dig at the UCB faculty and admin, who act like they're better than
the rest of the UC. (I'm a UCSD brat.)

------
Too
Strongly disagree about the IDE part. At so many places I've been it's been
the complete opposite problem. Most developers are using notepad++, or at best
vscode without any plugins or custom config.

When you ask them to put a breakpoint somewhere you get a puzzled look back:
_" what's a breakpoint?"_.

They don't even know that debuggers exist!! Instead they add printf all over
the place, recompile and rerun. Mind you these are people whose CV claim 5+
years of experience.

It's terribly ineffective. University should teach the fastest way to iterate
logic, Being able to pause your code, introspect the data and then step
through it slowly line by line is the best way to really understand and learn
the theory of what is going on. Autocomplete is also a fantastic inspiration
on what else that's possible to do that's not covered in your lab handouts.

How to import libraries and configure your build system will come later by
necessity and will have changed by the time you start your next project.
Knowing that debuggers exist and how to use them is a more general knowledge
and it's something you have to be shown first before you miss it, (if Henry
Ford asked what people wanted they would have said faster horses). Build
systems and compiler flags can also be very challenging and uninspiring to
understand before you even know what a linked list is. As someone else said
below, after decades of experience i still have problems understanding the
intricacies of CLASSPATH, or PYTHONPATH, ask a student to get this right and
they'll just blindly copy-paste the first answer from stackoverflow so they
can continue their printf-debugging session and finish their assignment before
deadline.

------
Animats
"Software Build Processes" is now a field in its own right. There's not just a
compiler. There's a build process, a dependency manager, a package manager, a
source control system, tools for updating the files those use, etc. It used to
be just "make", but now each language has some kind of package management
system. Crates, wheels, eggs, containers, boxes inside of boxes - it's
complicated.

This is all trade-school stuff, really. It's like learning how to wire
electric power, with wire size, type, and color rules, fixtures, grounding,
and in the US per the National Electrical Code. There's little academic
content there; it's just a mass of detail. Not too hard if it's written down
and the documentation is current. Which it won't be at many companies.

An argument against teaching the details in college is that students will need
to know the one they're using in great detail. Knowledge about unrelated build
systems doesn't transfer much.

Then there's the machine learning parallel universe, with notebooks and YAML.

~~~
NoraCodes
I basically agree with this. This is why, at the end of the post, I recommend
Python in a Ubuntu environment, where the "build process" is a single step
(`python my_program.py`), and packages can generally be managed with `apt`,
which is a standard tool representative of a large class of tools, which are
likely to be used at some point by a large fraction of CS students.

~~~
juped
I think Python builds have gotten nearly as confusing as Java builds (judging
by how every Python project these days wants me to use virtualenv).

~~~
Animats
Yes, virtualenv. A few years ago, I said that "version pinning" was not going
to end well, because it would reduce the pressure on library developers to
maintain backwards compatibility. Now something equivalent to version pinning
is everywhere. Moving forward is tough when, three levels down, some package
wants an obsolete version of some other package.

------
sumukh1
I used to spend a lot of time thinking about this while helping build software
& TA'ing for Berkeley's introductory course (which uses Python & Scheme) and I
largely agree with the author. If you're wondering why the author ignores
large schools, it's because they have the resources to invest in this. Here's
a sample of the things the efforts that Berkeley did for their introductory
course [1]

* Online tools to run & visualize code execution directly from the online textbook (ex: [https://composingprograms.com/pages/16-higher-order-function...](https://composingprograms.com/pages/16-higher-order-functions.html#functions-as-returned-values)) * Easy submission for students (no git in CS1, no scp, no printing) * Instructor autograding for all assignments so the course staff could focus on reviewing code for style/other components. * Automatically backing up student code * In some assignments, there were automated hints for syntax, styling, and even correctness [2, 3] * Online collaborative editing for partner assignments [4] * Full time staff allocated to building teaching infrastructure to "reduce accidental complexities when using code to solve problems" * Completely hosted environments (via Jupyter Notebooks or Scratch) for courses with a lot of non-majors.

[1] [https://cs61a.org](https://cs61a.org) [2]
[https://dl.acm.org/doi/10.1145/3059009.3059058](https://dl.acm.org/doi/10.1145/3059009.3059058)
[3]
[https://okpy.org/about/publications/](https://okpy.org/about/publications/)
[4]
[https://www.youtube.com/watch?v=polTBnMXGQI&rel=0](https://www.youtube.com/watch?v=polTBnMXGQI&rel=0)

------
stefan_
If there is one thing that Eclipse doesn't do is _insulate_ anyone. Half of
Java Enterprise development involves various concoctions of Eclipse projects.

I'm not sure what the difference is between a student learning about Eclipse
idiosyncrasies or .DS_STORE files. One topic is as pointless as the other.

------
The_rationalist
Defering learning of implementation details is virtuous and on the plus side,
intellij IDEs have state of the art static analysis that show to the coder
anti patterns and help it rewrite them in a cleaner way, and with an
explanation.

Autocompletion and integrated documentation do _increase_ discoverability and
learning of the language, not the reverse.

BTW intellij has launched an IDE specialized for teaching:
[https://blog.jetbrains.com/idea/2019/10/intellij-idea-edu-
ea...](https://blog.jetbrains.com/idea/2019/10/intellij-idea-edu-eap/)

------
uk_programmer
I agree with sentiment of this. I meet a lot of developers that cannot
function outside of the IDE (in my case Visual Studio). As a consequence they
struggle when the IDE fails.

------
8f2ab37a-ed6c
The music analogy here would be: We'd like you to learn the C major scale, but
first, please become familiar with Pro Tools.

------
BeetleB
In the introductory classes I took, there was no IDE. We telnet into a server,
and were taught Pico as an editor (although you were free to use vi or emacs
if you wanted). You compiled using g++. You did everything via the command
line.

Most of the problems the author is pointing out existed there as well.

The author is misguided in assuming that IDE's are the cause.

------
cordite
I used to do C, C++, Haskell, and php in sublime when I was a student.

But I greatly disagree about students using IDEs on languages like Java.
Getting familiar with debuggers, stepping around, that's absolutely a
necessary skill--unless you want to go into stdio, or echo based debugging
(which is what I'd do with the languages above).

------
msingh_5
I guess the sentiment is more like "Don't make students start programming in
IDEs first"

I get it. It shields them from understanding what's happening underneath. But
not everybody is interested or needs to know all the things happening
underneath, and its okay. If they're going to learn the whole stack, they
will.

~~~
afarrell
Even for someone who _is_ interested in knowing what happens underneath. To
succeed at actions, it important not to expand the scope of what you're trying
to do too broadly.

------
ericmcer
I like the idea of starting in a browser. It is a more familiar way to get
people used to the concept of text controlling behavior. The jump to
compilation and executables might still be difficult, but it’s way better than
students on their second year who only know how to run their programs by
clicking a green triangle.

------
pkamb
"public static void main string bracket bracket args"

"public static void main string bracket bracket args"

"public static void main string bracket bracket args"

kind of sad that my first exposure to programming of any kind at University
was just repeating that mantra.

~~~
saagarjha
Wait until you learn that you can use

    
    
      public static void main(String... args)
    

;)

~~~
pkamb
I gave up Java immediately after that class!

------
zmmmmm
I thought this was going to be the standard Eclipse bashing and then found it
was more fundamental than that.

In many ways Eclipse is one of the less problematic IDEs because it _does_
expose a lot of the underlying warts... it's one of the reasons people dislike
it (among others, to be clear - memory usage, less fluid ergonmics in many
other ways). But one of the reasons I have stuck with it is that, like when
you understand Git at a fundamental level it all "makes sense", Eclipse has a
better direct relationship to the underlying mechanics than other IDEs I've
used.

------
yters
I like Eclipse, but now that I know my way about, it's much easier to knock
out a small Java problem on the command line than to fire up Eclipse, setup a
project, etc. Then there's all the magical metadata and whatnot that can get
screwed up.

Much less mental overhead and less things to worry about on the Linux command
line. Plus, I can do more with the commandline tools.

I think students in general will be more versatile if they start with the
command line, and then graduate to Eclipse. That way, they'll realize what
they lose and gain in an IDE.

------
oaiey
Maybe eclipse is too much IDE. Maybe a advanced editors like VS Code hit the
sweet point. The tasks infrastructure there - as bad as it is - will force you
to understand details. It also has a terminal.

I do not understand the Java bashing. Python is nice, but it is an
interpreter, does not compile, link or create executables. It misses so much
in the compilation chain that it is neither a good language in the regard of
this post.

C++ has all, but well, editors are crappy and pointers for a first lesson
student are hard.

------
29athrowaway
Java might not be the best first language to learn, but if you can't grasp
Java as a college student, you won't survive the winter as a professional
programmer.

------
stordoff
I liked the approach Cambridge took for computer science (at least while I was
there). Practical assessments:

* Year 1, term 1: ML, on a Windows machine, using Cambridge ML (for the practicals; the actual course, Foundations of Computer Science, used any Standard ML and recommended Moscow ML)

* Year 1, term 2: Java, on a Linux machine[1], using javac; Eclipse was introduced in another course

* Year 2, term 1: Further Java, on a Linux machine, using Eclipse, Verilog on a Windows machine with a DE2 Board, MIPS assembler using a soft processor (same board) plus one or both of:

* * C/C++, non-compiler specific, no recommended IDE/editor, must run against gcc -std=c99 -Wall --pedantic sourcefile.c or g++ -std=c++98 -Wall --pedantic sourcefile.cc (your choice) with no warnings

* * Prolog, on a Linux machine, using SWI-Prolog

* Year 2, term 2: Group project - group's choice (we used C on an Arm mBed board in whatever IDE that came with and Java in Eclipse)

Everything else (the bulk of the course) was either abstract/theoretical or
used you/your supervisors' choice of tools - courses used a varying mix of
pseudocode/ML/Java/C where useful, but you didn't necessarily have to use them
outside of the lectures and there were no practical exams on these (someone I
knew used Haskell for his group project and dissertation, and for testing
concepts in supervisions).

The idea was to make you comfortable with the fundamentals and moving between
technologies, and not be reliant on any particular set of tools. IMO, the
contrasting concepts (Windows vs. Linux; functional vs. object-oriented; high-
level vs. low-level; hardware vs. software) did this rather successfully. It
didn't necessarily get you completely fluent in any particular language (you
were largely expected to do this in your own time if it was a direction you
wanted to pursue), but it did prepare you for jumping into pretty much any
language/environment and getting up to speed quickly.

(There were also digital electronics and physics practicals in the first year,
but they're a bit of a different thing)

[1] It gave you enough bash to run javac and manipulate files. There was a
follow-up course the next year that went into a bit more depth on shell, and
introduced make/Perl/LaTeX/MATLAB.

------
ineedasername
Honestly I wasn't aware that current curriculums used any sort of advanced
IDE's.

When I took courses in the late 90's & early 00's, from assembly, c++, java
and python the focus was on minimal text editors and command line compile,
link etc. Though for python, Idle was promoted, but that's pretty bare bones
relatively speaking.

I wasn't aware that a shift away from basics had occurred.

------
bcruddy
I feel like people upvoted this because it said don't use eclipse but didn't
read the article. Now I'm questioning my sanity - given a choice, do
professional developers choose to use eclipse?

The question is somewhat loaded given the previous statement based on my own
biases but I've never written java professionally so excuse my ignorance.

~~~
vips7L
Most java devs use intellij. But the eclipse language server powers the vs-
code plugin for java. It's quite good and it's what I use personally.

~~~
bcruddy
Totally makes sense as a plugin - I love vscode for both golang and
javascript. The IDE itself seems clunky but I'm not against IDEs themselves.

------
jbverschoor
Actually.. for the basic basics it's fine to do let them use a text editor and
compiler.

But after like 2 files, it's easier to learn the language due to autocomplete
and errorchecking.

The whole compilation / dependency stack, well I don't think that's the issue
here.

------
shean_massey
My uni was nothing like this and I appreciate that. First year: every thing is
terminal based, vim was taught, Javac was used by hand, as was nasm/ld/gcc.
Only in the second year were we moved to netbeans and eclipse.

------
DrKabab
Harvard's CS50 does a great job at this. My first intro to CS was through this
course, and I'm grateful I did it this way rather than wait till I was taught
in the "broken" way at college.

------
rschulman
My first year CS classes went by SCIP and were taught in scheme. Of course, I
went to a place that didn't much distinguish between comp sci and comp eng, so
what do I know?

------
Havoc
Yeah I found Eclipse a pain to set up for python the first time I tried. Kept
throwing weird Java errors and GUI glitches. Abandoned that plan very fast

------
pbhjpbhj
>Using Java or Python in a professional IDE like IntelliJ IDEA, NetBeans,
PyCharm, or Eclipse is not a good first introduction to programming for
computer science students, whether they’re in the field to become web
developers, systems software engineers, or academic computer science
researchers. //

So "for computer science students".

Which seems like too major a thing to miss out of the title.

Also, how does webdev fit in here: seems like webdevs should probably be using
IDEs from lesson 2. And I say that as someone who started their web content
production path writing HTML in pico.

------
pacetherace
While I agree with not using very advanced IDEs. It is important to have the
means to quickly navigate standard libraries. MSDN gets my vote for that.

------
rukuu001
I mean, I get this.

I don’t think students should start with Eclipse - it’s a while learning curve
on its own.

But they should definitely be familiar with it by the time they graduate.

------
lonelappde
This article is a confused mess with no point. Sure it would be nice to teach
students everything at first. But that's obviously impossible.

~~~
mr_toad
People often forget how few hours go into a typical university paper.

It’s not unlikely that a programmer with a full-time job could put in more
hours in just one month than a student would for an entire introduction to
programming paper.

It’s unrealistic to expect to be able to cover all aspects of programming in
such a short time.

------
Guest42
In my academic experience netbeans was used and it seemed to simplify things.

------
shmerl
Start without using any IDE.

------
thewebcount
> First, in a Java-focused curriculum, it insulates the student from the javac
> command line program, and the command line environment itself.

I take exception to this line of thinking. Students should not be using the
command line for programming. I believe that forcing students to learn to use
command line tools is the reason why so much software has such horrible user
experience. They learn that users don't matter unless they've steeped
themselves in the arcana of each particular program and have practically
become programmers themselves.

> Second, it catches some basic mistakes and allows the student to defer
> learning about the finnicky language requirements that aren’t deemed core to
> the curriculum, like imports and file naming requirements.

I had the exact opposite experience. At university, they sat us down at a Unix
shell with almost no instruction on the shell or the compiler. We spent so
much time learning the finicky shell requirements (and which we had no clear
understanding were part of the shell and not the compiler itself or something
else), that we were sidelined from understanding what the compiler was telling
us or how it worked. You'd run your program and if it gave you an error 11,
well, you just read and re-read it until you noticed something off.

Nowadays with an IDE and a static analyzer, it can show my code and show the
exact path of execution that will lead to an invalid memory access before I've
even run it. Students can learn to find problems themselves because it's laid
out right in front of their eyes in relatively-understandable java or C or
whatever language they're programming in. They don't need to worry about, "Oh
when I compile on this machine, I have to specify the -I argument to the
compiler for includes, but on machines I actually use in real life, I don't
have to specify anything because it finds all the files I'm actually using
because I put them into the IDE myself and can see their relationships."

> it’s crucial to introduce these inconvenient details eventually.

Why? If I'm going to be downloading my IDE from the Internet or an App Store
why the heck should I ever learn fiddly Unix commands? I'm writing GUI-based
applications. I don't _need_ to understand any of that crap if I don't want
to. It's like saying you can't be a taxi driver if you don't understand how
the carburetor works. Really? My job is to drive the car around, not to fix
it. I know a good mechanic who can do that if the need arises. If they want to
learn it, then all the better, but it shouldn't be a requirement.

> What they can’t do, unless they’ve figured it out on their own, is operate a
> computer outside of the confines of the IDE they’ve been taught.

On the contrary, I had no problem operating the GUI-based computers of my day.
It was the bizarre, often contradictory commands in the Unix shell that
baffled me. Their names were often stupid puns, their "help" pages did no such
thing, and I wasted years learning a bunch of stuff that ended up not being
very helpful in the real world.

> When students have only ever programmed in Java using some bespoke learning
> library provided by their professor, it will take them much longer than
> necessary to figure out other languages, other libraries, and other
> approaches.

That has nothing to do with IDEs. That has to do with a deficient teaching
environment, and is the exact same problem I described above, which sounds
like what the author is advocating.

> Teaching someone to use git is very difficult if they’ve never been taught
> that a file is an logical unit composed of bytes and metadata.

No, teaching someone to use git is very difficult because it was designed to
be difficult because the self-absorbed creator thinks that people should have
to suffer to become good programmers. It's just sadistic.

> Students need to know how to use computers before they can program them in a
> serious way.

I agree, and what the author is proposing sounds like the opposite of that to
me.

> After the first foray into programming, take time to teach students about
> the UNIX command line.

Ugh. I disagree strongly with this sentiment. CS students need to get away
from the mentality that Unix is the be-all-end-all of operating systems and
programming environments and the quicker that happens the better in my
opinion.

------
erdos4d
Wait, I shouldn't make students learn the tool they will be forced to use when
they get a job? Um, no.

~~~
nullc
People who learn the tool _alone_ are substantially unhireable.

When you hire a developer you usually need them to also be at least be
something of an expert computer user, especially if they're going to be
working on a small team without 20 other experts to micromanage them.

Over-reliance on the IDEs leaves people appliance operators that are lost when
there isn't a magic button to press.

It isn't just an issue in the job market. "Programmers" who aren't
sufficiently advanced computer users can't advance their own projects in
academia either-- they're stuck working on precooked assignments. I suspect
this is one of the forces that has resulted in academic research being utterly
starved for competent software engineering (though the main one remains that
competent software engineers can get stable high paying jobs, and academia
provides them with neither).

------
nunez
Truth. I work with plenty of engineers that have only written Java with
Eclipse or Jetbrains. Many have a lot of trouble getting their app to compile
locally when asked to do so upon moving the app into containers. Many also had
issues even writing software upon trying to use something like Vi or VSCode.

At some point, the training wheels need to come off.

------
dacracot
I agree, and it has been going on for a very long time. I have coworkers who's
productivity (if you can call it that) would slide to zero if you took away
Eclipse. If it isn't implemented in an Eclipse plugin, well forget it. Setting
up the deployment environment is so far outside of their capability as to be a
joke. And these people have been out of college for over a decade.

------
gwbas1c
> What they can’t do, unless they’ve figured it out on their own, is operate a
> computer outside of the confines of the IDE they’ve been taught.

Understanding what a file is and what a text editor should be prerequisites
for entering a computer science department. Someone who doesn't understand
these concepts has no business learning to program.

At my "not MIT" school, it was expected that most incoming CS students
understood some basic programming before they entered school.

A CD department that tolerates students who don't know what a file is probably
has other problems.

~~~
stordoff
> At my "not MIT" school, it was expected that most incoming CS students
> understood some basic programming before they entered school.

At Cambridge (UK), this is _not_ the case. They merely note that "some
knowledge of procedural programming is useful"[1] and "[n]o prior knowledge of
programming is required"[2]. The main thing they are looking for, in terms of
qualifications, is mathematics, so you'd typically see an A-level in
mathematics plus two further ones in further mathematics, the physical
sciences, or computing depending on what your school offers.

At interview (for two colleges), I was not asked about programming - the first
was purely mathematics based, and the second was primarily maths based with
some CS concepts introduced to see how you thought about and were able to
manipulate the information given in the interview. It's not something you were
necessarily expected to know.

Until this year, the introductory CS modules (making up 25% of the first
year's content) were available to natural sciences students, so you would have
students from a fairly wide range of backgrounds _successfully_ learning CS
and to program (the maths modules, also making up 25%, are still shared, for
what it's worth).

[1]
[https://www.cst.cam.ac.uk/admissions/undergraduate/entry](https://www.cst.cam.ac.uk/admissions/undergraduate/entry)

[2]
[https://www.undergraduate.study.cam.ac.uk/courses/computer-s...](https://www.undergraduate.study.cam.ac.uk/courses/computer-
science)

