From my personal experience, a good vs. a mediocre IDE can be the tipping point between really getting into developing or only doing it because you have to.
Of course CS students who come to university already programming and with a strong intrinsic desire will overcome difficulties regardless, but a good chunk of fellow students in business informatics/information systems were turned off by complicated setups and steep learning curves of IDEs and chose to steer clear of technical specializations.
I honestly do not experience any of Jetbrains' products as enterprise Java IDEs. To me, they are very well thought out tools to fluently automate menial tasks of development, quickly navigate context and structure, and "know what I mean" and take care of bookkeeping when I wish to shape code by refactoring by virtue of Jetbrains' very high capacity for writing powerful language parser and introspection and couple it with a powerful user interface with only a relatively mild learning curve. So yes, I do strongly believe that students will benefit from using Jetbrains' tools to get to the core of programming - as part of a balanced and supervised diet of ideas from very low abstraction to high.
I see no use in burdening students with feeding little text files to compilers, pushing the semicolon button, gardening header files, or cranking package manager handles.
I think the community edition of IntelliJ should usually be enough for a college student programming in Java. Though if they're using other languages or frameworks they'll want the commercial editions.
It depends on what you're building. The lack of Java EE support, JavaScript support, and Spring support are pretty notable exclusions.
You don't need to be doing enterprise programming to find the dependency injection pattern useful, it's very nice for building testable code. And Java EE is the beating heart of a Java webdev backend. Almost everything is built on Servlets and Filters and the web.xml configuration mappings, even if these are abstracted away (and the most common abstraction is - wait for it - Spring+Spring MVC). I guess you can always write Javascript without an IDE but it's definitely nice to use an IDE instead of just winging it with a browser console.
Speaking as someone who built his master's these using Notepad and javac, I can say had I used IntelliJ, I would have had a much more enjoyable time.
Students don't need these tools, but they do go along way to help make them more productive and enjoy the experience. I also wouldn't call IntelliJ (or Visual Studio) as "enterprise" tools. They are definitely the product of people who spend a LOT of time building software in the supported languages.
You can define "enterprise tools" any way you like, but there are software tools that cost millions of dollars that only an "enterprise" would ever buy, and tools like the JetBrains tools that are priced at a level where many individuals buy them for themselves. Many tools like this are still very popular within enterprises, as are many free, open-source tools, so you might mean "commonly used within enterprises" when you say "enterprise tools" but it's more common (I believe) for people to mean expensive tools that ONLY an enterprise would ever buy when they say "enterprise tools".
Thanks, that confirms my intuition. So maybe the marketers use it to scare-away the people who wouldn't be able to afford the product and would waste their time by contacting them for a price and even request demos.
As an example of "enterprise", scroll all the way down to the bottom of the IntelliJ page[1] for the section "Choose
your edition". In the "Ultimate" column, you'll see extra features such as support for IBM Rational Clearcase, MS TFS, and Java EE.
Hobbyists, students, and most startups in the web/mobile space don't use those corporate/enterprise products.[2]
Since this new announcement makes the Ultimate version free for students, I suppose some observers wonder why college students couldn't just use the Community edition which was already free.
Well that confused me at first. I questioned why those features would qualify for "enterprise software". Then I remembered that the EE in Java EE is for "Enterprise Edition" and my serach made me end up on Wikipedia[1], which explains enterprise software as "computer software used to satisfy the needs of an organization rather than individual users" - it's simple and makes total sense.
Hobbyists and startups might choose TFS since Visual Studio Online is free for orgs of a certain.
> "computer software used to satisfy the needs of an organization rather than individual users"
This applies to software like HP's ClearCase and Rational rose, whereas the EE in Java is bit of a misnomer. Originally, Java SE was designed primarily for single threaded desktop applications and applets, whereas Java EE was designed for a more networked application with application servers.
What happened is that Java EE was a beast to work with, but some features of it like servlets, injection, and data mappings were useful, so developers built versions of those that could work with Java SE (think Tomcat and Spring). The Java team took the lessons and redid Java EE to make it easier to work with. It's still a bit of a beast to work with, but good enough to build an application with.
> What happened is that Java EE was a beast to work with, but some features of it like servlets, injection, and data mappings were useful, so developers built versions of those that could work with Java SE (think Tomcat and Spring). The Java team took the lessons and redid Java EE to make it easier to work with. It's still a bit of a beast to work with, but good enough to build an application with.
This is a really important point for all of Java, in fact. It's a fairly old language (21 years) that has had a lot of trial-and-error and a lot of very niche applications (embedded/mobile development). There is a lot of stuff that is abandoned, obscure, deprecated, or not really used for its original purposes anymore.
For example of something that's widely acknowledged as an outright mistake, see the Cloneable interface.
Do also see the DEFCON talk "The Secret Life Of SIM Cards" that was posted here last night, for an example of a niche embedded usage of Java. There is a LOT of Java running around - not just on smartphones, but on all kinds of embeddable/mobile devices.
In many ways DotNet is a clean-slate reimplementation of what Java could have been. It avoids many of the pitfalls that Java ran into, but I think it also misses the boat on some others. I would love a Maven equivalent for C#. And checked exceptions actually are useful in some contexts and C# misses out, but on the other hand Java took it way too far by adding tons and tons of checked exceptions for generic "something happened!" failure cases, many of which are implementation errors and should be unchecked. C# has a lot less boilerplate but also more opportunity for mistakes if you aren't careful.
Java EE is the foundation of all Java webdev work. With the exception of a few micro-servers for (eg) testing work, all Java web servers (Tomcat/Jetty/etc) will provide implementations of the Java EE APIs for Servlets, Filters, the web.xml format, etc.
Lack of Spring support in the Community Edition is another biggie. It's the de-facto standard dependency-injection framework for Java. For regular usage, the whole "swap out components on the fly!" thing is oversold and overrated but the DI pattern does lead to easily testable code.
Finally, the lack of Javascript support is just bizarre.
Taken as a whole, the whole thing implies that all webdev work is somehow "enterprise". Like nobody ever did a CRUD app for a final project or a capstone or something?
There are some other things that aren't in the Community edition that would be much more appealing to students or startups such as Javascript, SQL, CSS, Ruby, React, Angular and Node support.
> Do students need enterprise Java IDEs (and IDEs for other languages designed by enterpirse Java developers)?
Yes, there was a software project that we as students built with Java EE (we used Eclipse at that time) - we had to build on legacy code that another student wrote for his diploma thesis in Java EE. This is surely not typical, but sometimes it happens.
I also like Visual Studio 2015 Enterprise, which one can get by the Dreamspark Premium program (I use it mostly for C++ and C# development), though there are many features that were once Visual Studio Premium and Ultimate only that are now also included in the Professional/Community Edition, too (for example Static Code Analysis in C++). So the difference is much smaller than in earlier times, but some testing tools, which I use, (in particular Code Coverage) are still Enterprise only:
For Java yes, but learn first javac and the command line tools. Then you understand why it's unbearable developing non trivial programs without an IDE. Too much time wasted.
For Node, Python and Ruby you can do without an IDE.
It's mainly for compiling automatically when the code changes and for hot reloading. It's important for working with web apps. For desktop maybe not but it's been maybe 10 years since I built a desktop Java application.
Maven is actually very important since it is a "generic" project format that all IDEs understand, it handles dependency management/downloading, etc. Ant and Gradle are nowhere near as useful since they are not a format an IDE can understand natively. They are a build script, not a project file, so you need to keep another project file in sync for each client you're using.
You don't even necessarily need to be building a Java target for Maven to be useful. It's also a common way to build continuous-integration build scripts for things like Docker packages, database artifacts, etc.
I'm not a fan of subscription-based models for software, but PHPStorm is good enough for me to ignore that. Plus it gets cheaper yearly for the first 3 years.
I agree and I was a bit disappointed at first being a long time customer, but they addressed that with the perpetual license. Also, for long term customer like me, it ended up costing less (I also got one year free when renewing, although I think that was a limited offer).
It left me kicking myself for not buying PHPStorm sooner so I could've gotten in on the perpetual license pricing. But oh well! It paid for itself pretty quickly, so I can't complain!
When I last looked at their pricing you could keep using their version you subscription expired on you just could get any updates for it until you subscribed again, is that not the case anymore?
Not sure. I only let it expire once, but I just assumed it wouldn't work and uninstalled and went back to SublimeText (and obviously I came running back!)
Jetbrains are my IDE of choice, I started with phpStorm when I was doing webdev and have used most flavours during my studies - I recommend anyone studying to give this offer a try it is incredible value.
Edit: I'd like to add all that's needed to get the student licence is a valid university email, at least for myself.
That also includes Reshaper, PyCharm, Webstorm, and CLion. These tools are awesome for students.
Somewhere else mentioned if students really need these kinds of tools? To write code? Probably not, it's better if they spent the time to use Vim/Emacs or just got going with Atom/VSCode/Sublime. But none of those editors support the ease of clicking on something and seeing what that is. A class, a function, etc. Jetbrain's support for this in any language they support is probably the best anywhere and the editor itself is damn good. I try my very best to get rid of it and I always find myself coming back. Rarely can anything match it's features which once you learn how to use them you'll often need on a day to day basis.
For Java I'd say yes, students do need an IDE (or to be more specific their life would be very difficult without an IDE). It is really difficult to write java, even trivial programs without an IDE (because of Java's long package and class names).
Since IntelliJ Studio is the defacto standard in Java IDEs (having surpassed Eclipse and Netbeans) I think that it is really great for students to be able use that IDE for their student projects.
Of course the usage of the IDE must not prevent then from familiaring themselves with classpaths and compiling a Java program with more than one packages through the command line!
Having also used Eclipse, I strongly disagree about its superiority; If it is popular, then I believe that is explained by its price and the self-sustaining property of ubiquity.
I myself found Eclipse cumbersome and lacking in capacity. I do respect others' preference for it, but it cannot be said to be objectively superior.
Agreed. Started with Eclipse, then Netbeans, now IntelliJ. Cumbersome seems like a good description for Eclipse.
I love the ease with which you can reconfigure the layout from task to task with IntelliJ. "Distraction Free" mode shows that they "get" what bugs many people about IDEs sucking up screen space for very little in some cases.
As someone who grew up in my Java career on Eclipse, have had a paid IntelliJ license and then started using Netbeans despite all warnings against it I strongly encourage everyone to at least try Netbeans on their own.
Main benefits:
- The whole thing is free. No pro or enterprise version. (That said this isn't cheapness on my side: I can have an IntelliJ license any day I ask my boss as he is an incurable fan. For me it is enough to fix his IntelliJ once in a while. ;-)
- Happily uses Maven poms as project models. No more problems with out of sync IDE configs. What builds on the build server is exactly what I see in the Project view.
- Standard keybindings follows modern OS conventions and you can switch to Eclipse or IntelliJ keybindings in options if you want.
- Doesn't scare noobs the way eclipse does. Not a problem for me, I used to love eclipse, but for a team lead this might be an advantage.
"it's better if they spent the time to use Vim/Emacs or just got going with Atom/VSCode/Sublime."
It's better learning to use the tools they will need. Period.
The problem is what tools will they need? The tools for Web Dev is different from iOS dev is different from game programming is different from... The tools available on Windows are different from the tools available on Linux... different form the tools on Macs...
I'm sorry, but "real programmers learn to use VIM and bad ones use IDEs" is BS.
Real programmers do what every craft does: Gets the best tools they can get their hands on and learns the in's and out's of them.
Which is why you keep going back to the best tools available. You'd be an idiot not to.
Never said that. A student should learn the way things actually work. They shouldn't get thrown in to an IDE so teachers don't need to explain the basics of a developer's workflow to them. However, after a period of getting used to things, they should DEFINITELY use an IDE as a tool to expand their understanding since eventually they'd use it to get actual work done.
An editor is MUCH easier to learn the in's and out's of than a full-blown IDE. Start small. Force them to understand. And THEN introduce them to IDEs. Does this happen this way? Not Really. I started with Visual Studio. But I've taught friends this way and it really helps accelerate them past the usual bumps in the road when you're first learning.
Learning how things "actually" work is different than learning how to get things done.
There is definitely room for learning how things work "under then hood". Aka algorithm work, creating your own bubble sort, creating your own blog, etc. Those skills get added to your list of tools. Understanding which sort is best for which application... which language... which paradigm.
If you don't learn the different things, you become a programmer that uses a hammer for a solutions - because it's the only tool you know.
Granted, I may have been a bit harsh - it's hard to do sarcasm, tone of voice, etc in text message. So take my post with a grain of salt :)
> Learning how things "actually" work is different than learning how to get things done.
And that's how you get C++ programmers who don't know, what is a linker and what it does. Their IDE presents them a project organized in a tree and when then press "Build project" button, an exe is on the other end.
That's an important point of learning C++... and one I would agree needs to be learned for that level/line of programming.
Does a Web Developer or a LoB developer (which is mainly my pervue) - who is never going to go that deep - need to know linking and header files? That experience is vital for C/C++... but for PHP or Javascript?
I've always meant to learn a little more of C/C++ and maybe even learn some Assembly - but in my years of work I've never personally NEEDED that knowledge to get paid.
As a .Net/C# programmer, I've only touched those lower levels as an educational exercise or many years ago during entry level classes I've since long forgotten.
All of my important work has been in two core places: SSMS (or a couple other database IDEs) and Visual Studio (2005 through "15"). I've never used the command line to build a project - although I know that exists.
Does that make me a bad programmer? I don't think so. That would be a different answer if I was a C/C++ programmer.
> I've never used the command line to build a project
That means you probably couldn't, for example, write a small script that, for each of the last 10 commits, compiles the project and runs the tests -- to see where a bug was introduced.
Well, considering my last few jobs don't enforce tests that is a shortcoming of mine I'll admit too freely.
My current job is a new batch of programmers (all at the company less than a year and me the newest) that introduced SVN, a dev environment, Nugets and a build system (Jenkins). Needless to say the code that we are working with involves more WTFs than you can shake a stick at and testing is down the list, unfortunately.
I have no doubt I could figure that sort of system out but it would definitely be a challenge for me. There any good demo's of that sort of setup and learning how to navigate it?
I haven't done any development on Windows for almost 10 years, so I don't have an opinion on Nugets. Git seems more popular than SVN, but SVN is simpler to use. Jenkins is very widely used by Java developers, especially, but works with other languages. At least for Java, it builds on the command-line approach of Maven (a build tool), since it essentially runs commands like "mvn compile" "mvn test" in sequence and reports the result -- exactly as a developer would, either by typing them or pressing a button in the IDE.
Version control, a development environment, dependency management and a build server are all sensible parts of continuous integration (i.e. having automatic builds of the software which run the tests, to avoid introducing new bugs and mean the software is usually in a state where it can be demonstrated to the boss, or released). "Continuous Integration" (book [1]) is a good general guide, which helped me explain what the benefit of these tools would be to a reluctant team in a previous job.
-
I have sat near to developers using Windows, and I think the typical Linux (especially) "command line first" approach has significant benefits for any developer. Some one-off problems can be solved very quickly, and the solution is usually repeatable and can be automated.
Last week's issue was ~10000 identifiers, of which about 10 were known to cause an error in our REST API. The logging wasn't sufficient, but it was easy to make the read-only API call with every identifier:
I began with a single identifier:
curl -Ss http://api.example.org/get/1234
(retrieves the content of the URL)
Then made the test:
curl -Ss http://api.example.org/get/1234 | grep SUCCESS || echo "Problem with record 1234"
(finds any line containing "SUCCESS", returns true if found, false otherwise)
Then saw that I could read my identifiers (in reality, they were output from another command rather than read from a file):
for i in $( cat identifiers ) ; do
echo $i
done
Then tied it all together:
for i in $( cat identifiers ) ; do
curl -Ss http://api.example.org/get/$i | grep SUCCESS || echo "Problem with record $i"
done
Of course, this could be done in many languages (even Excel), but it's hard to beat shell script for development speed, and with the bug fixed we don't need to run this check again.
Last month, it was which of 100,000 ZIP archives contains invalid TSV data (wrong number of columns, should be 50)
for i in *.zip; do
unzip -p $i output.tsv | tr -d -c $'\t\n' | awk '{ print length }' | grep -v '^50$' && echo "$i corrupt"
done
(i.e. unpack only output.tsv, discard everything that isn't a tab or newline, print each line's length, then look for lines that aren't "50" and report.)
It's not the tool for everything: I wouldn't try and process XML, and CSV files with quoted commas would be better handled with a proper library, but hopefully that's an idea of some strengths.
For the specific task I mentioned (finding the bad commit), semi-pseudocode is
for c in $( svn print-out-last-10-commit-identifiers-from [repository] ); do
svn checkout --revision $c [repository] $c
cd $c
mvn compile test || break
done
The linking was just an example (although important for those who generate native binaries). With java or c# there are other, but similar low-level issues that the programmer should be aware, because they can affect the deployment. The typical example may be a 3rd-party library or SDK you are using was compiled with the same library as you are using, just with different version. Maybe even the runtime you are using supplies some version too (think a Java application server like JBoss, your .ear containing your app with dependencies and one of those dependencies is a third-party jar with the same-but-different lib). Even in PHP or JavaScript you can end up with dependency hell, solving which is miles away from organizing your files in the IDE and necessity to know how things work under the hood.
I've got personal experiences which says IDE-first is a bad approach. However, once you've learn the basics you should definitely graduate to an IDE as a student like you say.
My experience has been that many students don't learn a single thing well enough to build upon to gain those extra tools you mentioned. An IDE might bring them closer to that point faster, but I also think it makes them leave things behind they should know.
(recent graduate, informal teacher to many friends getting in to CS industry)
It's definitely a part of getting a well rounded education... but a large part depends on WHAT you are learning.
What's needed to learn C/C++ is different than what's needed to learn Javascript. C#. Ruby. PHP. SQL. Etc...
A Javascript developer could spend his/her life without ever touching a compiler. I've spent my "career" without ever needing that level of knowledge as a .Net Developer (C#/VB) and Sql Reporting guy (SSMS/Crystal Reports/etc).
I would agree wholeheartedly that a C/C++/Assembly guy needs that experience... but most programmers don't need to know how a linker works.
I really think it should be the other way around, at least in a computer science program. Start them in an as easy environment as possible where they can spend their time learning programming concepts and computer science rather than fighting archaic tools.
Once they're comfortable with programming and understand the basic concepts, then you can step back and explain exactly how to set up a build environment and write a Makefile and all other workflow steps needed to get something that can actually run.
Having been a tutorial assistant for novice first year computer scientists: the text editor is the easy environment, assuming the lab computers have all been set up correctly with the necessary tools.
The instructions given to students were to use something like gedit, and "javac" and "java". This rarely caused problems, but the students who tried to use Eclipse were more likely to get stuck operating it, or else distracted by it.
The vim plugin is a good extension. You get all the automated viewing / searching / generation (if need be), plus the "hands planted on the keyboard" few-key-strokes low level editing.
E.g. - the "yank" (y) and "put" (p) command combos are nice for quickly rearranging a few small things - yank (N) word(s), yank (N) line(s), move a bit (N words/lines), put chunk in new place.
Actually, tools are not that different across platforms as long as you write code, use version control and so on. As per topic - if you chose any of JetBrains product as your IDE of choice, it's cross platform (linux/windows/osx). And everything else you need from web stack is cross platform. If it's not (looking at you, windows), you can always go for ubuntu on windows via WSL, which is somewhat flawed with a few annoying bugs, but it'll come around.
Learn open source tools, you'll be able to use them freely your entire life. These tools may be shinier, but they offer no real productivity gains in the long run.
Ugly Eclipse keeps pulling me away from shiny IntelliJ.
I've been switching to Java from C# for the last year or so. At my company, the Java developers that I most admire use Eclipse.
Coming from Visual Studio, the weirdest thing about Eclipse was having multiple projects loaded in the same Eclipse instance. But as I get used to it, switching back to IntelliJ confuses me. I get lost with the multiple instances.
The huge advantage with using multiple projects at the same time is you can trivially factor out mutual pieces of code and include them as libraries. It's a really important thing for extremely integrated large projects that have big overarching goals.
For instance the game I'm writing as a server and a client. The idea of the networking components are abstracted away from the server and client. They include a library all together that handles everything. They don't need their own implementations and I don't need to switch back and forth in the IDEs to get to the right projects, start them, compile the library project, and go back to each sub-project and include it.
It's so much nicer when working on client-server architectures. That's why I love eclipse
"but they offer no real productivity gains in the long run."
I guess if you define 'long run' however you want... sure. Your point may stand.
For almost everyone I know, JetBrains tools have delivered a massive, measurable amount of productivity gain, compared to any other tools they were using (commercial or free). "no real productivity gain" is highly subjective, and doesn't come close to matching the experience of most of the developers I know in their day to day work.
>but they offer no real productivity gains in the long run.
I'm pretty sure things like code completion, interactive debugging, and static analysis have increased my productivity by an order of magnitude. Sure, I could spend days and weeks memorizing every Vim command and obscure UNIX program to handle these things, but why?
When I was in college, Microsoft had DreamSpark, which was a similar kind of thing (use your school email, get a bunch of free licenses to VS, SQL Server, etc). I don't know if they still do it, but especially in those days, it was great, because the free Express editions hadn't quite come out yet, and when they did, they were pretty gimped. Using a real version of Visual C++ was head and shoulders better than trying to fight with Eclipse, or CodeBlocks, or DevC++ in those days.
Always very wary about suggesting people cut their teeth in the warm embrace of a IDE. It's often unrealistic.
If it's the industry standard —like it was and probably still is completely normal to use VS.NET for .NET development— that might be okay but reducing exposure to things that the rest of your industry like a makefile or [gp]db, Maven/Gradle/Ant, or whatever... It's a real disservice to your students.
If you're an educator and you want your students to get a job, make sure you're teaching the stuff we're actually using.
There's nothing stopping you learning other stuff but I've found from both personal experience and dealing with new hires, people like to stick with what they learnt on.
My experience is green graduates who grew up on IDEs struggle —for much longer than you'd expect— to get on with command line scripting and tools. They avoid a lot of very necessary experience when you have an IDE do everything.
I'll stop well short of saying "real programmers only use VIM" but experience is everything, especially when differentiating juniors. Learning how to do everything with one IDE is a great way to get very little real-world experience.
That is a fair point, although my experience was that the IDE didn't matter much. Most of my fellow students didn't learn build systems regardless of whether they worked in the popular IDE at the time or just a text editor.
I would hope that build systems would be taught regardless of the IDE.
I don't know about Eclipse being better. I switched to IntelliJ two years ago and I love it. I find it much better, faster and less buggy compared to Eclipse.
I haven't used Borland's stuff (Turbo Pascal, Turbo C++, TP-Windows, Debugger) since the early 90s. I bought a copy of Delphi around 96, but never really used it, as my late 90s job was more off in the unix side of things by then (Linux at home, but IRIX/AIX at work).
No employer wants Borland's languages now. I suspect Kotlin will suffer the same fate.
When I first started doing ANSI C work in the early 90s (several platforms, including non POSIX), it was helpful to be able to use Turbo C[++] / Turbo Debugger to work on an otherwise standardized language. That seems to be what JetBrains is doing best, now.
I have not used Embarcadero's Delphi, just their database client. I have used Free Pascal, though. Interesting, but no demand for it :-(
The whole 90s C/C++ thing was such a debacle. Running C for app work in the internet era reminded me of "Hunt for Red October" - "Next, he'll be removing the safeties from his torpedos" - "you arrogant ass, now you have killed us!". Widespread internet adoption was the "extinction level event" for C/C++ apps. (along with faster processors and garbage collection)
Anyway, if more companies had used an Algol descended language that actually did bounds checking, and made less use of points constantly, the crisis that forced Java adoption could have been avoided.
There are good high level languages out there that use automatic memory management. Java (language) just isn't high up that list. If I'm going to pay for a garbage collector, I want to do functional programming, NOT mutable OOP.
I've been using pyCharm for the last 2 years and its code completion has helped me code and learn at a much faster pace than other editors.
It offers code suggestions for any module that has been imported in addition to everything in the current script. Sublime and vim's code completion seem very primitive in comparison.
That said, I usually use the free Community Edition because it loads faster.
Emacs's elpy package is also great at auto-complete. I haven't used PyCharm myself but Emacs is more than enough. Also, most of my other programming are done in Emacs.
Resharper is great, totally awesome features for C#... unless you have a large professional project. The performance tanks and features become unreliable the larger the project gets. This has been a problem with every resharper version since 5.x
I am currently a CS Student and use a lot of the tools from jet brains. It's awesome that they are free!
To give a bit of an perspective/motivation: They make it really easy to try something out. You can click things, visualise things and get guided by the IDE, then they scale with your skill until you never click things and only use the shortcuts. There is a plugin for nearly everything and the documentation (NOT the openapi-doc, thats horrible or nonexistent) is great. I would not want to teach an freshmen (is this correct? first year university?) javascript with vim/emacs.
One thing I love about the jetbrains suite is that the keyboard shortcuts remain mostly the same across all of them - whether I'm coding python in PyCharm or javascript in Webstorm, I can use the same keyboard shortcuts.
91 comments
[ 5.4 ms ] story [ 148 ms ] threadOf course CS students who come to university already programming and with a strong intrinsic desire will overcome difficulties regardless, but a good chunk of fellow students in business informatics/information systems were turned off by complicated setups and steep learning curves of IDEs and chose to steer clear of technical specializations.
I see no use in burdening students with feeding little text files to compilers, pushing the semicolon button, gardening header files, or cranking package manager handles.
You don't need to be doing enterprise programming to find the dependency injection pattern useful, it's very nice for building testable code. And Java EE is the beating heart of a Java webdev backend. Almost everything is built on Servlets and Filters and the web.xml configuration mappings, even if these are abstracted away (and the most common abstraction is - wait for it - Spring+Spring MVC). I guess you can always write Javascript without an IDE but it's definitely nice to use an IDE instead of just winging it with a browser console.
Students don't need these tools, but they do go along way to help make them more productive and enjoy the experience. I also wouldn't call IntelliJ (or Visual Studio) as "enterprise" tools. They are definitely the product of people who spend a LOT of time building software in the supported languages.
Hobbyists, students, and most startups in the web/mobile space don't use those corporate/enterprise products.[2]
Since this new announcement makes the Ultimate version free for students, I suppose some observers wonder why college students couldn't just use the Community edition which was already free.
[1]http://www.jetbrains.com/idea/features/#out-of-tools
[2]the IBM Clearcase of $2000 is example of "enterprise" pricing: http://estore.gemini-systems.com/ibm/software-license/ration...
(Most college students would probably just use Git/Github instead of IBM Clearcase.)
[1]: https://en.wikipedia.org/wiki/Enterprise_software
Hobbyists and startups might choose TFS since Visual Studio Online is free for orgs of a certain.
> "computer software used to satisfy the needs of an organization rather than individual users"
This applies to software like HP's ClearCase and Rational rose, whereas the EE in Java is bit of a misnomer. Originally, Java SE was designed primarily for single threaded desktop applications and applets, whereas Java EE was designed for a more networked application with application servers.
What happened is that Java EE was a beast to work with, but some features of it like servlets, injection, and data mappings were useful, so developers built versions of those that could work with Java SE (think Tomcat and Spring). The Java team took the lessons and redid Java EE to make it easier to work with. It's still a bit of a beast to work with, but good enough to build an application with.
This is a really important point for all of Java, in fact. It's a fairly old language (21 years) that has had a lot of trial-and-error and a lot of very niche applications (embedded/mobile development). There is a lot of stuff that is abandoned, obscure, deprecated, or not really used for its original purposes anymore.
For example of something that's widely acknowledged as an outright mistake, see the Cloneable interface.
http://www.artima.com/intv/issues3.html
Do also see the DEFCON talk "The Secret Life Of SIM Cards" that was posted here last night, for an example of a niche embedded usage of Java. There is a LOT of Java running around - not just on smartphones, but on all kinds of embeddable/mobile devices.
https://www.youtube.com/watch?v=_-nxemBCcmU
In many ways DotNet is a clean-slate reimplementation of what Java could have been. It avoids many of the pitfalls that Java ran into, but I think it also misses the boat on some others. I would love a Maven equivalent for C#. And checked exceptions actually are useful in some contexts and C# misses out, but on the other hand Java took it way too far by adding tons and tons of checked exceptions for generic "something happened!" failure cases, many of which are implementation errors and should be unchecked. C# has a lot less boilerplate but also more opportunity for mistakes if you aren't careful.
Lack of Spring support in the Community Edition is another biggie. It's the de-facto standard dependency-injection framework for Java. For regular usage, the whole "swap out components on the fly!" thing is oversold and overrated but the DI pattern does lead to easily testable code.
Finally, the lack of Javascript support is just bizarre.
Taken as a whole, the whole thing implies that all webdev work is somehow "enterprise". Like nobody ever did a CRUD app for a final project or a capstone or something?
Yes, there was a software project that we as students built with Java EE (we used Eclipse at that time) - we had to build on legacy code that another student wrote for his diploma thesis in Java EE. This is surely not typical, but sometimes it happens.
I also like Visual Studio 2015 Enterprise, which one can get by the Dreamspark Premium program (I use it mostly for C++ and C# development), though there are many features that were once Visual Studio Premium and Ultimate only that are now also included in the Professional/Community Edition, too (for example Static Code Analysis in C++). So the difference is much smaller than in earlier times, but some testing tools, which I use, (in particular Code Coverage) are still Enterprise only:
> https://www.visualstudio.com/vs/compare/
For Node, Python and Ruby you can do without an IDE.
You don't even necessarily need to be building a Java target for Maven to be useful. It's also a common way to build continuous-integration build scripts for things like Docker packages, database artifacts, etc.
You need to practice to become your most productive self. If you aren't productive you aren't going to find someone who will hire you.
Not sure if they still do but JetBrains used to offer its IDEs for free to open source developers.
https://www.jetbrains.com/buy/opensource/
Edit: I'd like to add all that's needed to get the student licence is a valid university email, at least for myself.
Somewhere else mentioned if students really need these kinds of tools? To write code? Probably not, it's better if they spent the time to use Vim/Emacs or just got going with Atom/VSCode/Sublime. But none of those editors support the ease of clicking on something and seeing what that is. A class, a function, etc. Jetbrain's support for this in any language they support is probably the best anywhere and the editor itself is damn good. I try my very best to get rid of it and I always find myself coming back. Rarely can anything match it's features which once you learn how to use them you'll often need on a day to day basis.
Since IntelliJ Studio is the defacto standard in Java IDEs (having surpassed Eclipse and Netbeans) I think that it is really great for students to be able use that IDE for their student projects.
Of course the usage of the IDE must not prevent then from familiaring themselves with classpaths and compiling a Java program with more than one packages through the command line!
Incorrect. Eclipse remains superior and is in far greater use across the world and the enterprise landscape.
I myself found Eclipse cumbersome and lacking in capacity. I do respect others' preference for it, but it cannot be said to be objectively superior.
I love the ease with which you can reconfigure the layout from task to task with IntelliJ. "Distraction Free" mode shows that they "get" what bugs many people about IDEs sucking up screen space for very little in some cases.
Main benefits:
- The whole thing is free. No pro or enterprise version. (That said this isn't cheapness on my side: I can have an IntelliJ license any day I ask my boss as he is an incurable fan. For me it is enough to fix his IntelliJ once in a while. ;-)
- Happily uses Maven poms as project models. No more problems with out of sync IDE configs. What builds on the build server is exactly what I see in the Project view.
- Standard keybindings follows modern OS conventions and you can switch to Eclipse or IntelliJ keybindings in options if you want.
- Doesn't scare noobs the way eclipse does. Not a problem for me, I used to love eclipse, but for a team lead this might be an advantage.
It's better learning to use the tools they will need. Period.
The problem is what tools will they need? The tools for Web Dev is different from iOS dev is different from game programming is different from... The tools available on Windows are different from the tools available on Linux... different form the tools on Macs...
I'm sorry, but "real programmers learn to use VIM and bad ones use IDEs" is BS.
Real programmers do what every craft does: Gets the best tools they can get their hands on and learns the in's and out's of them.
Which is why you keep going back to the best tools available. You'd be an idiot not to.
An editor is MUCH easier to learn the in's and out's of than a full-blown IDE. Start small. Force them to understand. And THEN introduce them to IDEs. Does this happen this way? Not Really. I started with Visual Studio. But I've taught friends this way and it really helps accelerate them past the usual bumps in the road when you're first learning.
There is definitely room for learning how things work "under then hood". Aka algorithm work, creating your own bubble sort, creating your own blog, etc. Those skills get added to your list of tools. Understanding which sort is best for which application... which language... which paradigm.
If you don't learn the different things, you become a programmer that uses a hammer for a solutions - because it's the only tool you know.
Granted, I may have been a bit harsh - it's hard to do sarcasm, tone of voice, etc in text message. So take my post with a grain of salt :)
And that's how you get C++ programmers who don't know, what is a linker and what it does. Their IDE presents them a project organized in a tree and when then press "Build project" button, an exe is on the other end.
Does a Web Developer or a LoB developer (which is mainly my pervue) - who is never going to go that deep - need to know linking and header files? That experience is vital for C/C++... but for PHP or Javascript?
I've always meant to learn a little more of C/C++ and maybe even learn some Assembly - but in my years of work I've never personally NEEDED that knowledge to get paid.
As a .Net/C# programmer, I've only touched those lower levels as an educational exercise or many years ago during entry level classes I've since long forgotten.
All of my important work has been in two core places: SSMS (or a couple other database IDEs) and Visual Studio (2005 through "15"). I've never used the command line to build a project - although I know that exists.
Does that make me a bad programmer? I don't think so. That would be a different answer if I was a C/C++ programmer.
That means you probably couldn't, for example, write a small script that, for each of the last 10 commits, compiles the project and runs the tests -- to see where a bug was introduced.
My current job is a new batch of programmers (all at the company less than a year and me the newest) that introduced SVN, a dev environment, Nugets and a build system (Jenkins). Needless to say the code that we are working with involves more WTFs than you can shake a stick at and testing is down the list, unfortunately.
I have no doubt I could figure that sort of system out but it would definitely be a challenge for me. There any good demo's of that sort of setup and learning how to navigate it?
Version control, a development environment, dependency management and a build server are all sensible parts of continuous integration (i.e. having automatic builds of the software which run the tests, to avoid introducing new bugs and mean the software is usually in a state where it can be demonstrated to the boss, or released). "Continuous Integration" (book [1]) is a good general guide, which helped me explain what the benefit of these tools would be to a reluctant team in a previous job.
-
I have sat near to developers using Windows, and I think the typical Linux (especially) "command line first" approach has significant benefits for any developer. Some one-off problems can be solved very quickly, and the solution is usually repeatable and can be automated.
Last week's issue was ~10000 identifiers, of which about 10 were known to cause an error in our REST API. The logging wasn't sufficient, but it was easy to make the read-only API call with every identifier:
I began with a single identifier:
(retrieves the content of the URL)Then made the test:
(finds any line containing "SUCCESS", returns true if found, false otherwise)Then saw that I could read my identifiers (in reality, they were output from another command rather than read from a file):
Then tied it all together: Of course, this could be done in many languages (even Excel), but it's hard to beat shell script for development speed, and with the bug fixed we don't need to run this check again.Last month, it was which of 100,000 ZIP archives contains invalid TSV data (wrong number of columns, should be 50)
(i.e. unpack only output.tsv, discard everything that isn't a tab or newline, print each line's length, then look for lines that aren't "50" and report.)It's not the tool for everything: I wouldn't try and process XML, and CSV files with quoted commas would be better handled with a proper library, but hopefully that's an idea of some strengths.
For the specific task I mentioned (finding the bad commit), semi-pseudocode is
[1] https://books.google.dk/books/about/Continuous_Integration.h...I've got personal experiences which says IDE-first is a bad approach. However, once you've learn the basics you should definitely graduate to an IDE as a student like you say.
My experience has been that many students don't learn a single thing well enough to build upon to gain those extra tools you mentioned. An IDE might bring them closer to that point faster, but I also think it makes them leave things behind they should know.
(recent graduate, informal teacher to many friends getting in to CS industry)
What's needed to learn C/C++ is different than what's needed to learn Javascript. C#. Ruby. PHP. SQL. Etc...
A Javascript developer could spend his/her life without ever touching a compiler. I've spent my "career" without ever needing that level of knowledge as a .Net Developer (C#/VB) and Sql Reporting guy (SSMS/Crystal Reports/etc).
I would agree wholeheartedly that a C/C++/Assembly guy needs that experience... but most programmers don't need to know how a linker works.
Once they're comfortable with programming and understand the basic concepts, then you can step back and explain exactly how to set up a build environment and write a Makefile and all other workflow steps needed to get something that can actually run.
The instructions given to students were to use something like gedit, and "javac" and "java". This rarely caused problems, but the students who tried to use Eclipse were more likely to get stuck operating it, or else distracted by it.
The vim plugin is a good extension. You get all the automated viewing / searching / generation (if need be), plus the "hands planted on the keyboard" few-key-strokes low level editing.
E.g. - the "yank" (y) and "put" (p) command combos are nice for quickly rearranging a few small things - yank (N) word(s), yank (N) line(s), move a bit (N words/lines), put chunk in new place.
My current hat is .Net and I haven't touched VIM - or the bash prompt - in almost a year.
I've been switching to Java from C# for the last year or so. At my company, the Java developers that I most admire use Eclipse.
Coming from Visual Studio, the weirdest thing about Eclipse was having multiple projects loaded in the same Eclipse instance. But as I get used to it, switching back to IntelliJ confuses me. I get lost with the multiple instances.
For instance the game I'm writing as a server and a client. The idea of the networking components are abstracted away from the server and client. They include a library all together that handles everything. They don't need their own implementations and I don't need to switch back and forth in the IDEs to get to the right projects, start them, compile the library project, and go back to each sub-project and include it.
It's so much nicer when working on client-server architectures. That's why I love eclipse
I guess if you define 'long run' however you want... sure. Your point may stand.
For almost everyone I know, JetBrains tools have delivered a massive, measurable amount of productivity gain, compared to any other tools they were using (commercial or free). "no real productivity gain" is highly subjective, and doesn't come close to matching the experience of most of the developers I know in their day to day work.
IntelliJ Community edition is free.
I'm pretty sure things like code completion, interactive debugging, and static analysis have increased my productivity by an order of magnitude. Sure, I could spend days and weeks memorizing every Vim command and obscure UNIX program to handle these things, but why?
If it's the industry standard —like it was and probably still is completely normal to use VS.NET for .NET development— that might be okay but reducing exposure to things that the rest of your industry like a makefile or [gp]db, Maven/Gradle/Ant, or whatever... It's a real disservice to your students.
If you're an educator and you want your students to get a job, make sure you're teaching the stuff we're actually using.
Although I do think it is unfortunately that a lot of CS courses pay little attention to build tools.
My experience is green graduates who grew up on IDEs struggle —for much longer than you'd expect— to get on with command line scripting and tools. They avoid a lot of very necessary experience when you have an IDE do everything.
I'll stop well short of saying "real programmers only use VIM" but experience is everything, especially when differentiating juniors. Learning how to do everything with one IDE is a great way to get very little real-world experience.
I would hope that build systems would be taught regardless of the IDE.
IntellJ is far less resource intensive but eclipse has some features (mutli-projects in one 'solution') that IntellJ won't add.
(Except JBuilder, the Java IDE. Did you use it back in the day? What did you think of it?)
No employer wants Borland's languages now. I suspect Kotlin will suffer the same fate.
When I first started doing ANSI C work in the early 90s (several platforms, including non POSIX), it was helpful to be able to use Turbo C[++] / Turbo Debugger to work on an otherwise standardized language. That seems to be what JetBrains is doing best, now.
The whole 90s C/C++ thing was such a debacle. Running C for app work in the internet era reminded me of "Hunt for Red October" - "Next, he'll be removing the safeties from his torpedos" - "you arrogant ass, now you have killed us!". Widespread internet adoption was the "extinction level event" for C/C++ apps. (along with faster processors and garbage collection)
Anyway, if more companies had used an Algol descended language that actually did bounds checking, and made less use of points constantly, the crisis that forced Java adoption could have been avoided.
It offers code suggestions for any module that has been imported in addition to everything in the current script. Sublime and vim's code completion seem very primitive in comparison.
That said, I usually use the free Community Edition because it loads faster.
Too bad for non American non UK students.
To give a bit of an perspective/motivation: They make it really easy to try something out. You can click things, visualise things and get guided by the IDE, then they scale with your skill until you never click things and only use the shortcuts. There is a plugin for nearly everything and the documentation (NOT the openapi-doc, thats horrible or nonexistent) is great. I would not want to teach an freshmen (is this correct? first year university?) javascript with vim/emacs.