1 The Components of an IDE

What’s the minimum that we expect in an IDE?

• editor

• build support

  • maybe no more than compiler & linkerinvocation
  • with error messages captured/interpreted/walked by editor
• run/execute programs
• debugger

The Components of an IDE (optional)

What would we like to see in an IDE?

• syntax highlighting & aid in editor

  • Do we need to wait until we actually run the compiler to be notified of simple mistakes?

• documentation (API) look-up
  • e.g., I know this variable m is a pointer to a std::map<int,string>, so what can I write after “m->”?
• flexible/configurable build support
  • What if our project uses multiple programming languages?
  • What if we have a program that generates part of the source code and so needs to be run before we start compiling?

• packaging/deployment options

  • preparing zip, jar, and war archives
  • packaging code as a static or dynamic library
  • posting compiled code to an online repository

The Components of an IDE (deluxe)

What makes us positively giddy when we see it in an IDE?

• smart feedback in the editor
  • learns API of code we wrote
    • e.g., I know this variable p is a pointer to a MyOwnADT, so what can I write after “p->”?
  • suggestions
• coding aids in editor
  • templates
  • common refactoring (transformations)
• documentation generation
• test integration
• integration with version control

2 IDE Examples

2.1 emacs

The *nix swiss army knife of editors, emacs has long functioned as a basic IDE:

• syntax-highlighting editor
• build support (invokes *nix make)
  • parses error messages from compilers & other tools
• debugger interface
• works directly with many version control systems

References, if you are unfamiliar with this:

2.1.1 emacs Strengths and Weaknesses

• highly portable
• supports virtually any language you would have a compiler for
• even in windowed mode, leans toward keyboard rather than mouse
  • (Not sure if that’s a pro or a con – personally I hate having to lift my hand from the keyboard to reach for my mouse every few seconds. YMMV.)
• outdated interface

  I’m just waiting to see, some day, some Linux IDE come out that announces a “retro” emacs-style skin.

• high learning curve

2.2 Microsoft Visual

Visual Studio

• syntax-highlighting editor
  • background compilation provides quick feedback on simple errors
• built-in build manager
  • limited configurability
• debugger interface
• some designer tools (e.g., design classes in UML)

2.2.1 Visual Strengths and Weaknesses

• wide variety of languages (but Microsoft processors)
• single-OS
• closely integrated with Microsoft compilers
• modern, mouse-oriented interface

I’ve never been fond of Visual, but that comes more from my opinion of the MS compilers. MS C++ had recurring issues with basic standards conformance and std library implementation. And MS’s support of Java was perpetually luke-warm.

2.3 NetBeans

Free IDE originally distributed by Sun as “the” development platform for Java.

• Still largely Java centric, though some support for other languages
  • particularly web-related languages like Javascript, CSS, XSL
• Portable (written in Java)
• Tends to track the trends and hot topics in the Java world promptly
• editor, build manager, debugger
• moderately extensible

Netbeans and Visual clearly stole interface ideas from one another.

(Then Eclipse came along and stole from them both. Nowadays it’s pretty clear that they are all very much aware of anything resembling an innovation by one of the others.)

I have not used NetBeans in a long time. I remember it as being incredibly sluggish even on reasonably high-powered desktops.

My enduring impression is that Eclipse seemed to do everything NetBeans wanted to do, did it about 6 months later, but did it better.

2.4 Single-Language IDEs

The open source community has produced numerous single-language IDEs.

Many are focused on educational use.

Examples:

C++

Bloodshed Dev-C++, Code::Blocks

Java

BlueJ, Dr. Java, jGrasp

3 Eclipse

Probably the hottest IDE in the open source world:

• syntax-highlighting editor, multi-language support
  • strong hinting based on both standard and user-written APIs, interface aid
  • templates and refactoring
• build support
  • easily configured or switched to other build tools
• background compilation for quick detection of language errors
• integrated *unit testing support
• solid debugger, intuitive handling of threads
• some packaging & deployment support
• integrates with most version control systems
• modular plug-in extensibility with a rich variety available