3D-IDE

From VitalWiki

Jump to: navigation, search

Contents

Problem Statement

As shown in [1], a software engineer spent about 70 percent of his or her time on cooperative activities. Therefore, collaboration is essential for software development. With the progress of globalization, a growing number of software development projects are temporarily and geographically distributed, which increases the difficulty of collaboration, since increasing distance between team members usually leads to less effective teams. Meanwhile, with the scale of software development becoming larger, the complicity of software development is increasing too, which thus puts more requirement on collaboration. However, currently, software developing team tend to use an Interactive Development Environment (IDE) to develop software, while collaborating with each other through existing configuration management systems, issue tracking databases, and communication tools such as email and Instant Messaging (IM). This incurs the cost of context switch between tools inside and outside of the IDE, which may not satisfy the increasing requirement on collaboration. Furthermore, in the current state of software development practices, to know the other team members' status, a team member usually has to communicate with them directly, which needs to interrupt them, or check the project artifacts, which may take times, and does not get the real time information. To improve the efficiency of collaboration among the team, a passive and real-time team awareness is needed.

To reduce the cost and satisfy the increasing collaboration requirement, the collaborative components need to be embedded in the IDE itself, under which, they can communicate and collaborate with each other, without leaving the IDE they usually use. Also a passive and real-time team awareness mechanism need to be provided. This kinds of IDE is also called Collaborative Development Environment (CDE). A CDE is a collaborative IDE, which seamlessly integrates a IDE with communication and collaboration tools, to enable awareness and coordination among team. Different from IDEs, which are essentially developer-centric, focusing upon improving the efficiencies of the individual developer, CDEs are essentially team-centric, focusing upon improving the efficiencies of the development team as a whole[2].

Three-dimensional online Virtual Worlds (VWs) such as Second Life (SL) are well known as a socialized and collaborative persistent environment, since they usually support avatar-based communications, a wide spectrum of online activities, and development of various in-world teaching and learning tools. Recently many big IT companies such as IBM and SUN have been investigating how to use them to enhance collaboration among employees from different branches distributed in the globe. At the same time, compared with 2-D tools, 3-D tools provide a more intuitive and realistic simulation and visualization, since we live in a 3-D world and familiar with 3-D objects in the world.

To utilize the enriched collaboration and visualization functionalities provided by VWs, we propose to build a 3D-IDE, which will be a CDE in the VW. To the best of our knowledge, though, no one has ever created this kinds of 3D-IDE in the world.

Related Work

Cheng et al. have done much research on how to introduce collaboration into an IDE. One of their projects, Jazz, focused on supporting the collaboration among small software developing teams in the Eclipse IDE [3, 4]. They developed an Eclipse plug-in also called Jazz. The features on the Jazz plug-in include the "Jazz Band", chat, IM, screen sharing and "Concert Awareness". "Jazz Band" is a window in Eclipse used to show the team members' icon with status. Software engineers can touch the user icon to chat or IM the other team members. They can also use screening sharing to discuss the project by sharing current code snippets with other team members. "Concert Awareness" puts decorators on the resources in Eclipse, which, for example, can indicate a file with the change information, such as who modified the file recently.

Storey et al. proposed the conceptual design of Tags for Software Engineering Activities (TagSEA), a collaborative tool [5, 6]. TagSEA used shared waypoints and social tagging to support collaboration in asynchronous software development. "Waypoints are used by Geographical Positioning Systems (GPSs) to save locations of interest that may include checkpoints on a route or a ground feature to be avoided". "Social Tagging, also known as social bookmarking, enables users to create shared bookmarks to online resources with additional metadata beyond the site location". In the TagSEA, the waypoints refer to specific locations in the software such as Java Class, or a specific line of code. The social tagging element is introduced to describe waypoints by a set of tags supplied by the programmers. Waypoints can also be associated with the software's version information or related bugs. Routes are sequences of waypoints to specific code features or file locations, which can indicate an order relationship between waypoints. Routes thus can be used to document a series of steps in a software development workflow, which is useful for a software inspection or code review.

Redmiles, Hoek, and their colleagues proposed a new approach to support collaborative software development called continuous coordination[7, 8]. Continuous coordination aims to solve the problems existing in two traditional coordination approaches: formal coordination and informal coordination. Formal coordination usually uses formal processes to regulate the development activities. The processes typically divide work into multiple, independent tasks. Developers work on their own assigned tasks separately, and re-synchronize their work together periodically. However, the periodic re-synchronization often involved with conflicts, since developers are hardly aware of each other's activities. Informal coordination usually coordinates the development through group awareness. Awareness is an informal and passive understanding of the ongoing activities of others, which provides a context for monitoring and assessing group and individual activity. It is hard for informal coordination scale to large scale software development since the users have limits on the amount of information they can process, and the amount of information increases with the scale of software development. Continuous coordination tries to integrate these two approaches together by keeping the periodic re-synchronization in the formal coordination while adding informational coordination support between two re-synchronization points. To support the continuous coordination, they have developed or been developing various software engineering tools. When using traditional Software Configuration Management (SCM) tools, developers are only aware of other's activities when they do some operations such as check-in to the SCM repository. This often leads to conflicting changes when developers check in their updated artifacts to the repository. To relieve this situation, Sarma et al. have developed a workspace awareness tool named Palantir, based on the existing SCM systems[9]. Palantir provides developers the information about others' activities that are related to their own workspaces, such as what the others do on the artifact they are modifying, by monitoring operations done to the central SCM repository and local workspaces. To avoid information overload, Palantir is integrated with a event notification service, with which developers can register and receive only the events they are interested. Ripley et al. have developed a 3-D visualization tool named Workspace Activity Viewer to visualize workspace activities and their evolution on a project-wide basis[10]. Different from Palantir, which focuses on individual developers' awareness needs, Workspace Activity Viewer provides developers a overview of all the workspaces' current activities that can be grouped by developer or artifact. Workspace Activity Viewer also traces the project evolution history by recording all the activities in the workspaces.

To promote effective management of largely increasing number of change requests at sizable software development projects, Halverson, Ellis and colleagues have proposed to visualize change request history based on data available in change (or issue) tracking systems such as Bugzilla. The visualization can help project "drivers" identify relevant and critical change requests, and detect possible problematic bug patterns (e.g. unevaluated patches, zombie bugs, etc.)[11]. A prototype named Social Health Overview was developed and evaluated against among a few subjects involved in open source development[12].

In [13], Sarma et al. proposed a collaboration classification framework, which classified collaboration tools according to developers' collaboration needs. Developers' collaboration needs can be divided into three categories: basic needs, enhanced needs, and comfort needs. Each of the last two needs is further divided into two layers. Then they used the framework to classify the Eclipse plug-ins supporting collaboration. Finally they concluded that most of Eclipse plug-ins belonged to the first three players. The Jazz plug-in belonged to the Layer 4, which allows developers to monitor coordination information without having to switch context from their development environment. However, there was no any plug-ins in Layer 5, which provides fully-integrated collaboration environments. After that, Sarma further surveyed collaborative tools in software development in [14]. In the survey, Sarma refined the framework proposed in [13] by specifying the five layers as functional, defined, proactive, passive, and seamless, and analyzing collaboration tools at each layers.

Proposed Solution

To meet the increasing collaboration needs in the global and (or) large-scale software development, we propose to build a 3D-IDE in the VWs. We choose Eclipse as the IDE, and SL as the VW. We choose Eclipse because it is a widely-used open-source IDE with platform-independent extensible plug-in architecture. We choose SL because it is one of the most popular VWs with open-source client (they also plan to open source server in the future), various communication and collaboration approaches, powerful 3-D creation tools and Linden Script Language.

The implementation of 3D-IDE can be divided into the following components:

  • Eclipse needs to be integrated with SL. There are two options for the integration. One is that SL is integrated into Eclipse as a view. The other is that Eclipse is integrated into SL as an application. We can utilize the in-world and out-world communication mechanisms provided in SL to create a communication infrastructure between Eclipse and SL. We also need to add security and permission management to the infrastructure to ensure the safety and security of communication. A in-world and out-world communication scenario between SL and Eclipse is listed below:
  1. A developer selects a few lines of code in Eclipse, and chat/IM his team member by dragging the code to his team member's avatar in SL.
  2. When the team member accepts the chat/IM, the snapshot of the code snippets can be shown to him in SL.
  3. After the chat/IM, chat logs can be saved as a noteword attached to the primitive/object representing the artifact (e.g. a Java class) in SL. They can be also saved as the comments in the artifact in Eclipse.
  • (Assigned to En) A passive and real time team awareness mechanism needs to be created. we can utilize various communication approaches (i.e. chat, instance message, and group message) provided in SL. But We need to add to the communication contextual information, such as who is doing what now. We also need to create a event notification system for notifying users of events they are interested. A example scenario for a passive and real time team awareness is listed below:
  1. A team member’s status can be shown above the head of the avatar (e.g. using a tag), and in the buddy list in the “friends” window. The status info not only tells whether the team member is available or not, but also shows what he is working on now (this information needed to be transferred from Eclipse to SL), etc.
  2. The developer can register the events at which he is interested, e.g. “an artifact is changed”, by clicking the corresponding primitive representing the artifact in SL. When the artifact is changed, an instant message is automatically sent to him, or the notification message is shown in the HUD.
  • (Assigned to Josh) Besides the IDE, developers usually use a SCM system to manage artifacts (e.g. code, documents, etc). So we will implement a SCM system in SL.
  • (Assigned to Jarrod) Developers also usually use a issue tracking system to manage tasks (e.g. bug fixing). So we will implement a issue tracking system in SL.
  • We can develop a collaborative code review, inpecting or debugging system by using collaborative features provided in SL.
  • We can create a build tool in SL, which visualize the building process of the software system, and notify the developer if there is an error related to his work.
  • We can simulate the UML diagrams in the requirement and design documents. The developer can create or modify the diagrams by manipulating the objects in SL.

Scenario

Image:Bug.png

References

  1. Iris Vessey and Ajay Paul Sravanapudi. CASE tools as collaborative support technologies. Communications of the ACM, 38(1):83-95, 1995.
  2. Grady Booch and Alan W. Brown. Collaborative development environments. Advances in Computers, 59, 2003. (2003)
  3. Susanne Hupfer, Li-Te Cheng, Steven Ross, and John Patterson. Introducing collaboration into an application development environment. In CSCW '04: Proceedings of the 2004 ACM conference on Computer supported co-operative work, pages 21-24, New York, NY, USA, 2004. ACM Press.
  4. Li-Te Cheng, Susanne Hupfer, Steven Ross, and John Patterson. Jazz-ing up Eclipse with collaborative tools. In eclipse '03: Proceedings of the 2003 OOPSLA workshop on eclipse technology eXchange, pages 45-49, New York, NY, USA, 2003. ACM Press.
  5. Margaret-Anne Storey, Li-Te Cheng, Ian Bull, and Peter Rigby. Shared waypoints and social tagging to support collaboration in software development. In CSCW '06: Proceedings of the 2006 20th anniversary conference on Computer supported cooperative work, pages 195-198, New York, NY, USA, 2006. ACM Press.
  6. Margaret-Anne Storey, Li-Te Cheng, Ian Bull, and Peter Rigby. Waypointing and social tagging to support program navigation. In CHI '06: CHI '06 extended abstracts on Human factors in computing systems, pages 1367-1372, New York, NY, USA, 2006. ACM Press.
  7. David Redmiles, Andre van der Hoek, Ban Al-Ani, Tobias Hildenbrand, Stephen Quirk, Anita Sarma, Roberto Silveira Silva Filho, Cleidson de Souza, and Erik Trainer. Continuous coordination: A new paradigm to support globally distributed software development projects. Wirtschaftsinformatik, Special Issue on the Industrialization of Software Development, 49(Special issue):S28-S38, 2007.
  8. Andr van der Hoek, David Redmiles, Paul Dourish, Anita Sarma, Roberto Silva Filho, and Cleidson de Souza. Continuous coordination: A new paradigm for collaborative software engineering tools. In Workshop on Directions in Software Engineering Environments, pages 29-36, 2004.
  9. Anita Sarma, Zahra Noroozi, and Andre van der Hoek. Palantir: raising awareness among configuration management workspaces. In ICSE '03: Proceedings of the 25th International Conference on Software Engineering, pages 444-454, Washington, DC, USA, 2003. IEEE Computer Society.
  10. Roger M. Ripley, Anita Sarma, and Andre van der Hoek. A visualization for software project awareness and evolution. In VISSOFT '07: Fourth International Workshop on Visualizing Software for Understanding and Analysis, 2007.
  11. Christine A. Halverson, Jason B. Ellis, Catalina Danis, and Wendy A. Kellogg. Designing task visualizations to support the coordination of work in software development. In CSCW '06: Proceedings of the 2006 20th anniversary conference on Computer supported cooperative work, pages 39-48, New York, NY, USA, 2006.
  12. Jason B. Ellis, Shahtab Wahid, Catalina Danis, and Wendy A. Kellogg. Task and social visualization in software development: evaluation of a prototype. In CHI '07: Proceedings of the SIGCHI conference on Human factors in computing systems, pages 577-586, New York, NY, USA, 2007.ACM Press.
  13. Anita Sarma, Andre van der Hoek, and Li-Te Cheng. A need-based collaboration classification framework. In Proceedings of the 1st Workshop on Eclipse as a Vehicle for CSCW Research, 2004.
  14. Anita Sarma. A survey of collaborative tools in software development. Technical report, University of California, Irvine, 2005.
Retrieved from "http://vital.cs.ohiou.edu/vitalwiki/index.php/3D-IDE"