There’s a question that might be deemed a duplicate of this one (I use an IDE (Eclipse) to develop software. Why should I switch to vim or emacs?) but I don’t think answers my question.
I usually program in C++ (not exactly to create GUIs so rather low-level) and I find myself comfortable with editing code into visual studio, compiling it and debugging it.
I know that all of this can be done in a linux/unix environment (even on Windows) as well, but I’m wondering how come that many low-level programmers are proficient with tools like emacs which I suppose hasn’t any debugger integrated (no breakpoints setting, doing that with gdb seems pretty slow and really unhelpful).
How can they develop a complex software with a write-compile-debug cycle in such environments? Am I missing something? I doubt that they develop code in Eclipse, Qt Creator or Visual Studio and then get back to their textual tools.
8
Basically, sometimes you prefer things more tightly integrated and streamlined, sometimes you want looser integration with hopefully wider choice of parts.
Hint: source-level debugging is also available via gdb.
There are also various build systems, some possibly superior to, or more flexible / extensible than what is built into VS.
No doubt, having everything integrated is often convenient.
In different circumstances, you could benefit from an ability to run a debugger on a remote machine two firewalls away (via ssh), or on a tiny embedded system.
It is not impossible, of course, to integrate various tools into a scriptable editor; both Vim and Emacs have modes for interaction with various debuggers, build systems, version control systems, etc. Some prefer these other tools.
It is also possible, of course, to create some kind of remote debugging probe or an exotic VCS interface for an IDE (like VS). But this begins to become suspiciously similar to the approach above 🙂
The strong point of IDEs, to my mind, is superior source code handling: navigation, refactoring, validation, frameworks support, everything that having a properly indexed, AST-represented code base gives you.
4
Emacs does some things much better than other editors:
- Startup time. One of the most important features for an editor is startup time. With IDE you need to wait 30 seconds to get your project to open, and another 30 seconds every time you switch to another project. Emacs just starts up so fast that editing software is easy.
-
Multiple instances. There will be multiple copies of emacs running. Not just single ide, but multiple copies of the text editor.
-
Large files. You’ll end up having large amounts of code in single file. If your editor breaks when it loads 20kloc file, it’s useless.
- Searching. Finding correct place inside your code needs to be easy. Right way to do this is proper searching from within current file.
- Navigation. Beginning-of-file is one of the most important features.
- Goto-line. When compiler gives you error, it has line number included. goto-line will allow you to type the line number and instantly find the correct place in the code.
- Buffers.. Both header file and .cpp file needs to be visible at the same time. Multiple editor buffers with split-screen are essential for seeing the source code.
- Loading new files. Switching between files is rare, but necessary feature.
- Saving. If your editor loses the code if you simultaniously edit the file from two copies of the editor, its no good. Emacs saves the code correctly every time.
Text editors are not suitable for compiling, debugging your code. Instead, the following tools will do the trick:
- Compiling will work with makefiles from the command prompt. Typing “make” in command prompt will do the trick.
- Debugging will use gdb and valgrind. Both of them are useful for getting call stacks. Trying to do single-stepping through the code is just waste of time.
- Version control with git.
Note that these are outside of integrated development environment.
1
I’m presently developing software for embedded systems and an occasional PC application.
I have the following applications open during coding and debugging:
- XEmacs — Has nice features that Eclipse doesn’t. Also doesn’t force
a file tree on you. - Visual Studio — Nice debugger. Can write console programs to test
embedded functions. - Parasoft C/C++ Test — A Static Analyzer built on the Eclipse frame
work. Can edit can compile using the target compiler; but can’t
access the JTAG debugger to the target device. - IAR EWARM — IDE with capability to talk to a JTAGJet debugger to our
target platform. Decent debugger, builds in the target processor’s
tongue, but lacks the analysis of the static platform. - Command Window — For running Coverity Static Analysis scripts.
- Cygwin Terminal — Unix has nice features like find and grep.
- UltraEdit — used to edit batch files; can print syntax highlighted
source code with line numbers to color printers! - PTC — Code Management System for checking files in and out.
I can’t find the “one true GUI”, so I have multiple applications open. I find Eclipse very nice for Java and a pain for C or C++.
I also grew up programming before the IDEs were invented. So, one would edit the file, close the editor, then build using a command line system (like make).
A lot of GUIs I have looked at are trying to sell a company’s tool chain set. You either by all of the tools to get their good GUI or nothing.
In summary, I develop code by bouncing around in applications. There is no complete IDE that contains all the functionality for programming an embedded system and has features that I like and few of the ones I dislike.