39 ms·

Stop Making Students Use Eclipse (2020)

• namero999 5y ago
  As a teen, I taught myself Java several years ago (pre 1.2) on BlueJ, and I'm so happy to see that it is still a thing! https://www.bluej.org https://www.bluej.org It really helped a lot back then!
• Ekaros 5y ago
  I don't really see much difference for a newbie between a button in IDE or copy pasting some arcane command line command to get something out of mess of text they don't understand they copy pasted in a file... Many forget that these students are essentially starting from zero. And just to get something that prints text in first place is good start. With luck they should also learn some flow controls and functions too.
• changoplatanero 5y ago
  Im glad he put in there that he’s not talking about mit or cmu. There is a world of difference between a cs student there and someone learning programming at the average American university.
  • ternaryoperator 5y ago
    *she
    • nesarkvechnep 5y ago
      Maybe he didn't get the memo
• fredgrott 5y ago
  I am going through the process of creating a stepping stone in the form of a small app code sample that already has the feedback including UML visualization in place as a way to address this in my tutorials and upcoming Flutter dev book series. Its kind of the right way to pair the livebook way of teaching Flutter frontend and frontend in general.
• bazhova 5y ago
  Do people still use IDEs? I've worked as a web dev for years and the only person I know who used an IDE was an older DBA. Honestly just learning how to run and compile shit from the CLI is the most direct way to learn to program, and not that hard. VSCode is free? I learn this way both on my own, bootcamp, and now in grad school. Only older YT videos suggested Eclipse and such
• 999900000999 5y ago
  I legitimately left a job once over being made to use eclipse. Absolutely abominable horrible IDE. Our environment was so fragile, we needed everyone to be on eclipse for things to work. To this day I don't really like Java, and I typically don't even apply to Java roles. Eclipse is just that bad. Visual studio on the other hand is one of the best Ides ever made, you can tell Microsoft puts in some effort.
• david_allison 5y ago
  Absolutely not. There's significant educational benefit in timely, corrective feedback, which an IDE with incremental compilation and a linter is perfect for. Eclipse isn't a good IDE for teaching[0], but it's significantly better than the commandline and javac. By introducing too many concepts, you water down the educational value and motivation to learn. Seeing output on the screen is exciting, don't get in the way of this. javac doesn't provide value for beginners, it's a roadblock to a user seeing output on the screen. Take it out the way of new developers, maybe show it in a "commands executed" window to drive curiosity and introduce it properly in a later course, but only after a user feels comfortable with the basics of software development [0] I don't think a good IDE for teaching exists currently. Customizing IntelliJ would be fantastic for this, and I'd love to see if someone's working on this.
• einpoklum 5y ago
  > 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 I agree. But I would say that using Java itself is not a good first introduction to programming for Computer Science students. Python interpreter in a textual terminal seems like a better place to start. Alternatively, JS code in an HTML page. Students should not feel they're steering a large airplane with an infinite number of indicators, knobs and switches; it should be a low-epistemological-noise environment - where, initially, the only new thing to learn is the language and what output you get when trying to (compile and) run a program.
• todd8 5y ago
  Nora.codes makes a lot of sense in this essay. CS instruction is a mixed bag. I started out in CS in it's Middle Ages so my own initial experiences aren't relevant. As a graduate student for many years though, I have watched and taught new CS students, which has given me a perspective on learning CS. More importantly, I've had an opportunity to observe my own daughter who started programming in college, got a degree in CS and will soon be finishing grad school. Observing how my daughter and her friends at other colleges were taught, I saw many unnecessary difficulties (Eclipse being one of them) and on the other hand some outstanding approaches to teaching them CS. Her first language was Racket (interesting) and her first book was How to Design Programs, 2nd Ed. (excellent choice, see [1]). This course taught her basic principles and heuristics for designing programs. She was able to go back to these ideas when she was uncertain how to proceed and though the steps elucidated in the text was able to work through her assignments; by the end of the semester she wrote a simple video game going above and beyond the assignments requirements. Essential to making this course accessible to someone who had never programmed before college was the controlled environment provided by Racket. I believe that she did all of her programming within the IDE provided by installing Racket. For an absolute beginner, a controlled environment hiding the complexities of the file system, etc. worked very well. She wasn't sure if she was going to like CS, but this experience helped her decide to keep going. Thumbs up for Racket and How to Design Programs. A couple of semesters later, she had to take the Data Structures course. Inexplicably to me, the course which covered subjects like single and doubly linked lists, hash tables, and binary trees used Java and Eclipse. I feel like this is just teaching bad habits. If you are using Java, why aren't you learning to use Java's own collection libraries. Why use a garbage collected language, without an explicit random addressable memory visible to the new programmer, in order to teach how one builds doubly linked lists? The book was terrible. Thumbs down on Java and Eclipse for teaching Data Structures. So, I agree with the essay that learning the details of Java in an intro course is inappropriate. The Racket course provided a series of increasingly more comprehensive subsets of the language as the semester advanced, perfect for insulating the students from incidental complexity. And, I also agree with Nora.codes that learning the details matter. Java was too high level, to full of other stuff (like type erasure) to get in the way and it really obscured the ideas behind pointers, and implementing one's own binary trees. [1] https://htdp.org/2019-02-24/index.html https://htdp.org/2019-02-24/index.html
• cletus 5y ago
  Personally, I'm against making students use Eclipse because it's a terrible IDE and this constitutes cruel and unusual punishment. Seriously though, I have trouble following the author's argument here. For example, she points out that details like the Windows filesystem being case-insensitive are hidden. Well, that's true if you use an IDE or not. And how does not using an IDE expose you to that? Also, what 300 level software engineering course is taking time out to teach you how to use an IDE? Is my experience abnormal? I can remember showing up to second year and being told "we're using C now, here's an 8 page pamphlet about how that works" and that was it. I'm all for not making learning programming arbitrarily more difficult in the beginning as that's how you lose people. Having done things is not a badge of honor. In fact, encouraging this kind of gatekeeping as acceptable is (IMHO) far more harmful.
• catbuttes 5y ago
  Anecdotally if I’m collaborating/helping a newer programmer with python, I can tell if they are using and have only used PyCharm. PyCharm users never seem to understand virtualenvs or requirements.txt. Collaboration with pycharm users at that level always gets frustrating as they seem to routinely fail to update requirements.txt - as their setup isn’t using it and it isn’t easy for them to do
• nec4b 5y ago
  It is almost scary to me how many people here think that by knowing how to run a compiler from a command line, they now know how a computer works.
• thrower123 5y ago
  I agree with the title. No one should use Eclipse unless there is no other option. The article appears to be typical comp sci masochism though. I've built Java projects with make and javac, and it was fine, for 2006 when everything was much simpler. But the only reason I ever did that was because I bought into the terminal Stockholm syndrome that afflicts programmers, and switched from using JCreator to emacs. Eventually I came to my senses and bought an IntelliJ license. The thing that I really think that software pedagogy needs, is some coursework on the history of software, which explains why things are the way that they are, and how they got to be that way. Everything about software and how computers actually work is this dirty, messy accumulation of ideas piled higgeldy-piggeldy atop one another over the decades. If you just try to understand the result without understanding the stratums and accumulations the created that result, you miss an enormous context, and you are in enormoys danger of just recreating wheels.
• hermitsings 5y ago
  I didn't know about jGRASP. Good to learn it exists.
• twobitshifter 5y ago
  They reference an improved student centered IDE and then jump into what IDEs are good for and finally that in first or second year: >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. In none of the curricula I’ve seen, through personal experience or reading syllabi provided by other students, is there a place for students to get past the myriad of barriers that constitute the use of a computer in the modern day. I have to unpack this but first of all, the use of a computer in the modern day for many engineers does involve an IDE, so I question whether that is even a true claim, but continuing the things missing from an IDE are: > First, in a Java-focused curriculum, it insulates the student from the javac command line program, and the command line environment itself. 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 don’t know about others but this didn’t fill me with horror. Those are the things that would make a student in an introductory class want to quit, and the number of drops in CS is already very high. If as the author said it takes 2 to 3 years to grasp control structures, why mess with the finicky software engineering headaches when it’s an added load on the students? By the time they graduate they should have a complete view of the system and in my experience things like the stack, logic gates, and compilation are taught in intro CS, the students are just not forced into it when coding which is really another endeavor. Here I do agree with the author that some more granularity in the department of CS would help, but I’d argue that would lead to more specialization and fewer graduates who understand the entire system.
• easton 5y ago
  I’m at a school right now where they teach C++ using Visual Studio on Windows. I transferred here, and at my old school we used gcc on the command line (using WSL if you were on Windows). The amount of time wasted in class trying to get VS to behave right is ridiculous. On top of that, none of the kids know how to troubleshoot anything outside of copy pasting their code out to Notepad and asking VS to build a new project (and sometimes that doesn’t work, and they are stuck). It’s a productivity killer, and they’re all super scared of the command line (so when Web Dev with npm or Cloud Computing with Docker is taught, they have to be hand held for the first few weeks on how to get to know the command line). Apparently employers don’t care (probably because when they get to work everyone else uses a IDE anyway) but I don’t think it’s a good idea in the long run.
• emrah 5y ago
  The author appears to be a purist. While I respect the position, I'm a pragmatist and respectfully disagree. Also the title seems misleading. It should probably be "Stop making students use IDE". Schools' job should be to teach how to learn in my opinion. Back when I was in university, I was taught a lot of things too and some of it were fundamentals thus necessary. Others could have been cut out for more discovery based learning. I "learned" Java after many other languages (C, C++, Perl, C#, Python, JS, etc). I've used Eclipse and NetBeans but I feel IntelliJ is special. It has a great feedback mechanism that teaches the language too as a side effect. Dealing with the command line to compile code does teach a few things but after a short while it's just busy work imo. Learning imports? Sure, but again, not having to spend much time in mechanics means one can spend more time on more exciting aspects like refactoring. It all depends on what the teaching focuses on after allowing or disallowing the use of IDE.
  • NoraCodes 5y ago
    I'm curious what you think I'm a purist about - CLI usage? Languages? That wasn't the intention of the post, so if that's what's coming across, my writing is poorer than I thought.
• booleandilemma 5y ago
  This guy is making a bigger deal out of this than it needs to be. On days 1 and 2 use javac and notepad.exe (or whatever). On day 3 move to an IDE. This as how we did it back at my school and it works.
• hda111 5y ago
  Looking at the screenshot of jGRASP I can see it looks similar to IntelliJ. The icons are identical. I assume it’s based on IntelliJ. What’s the point of the article? Yes Eclipse is too complicated but I think IntelliJ is good for starting.
• downrightmike 5y ago
  Honestly figuring out the tooling is going to be a big thing you'll have to get used to. Eclipse with maven on linux is way easier than on windows. Dead simple even. If you're going to be building code, you'll probably be using linux to run in prod, might as well get introduced to that now in school. You have to do some extracurricular learning, but everyone has to. That's just how it all works. Java is taught because it is more C than python where you don't really have to think about how things works, you can just throw shit at the wall and it'll stick. But XX year old systems you'll be working with in the field won't be like that. so learn typed languages, learn you some nix and get used to running into frustration, because figuring things out the hard way is usually what it takes.
  • wombatpm 5y ago
    Unless you are at a place using Java 8 with tomcat in windows for production with powershell scripts inside Jenkins for build systems. Good times. Nothing like hitting stackoverflow and coming up empty because your entire took chain is stupid and wrong
    • still_grokking 5y ago
      My heartfelt condolences.
• idontwantthis 5y ago
  Importing external libraries is absolutely the most frustrating part of learning a new programming language. I’m glad Eclipse handled that for me in my first few programming classes. New students shouldn’t need to get hung up on imports before they get to write a single bit of logic. If they’re serious then they will get to have all that fun later when they are a bit more advanced.
  • swiley 5y ago
    It should be frustrating because you should avoid doing it.
  • bodhiandphysics 5y ago
    Ironically importing external jars is particularly easy in java... and frankly rarely nescessary in an early course. Java gives you a lot!
  • AussieWog93 5y ago
    100% agreed that this is a huge problem. My first programming intro (I did EEE) was in MATLAB, where this isn't an issue. When we moved onto C/C++, though, this was an enormous headache. Even after a couple of years in industry it could be a massive pain the arse in terms of configuring CI/CD and porting it cross platform. To be honest, I think the best way to solve this is not so much to use IDEs that handwave over things, but a beginner-friendly, useful language where the problem simply doesn't exist - namely Python.
    • KronisLV 5y ago
      > Python I'm tempted to share this xkcd, called "Python Environment": https://xkcd.com/1987/ https://xkcd.com/1987/ I'd say that Python is an absolutely stellar language when it comes to readability and getting things done thanks to its rich ecosystem, but at the same time is about as bad as Ruby when it comes to managing dependencies. In my eyes, something like Java/.NET/Go could be better choices for when you need to work with dependencies as a beginner, whereas Python is probably the better choice when you don't.
• armchairhacker 5y ago
  I don’t agree with this perspective: why do entry-level students have to understand the internals behind compiling their code, and weird edge-cases like misspelling import? In my experience this is actually the stuff that hinders learning and confuses students. The author claims that students won’t be able to do real-world programming without learning this esoteric stuff, but actually this is the exact stuff they don’t need to know: full teams can and have built huge java projects just by using the intellij project wizard and maybe a tiny bit of Gradle from stack overflow. Actually students can solve most of the author’s problems by spending 5 seconds on Stack Overflow. I’m not saying that these more esoteric details are completely useless. Learning e.g. the difference between char and UTF8 “character” is actually pretty important so that emoji inputs don’t crash your website. But this is stuff that should come in later classes, particularly for students who are interested in those details. Not everyone needs to know it. In fact my experience is that some colleges have the exact opposite problem: they teach students old tools and techniques which are tedious and not actually used much later on. Like writing code by hand and deducting points for syntax errors, or using some outdated framework e.g. jQuery. When I saw the title my first thought was literally “yeah stop making students use eclipse, they should be using IntelliJ!”
  • tomc1985 5y ago
    My first real uni programming class was Java and we used BlueJ. I tried to set up Eclipse but I was so freaking lost. And I've been a computer nerd most my life, just not a programmer at that time. I am so glad we were set up for the simpler IDE, learning your first couple languages is hard enough as it is.
  • deleted 5y ago
    [deleted]
  • SPBS 5y ago
    I pity the student who only knows how to hit the compile button in the IDE and not `javac`. That's a terrible thing to inflict on a beginner, everything will seem like a mystical black box to them with no way forward when they hit encounter their first compilation problem.
• JCharante 5y ago
  To start with, shouldn't universities just not teach programming? I'm taking a graduate class on artificial intelligence which involves coming up with a novel project and implementing it, but we have free reign to choose what tech stack we want. It's just assumed that everyone can handle picking up a new programming language if they have to, despite people in completely different backgrounds being in the course (such as my neighbor, who majored in physics) You don't need class time to learn how to follow codecademy tutorials or to learn how to Google. You need class time to learn a bunch of theory and algorithms and higher level topics. Pointing out syntax errors is a waste of a TA's time. We don't have addition or algebra as part of the core curriculum at univeristies, so why is basic computer competency like writing the most basic of programs or using CLIs, a part of the curriculum at a lot of schools?
  • crooked-v 5y ago
    To start with, universities need to decide if they're teaching computer science or computer programming. Currently a bachelor's in the former is actually mostly the latter.
    • therealdrag0 5y ago
      Where did you get this impression?
      • crooked-v 5y ago
        From my own degree.
    • denton-scratch 5y ago
      I don't think "computer programming" is an appropriate subject for a batchelor's degree. That's called a "training course".
  • nesarkvechnep 5y ago
    Universities shouldn't teach programming in X language, producing monoglots.
• cm2187 5y ago
  Feels like one of these “let’s introduce them to programming with c++ in a text editor with debug by printf because that’s how I learned in the 80s”. I had a professor like that, and that turned me off from programming for a few years before I came back later through higher level languages.
  • LogonType10 5y ago
    Controversial opinion ahead. Take a deep breath. If a student can't handle C/C++ in nano/vim/emacs and debugging with gdb, maybe a computer science degree just isn't right for them.
    • saberience 5y ago
      Yeah I don't agree with that at all. That's like saying mechanical engineers should all learn starting with hammers and nails. Computer Science isn't about the tools! C/C++ nano/emacs are tools only, and mostly outdated tools used less and less by most companies. Most professional software engineers starting today are not using these tools, they are using Java, C#, Javascript, Swift, using IDEs. Also, learning Computer Science has very little to do with programming language or tools. Computer Science is a Science (it's in the name). You can learn about logic, grammars, discrete math, computational complexity etc, without knowing anything about Java or C#.
      • LogonType10 5y ago
        Do you think the only purpose of a CS degree is to teach software development? Many people with the degree don't end up writing software. The point of a CS degree isn't to teach you the tools and languages being used at companies in 2021; go to a coding bootcamp if you want that. It's to teach computer science. After you learn that, picking up languages and tools is easy. The point with learning with simple tools is that you learn from first principles with as much as possible stripped down. Most of the time C has a straightforward correlation with the instructions emitted by the compiler, and the language rarely does something behind your back. Try explaining memory management (in detail) to a first year student using JavaScript or Python.
• devwastaken 5y ago
  Eclipse is poor tooling for teaching. Far too many buttons and noise that gets in the way. But the opposite, programming with no debugger and no linter is just as bad. It punishes you for getting the smallest syntax mistakes by waiting for the compiler and reading out erroneous messages. A debugger makes it far better to understand the execution of code line by line, and should be standard in education, but it's not. I feel that visual studio code, with some modifications, would be perfect to begin with. Then when building things at a higher level, introduce why to use eclipse, like how it handles packages, etc.
  • convolutionart 5y ago
    What kind of modifications?
  • bodhiandphysics 5y ago
    To be fair I’m taking an assembly course right now, a massive component of which is learning (command line!) gcc...
  • userbinator 5y ago
    A debugger makes it far better to understand the execution of code line by line, and should be standard in education, but it's not In practice, from what I've seen teaching programming (not using Eclipse nor Java), this tends to cause "debugging tunnel-vision" instead, where someone will just keep stepping through code that has a problem, and not even know what happened until the wrong result was seen.
  • cerved 5y ago
    Literally the second paragraph is about an alternative Java IDE suitable for teaching introductory programming
• pfh 5y ago
  The link certainly reflects my own undergraduate experience, where these skills were not the focus of teaching. It sounds like the sort of thing covered in "Software Carpentry" workshops -- practical skills around unix, git, and a scripting language. These are generally aimed at graduate-level students who now suddenly need these skills. The name "carpentry" is very deliberate. These aren't fancy skills that can only be be taught at a university, but it also seems to mean they aren't taught at university.
• DeathArrow 5y ago
  I do not agree. If you follow a course about algorithms or data structures, or Java, or parallel programming, you should focus on that. Learning the same time an operating system or command line will introduce unnecessary complexity. Anyway, when I was a student in University, most of my colleagues knew the command line and had a strong understanding of operating systems. By the time we did the OS courses the only things we had to learn was about the more advanced architecture, system calls. As a working professional the IDE is a huge time saver. From quick refactoring to debugging, to step through, to step into, to watch memory, to renaming, to jumping to definition, to method or variable exploring, to function definition, to writing common patterns, to running unit tests, everything sits at one keyboard shortcut away. And the IDE is smart enough to correct my mistake as I am typing, so by the time I hit build, the software builds without errors. Without an IDE, my development time will take longer. And why shouldn't someone who is aspiring to become a professional not use the tools a professional uses? If anything the IDE showing his mistakes might make it a more pleasurable experience since he doesn't have to search Google or Stack Overflow as often. And by having a good experience, he will be encouraged to learn.
  • selfhoster11 5y ago
    > As a working professional the IDE is a huge time saver. From quick refactoring to debugging, to step through, to step into, to watch memory, to renaming, to jumping to definition, to method or variable exploring, to function definition, to writing common patterns, to running unit tests, everything sits at one keyboard shortcut away. And the IDE is smart enough to correct my mistake as I am typing, so by the time I hit build, the software builds without errors. I'm glad someone mentioned this. When I was learning programming for the first time, the Eclipse debugger help me to understand for/while loops, because I could see exactly how the computer behaves, as it runs through my code line by line.
  • bodhiandphysics 5y ago
    Umm. You do realize you can set watchpoint in a command line debugger
    • selfhoster11 5y ago
• bitwize 5y ago
  Where I work, I was just assigned a project to add functionality to. The README instructions for the project started thus: 1) Download Visual Studio Code from https://code.visualstudio.com https://code.visualstudio.com. 2) Clone the repository from BitBucket at <blah>. 3) Download Kafka and Zookeeper, and follow such-and-such directions to run them. 4) Make configuration changes <foo>, <bar>, and <blatz> to connect to the nonprod Mongo database. 5) To run the program, right-click on Application.java in VSCode and then click on Run. 6) To run unit tests, right-click on their names in VSCode and click on Run Unit Test. The real world is just like the university! IDEs are how you engage with the program in the enterprise -- and you'd better be using the same one that the original author used because if something goes wrong, you're not going to be able to find someone who can fix it without that particular IDE. This idea that software should build and run with just the compiler and simple, scriptable build tools is a quirk of open-source development and distribution practice from the 90s and it does not generalize. In the real world, if it can't be done from the IDE it generally can't be done. I know, I know, CI/CD -- but that's generally provided by templates from the corporate CI/CD team and the average line programmer need never touch it, nor know how it works. You may think this is a totally clownshoes way to handle software, and you may be right. But billion-dollar companies run on software handled this way -- and worse ways! -- and you're not going to be able to change it. This stuff was written by tired programmers who just want to play with their kids after putting in their 9-5. You need to budget for these kinds of changes during work hours if you want them done -- and knowing how to operate javac, and structuring your software so that it can be edited, compiled, and run with any tools that are up to the job, do not deliver value to the customer and will not be budgeted for.
  • vincnetas 5y ago
    where i work most projects are IDE agnostic. Clone repo, cd to folder and "gradle build". In this case person can choose whatever ide he likes, or just use command line tools.
  • denton-scratch 5y ago
    > but that's generally provided by templates from the corporate CI/CD team That's rather a "corporate" perspective. And having to rely on corporate infrastructure, build-teams and so on results in a mushroom outlook, in my experience, which I found depressing and disempowering. In most modern non-corporate development work, you are the CI/CD team.
• robertoandred 5y ago
  Using Java at all is not a good first introduction to programming for computer science students.
  • NoraCodes 5y ago
    You'll note that I actually do say this in the article.
  • abhisuri97 5y ago
    Fully agree with this. The fact that the "hello world" program involves the use of several keywords (public static void main String[] args System.out.println) that students will have no idea about until 1-2 months later is not ideal. Compare that to python "print('hello world')" is very intuitive.
    • yeputons 5y ago
      I don't see much difference between `System.out.println` and `print`. Both should be spelled exactly as they are. You cannot say `write`, `say` or `Print` in Python despite it being somewhat synonym to `print` in English. They are parts of syntax, and any language will have some syntax to learn, and there are always syntactic quirks. Granted, Python has lighter syntax than Java, but I don't think Java is too verbose for beginner's purposes.
      • cerved 5y ago
        what's System what's out why is there a period, what does that mean what's ln what's pubic what's static what's void what's main what's String[] what's args Java is as verbose as it gets with lots of unnecessary information at a beginner level
        • yeputons 5y ago
          Why parenthesis? Why is the string quoted? Why I cannot write `print("a") print("b")` on the same line? Why `print`, if it shows on a screen, not a printer? What is `.py`? What is file? Why `write` on a file does something different than `print`? I agree that Java shows you more syntax which is intimidating. But the answer to all these questions for all languages is: "it's a special syntax, you should write it exactly as it is. We will learn more details later in the course". There is literally no need to dive in. You wouldn't dive to variadic functions, builtins and CPython implementation details when asked about the name `print` or how it can take multiple arguments, would you? You get some kind of syntax questions no matter what programming language you teach, even Python. Granted, there may be less with Python in the beginning, but in lots of scenarios the difference is negligible.
• DeathArrow 5y ago
  I started programming with text editors. I wouldn't recommend that to anyone. While learning how build systems work is valuable, it should be done through inflicting pain or wasting time. And learning languages, algorithms and data structures is more valuable than learning the build systems. Also, most assumptions in the article are false. Most courses targeting Java or .NET will teach what the underlying framework is, what is the difference between the compiler and the VM, what jit means, what is the memory model, what a library is. Without going into unnecessary details.
  • NoraCodes 5y ago
    > Also, most assumptions in the article are false. Can I ask what assumptions I made that you consider to be false?
• FpUser 5y ago
  Lemme up the ante. Before starting a course students should design and assemble a computer they'll be learning to program on. Oh and while we are at it please prohibit all languages with automatic memory management, safe arrays, range checking etc. etc. Real programmers code by flipping switches.
  • Ekaros 5y ago
    Why not build it from ground up. That it first have them learn physics, without teaching them calculus, and expecting them to figure that one out themselves. Next they can learn semi-conductors. Then gates and so on. Why not have them design their own CPU and assembler, ofc, never giving them tools for this... Once they have some working system, we can move to things like data structures.
    • JasonFruit 5y ago
      We could use it to teach them mining, smelting…
• kristov 5y ago
  What we need is a good separation between computer science, and computer engineering - as there is is a separation between physics as a science and mechanical or civil engineering. What this article laments is students coming out of CS with little practical know-how. But practicality/application is not a requirement from a pure science. Let the scientists do science, and the engineers do engineering. And stop making a CS degree a requirement for a software engineering job.
  • rswail 5y ago
    There is a 3 way split: Computer science is about conceptual development and research. It's learning what Turing-complete means etc. Computer engineering is about systems and processes and practical application of the concepts of CS. It's about things like why TLA+ is a good approach to developing safe and effective systems, it's about the SDLC generically and the potential different approaches and their cost/benefits. Computer programming is a technical skill. It's learning the specifics of a particular environment and language. Any CS graduate should understand programming, because it's a basic required skill, same for a CE graduate. But specific skills in Java vs C++ vs etc is virtually irrelevant to a grad getting their 1st job. It's also something that any student should have already picked up as a side effect of a competent CS/CE course. But does a CS grad need to know the difference between agile and Agile and iterative development and CI/CD and... I'd say no, because it's not particularly relevant to type theory or provability etc. It's also not particularly relevant to ongoing CS research. Our industry is well short of good CE graduates, because the focus is on the stupid details of languages instead of the conceptual grounding needed to actually engineer. Same with the dumb interviewing about reversing a list on a whiteboard. We've adopted the language of engineering, without the actual approach.
    • Ekaros 5y ago
      To me Computer Engineering should be about engineering computers. What runs on them is entirely secondary. Not really even involved, the people using the computer have to figure out how to develop that...
    • MikePlacid 5y ago
• ozim 5y ago
  I think there is really important reason "to force students to figure this stuff out on their own". Figuring stuff ON YOUR OWN is what higher education is all about. It is not about teaching one tool or the other and if someone is learning tools instead of "how to learn to use those tools" he is doing it wrong. Dev work is from my experience mostly about "figuring stuff on your own" and I expect that this should still be main goal of higher education.
  • denton-scratch 5y ago
    > Figuring stuff ON YOUR OWN is what higher education is all about. I share this view. Not everyone agrees. Maybe it depends on what you mean by "higher education". I mean a degree. If you have a degree, that should signify that you know how to study on your own, and have a general overview of your degree subject. You should be able to make some sense of a research paper in your subject, even if you can't follow it in detail. A degree isn't a vocational training course. If you hold a good batchelor's degree, then you should be qualified to undertake a master's degree, which in itself isn't much use, IMO; the purpose of a master's degree is entry-level training in research. You get to find out whether you want to/have the ability to undertake a doctorate. If what you want is to learn how to do a certain job, then surely a vocational course is more appropriate (the hint is in the word "vocational").
• agmyintmyatoo 5y ago
  > Please, please don't Java. Weak. My university starts with C++.
• fareesh 5y ago
  Anecdotally I find these Java IDEs - IntelliJ, Eclipse, etc. all painfully slow. Is there some magic configuration that's required to make them run decently? On Android Studio, for example, there are times when I tap a menu item and it takes a good 5-6 seconds to open. I'm on one of the latest Ryzen processors and I have 16GB RAM. Do I need 32GB? EDIT: SSD for my work files and OS and the applications themselves
  • david_allison 5y ago
    I have 16GB for Android development and it gets painful, 32GB is recommended. Are you paging to disk? You may want to increase your heap size if you haven't already. https://developer.android.com/studio/intro/studio-config#adjusting_heap_size https://developer.android.com/studio/intro/studio-config#adj...
  • KronisLV 5y ago
    My current configuration is: Ryzen 3 1200, 16 GB of RAM, SSD for the OS, another SSD for the IDEs/code. In my experience: - NetBeans is reasonably fast for code editing, but slows down once you try to do refactoring or even search for things; overall it ends up feeling a bit lacking when compared against the alternatives - Eclipse is always horrible, both in regards to usability, as well as performance; some people swear by its extensibility and workflows, but i do not share their experiences - IntelliJ (and other JetBrains products) are slow when opening and indexing projects, as well as somewhat slow when they aren't given >2 GB of memory for the IDE itself, or swap is hit; perhaps the best functionality though - Android Studio feels like an exception to the above, as it's almost always been slow in my experience Some suggestions: - don't attempt to do anything when your project is opening/indexing, especially in cases of medium to large codebases (e.g. >100k SLoC) or large amounts of dependencies (e.g. >20 packages) - disk performance also probably matters a lot in this case, i'd suggest using SSDs for any development workstation and HDDs only for storing data for longer periods of time, or fewer larger files - consider increasing the amount of memory that's available to the IDE itself, which you should be able to do in the case of IntelliJ through Help > Change Memory Settings - the JDK that you use may or may not have an impact on this, switching from Oracle JDK to OpenJDK has improved performance in prod projects by a factor of 10, might have minute improvements for IDEs - consider whether you need swap or a paging file, since if memory gets persisted to disk, accessing it might slow things down more than necessary, or decrease your OSes swappiness value https://www.howtogeek.com/449691/what-is-swapiness-on-linux-and-how-to-change-it/ The latter two steps probably aren't too important, as long as you have enough memory and a fast enough disk, you should be good: currently IntelliJ menus open in <1 second once the project has been indexed and when there are no problematic third party plugins present, e.g. Codota (an earlier version of which thrashed my CPU usage).
• tofflos 5y ago
  > Use a language that teaches the fundamentals of the paradigm you’re interested in, like Scheme or Python. (Please, please not Java.) If not Java then at least use a statically typed language. I feel that understanding types, and type-systems, is fundamental to computer science.
  • maweki 5y ago
    Only if you want to teach that. An introduction to programming might very well skip over static typing checks.
• willjp 5y ago
  This is interesting, since I normally fall on the “let’s keep this approachable” side of things - but in this case I disagree. Maybe I’m just old, but I found using the tools directly very comforting. Learning some static html in a computer camp in notepad.exe was approachable and empowering. I could do it anywhere. I don’t think connecting code to files or compiling it yourself (in simple cases) adds too much complexity while learning. The first time I opened vs studio I was terrified. I was suddenly not in control of my project. What if I bork it? What if there is an incompatible project change? I think these tools are fantastic and should be used, I just also think learning your toolchain is useful. Disclaimer - I learned these at my own pace, outside of the pressures of a classroom.
  • yeputons 5y ago
    I believe it's a question of how good the tools are. If you're "using the tools directly", you probably don't have much knobs to fiddle with and everything either works by default or does not work because of some well-known and searchable reason, e.g. "you Java source file should have the same name as the only public class". However, if try some higher-level tools, they may: * Try to guess your preferred options and guess incorrectly. * Hide some low-level details which actually matter in your specific case. * Provide error messages that are not easy to look up because the tool itself is not as popular as its lower-level counterpart For example, I found Eclipse (GUI) and Gradle (CLI) very frustrating to use, but IntelliJ (GUI) and Maven (CLI) worked wonderfully for me. The only downside of Maven comparing to pure javac for me was that it needed some boilerplate config. Other than that, it felt magical.
• Animats 5y ago
  They should have to use EMACS. And git. And the UNIX command line. And learn to suffer. And get off my lawn. Right. At least with an IDE, you have a set of tooling that plays together.
• primitivesuave 5y ago
  I taught Java to tens of thousands of middle/high school kids using Eclipse. It is certainly not a friendly interface to beginners, but is vastly preferable to teaching the command line. This post comes across as highly dogmatic and ignores the realities of teaching in a classroom.
  • rswail 5y ago
    Were you teaching programming or Java?
  • nickkell 5y ago
    It's nice to see a reply from an actual educator. Maybe you could elaborate on your experience. How was the language selected? Did you ever try a language specifically designed for pedagogical purposes? I can't find anything on the author's page about being an educator, so I assume they're talking about what they themselves would have preferred.
    • primitivesuave 5y ago
      I started a Bay Area summer camp in 2013 and expanded it over five years into multiple locations and a year-round after-school program. Java is widely known for its role in the AP Computer Science course, so there is a pretty strong demand from parents. I also developed introductory courses for Python, and built a custom browser-based teaching platform with Skulpt (skulpt.org) - the idea was to give kids a giant green run button so they would keep testing and iterating on their programs, and to parse the native Python error messages into helpful suggestions. My contention with the article is that instead of bringing up any real issues that educators have with Eclipse (my list goes on and on), it instead posits that students would be better served by using the command line and `javac`. It strikes me as completely ignorant toward the realities that come from a diverse group of students with varying degrees of prior knowledge. Unfortunately, this opinionated pedagogical thinking makes its way into curriculum all the time. My opinion, supported by years of physical presence at the head of many classes, is that students are most successful when they have fun. Dealing with the terminal, or really any repetitive process, is not fun. This is why my entire Java curriculum explained concepts through animation and game design (https://www.youtube.com/watch?v=KNphPVif26I https://www.youtube.com/watch?v=KNphPVif26I), while trying to lift as much of the burden of syntax and the runtime environment. Eclipse is open-source, and I'd love to see an article that motivates an Eclipse developer to create a kid-friendly version of the software for classrooms.
• rswail 5y ago
  Teaching programming is a technical skill. Teaching engineering is about conceptual skills and how to apply them, preferably in a standard and proven and consistent way. Teaching science is about research and developing concepts. They are 3 different sorts of education. An introduction to computing needs to cover all 3 so that the student can then specialize. The details of Java or C or C++ or <insert language> is not the point in 1st year courses. It should be about teaching all 3 aspects. Learning "import" is not important from a file system/CLI POV, but learning about libraries and APIs and how they relate to your programming and engineering is. Learning about file systems and UTF-8 and OSes etc need you to have grasped the concepts of persistent vs ephemeral storage and i18n/l10n and string manipulation. They are concepts that are relevant to the engineering side of computing. IDEs vs CLIs vs non-integrated DEs aren't that relevant to 1st year courses. A well structured course won't need to push Java vs C++ vs Ruby vs Rust vs Python. The conceptual elements are mostly the same and the title of Wirth's book, "Algorithms + Data Structures = Programs" summarizes it well.
• krzyk 5y ago
  I thought it would be a rant why they don't allow using community version of Intellij.
• plank 5y ago
  Reading all the comments, the bulk of which are in agreement with my own beliefs in this, it is perhaps better to write an alternative article that has the opposite position. Or, indeed, instead of <<article>> an <<!article>>
  • NoraCodes 5y ago
    I would appreciate that! A lot of people have criticized this piece pretty vaguely and I'd love to see some points in opposition laid out in a more long-form piece.
• maweki 5y ago
  We use java in the database programming course with jdbc. We use eclipse and maven and I give a 5-minute introduction and a boilerplate, after the students used a web-based java ide in the previous year. I will not subject my students to managing compilation, classpaths, and dependencies to get on with jdbc (and other abstraction layers). This sounds strange, but learning how to compile or run a program is, in my opinion, not necessary in the academic context, if that's not one of the goals of that special subject.
• nhoughto 5y ago
  Interesting problem, I imagine many here grew up on computers not because it was valuable or strategic but because they couldn’t not, such was it’s draw. Learning the concepts by brute force was the norm, the idea of not knowing what a file, file system etc is is foreign because you’ve lived and breathed it for so long before higher education. I guess there are people today who don’t fit that mold and approachability becomes important, shouldn’t be surprising.
  • DnDGrognard 5y ago
    This was the initial concept behind the Pi - something to give A Level students (16-18) a basic computer to learn the basics before they went to university
• abhisuri97 5y ago
  I had to teach web dev to students who were coming straight out of the intro courses that used Eclipse and yeah...everything that the author is saying here is right and these IDEs do a disservice to them. A surprising amount of students don't have an idea of working around the command line, file systems, and in general develop poor debugging skills (and, in turn, poor programming skills since they're used to eclipse etc filling in everything for them). I think a good middleground is the IDE that CS50 has their students use. It gives them exposure to the command line and allows them to actually debug on their own. Of course, utilization of that IDE in intro CS courses means that these courses won't be using java anymore (and I frankly have no idea why it's still a mainstay of cs courses to this day).
• pjmlp 5y ago
  Stop teaching how to drive, teach combustion engines and mechanics instead.
  • Jorge1o1 5y ago
    But before you can teach them combustion engines you have to teach them combustion. AP Chemistry should be required for all 15 year olds.
    • pjmlp 5y ago
      I bet most of them understand what happens throwing out sulphur dust into water.
  • NoraCodes 5y ago
    This strikes me as an unfair comparison - we don't have for cars what IDEs are for programming. The best analogy I can think of is, "you should teach people to drive the car before you let them use Tesla Autopilot".
• jillesvangurp 5y ago
  I think people need to appreciate that universities are not updating their courses and tools that often. Eclipse was a pretty reasonable choice a few years ago. I used it for well over a decade before grudgingly switching to Intellij. If you are doing Java, it's still pretty nice. It always was pretty good at that. For a university software engineering course, it's more than adequate. It's representative of what people in the industry would use, or would have used until a few years ago. It's open source and easily customizable. It has most of the bells and whistles you could want in such a tool. And it runs on modest hardware and more than meets the requirements for implementing some simple toy project for school; which is a big deal when you deal with students working on old/slow laptops. Are there other alternatives? Of course, many. But it helps having students all use the same thing when supporting them and it helps when that tool is not Notepad or something similarly backwards. I actually taught Java to students back in 1996-1998, trust me dealing with weird/odd/misguided choices as to what to use to edit files was a thing I had to deal with. Actually one of the key things to learn in university is learning new things. So, a slightly complicated but genuine IDE is exactly the right kind of thing to learn to wrap your head around in university.
  • elric 5y ago
    IMO eclipse is still a reasonable choice for a university (or a developer). It's open source, actually free, and comes with all the bells and whistles one needs. Unfortunately, it's gotten pretty buggy over the years, and their tooling and process seems very unwelcoming towards new contributors.
    • mdaniel 5y ago
      That is a misguided characterization, as it makes it seem that IntelliJ is not open source, not "actually" free, and does not come with all the bells and whistles one needs: https://github.com/JetBrains/intellij-community/blob/idea/213.5605.12/LICENSE.txt https://github.com/JetBrains/intellij-community/blob/idea/21... I am trying really hard to ween myself off of weighing into this discussion every time it comes up, because it's getting to be the emacs-vs-vi of IDEs, but we should at least stick to factual arguments
• francislavoie 5y ago
  You don't teach a kid to swim by starting in the deep end. There's a reason training wheels exist for learning to ride a bike. Same applies here. You need to understand what code even is before diving into the specifics of the compilation step. That said, I agree with the title but for different reasons. Eclipse is terrible compared to other available options (JetBrains is so vastly superior). I do agree that Java is a terrible first language to teach, it has so much arcane boilerplate to get through before doing anything useful. Especially the whole "public static void main(String[] args)" incantation you're taught up-front. So many meaningless words for a beginner. And yes I do agree "how to use your computer" type stuff should be covered at least after the first assignment, things like how to use a terminal and the filesystem as mentioned. And IMO git should never be taught CLI-first, it's way too hard to wrap your head around without the visual of the commit graph. GitKraken does it best, and is free for students.
  • selfhoster11 5y ago
    > I do agree that Java is a terrible first language to teach, it has so much arcane boilerplate to get through before doing anything useful. Especially the whole "public static void main(String[] args)" incantation you're taught up-front. So many meaningless words for a beginner. The boilerplate is annoying, but it's an obstacle that can be overcome. My lecturer/lab tutor for introductory Java just gave us a pre-prepared: public class Main { } And told us to write all the code in between the two curly braces and don't worry about what's outside of them. The main method is another piece of boilerplate to ignore.
  • ldehaan 5y ago
    Everyone I knew growing up learned to swim by getting tossed in the deep end. The kids who's parents babied them didn't go to the pool or have many friends. I'm sure those kids are all managers at fast food places or live off the dole now. Of course I'm a dad of 4, full time, so my viewpoint on kids is different from "parents" who feed their kids baby formula and hire babysitters and nannys instead of taking care of their kids themselves and so therefore have no idea how resilient humans are and how we can only achieve what we're led to believe is possible. If you're restricting your kids so much as to protect them from life, they'll only get hurt later, and usually those people have no idea how to deal, so they blame everyone around them for things they're responsible for, and we currently have so many of these kids, now adults, that they're passing laws to protect themselves later in life because they never had to face real adversity ever in their lives. Anyways. I disagree. A bunch.
• austincheney 5y ago
  This completely misses the point. The deeper problem is that it’s a Java focused curriculum.
  • NoraCodes 5y ago
    You may note that I do, in fact, call that out as the deeper problem: > Use a language that teaches the fundamentals of the paradigm you’re interested in, like Scheme or Python. (Please, please not Java.)
• watermelon0 5y ago
  Can we maybe agree that the real question is not if/when do people need to learn toolchains they use, but why do we need this knowledge in the first place? Basically, regardless of whether you are a student or have been using $toolchain for the past 10 years, troubleshooting of (or even just the need to understand) it gets in the way of doing the actual work. We should strive to have better tools, that just work, without the need to debug cryptic errors.
  • NoraCodes 5y ago
    I agree completely here. I refrained from recommending them in this article because it would have made it even more controversial, but both Elm and Rust have made _incredible_ strides on this front.
  • cerved 5y ago
    Given how much time and effort is spent on developing tool chains, I'm a afraid one that "just works" is a pipe dream.
• sswastioyono18 5y ago
  yes, stop making students to use eclipse, or blueJ or whatever it is. They can choose whatever they want. In real world, very rarely a workplace force you to use specific IDE. Most of the time they use eclipse because no one knows how to setup their project in other IDE so they stuck with it even though it sucks. I remember a project which I have to setup linking each project manually inside eclipse. I asked myself "this is ridiculous, if I switch my PC, I have to re-do all this again?" Switched to Intellij and use other jetbrains product, never looked back
• smarri 5y ago
  I'm 3 months into a 3 year part time Software Development university course. First module is Java and using Eclipse. Can someone recommend something else I should be learning in line with this article/your view?
  • yeputons 5y ago
    I'd recommend this one: https://missing.csail.mit.edu/ https://missing.csail.mit.edu/
  • ldehaan 5y ago
    I like intellij ultimate, it's not expensive, it's a netflix subscription essentially, but better, endless fun :). They have built in educational materials, and you can easily jump through libraries to see how a function works, all the way down. It's fantastic. The MIT courses suck, even if they weren't evil. Anyone looking to support MIT should look up Aaron Schwartz and then go elsewhere.
• eitland 5y ago
  > 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. I was forced to program Java without an IDE and my experience is that I learned less in all those lessons over a year than in a few select days at work during my first year. Furthermore, according to a friend who is a specialist teacher this is a common problem: Most kids are inclined to see how things works as a whole while most teachers want to teach analytically by tearing everything apart. I'm grown-up now and don't mind diving deep into stuff (in fact I enjoy it) but in my understanding we really should try to go with the flow when teaching: Teach kids the wonders of programming (and everything else) and then go into the details as needed. Because, if my friend is right and I understood him right (he doesn't teach programming) most kids doesn't want to learn programming because they want to know how to please javac but because they want to create cool stuff.
  • cerved 5y ago
    I feel like a lot of people misread the article. It doesn't say you shouldn't use and IDE to teach students. It says you should avoid professional IDEs and at some later point you shouldn't neglect teaching them about other things like compilers and files. At some point they should have an understanding of how some of the underlying mechanics that a professional IDE abstract away. Also it's about teaching adults at University, not kids
    • eitland 5y ago
      When one teach driving, do one start with the ignition system and the gas pump or do one start with the high level controls and how to behave in traffic? Do one (ideally) start in a new, safe car or in an old one with unsyncronized stick shift (the ones where you need to match the engine RPM before the gear lever will enter). Because that, in my eyes, is how programming is taught many places. Edit: What is the result of all this? It takes longer time to grasp the easy parts and the parts that fuel motivation. People drop out. What if we instead taught students using proper tools (e.g. non nerfed versions of Eclipse, IntelliJ or NetBeans for Java) and then used the time we saved in the beginning to dive deeper and deeper towards the end of the course?
• webreac 5y ago
  This discussion shows that there are several types of developers who have radically opposite ways of functioning. There are those who think that a car driver can ignore all aspects of the car other than the interior. There are those who say that knowing how a car works makes us a better driver. I think we have to accept that these differences do not mean that one is better than the other.
• ldehaan 5y ago
  This is horrible advice, yes use a old rusty hammer instead of an airgun to build that house, if you don't, the house will suck and you won't understand how it was ... built? Huh?. I have 4 kids, and 3 can write code, one has downs and she is just taking her time is all :). They all learned on Intellij Ultimate babay! My 10 year old can write in 3 diff languages already, thanks to the help he gets from his dad and the error checking his ide does. I've been using ides since dos edit. If you don't use one, I give 0 fuches.
• buserror 5y ago
  I don't know what the rage is all about with Eclise really. I'm a hard code dev for 30+ years, kernel, embedded, I do a lot of C, last time I wrote some java was in 1995 to give it a spin, none since.... ... And I use Eclipse CDT as my primary "IDE" all day. It's stable, it's as quick as the other JS monsters out there, and one thing it has is that the Indexer is unique -- the Eclipse Indexer will index /anything/ -- even enormous codebase. And it's not "ctags" dump indexing, it's full C preprocessor expanded macros. And really, if you use the "Makefile" projects, it's just an IDE. And it's better than everything I tried (as of last year) -- most IDEs out there can't even parse "Make" output correctly to parse the error messages!
• kryptiskt 5y ago
  Starting with the CLI only makes sense for students who are already using CLIs, the connection to familiar ground will help them. For other students it's just another burden. Not that Eclipse is the ideal solution. These days I would probably start off teaching beginners in a web IDE like Repl.it to lower the friction even more. Of course there is a ton of things about development environments that need to be taught before they are fully-fledged programmers, but there is no need to frontload that and overwhelm them at the beginning.
• prof-dr-ir 5y ago
  I just would like to add that I think this was an outstandingly written post. For example, look at the first sentence: it promptly sets the stage ('first introduction programming for computer science students') and confers the main point (about using a professional IDE), all while remaining straightforward to understand. The reader knows exactly what is coming! I thought the remainder of the article was equally sharp, well-argued, and stylistically quite pleasant. Sadly, the main points of the article seem to be sorely misrepresented in this comment thread. I do not know why, but I really would not want this to discourage the author from writing more.
  • NoraCodes 5y ago
    Thanks! I appreciate the compliment and I'm glad you took away what I was intending!
  • cerved 5y ago
    maybe professional deserved emphasis since that part seems lost on pretty much everybody
• bluenose69 5y ago
  I suppose IDEs can be a good productivity tool, but they seem to be a poor teaching tool in a university setting. It's difficult to learn how to drive a car by peering through the smoked glass at the chauffeur. For first-year classes, I suggest restricting lectures to concepts (linked lists, big-O notation, and so forth) and not coding. Let students learn coding by themselves, by reading an assigned textbook on the language of choice, supplemented by a few one-page handouts on linux, vim/emacs, version control, etc. Assignments should involve both writing short essays about concepts and writing code. The latter should be expected to work, to be well-documented and, as the class progresses, to be elegant. In mid-term and final examinations, students should expected to again write essays and code, but this time by hand, on paper, and in a room without computers, books, cell phones, etc. The goal, it seems to me, is to expose students to fundamental concepts and give them the skills to learn more by themselves. The use of IDEs can come up later, as they start working on larger projects.
• markus_zhang 5y ago
  For first time students I'd argue they should stick to good IDEs with minimum hassle. They can learn the command line stuffs later. Back when I taught myself C++ the least thing I wanted was to learn the compiling process at the same time, so I picked Visual Studio. After that I switched to manual compiling and linking when I studied C.