Win a copy of Rust Web Development this week in the Other Languages forum!
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Tim Cooke
  • Campbell Ritchie
  • Ron McLeod
  • Liutauras Vilda
  • Jeanne Boyarsky
Sheriffs:
  • Junilu Lacar
  • Rob Spoor
  • Paul Clapham
Saloon Keepers:
  • Tim Holloway
  • Tim Moores
  • Jesse Silverman
  • Stephan van Hulst
  • Carey Brown
Bartenders:
  • Al Hobbs
  • Piet Souris
  • Frits Walraven

Educator makes compelling case for beginners NOT starting in an IDE

 
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Likes 2
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I have always been kind of on the fence about our "party line" here at the Ranch for beginners to eschew the IDE in favor of a plain text editor and the command line.

JetBrains, the company that creates the excellent IntelliJ IDEA, recently published a webinar they hosted and presented by Geoffrey Challen, a professor at the University of Illinios in Urbana-Champaign, who talked about developing course material for CS1 in Kotlin. Towards the end of the presentation, he makes the case for beginners just learning how to program to NOT start with an IDE. The link below will take you directly to that part of the video:

https://youtu.be/X8Az9X0mwUE?t=1h16m16s

I think this educator has pushed me off the fence and has me squarely toeing the line on CodeRanch's recommendation. I guess I just needed a really good, compelling metaphor to convince me, and the 747 Jumbo Jet vs Cessna metaphor is perfect.

In the video, he also links to what looks like a very good resource for learning materials on both Java and Kotlin. Check it out:
https://www.cs124.org/start/

 
Saloon Keeper
Posts: 13481
304
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
For those who prefer to read, can you paraphrase the metaphor?
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Stephan van Hulst wrote:For those who prefer to read, can you paraphrase the metaphor?



Thank you for the gentle call-out Stephan.

Here's an abridged transcript of what he said in the webinar:

"How do we bootstrap students in a good way that gives them the foundation for success? For me, having them start with the IDE is not always the best thing. These (IDEs) are complex pieces of software. As soon as you open up one of these IDEs, it's like you're at the controls of a 747... You don't take someone who's still trying to learn how to fly a plane and take them into the cockpit of a 747. That's not where you start, right? You start with something that has the minimal set of controls that you need and you teach them there first and then eventually they build their way up to that (the 747)."


Like I said, the image he paints with that metaphor is very compelling.
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
As with any other rule, there are contexts that allow for a few exceptions. For example, if the learner already has prior experience with other languages and/or IDEs and is comfortable working directly in an IDE.

I fall into that category. Sure, if the language has a REPL, I might mess around in that a little but more likely than not, my first instinct as an experienced programmer would be to find the most popular development tool for that language and use it, be it an IDE or just a specific collection of tools and utilities.

Except for C#. Even though Visual Studio and VSCode are the most commonly used tools for it, I still prefer JetBrains Rider because I'm comfortable with the controls. It helps, too, that JetBrains seems to make their controls as consistent as possible across their product line. Very smart decision on their part.
 
Bartender
Posts: 4731
183
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I have two comments to make:

First, the man talks about "not always", so there must be some cases where starting with an ide IS the right thing to do.

And, in math one counter example is enough to disprove a theoreme, and I myself is (am?) such an example.
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Sorry, Piet, I got my answer in right before you posted. We must be on the same wavelength today.
 
Stephan van Hulst
Saloon Keeper
Posts: 13481
304
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I don't necessarily think that every beginner must start out without using an IDE, but I DO firmly believe that every beginner that is serious about programming professionally, MUST learn to use the console early during their studies.

There are important features of the Java platform that are relatively easy to understand and debug, that even intermediate Java programmers often have issues with for the simple reason that they haven't bothered to learn the tools they are using. The class path and resource loading are classic examples, and since Java 9, the module system.

The problem is that many people who start out using an IDE will then be apprehensive about using the console. It is for that reason that I strongly recommend starting with the console instead of with an IDE.
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Luckily, I learned to program during a time when the only option was the command line. Or rather, I should say, with a text-based interface. I learned to program by learning BASIC and Pascal at the same. In school, it was Pascal. I was so enamored with programming that I enrolled in our local computer training center (the only one in our city) that was run by professors in my school.

Anyway, we used one of the early versions of Turbo Pascal which had a very rudimentary text-based menu. This is what it looked like:
Filename: 9453806_orig.png
Description: Borland Turbo Pascal 3 text menu
File size: 20 Kbytes
 
Marshal
Posts: 74637
335
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Barnes and Kölling, in their book Objects First, say their motivation for creating BlueJ came from seeing people getting frustrated with the many controls available in an IDE. Unfortunately, I don't rate BlueJ at all.
 
Stephan van Hulst
Saloon Keeper
Posts: 13481
304
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
That's fun Junilu, you could say my passion for programming started with Basic and Pascal as well.

My first experience with programming was in a modified version of BASIC that was used to write small programs for the Casio CFX-9850GC PLUS. A friend of mine in high school then told me about Pascal and gave me a copy of Borland Turbo Pascal:




In the first year of university, they used Eclipse to teach us Java, but at that time I felt much more comfortable using a simple text editor and the command line, so that's what used for most of the first year. I was already a member of CodeRanch when I started using an IDE more regularly (specifically NetBeans, I still have a strong distaste for Eclipse).
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
The first two images on this wikipedia page bring back many memories: https://en.m.wikipedia.org/wiki/Apple_II_series

That's the kind of computer I learned to program on, except ours were Chinese knockoffs that could run dual mode with a Z80 card so you could run CP/M. We just called it the CP/M card. You'd literally have to flip a switch on the back of the computer to switch between CP/M and Apple II modes. Those were still 5.25" disks and we were so proud to walk around with our Dysan hard cases as a badge of geekdom. Pocket protectors were never a thing in my time.

When I learned intermediate BASIC to write programs that could read/write from disk, I used a TRS-80 Model III, an image of which can be found towards the bottom of this page: https://en.wikipedia.org/wiki/TRS-80

A blast from the past.
 
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
My recommendation to avoid IDEs when first starting comes from bitter experience.

A LONG time ago, I was trying to learn some hot new Java technology (I forget what) and I made a mistake of letting an IDE's  "wizards" build the system. However, as is commonly the case, the pre-built stuff was not flexible enough to do what I really wanted, so I tried to modify things.

It was an unmitigated disaster. Because I'd let the IDE do all the thinking, I didn't know what all the components were or where they were located. It just became a bigger and bigger mess. I had to start all over again, this time manually. One reason why I laugh at management who think that they can hire monkeys because $FLASHY_NEW_SOFTWARE_TOOL will allow them to produce major systems without any actual skills.
 
Junilu Lacar
Sheriff
Posts: 16767
281
Mac Android IntelliJ IDE Eclipse IDE Spring Debian Java Ubuntu Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Tim Holloway wrote:One reason why I laugh at management who think that they can hire monkeys because $FLASHY_NEW_SOFTWARE_TOOL will allow them to produce major systems without any actual skills.



Yeah, in the same vein that some managers think that CI/CD can be achieve by installing tools like Git and Jenkins and imposing their use on development without so much as a conversation about CI/CD practices outside of the tools and how the tools should be used with said practices to achieve CI/CD.
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Junilu Lacar wrote:

Tim Holloway wrote:One reason why I laugh at management who think that they can hire monkeys because $FLASHY_NEW_SOFTWARE_TOOL will allow them to produce major systems without any actual skills.



Yeah, in the same vein that some managers think that CI/CD can be achieve by installing tools like Git and Jenkins and imposing their use on development without so much as a conversation about CI/CD practices outside of the tools and how the tools should be used with said practices to achieve CI/CD.



Definitely. In the case of the Ranch, both Devaka and myself are too paranoid to do CD, but I have been working on getting Jenkins to do the leading stages for manually-initiated deployment. By putting a suitable hook into Git, Jenkins can trigger when a production marker tag gets set, producing deployable WARs customized for CodeRanch and Permies. That would be a change from the current setup where the git server gets polled every 5 minutes and does a generic build when any change gets committed without regard to deployability.
 
Marshal
Posts: 8198
585
Mac OS X VI Editor BSD Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

"How do we bootstrap students in a good way that gives them the foundation for success? For me, having them start with the IDE is not always the best thing. These (IDEs) are complex pieces of software. As soon as you open up one of these IDEs, it's like you're at the controls of a 747... You don't take someone who's still trying to learn how to fly a plane and take them into the cockpit of a 747. That's not where you start, right? You start with something that has the minimal set of controls that you need and you teach them there first and then eventually they build their way up to that (the 747)."


I'm all up for starting with command line for compiling source code and some primitive text editor for writing code. First, it is fun, second, it really helps better understand the ongoing process, meaning, add required dependencies to the class path (if needed), then get source code compiled (that's no longer mandatory with jdk11+, right?), and eventually run it.

But contrary to all that, to open up an IDE and have an initial project created and be able to run a simple hello world program, all IDEs I know they make all that so simple out of the box, that I can't imagine what can go so horribly wrong that students would get so frustrated, that couldn't even concentrate anymore on actual code writing.

So, I'm seeing it slightly differently. It is beneficial to understand the manual process, instead of jumping straight to a more automated one. And when is the best time for that if not right from the start.

The analogy which comes to my mind would be to ride a scooter vs geared motorcycle or equivalently car with manual vs automatic transmission gearbox.

Once you try automatic, you quite likely wouldn't like even to think about manual, even if that would be just for a very short time. So the chances that you'd ever learn to ride a vehicle with a manual transmission box would become less and less likely over the time. Now, the opposite is perfectly fine and very standard thing, at least in our current age generation. You learn the manual way, then you are equally proficient with an automatic. In the coming years probably less and less people would know how to ride a vehicle with manual transmission gearbox. Isn't quite the same with all those frameworks we learn and use them, that we could barely do the same things if we'd need to do them manually now?

The benefit for people who took the driving test with manual gearbox is, they can drive both: manual and automatic cars, while those who took with automatic, they can drive only automatic.

So once again, I'm not seeing an IDE as something what necessarily  would add much extra complexity (of course it could if you wanted to, but you don't have to), but simply as something what would take away from you the chance to learn the core/old ways of doing things. You may need it at some point, or you may not.

Command line is something we all often use even in nowadays. Whether it be a project build with some build tool, whether it be a simple git project checkout. Even though you could do those things via IDE, I believe quite a few still do that via command line (I do, not everything, but still a handful things). So again, adding command line to a toolset right from the beginning - it makes a perfect sense to me.
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
One thing to keep in mind, though, is that when it comes to professional work, you are going to hear words like "java compiler", "jar", "jvm", "war" and stuff like that on a routine, if not daily basis. And it's really not a good thing when you just stare there slack-jawed because you've never actually worked with those things and don't know what they mean.

Perhaps one of the more extreme examples, is "war". How many times have we told people that they can't just fling files at a webapp server and expect them to work?
 
Ranch Hand
Posts: 112
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
It's an interesting question. My feeling is that while learning CLI is more useful later on, starting with an IDE for a beginner is a lot more inviting. Although I avoid using IDEs now, looking back I used a LOT of IDEs in my education and professional experience: QBasic, Turbo C++, MASM, TASM, BlueJ, etc. It's hard to say whether I would have continued into programming at all without the existence of those early IDEs. Nowadays I like separate specific tools (editor, compiler, linker, build system, dependency management, source control, etc.) so that I don't need to learn (or be locked into) a specific IDE's way of doing things. Once a beginner has proficiency using an IDE, they can then learn CLI, and disspell the illusion of simplicity that an IDE provides. They can make their own choices as to what editors, compilers, libraries, and source control tools to use. For example, I use (seriously) Notepad++ as an editor, PowerShell (on Windows, else bash shell), Git as a source control system, Ant as a build system, Javac as a compiler, gcc and make for JNI dependencies, etc, etc. If I wanted that setup in an IDE I'd have to learn how to configure that specific IDE for all my particularities.
 
Campbell Ritchie
Marshal
Posts: 74637
335
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Damon McNeill wrote:. . . Notepad++ as an editor . . .

An excellent tool.
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Campbell Ritchie wrote:

Damon McNeill wrote:. . . Notepad++ as an editor . . .

An excellent tool.


Heathen. emacs is the One True Editor!
 
Campbell Ritchie
Marshal
Posts: 74637
335
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
He's using Windows®. The only editors he can get to work are Notepad, Notepad++ and vi
 
Rancher
Posts: 193
5
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Actually as someone still using notepad + cmd after 15 years for the majority of my time I always encourage to start learning your first language without an IDE.
Why? Two points:
1) to learn what black magic is actually happen under the hood
2) to learn your way around without autocompletion and code generation

Yes, if you already have experience with another language and know the stages of maybe pre-processing, compiling and even linking to get a final binary from some sources and make money with it - an IDE is an required all day tool to get your job done.
But if you new to the scene you first have to learn how to crawl before you can stand up and walk around.

To me it is actual a required skill of being able to copy some source into an editor and compile it from command line - How often we see beginners struggle to reply on simple tasks like "cut down to most basic compileable example - what's the output" - or: "when I click on a *.jar 'nothin happens' - run it from cli - 'How am I do that?'". It's some basic skill you just HAVE to know when you start programming - or, how I like to put it: "if you want to tell that magic machine what to do - please first make yourself familiar with how to use it in the first place".

Or to put it that way: We all here have seen so many threads like "I have a deadline tomorrow and our teacher taught is nothing" ... and I'm just sick of it when you ask to just provide a simple example and many fail to even that simple task because "yea, mostly the IDE does what the prof told us" without understanding what's actually happening behind the scene.
Part of that also comes from personal job experience past 10 years: so called "professioal devs" not understanding a sh!t of my job get about twice the salary and fail in so many ways (as a "recent" example: some change back in april this year(!) caused our customers to have issues with their banking account information and the company lost quite some money by taking over direct debit returns - ok, I guess it's just cheaper to pay couple of minimum wage customer service employees instead of just rolling back what ever was changed in april - we have the money for it because we're one of the four nuclear power plant operators in germany with a two-digit million figure of customers - who give's a damn?).
Seriously - I'm  a hobbyist dev for past 15 years and I'm able to fix a simple android app withing minuts to hours - this issue goes on for OVER HALF A YEAR!
 
Rancher
Posts: 359
21
Mac OS X Monad Clojure Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Tim Holloway wrote:That would be a change from the current setup where the git server gets polled every 5 minutes and does a generic build when any change gets committed without regard to deployability.



But wouldn't it be even better to be in a situation where every change committed (to the main branch) could go straight to production?

Where I work, all changes go through PRs (pull requests) and are both reviewed by people and are automatically tested (by BitBucket Pipelines) and every approved, merged change to the main branch is automatically deployed to our staging environment. And then management (QA & Product Owners) can decide to push any artifact that made it to staging to one or more production servers via a web UI and deployment is fully automated. Our goal is to remove that gating factor and have every commit to the main branch go to production automatically and we're pretty close to the confidence level needed for that for most of our apps built from our monorepo.

Our full CI build cycle to staging takes about 20-30 minutes right now (we're working to tighten that up) and we can currently go to a full production deployment across the cluster in about 15-20 minutes from staging so we are currently capable of deploying changes over half a dozen times a day for a standard work day, which is a massive improvement from where we were a few years ago.
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Campbell Ritchie wrote:He's using Windows®. The only editors he can get to work are Notepad, Notepad++ and vi



http://mirror.team-cymru.com/gnu/emacs/windows/  
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Sean Corfield wrote:
But wouldn't it be even better to be in a situation where every change committed (to the main branch) could go straight to production?



If you're like Amazon and don't mind random massive hour-long outages.

There's "production" and there's "certified production" and the two are not the same in many shops. Last bank I worked at, I could post code to production, but before it actually went live, a review board had to approve it - and the failback plan that was a mandatory part of the change control process. There's always the possibility that a horrible realization might come to me between commit time and actual deployment, so that allows a window for last-minute fixes (as well as shops whose final review includes having non-developers do the pre-deployment build and Beta test. and/or code reviews).
 
Sean Corfield
Rancher
Posts: 359
21
Mac OS X Monad Clojure Linux
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Tim Holloway wrote:If you're like Amazon and don't mind random massive hour-long outages. ... Last bank I worked at...



I can imagine a bank being a bit squeamish about CD but NuBank has shown that can work, even for a bank: https://building.nubank.com.br/working-with-clojure-at-nubank/ (and I'm sure there are other banks that have CD these days).

Bugs make it to production whether you're doing CD or not, but if you have confidence in your code review process and your automated testing process, and have the ability to get even a single bug fix through that pipeline to production quickly, then CD is nothing to be afraid of -- but it is all about having good hygiene in your software development/deployment which, unfortunately, a lot of companies lack.

My original comment was meant to be more of a "Wouldn't it be great if you could be confident that every version of your main branch was well-tested enough to be deployed?" -- which I think is something every software development team should aspire to.

And to tie it into the original topic of this thread, a good argument (in my mind) for beginners to start with basic tooling and the command line is that they get a much better handle on automation upfront, and I think that knowing how to automate tasks around build/test/deploy is a really important skill for a software developer -- an IDE hides so much of that. I've known developers raised on visual tools and big, fancy IDEs and they often have no idea how to even compile their code from the command line, let alone automate anything.
 
Tim Holloway
Saloon Keeper
Posts: 24825
172
Android Eclipse IDE Tomcat Server Redhat Java Linux
  • Likes 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Sean Corfield wrote:
My original comment was meant to be more of a "Wouldn't it be great if you could be confident that every version of your main branch was well-tested enough to be deployed?" -- which I think is something every software development team should aspire to.



Well, the actual aspiration of said bank was "Git 'R Dun!" As in, we could fix this oft-repeating server-crippling bug, but we'll just turn it off and back on again, instead.

As to designing and building software without artificial assists, I don't think any of us here would disagree with you. I've likened it to learning to walk on crutches when you have perfectly good legs and feet. If that's the only way you can walk, you can't really walk.
reply
    Bookmark Topic Watch Topic
  • New Topic