====== Basic Software Development with Eclipse ======

In [[http://www.cis.udel.edu/~charlieg/labs/Lab1_Eclipse.pdf|Lab 1]] you learned Eclipse basics; today you'll learn about more advanced software development features:
  * Using the type hierarchy & call hierarchy
  * Introduction to refactoring
  * Using Eclipse's debugger

== Initial Setup ==

We'll be working with Freemind, a medium-sized (50 KLOC) open source application. You will need 65 MB of available space (or find a partner who does). On the composer machines, you should have no more than 37000 KB used (''quota -v'').

**Setup instructions for composer machines (can be adapted to other OS's):**
  - Download & extract Freemind
    * Download [[https://sourceforge.net/projects/freemind/files/freemind-unstable/0.9.0%20RC4/freemind-src-0.9.0_RC_4.tar.gz/download|freemind-src-0.9.0_RC_4.tar.gz]] from sourceforge
    * Open a terminal and navigate to the file (most likely in 'Desktop')
    * Unzip & untar (''gunzip freemind-src-0.9.0_RC_4.tar.gz;'' ''tar xvf freemind-src-0.9.0_RC_4.tar'')
    * If space is tight, delete the tar file once extracted (''rm freemind-src-0.9.0_RC_4.tar'')
  - Import Freemind into Eclipse
    * open eclipse (''eclipse &'')
    * Select File > New > Java Project
    * Name the project "freemind", and select "create from existing source"
    * Browse to your freemind folder (e.g., ''$USER_HOME/Desktop/freemind'')
{{:hill:screenshot.jpg|}}
    * Select "finish", and wait for "Building workspace" to finish in the bottom right of the screen.

== Running Freemind ==

Freemind is mind mapping software often used for knowledge and content management. It's a hierarchical editor that supports "folding"--that is, collapsing and expanding sections of the hierarchy. Today we'll focus on understanding how the **folding** functionality is implemented.

The easiest way to understand the concept of folding is to try it out:
  - In the package explorer, right click on the freemind folder & select "Run As > Java Application"
  - Select "freemind.main.FreemindStarter" as the main class to execute (ignore errors written to console)
{{:hill:main.png|}}
  - Create a new mind map about Software Engineering:
    * Add children nodes by going to "Insert > New Child Node", hitting the "insert" key, or selecting the lightbulb {{:hill:bulb.png|}}
    * Add at least 3 levels of children, with at least 2 children per level
    * Save the mind map
  - Select a middle node (not leaf or root) and attempt to fold it. There are 3 ways to change a node's folding status:
    * click the node
    * hit space bar
    * right click and select "toggle folded"
    * select "Navigate > Toggle Folded" in the menu

===== Using the type & call hierarchy to understand code =====

==== Call Hierarchy ====

The call hierarchy shows calling relationships between methods in a program. For example:

  * Navigate to the method ''toggleFolded(ListIterator listIterator)'' in class ''freemind.modes.minmapmode.actions.ToggleFoldedAction''
  * Right click the method name and select "Open Call Hierarchy"
  * Look at the callers {{:hill:callers.png|}} and callees {{:hill:callees.png|}}
  * Going back to the callers, expand ''toggleFolded'' & ''toggleFolded'' again. Look at the callers of ''actionPerformed''.
  * Try looking at the callers of other methods, such as ''nameSetFolded''

//**What information does the call hierarchy give you? Why is it useful for understanding a program?**//

==== Type Hierarchy ====

The type hierarchy shows how types are related. For example:

  * Right click in the editor window for ''ToggleFoldedAction'' and select "Open Type Hierarchy"
  * Right click on ''AbstractAction'' and select "Focus On 'AbstractAction'"

//**What information does the type hierarchy give you? Why is it useful for understanding a program?**//


**Exercise:** Show me an interesting call hierarchy and type hierarchy on **your own** project code (where "interesting" = more than 3 nodes)

===== Basic Refactoring =====

//**What is refactoring? Why use it?**//

==Rename==
  * Right click on ''toggleFolded'' and select "Refactor > Rename"
  * Add your name at the end of ''toggleFolded''
  * Verify your change is complete by looking at the call hierarchy & double clicking the callers

//**Why rename?**//

==Extract Method==
  * In the renamed ''toggleFolded'', select the 3 statements (6 lines) starting with ''modeController.getAction...''
  * Right click & select "Refactor > Extract Method"
  * Enter a name (e.g., "initiateToggleAction") and hit enter

//**Why extract methods?**//

===== Debugging in Eclipse =====
//**What's debugging? What's a debugger?**//

**Task:** How does the UI toggle folding action (click, space, etc.) initiate the ''toggleFolded'' implementation?

  * In the margin next to ''toggleFolded'', right click & select "Toggle Breakpoint"
  * In the menubar, select "Window > Open Perspective > Debug"
  * Make sure freemind isn't running
  * Next to the green "play" arrow, select the green bug icon {{:hill:bug.png|}} - there will be some delay
  * Toggle a node. Notice the upper-left "Debug" pane, investigate the upper-right "Variables" pane, and see the current statement in the editor pane. The arrows in the debug pane {{:hill:arrows.png|}} let you step through the execution by one method call, by one statement, or by returning.

**Exercise:** Show me a debugging trace for ''toggleFolded''. Which method calls in the trace do you think handle your input method (click, space, right click, etc.)?