RobotStudio: A Modern IDE-based Approach to Reality Computing

Li Xu
Department of Computer Science University of Massachusetts Lowell Lowell, MA 01854, USA

xu@cs.uml.edu ABSTRACT
The recent report by the ACM Job Migration Task Force points to the immediate need to teach programming-in-thelarge, the skills to work with and develop large and complex production-grade software and systems, so young computing professionals can stay competitive in the face of IT globalization and oshoring of software [4, 13]. However, current computer science curricula are inadequate to prepare college graduates to meet the reality of computing. Most course projects fall into the programming-in-the-small mode, in which students implement small, isolated projects to explore the course subject matter and with little emphasis on how the smaller pieces can be integrated to build sophisticated larger scale systems. This paper presents a modern IDE-based approach to address this inadequacy. We develop RobotStudio an extensible framework for building IDEs targeting a simple yet versatile educational robot platform. Student projects are implemented as plugin modules of RobotStudio and, when put together, they form a comprehensive IDE for programming the robotic environment. This paper describes the architecture of the RobotStudio framework, its extension mechanisms, and the teaching practice of using RobotStudio in an introductory compiler construction class to illustrate programming-in-the-large principles.

1.

INTRODUCTION

Categories and Subject Descriptors

K.3.2 [Computer and Information Science Education]

General Terms
IDE, Programming-in-the-large, Compilers, Robotics, Embedded Systems

Keywords
IDE, Compiler Construction, Eclipse, Educational Robotics

The recent report by the ACM Job Migration Task Force points to the immediate need to teach programming-in-thelarge, the skills to work with and develop large and complex production-grade software applications and systems, so young computing professionals can stay competitive in the face of IT globalization and oshoring of software [4, 13]. However, current computer science curricula are inadequate to prepare college graduates to meet the reality of computing. Most students gain experience in building software by doing course programming projects. However, the majority of these course projects fall into the programming-in-thesmall mode: students implement small, isolated projects to explore the course subject matter with little emphasis on how the smaller pieces can be integrated to build more sophisticated and larger scale systems. Research studies have long established that programming-in-the-large (building large multi-module systems) is signicantly dierent from programming-in-the-small (constructing individual modules) [6]. As a result, college graduates often lack the competitive skill set and experiences in dealing with large, sophisticated, industrial-strength software when they join the IT workforce [1]. To address this inadequacy and promote a balanced emphasis on programming-in-the-large principles, this paper presents a modern IDE-based approach for building computer science course projects. We develop RobotStudio, an extensible framework for building IDEs targeting a simple, yet versatile, educational robot platform. Student projects are implemented as plugin modules of RobotStudio and, when put together, they form a comprehensive IDE for programming the robotic environment. This paper describes the architecture of the RobotStudio framework, its extension mechanisms for student IDE projects, and teaching practices for using RobotStudio in an introductory compiler construction class. This paper makes the following contributions: 1. We present a new IDE-based approach to teaching programming in the large, skills critical in real-world production software development. Student projects are designed as plugin modules of the base IDE framework and will be integrated into the framework to form a comprehensive IDE. 2. We developed the RobotStudio framework for building student IDE projects. It leverages our previous work on the pedagogical robotic programming platform and builds upon the industrial-strength Eclipse RCP plat-

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for prot or commercial advantage and that copies bear this notice and the full citation on the rst page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specic permission and/or a fee. SIGCSE07, March 710, 2007, Covington, Kentucky, USA. Copyright 2007 ACM 1-59593-361-1/07/0003 ...$5.00.

form. The framework provides simplied core services and extension mechanisms to reduce complexity in developing student IDEs and serves as an example of a modern IDE. 3. We present teaching practices for using RobotStudio to teach an introductory compiler construction class. Student IDE plugins are organized into incremental levels to ease the learning curve on building plugins. The rest of this paper is organized as follows: Section 2 describes the rationale of our IDE-based approach, introduces RobotStudio and compares with related work. Section 3 gives the background of the RobotStudio building blocks: Eclipse RCP platform, the Handy Cricket robot controller and the Chirp programming language. Section 4 describes the RobotStudio framework: its architecture, core services, and extension mechanism. Section 5 describes the use of RobotStudio in an introductory compiler construction class. We conclude in Section 6.

built-in reference compiler and robot controller simulator, students can quickly learn the features of Chirp language and Cricket robot the target platform of their projects, thus minimizing the overhead of using the IDE. As shown in Figure 1, RobotStudio provides a simple and easy to use IDE interface that greatly reduces the complexity and overhead of using IDEs. The default IDE itself also serves as an implementation example to students when they build their own IDEs. 2. Provide an extensible framework to develop teaching projects as plugin modules to the framework, so student projects can be integrated into RobotStudio and form a complete IDE. In their projects, students must obey the specication of RobotStudio extension points and be aware of integration issues when implementing their projects. 3. Serve as an easy to understand example of modern IDEs. This will enhance student understanding of programming-in-the-large principles embodied in the student IDE plugin projects. Section 4 discusses the architecture of the framework that reects the above design goals.

2. RATIONALE OF IDE APPROACH

Integrated-development environments (IDEs) play a central role in production-quality software development. IDEs integrate the vast array of development tools into a single environment and provide sophisticated GUI interfaces to manage the multitude of tasks and resources in large-scale software development. Due to their importance and widespread use in the software industry, educators have tried to introduce the use of industrial-strength IDEs into classrooms. However, using o-the-shelf professional IDEs directly in teaching projects can cause signicant problems. Due to time constraints and limited resources, students can easily be overwhelmed by the complexity of a modern IDE and just trying to understand and use it to do simple tasks may need a non-trivial eort. To reduce the learning curve, educators have built teaching IDEs and IDE-like environments. DrJava [2] and BlueJ [8] are dedicated teaching IDEs for Java programming. The Kenya [5] and Penumbra [12] projects implement Eclipse plugins on top of Eclipse IDE to teach introductory programming. We believe bringing modern industrial-strength IDEs into the college teaching context has signicant benets: students are exposed to the common practices and tools used in real-world software development and gain experience using production tools. The IDE software itself is also a great example of programming-in-the-large principles and students can see and experience for themselves how large software works. However, the IDE-based approach must be used carefully and not interfere or conict with the primary goal of teaching the course subject matter. To realize the benets of the IDE approach and also minimize the negative eects caused by the complexity and overhead of using IDEs, we developed the RobotStudio framework students not only learn and use IDEs, they build an entire IDE themselves by working on the course projects.

2.2

Comparison with Related Work

Although RobotStudio uses Eclipse, an o-the-shelf professional IDE, it hides most of the irrelevant features of Eclipse from students (see Section 4 for core services exposed by the framework). This reduces the complexity for students and allows them to focus on solving the course subject-matter related domain problems. Compared to the pure teaching-IDE approach, students get experience in using a production-quality IDE while RobotStudio helps ease the learning curve with a simplied interface. RobotStudio takes advantage of Eclipse Rich-Client Platform (RCP) technology and is implemented as a standalone application. It contains only student project related GUI components, while other Eclipse teaching plugins rely on the more general Eclipse GUI workbench and have to coexist with all other plugins installed with Eclipse.

3.

BACKGROUND

RobotStudio leverages our previous work on using the pedagogical Chirp and Cricket robot programming platform in undergraduate programming classes [15]. It builds on the Eclipse Rich-Client Platform (RCP) and provides a comprehensive IDE for the Chirp and Cricket educational robotic environment.

3.1

Eclipse Rich-Client Platform

2.1 Design Goals

RobotStudio framework is designed to achieve the following goals: 1. Serve as a modern IDE to program the Chirp and Cricket robot platform [15]. Using its default IDE, the

Eclipse is an industrial-strength open source Java application development platform [7, 3]. It provides a sophisticated Java IDE for Java development, which has been used in both commercial Java product development and as a teaching tool for Java programming. Eclipse is also a platform for IDE and rich-client application development. Users can use the Eclipse platform to develop plugins which can be integrated into the Eclipse base IDE. Educators have built teaching IDE plugins on top of the Eclipse platform [5, 12]. RobotStudio uses the latest Eclipse RCP technology [11] and is implemented as a standalone application rather than a plugin of the base Eclipse IDE.

Figure 1: RobotStudio IDE.

3.2 Chirp and Cricket

RobotStudio builds on our previous work using the Chirp and Cricket embedded educational robotic platform [15]. The Handy Cricket is an inexpensive, embedded controller that was developed for educational applications [9]. To program the Cricket robot controller, we have designed a simple, yet capable, new language called Chirp to build Cricketbased robotic programs to control robot sensors and motors [14]. The platform has been used to teach compiler construction basics in an undergraduate programming class. RobotStudio targets the Chirp and Cricket programming platform and provides a modern IDE to develop Chirp programs. The simple yet versatile structure and feature set of the Chirp and Cricket platform make it an ideal target to develop student projects on system topics, including compiler construction, assembly programming, computer organization, and embedded robotic systems.

for managing Chirp projects and les, and the Console view to print out text messages. Workspace resource management: managing the IDE workspace which consists of user projects and les. RobotStudio uses a simple two-level workspace model which consists of top level projects and second level project les. The projects and les are mapped to folders and les in the host le system. Chirp reference compiler: the built-in compiler used by the default RobotStudio IDE. The compiler consists of a scanner, parser, abstract-syntax tree (AST) intermediate representation (IR), and Cricket bytecode generator. Cricket simulator: a cycle-accurate Cricket controller simulator based on Virtual Cricket [10], which is used to test and debug Chirp programs. Cricket device binary code programmer: a serial portbased device programmer tool to program the Cricket hardware. The framework itself serves as a complete IDE for Chirp and Cricket program development. It also provides core services to student plugin projects to build separate IDEs. Student plugins connect to the framework through predened extension points and use the core services to form a complete IDE.

4. ROBOTSTUDIO FRAMEWORK 4.1 Architecture

The architecture of the RobotStudio framework is shown in Figure 2. The framework consists of the following components: Workbench: the RobotStudio GUI interface, which provides a source code editor, Project Explorer view

project plugin

project plugin

...

project plugin

Extension Points

<extension-point id="scanner" name="RobotStudio Scanner" schema= "scanner.exsd" />

GUI Workbench

Scanner

Parser

AST IR

CodeGen

<extension id="scannerExtension" name="Scanner Extension" point="RobotStudio.scanner"> <scanner class="myide.MyScanner" id="myide.myscanner" name="My Scanner"/> </extension>

Reference Compiler

Figure 3: Scanner Extension-Point and Example extension

Resource Mgmt

Virtual Cricket Simulator

Cricket Device Progmmer

5.

USING ROBOTSTUDIO IN A COMPILER COURSE

RobotStudio Framework
Figure 2: RobotStudio Framework Architecture

We have been using RobotStudio in an introductory compiler construction class. In this class, students develop their own Chirp scanner, parser, and code generator in three plugin modules and integrate them into RobotStudio to form a fully-edged IDE for the Chirp and Cricket platform.

4.2 Core Services

The framework provides GUI control and resource management services to the extension plugins. The workbench GUI interfaces respond to user interaction targeting user plugins. The event handler triggers the framework controller to dispatch the message to appropriate registered plugin objects, passing along the handle of any project and le resources. The user plugin can also request services directly from the framework core. The framework controller is a Singleton object and aggregates published services through the Facade design pattern. For example, a user plugin can request the Console service by calling the robotstudio.Robot StudioApp.log method to print out text messages in the Console view.

5.1

Student Projects as IDE Plugins

4.3 Plugin Extensions

Users can build plugin modules and connect to the RobotStudio extension points. The framework denes and publishes extension points for user plugins to connect to. The user plugin must conform to the extension point schema specication and implement the required extension Java interface. The extension points are published in the RobotStudio plugin XML le and their XML schema les, which specify unique ID, name, run-time Java class and description information for the extension point implementation. For example, Figure 3 shows the XML denition of the RobotStudio.scanner extension point and a sample plugin extension.

4.4 IDE Integration and Deployment

RobotStudio is distributed as a self-contained binary application. To integrate user plugins to build an IDE, once the project plugin is developed, the deployment process is simply to package the plugin as a ZIP le and to unpack it into the default plugin directory in the RobotStudio application folder. In addition, RobotStudio provides an Eclipse update site for remote online deployment.

Each student project centers around the course subject matter: to build scanner, parser and abstract-syntax tree (AST) representation, and then generate binary code using the AST. To support these projects, the base framework denes three extension points to link with the student scanner, parser, and code generator plugins. In addition, the workbench GUI is customized with perspectives congurations to show relevant views for each project. Special menu items and tool bar buttons are added to invoke the plugin modules implemented by the students. To ease the learning curve on building plugins, we use three diculty levels to guide students through the projects. Level 1 is the scanner plugin, in which students only need to implement the scanner class for the RobotStudio.scanner extension as shown in Figure 3. There is no GUI interaction with the workbench and the generated token stream is printed through the Console view service. Using the Level 1 plugin, students learn the basics of building and integrating plugins. Execution of the Level 1 plugin is shown in the left screen shot of Figure 4. The Level 2 parser plugin adds a GUI tree viewer to the workbench as shown in the right screen shot of Figure 4. Students need to build the parser and generate an AST tree suitable for use with the RobotStudio tree viewer: the tree viewer uses the Model-View-Controller (MVC) pattern, and to display the AST tree, student must adapt the AST tree and implement an ITreeContentProvider interface for the GUI viewer to display tree elements. This project demonstrates the use of design patterns and integration through published extension points and interfaces, which are key techniques in the programming-in-the-large methodology. Finally, the Level 3 code generator plugin closes the circle and builds a fully-edged Chirp IDE as shown in Figure 1.

5.2

RobotStudio as an IDE Artifact

As students gain more experience in using and developing with RobotStudio, the source code of the framework is given to students to study as a sample IDE artifact to il-

Figure 4: RobotStudio extension Level 1: Scanner and Level 2: Parser

lustrate programming-in-the-large principles and to help them understand modern IDE systems.

8.

REFERENCES

5.3 Preliminary Student Feedback

We have been using RobotStudio in the compiler construction class at UMass Lowell. The class consists of both senior undergraduate, full-time graduate, and part-time professional Master program students. Initial feedback from the students has been highly positive. In general, students identify with the approach and are enthusiastic about the whole IDE project. Several students with internships and work experience have commented that the techniques in this course will be immediately useful for their future tasks.

6. CONCLUSIONS
This paper has presented a modern IDE-based approach to teaching programming in the large, skills that are critical for real-world production software development. Leveraging on the industrial-strength Eclipse RCP platform, we developed the RobotStudio framework, an extensible framework for building IDEs targeting the simple, yet versatile, Chirp and Cricket educational robot platform. Using RobotStudio, student projects are implemented as plugin modules and connect to the base framework; through integration, they realize a comprehensive IDE. We have been using RobotStudio in a compiler construction class with encouraging initial results. We are excited to share our experiences on RobotStudio with other educators. In addition to compiler classes, we expect the framework can be adapted to use with other courses. More information, including the Eclipse plugin of the framework, can be accessed from URL: www.cs.uml.edu/ xu/robotstudio.

7. ACKNOWLEDGMENTS
This work has been supported by a UMass PDG grant. We would like to thank Mark Schlesinger for his help and support of the RobotStudio project. We are grateful to Jesse Heines for his very constructive comments on the presentation of this paper.

[1] UMass Lowell Computer Science Dept. post-graduate survey and personal feedback from recent Computer Science graduates. [2] E. Allen, R. Cartwright, and B. Stoler. Drjava: a lightweight pedagogic environment for java. In SIGCSE 02: Proceedings of the 33rd SIGCSE technical symposium on Computer science education, pages 137141, 2002. [3] J. Arthorne and C. Lara. Ocial eclipse 3.0 FAQs. Addison-Wesley, 2004. [4] W. Asprayn, F. Mayadas, and M. Y. Vardi. Globalization and Oshoring of Software: A Report of the ACM Job Migration Task Force. http://www.acm.org/globalizationreport/. [5] R. Chatley and T. Timbul. KenyaEclipse: learning to program in Eclipse. In ESEC/FSE-13: Proceedings of the 10th European software engineering conference, pages 245248, 2005. [6] F. DeRemer and H. Kron. Programming-in-the large versus programming-in-the-small. In Proceedings of the international conference on Reliable software, pages 114121, 1975. [7] E. Gamma and K. Beck. Contributing to Eclipse: Principles, Patterns, and Plug-Ins. Addison-Wesley, 2004. [8] M. Kolling and J. Rosenberg. Objects rst with Java and BlueJ. In SIGCSE 00: Proceedings of the thirty-rst SIGCSE technical symposium on Computer science education, page 429, 2000. [9] F. Martin, B. Mikhak, and B. Silverman. MetaCricket: A designers kit for making computational devices. IBM Systems Journal, 39(3 & 4), 2000. [10] F. G. Martin, N. Palmer, and B. Skinner. The virtual cricket: A web-based simulator for learning robot programming. In preparation. [11] J. McAer and J.-M. Lemieux. Eclipse Rich Client Platform : Designing, Coding, and Packaging Java Applications. Addison-Wesley, 2005. [12] F. Mueller and A. L. Hosking. Penumbra: an Eclipse plugin for introductory programming. In eclipse 03: Proceedings of the 2003 OOPSLA workshop on eclipse technology eXchange, pages 6568, 2003. [13] D. A. Patterson. Presidents letter: Oshoring: nally facts vs. folklore. Communications of the ACM, pages 4142, Feb. 2006. [14] L. Xu and F. Martin. The chirp language specication. Technical Report TR-2005-003, Dept. of Computer Science, UMass Lowell. [15] L. Xu and F. G. Martin. Chirp on crickets: teaching compilers using an embedded robot controller. In SIGCSE 06: Proceedings of the 37th SIGCSE technical symposium on Computer science education, pages 8286, 2006.