10 - Integrated Development Environments

Transcription

1 10 - Integrated Development Environments

2 Motivation Writing a toy application with a text editor is comparatively easy. Developing a large software system with just a text editor is much more difficult if not impossible. Tools available to help you with the job: Support in managing code Support for carrying out boring (but error-prone) tasks Integration in one central workplace to improve (team) efficiency Use of object-orientation is essential here, because it helps structuring the system. LTOOD Verified Software Systems 2

3 Integrated Development Environment: IDE Central tool of the implementation phase Supports almost all aspects of the implementation process. An IDE integrates a set of tools useful for software development in a single piece of software: Your working environment. Short edit/compile/debug roundtrip: no change of tools no format conversions LTOOD Verified Software Systems 3

4 Code Centric Tool: Integrated Development Environment (IDE) Requirements Analysis Project Management Groupware Version Tracking Quality Control Documentation Diagram Manipulation Code Editing Packaging LTOOD Verified Software Systems 4

5 IDE Functionality code editing code navigation building running core UIdesign advanced plugin refactoring packaging of code help systems version control code generation diagram manipulation LTOOD Verified Software Systems 5

6 Purpose An IDE is much more than a text editor, it eases manipulation of code through... syntax highlighting error highlighting documentation access code navigation code generation through code templates support for refactoring different levels of code analysis. LTOOD Verified Software Systems 6

7 Basic Functionality Code manipulation: Basically text editor functionality with additional completion features (suggestion of possible completions for the current word ; syntax-based editors) Highlighting: Color codify the language s syntax to make it easier to read Navigation: Offer rich ways to move through code (not only by file structure, but also by, e.g., inheritance hierarchy) LTOOD Verified Software Systems 7

8 Basic Idea Code is more than just plain text. Like a compiler, a development environment can understand the structure of the code. Therefore, (source) code can be computed. Easy example (older than IDEs): pretty printing; reformat code for printing (80, 120, columns) for a changed code style guide from inexperienced programmers from source code generators LTOOD Verified Software Systems 8

9 Pretty Printing LTOOD Verified Software Systems 9

10 Highlighting Highlighting of... language syntax errors (red) warnings (yellow) Context-sensitive display of information LTOOD Verified Software Systems 10

11 Code Navigation Navigating through code as if it were hyperlinked documents Different access paths: package structure inheritance hierarchy definition-use dependencies call graphs Bridges the gap between code writing and code execution Good navigational support is particularly important if you work with other people s code. LTOOD Verified Software Systems 11

12 Type Hierarchy and Navigation Class hierarchy Super types Clicking Logger opens its implementation (hold Ctrl in Eclipse) LTOOD Verified Software Systems 12

13 Advanced Features Templates: pre-stored fragments of code, saves typing Documentation access: Find the right piece of documentation depending on context Refactoring: restructuring patterns for code that can be automatically carried out by the IDE Code analysis: track down common anti-patterns An anti-pattern is an undesirable piece of code that works but will lead to problems later. Also see [2] LTOOD Verified Software Systems 13

14 Templates Code templates are pieces of code with holes Templates cover common expressions small scale examples: control-flow constructs like for-loops if-expression large scale examples: entire classes new files new methods LTOOD Verified Software Systems 14

15 Templates Example template for switch block LTOOD Verified Software Systems 15

16 Customizable Templates Templates and code format can be defined or changed by users. LTOOD Verified Software Systems 16

17 Documentation Access Various forms of context sensitive access to the language s documentation: Tooltips Jumping to the right position in the online documentation Navigating to comments Also see documentation tools (covered later). LTOOD Verified Software Systems 17

18 Documentation Generation Document code by, e.g., source code comments. IDEs support documentation language, e.g., Java doclets. JavaDoc, HTML as sublanguage of Java code completion, navigation, etc. work LTOOD Verified Software Systems 18

19 Refactoring Refactoring means improving the design of existing code without changing its external behavior. done incrementally during implementation demand driven (i.e., you refactor when the existing solution is not sufficient any more) Many refactoring patterns have been identified. Applying the patterns usually involves much typing and a mass of boring changes (error-prone process!) Patterns are supported (carried out semiautomatically) by some IDEs. LTOOD Verified Software Systems 19

20 Refactoring Patterns Some refactorings: Extracting Method: extract a new method from a single piece of spaghetti-code: double computeavg(int[] values) { int sum = 0; for (int i = 0; i < values.length; i++) sum += values[i]; double avg = sum / values.length; return avg; } int computesum(int[] values) { int sum = 0; for (int i = 0; i < values.length; i++) sum += values[i]; return sum; } double computeavg(int[] values) { return computesum(values) / values.length; } Encapsulate Field: create accessor and mutator methods (getxyz and setxyz) for a field. Replace accesses to the field with accesses to the methods. LTOOD Verified Software Systems 20

21 Refactoring Patterns (2) Some more refactorings: Pull up/push down: moving data members or methods up or down the inheritance hierarchy Shape Shape color Square Line color color Square Line Extract interface: use part of a class definition to create an interface. Let the class implement the interface and use the interface instead of the class wherever possible. LTOOD Verified Software Systems 21

22 Code Analysis Code analysis tools examine source code to find code with unwanted properties. These do not necessarily need to be errors. Common things an analyzer tries to find: difficult to understand code (e.g., overly long classes) code not following conventions (e.g., language-specific capitalizations) code not covered by unit-tests patterns that are likely to lead to problems later (e.g., redundancies, wrong implementations of clone() or finalize() in Java) clone() method creates an exact copy of an object. finalize() is called when an object is garbage-collected. A common error is to supply a wrong signature resulting in the supplied finalize never being called. LTOOD Verified Software Systems 22

23 Code Analysis (2) Code analysis cannot find semantic errors. Computers don t know the developer s intention. You can implement a method to do something entirely stupid and neither compiler nor analyzer will find it. LTOOD Verified Software Systems 23

24 Code Analysis (3) LTOOD Verified Software Systems 24

25 UI Design It is desirable that developers can design user interface dialogs graphically and an IDE generates appropriate code. This code is usually in the same language as your application but should not be edited. Advantages: Easier to build visually pleasing dialogs Faster to get first results Disadvantages: Generated code might not fit your favorite design pattern (e.g., MVC) or other side conditions Can become confusing with very complex or nonstandard dialogs LTOOD Verified Software Systems 25

26 UI-Design Often useful to quickly prototype dialogs. Complicated dialogs may actually be quicker to do by writing code. LTOOD Verified Software Systems 26

27 Plugins A plugin is a dependent piece of software that extends the host application. Plugins can be tightly integrated with their host application. Host application provides hook points that allow plugins to extend it in a framework-like manner, and loading and discovery mechanisms that loads the plugins at runtime. Other vendors can extend the IDE to integrate support for their technology. The concept of plugins is not specific to IDEs. LTOOD Verified Software Systems 27

28 Plugin Architecture Plugins Simplified Eclipse Architecture Eclipse Platform Workbench Help core application documentation Workspace Team collects your data version control Runtime Platform LTOOD Verified Software Systems 28

29 Plugin Architecture (2) Modern plugin-based systems implement much of their own functionality as plugins. Only core functionality is provided in the system itself. This allows to treat own functionality just the same as external plugins. Dependencies: All plugins use the core platform functionality. Plugins can also depend on other plugins. Usually, plugins try to be as self-reliant as possible to make installation easy. LTOOD Verified Software Systems 29

30 Plugins for IDEs Typical plugin functionality for IDEs includes: Connection to repository systems. Support for frameworks (code generation, graphical editors for configuration files), e.g., Struts, EJB, New languages (compiler, highlighting, running,...), e.g., C++, XML, In eclipse: plugin for plugin development. LTOOD Verified Software Systems 30

31 Plugin Management in eclipse Download and update of plugins via HTTP. Management of plugin versions etc. LTOOD Verified Software Systems 31

32 Overview of Tools The following slides select a small collection of Java IDEs. The selection is... OO-based STS-biased alphabetically ordered incomplete... LTOOD Verified Software Systems 32

33 Overview of Java IDEs Eclipse Free, opensource Extensible via plugins (many available) Well-documented Tooling platform, language support (e.g., for Java) and advanced features (e.g. J2EE) not in core IDE Basic refactorings Intelli-J IDEA Commercial (company: Jetbrains) Extensive refactoring support Code analysis (watching for anti-patterns) UI designer LTOOD Verified Software Systems 33

34 Overview of Java IDEs (2) JBuilder Commercial (Borland), Free (limited) version available UI-designer Basic refactorings Enterprise version has web service and EJB support Plugins JCreator Commercial (Xinox) Basic IDE Fast (native Windows code), Windows only LTOOD Verified Software Systems 34

35 Overview of Java IDEs (3) Netbeans Free, opensource J2EE support Not many refactorings Sun Studio Commercial (Sun Microsystems) Based on Netbeans Websphere Application Developer Commercial (IBM) Based on Eclipse LTOOD Verified Software Systems 35

36 Overview of Java IDEs (4) Together/J Commercial (Borland) Combines UML modeling and Java programming; code follows model changes Supports patterns (e.g., those named by the Gang of Four ) Support for JavaBeans and J2EE. LTOOD Verified Software Systems 36

37 References [1] Eric Allen. Bug Patterns in Java. APress, 2002 [2] W.H. Brown et al. Anti Patterns. John Wiley & Sons, 1998 LTOOD Verified Software Systems 37