1. 18
  1.  

  2. 19

    Agreed in general, but suggesting rails new as an example of “lean, efficient, simple” strikes me as a little odd.

    1. 8

      What you just said. A lot, and probably less tactfully.

      1. 3

        Weirder still is that the author seems to be in love with scaffolding tools.

        1. 3

          I’m not totally against scaffolding, although I’d like if it weren’t often pitched as an all-or-nothing thing. There are parts of many programs that I’d like to use it for, and parts that I wouldn’t.

          1. 5

            I’m not against scaffolding either. Starting a Django project w/o scaffolding would be unnecessarily bothersome. But I found weird to say: “These damn IDEs with their magic wizards and their project layouts guiding the developer”. And in the next sentence be all other scaffolding generators, which take care of the ‘red tape’ of some frameworks. When I think about a clean, lean understandable reality I think of CL, where one just opens a new file, defines a new package (optional but encouraged) and code away.

            1. 1

              Yes, that’s pretty much the example I’d use as well. :) Or maybe C, if I block out the fact that I have to find a way of actually building my project when I’m thinking about the initial complexity…

        2. 2

          That’s pretty much exactly what I wanted to say. In some ways rails is fairly equivalent to IDEs, and in pretty much every way he lambasted IDEs. No, it doesn’t require the initial massive dependency of an IDE, but it pulls in a fairly large number of gems, which aren’t a trivial size. It also can do pretty much all the babying an IDE does, and can be used as a crutch, just with a text-based over a graphical one.

          I think both have their place, you just have to know how to use them effectively, and it definitely pays to know what’s happening under the hood.

          1. 3

            I think of Rails as the CLI equivalent of Visual Basic: metaprogramming and generators write your code for you, and you fill in the blanks where necessary.

        3. 14

          It’s all about UNIX as IDE for me.

          1. 10

            Decent rant, but the culture on Windows, whether you like it or not, is usually “use VS to build.” Nobody really likes it, and it can be improved, but the not-great state of the Windows CLI means it doesn’t have quite the place it does on POSIX.

            I think the author has realized he meshes better with primarily CLI tools, as do I.

            But the deification of the CLI is not what we need more of. There’s a huge space for an IDE that is pleasant to use and understands your code, but there’s so much Real Programmer bullshit around the Perfect Editors Ever (Vim/Emacs) that it probably won’t happen in my lifetime. I want structure editors, GUI designers, automated refactoring tools without tinkering with loads of plugins.

            1. 2

              You know, actually a vision like this would make a pretty good article in its own right.

              I want all of those tools too, but it’s also important to me that they be loosely coupled. I suppose one could invent an IDE that could integrate tools not written solely for it. I’d also like it if it weren’t a multiple-document-interface windowing setup, because honestly that style of UI is really irritating and packs functionality way too densely. But if one changed both those things, I’m not sure what exactly would make it an IDE, in that case. Perhaps someone who is a fan of IDEs should write something talking about their good points and what’s worth saving. :)

              1. 2

                If anything the culture on Windows is being overtaken by POSIXy things or things vaguely inspired by POSIX. Cygwin/Ming are basically required for most open source things to build, PowerShell is taking over Windows admin and dev, SSH being added, etc.

              2. 5

                I don’t enjoy using IDEs: I write Java code for my master thesis and both Eclipse and IntelliJ are unbearably slow on my lab workstation and I feel that there is a lot that I don’t understand and that could bite me in the butt. However, I do believe that the advanced functionality that IDEs provides are productivity amplifiers for programmers. I don’t believe in using IDEs as a crutch (e.g. having inconsistent naming conventions and relying on the fact that a programmer can find what they need from a drop-down list), but I do think that, at least for me, they are helpful.

                This is why I really like a trend that seems to become more common: command-line utilities that can provide answers to IDE-like questions. For example, for OCaml there is Merlin which an editor can use to provide functionality such as jump-to-definition, auto-completion, displaying the type of an expression, etc. Merlin can be used from Emacs, Vim and Acme and I’m sure some clever hackers have made it work for Sublime Text or Atom.io. Rust has a similar tool called Racer.

                This makes a lot of sense because the “IDE” functionality is not tied to one particular software and so as a developer if I am using Emacs, but decide to switch to Sublime for any reason, I do not lose the functionality that I’ve grown to rely on. Better yet, it gives a greater sense of community as the choice of a particular editor is not terribly important so long as it can talk to the tool.

                1. 2

                  The way I see it there are two main parts to an IDE:
                  1) Project file/format
                  2) Editing features such as autocomplete, jump to declaration/definition, refactoring, class diagrams, continuous integration (Or similar), SCM, a good debugger with decent GUI, etc.

                  1) can be abstracted out somewhat by using cmake or make which either generate a project file or the IDE can build make files. KDevelop does this well, with a few clicks you can base your project on either a cmake or make file and it just works nicely.
                  2) is rarer, it is harder to find one IDE that has the features everyone wants. The top 10 IDEs say will please most people well enough, but there are always going to be features missing. I’ve used Visual Studio, Xcode, KDevelop, Eclipse and a few others, I don’t think any of those are “the perfect IDE”, I don’t even think it exists because none of them have all the features I want. So I settle for those, each of which contains a different selection of about 8/10 of the features I want.

                2. 3

                  No idea about Ruby specifically, but for C/C++ and other languages there is cmake. It can generate projects for Visual Studio, KDevelop, Xcode and make (And others).

                  What I’d really like is for Windows, Mac and Linux to embrace one IDE that works on all platforms so that I can just use the same project file and settings on all platforms. I don’t care if it is Visual Studio, Xcode, KDevelop, Eclipse or something else, as a cross platform developer it is annoying to have wildly different project files, default shortcuts, formatting, colours on all platforms. I know Eclipse and KDevelop are cross platform, but Microsoft and Apple haven’t ditched their own IDEs and embraced them. Google even stopped recommending Eclipse and use a new IDE :(

                  Once that is sorted we can talk about which libraries are available on each platform, which are shipped in OSs by default and version hell :(

                  1. 8

                    JetBrains’ IntelliJ IDEA might be a good-enough stopgap IDE for you. It is cross-platform, with a Java GUI that is heavily customized so it feels pretty native. And it has plugins that implement all the features of JetBrains’ other products such as WebStorm and RubyMine, so it work with many types of projects – Ruby, Python, C++, Java, Scala, etc.

                    It can replace Xcode and Android Studio – it works with their project files. (In fact, Android Studio is made by JetBrains – it’s basically IDEA Lite.) The major thing IDEA doesn’t do is .NET. JetBrains doesn’t provide a .NET plugin – instead, it sells an addon for Visual Studio, ReSharper.

                    1. 2

                      Yah, I’ve been using IntelliJ IDEA for close to 15 years and on a reasonably performant machine (it runs very well on 3-year old hardware) it’s the best I’ve used. Like any tool, once you learn it (especially the keyboard shortcuts), I can write (admittedly verbose) Java extremely fast. Refactoring is incredible, and the suggestions it makes (because it has completely parsed your code and all of your dependencies) sometimes border on mind-reading.

                      Also, since it’s itself written in Java, I can (and do) develop back and forth between my (aging) Windows box and my Linux box. Moving to a colleague’s Mac is only jarring because of the bizarre meta keys (command? cloverleaf? what?).

                      There’s a reason Google decided to go with IntelliJ IDEA as the foundation for its Android Studio.

                      1. 1

                        Thanks, I’ll give it a try, at work I port applications between Windows, Mac, iOS and sometimes Android so anything that can reduce the number of IDEs/project files would be great :)

                      2. 1

                        I don’t remember Google ever recommending Eclipse, but regardless, what do they recommend now?

                        1. 4

                          The encouraged way of doing Android development was with an Eclipse plugin until earlier this year when they switched to an IntelliJ based IDE, Android Studio. It suprised me with how good an IDE can be.

                      3. 5

                        I for one was glad to see this wasn’t the standard “do it all yourself in Vim and make like a real man” that I see so often from various people who’re mad that computing progressed after 1976 :)

                        1. 6

                          Yeah - it’s not, at all, that we shouldn’t have setup wizards, or editors for GUI layouts, or code completion, … It’s just that the tight coupling of the IDE model is a really bad idea. As the author notes, it makes it almost impossible for the community to improve its own tools.

                          1. 4

                            IMO, the key is having some lingua franca between components. In the case of people saying “do it all in Vim and make”, most of the time they really just want a robust CLI that they can fall back on to get things done, or do things that are beyond the existing design of the tool.

                            At work a release team exists to use a custom developed VS2010 plugin that handles pulling data from TFS shelvesets, performing some magic, doing a three-way merge, and pushing them back. This was apparently done because as of VS2010 the only way to do some magic - shelvesets or merging or whatever - was to go through the IDE. Now there are a handful of people stuck in this awful position with no end in sight.

                            When tools have that common language, these issues go away. Our team chat is a web app but it speaks IRC. Our ticket board is Trello but I can talk to a REST API. Our CI system works with plain text configuration files and command line arguments. So when I want my CI system to update Trello tickets and drop messages in team chat, the presence of a common core language lets me do that. And I don’t have to write an IDE plugin to get parts of that supported.

                            1. 2

                              Documented, rather than common, IMO, but I mostly agree. Although I think nearly all of the daily frustrations in programming stem from the insistence that thousands of completely disconnected (from each other) plain-text files should be the canonical declaration of your program - and that these should live in a 1970s filesystem, free for manipulation by anything without sensible partial-parsing, or even a centralised notification system one can subscribe to, nor any semantic information to the changes - if I were even able to know a source file changed, what’s the difference between the user manipulating code, vs “git checkout someOtherBranch” when everything goes through simple files and text?