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.<p>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.<p>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.<p>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!”
> 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.<p>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.<p>Furthermore, according to a friend who is a specialist teacher this is a common problem:<p>Most kids are inclined to see how things works as a whole while most teachers want to teach analytically by tearing everything apart.<p>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:<p>Teach kids the wonders of programming (and everything else) and then go into the details as needed.<p>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.
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.<p>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.<p>I feel that visual studio code, with some modifications, would be perfect to begin with. Then when building things at a higher level, introduce <i>why</i> to use eclipse, like how it handles packages, etc.
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.<p>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.<p>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.<p>Without an IDE, my development time will take longer.<p>And why shouldn't someone who is aspiring to become a professional not use the tools a professional uses?<p>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.
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.
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.<p>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.<p>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.
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.
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.
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.<p>That said, I agree with the title but for different reasons. Eclipse is terrible compared to other available options (JetBrains is so vastly superior).<p>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.<p>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.
I think there is really important reason "to force students to figure this stuff out on their own".<p>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.<p>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.
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.<p>I will not subject my students to managing compilation, classpaths, and dependencies to get on with jdbc (and other abstraction layers).<p>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.
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 <i>vastly</i> preferable to teaching the command line. This post comes across as highly dogmatic and ignores the realities of teaching in a classroom.
This is interesting, since I normally fall on the “let’s keep this approachable” side of things - but in this case I disagree.<p>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.<p>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.
I just would like to add that I think this was an outstandingly written post.<p>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.<p>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.
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.<p>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.
Nora.codes makes a lot of sense in this essay.<p>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.<p>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.<p>Her first language was Racket (interesting) and her first book was <i>How to Design Programs, 2nd Ed.</i> (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 <i>How to Design Programs</i>.<p>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.<p>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.<p>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.<p>[1] <a href="https://htdp.org/2019-02-24/index.html" rel="nofollow">https://htdp.org/2019-02-24/index.html</a>
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?<p>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?<p>EDIT: SSD for my work files and OS and the applications themselves
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.<p>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.<p>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.<p>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.<p>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.
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".<p>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.<p>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.<p>It all depends on what the teaching focuses on after allowing or disallowing the use of IDE.
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).<p>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.
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.
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 <i>unique</i> -- the Eclipse Indexer will index /anything/ -- even enormous codebase. And it's not "ctags" dump indexing, it's full C preprocessor expanded macros.<p>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!
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).<p>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).
Where I work, I was just assigned a project to add functionality to. The README instructions for the project started thus:<p>1) Download Visual Studio Code from <a href="https://code.visualstudio.com" rel="nofollow">https://code.visualstudio.com</a>.<p>2) Clone the repository from BitBucket at <blah>.<p>3) Download Kafka and Zookeeper, and follow such-and-such directions to run them.<p>4) Make configuration changes <foo>, <bar>, and <blatz> to connect to the
nonprod Mongo database.<p>5) To run the program, right-click on Application.java in VSCode and then click on Run.<p>6) To run unit tests, right-click on their names in VSCode and click on Run Unit Test.<p>The real world is just like the university! IDEs are <i>how you engage with the program</i> 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.<p>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.
They should have to use EMACS. And git. And the UNIX command line. And learn to suffer. And get off my lawn. Right.<p>At least with an IDE, you have a set of tooling that plays together.
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?<p>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.<p>We should strive to have better tools, that just work, without the need to debug cryptic errors.
Teaching <i>programming</i> is a technical skill.<p>Teaching <i>engineering</i> is about conceptual skills and how to apply them, preferably in a standard and proven and consistent way.<p>Teaching <i>science</i> is about research and developing concepts.<p>They are 3 different sorts of education. An introduction to computing needs to cover all 3 so that the student can then specialize.<p>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.<p>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.<p>They are concepts that are relevant to the engineering side of computing.<p>IDEs vs CLIs vs non-integrated DEs aren't that relevant to 1st year courses.<p>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.
I agree with the title. No one should use Eclipse unless there is no other option.<p>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.<p>Eventually I came to my senses and bought an IntelliJ license.<p>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.
They reference an improved student centered IDE and then jump into what IDEs are good for and finally that in first or second year:<p>>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.<p>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:<p>> 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.<p>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.<p>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.
Personally, I'm against making students use Eclipse because it's a terrible IDE and this constitutes cruel and unusual punishment.<p>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?<p>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.<p>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.
Absolutely not. There's significant educational benefit in timely, corrective feedback, which an IDE with incremental compilation and a linter is perfect for.<p>Eclipse isn't a good IDE for teaching[0], but it's significantly better than the commandline and javac.<p>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.<p>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<p>[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.
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)<p>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.<p>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?
> 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<p>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.
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! <a href="https://www.bluej.org" rel="nofollow">https://www.bluej.org</a><p>It really helped a lot back then!
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.
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.<p>And learning languages, algorithms and data structures is more valuable than learning the build systems.<p>Also, most assumptions in the article are false.<p>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.
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.<p>I guess there are people today who don’t fit that mold and approachability becomes important, shouldn’t be surprising.
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...<p>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.
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
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.
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
I legitimately left a job once over being made to use eclipse. Absolutely abominable horrible IDE.<p>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.<p>Visual studio on the other hand is one of the best Ides ever made, you can tell Microsoft puts in some effort.
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.
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.<p>Its kind of the right way to pair the livebook way of teaching Flutter frontend and frontend in general.
Lemme up the ante. Before starting a course students should design and assemble a computer they'll be learning to program on.<p>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.
> Use a language that teaches the fundamentals of the paradigm you’re interested in, like Scheme or Python. (Please, please not Java.)<p>If not Java then at least use a statically typed language. I feel that understanding types, and type-systems, is fundamental to computer science.
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.<p>Or, indeed, instead of <<article>> an <<!article>>
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?<p>Yes Eclipse is too complicated but I think IntelliJ is good for starting.
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?
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?"<p>Switched to Intellij and use other jetbrains product, never looked back
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.<p>This as how we did it back at my school and it works.
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.