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

What would we like to see in an IDE?

What would we like to see in an IDE?

• syntax highlighting & aid in editor

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?

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

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->”?

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 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 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?

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

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

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

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

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

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

• smart feedback in the editor

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

• smart feedback in the editor
  • learns API of code we wrote

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->”?

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

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

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

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)

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

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

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

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

• 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

• 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

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

• syntax-highlighting editor, multi-language support

• syntax-highlighting editor, multi-language support
  • strong hinting based on both standard and user-written APIs, interface aid

• syntax-highlighting editor, multi-language support
  • strong hinting based on both standard and user-written APIs, interface aid
  • templates and refactoring

• syntax-highlighting editor, multi-language support
  • strong hinting based on both standard and user-written APIs, interface aid
  • templates and refactoring
• build support

• 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

• 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

• 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

• 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

• 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

• 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

• 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