Organizing RUP SE Projects - Team Structure
(Page 3 of 5 )
The RUP SE project organization consists of the following teams with overlapping membership.
- Enterprise/business/mission modeling team. Develops enterprise business/context models in order to set system context and derive system requirements.
- System analysis team. Builds the analysis model, including the UML subsystem and localities. This team also develops and maintains the derived requirements to the analysis, and it may build the analysis-level process and data models.
- Design and implementation teams. Responsible for the detailed design and implementation of components within a given viewpoint.
- Subsystem teams. Develop detailed class design and associated software modules for one or more subsystems.
- Locality teams. Develop detailed hardware specifications, design, and hardware components for one or more localities.
- Other teams. Might include data modeling and computer/human interaction.
- Build and integration team. Receives components developed by the development and implementation teams and builds system iterations.
- System test team. Plans, executes, and reports on system tests.
- Operation and maintenance team. Performs field delivery, tracks problems, prioritizes change requests, and delivers updates and patches.
- Project management team. Performs ongoing iteration planning, context management, and stakeholder communications.
Figure 2 shows the relationships among the various teams, with the arrows indicating communication paths between teams.
Figure 2: RUP SE project team organization
Let's explore in detail what each of these teams does.
Enterprise/Business/Mission Modeling Team
This team is responsible for establishing system requirements by defining the role that the system under development will play in the overall enterprise. This team applies flow methods to create system use cases, system services, and system supplemental requirements. Over the course of development, this team may update the enterprise model as the system specification evolves. In addition, the team serves as an authoritative source for dealing with requirement issues that emerge during development.
Ideally, this team should consist of business analysts and/or domain or process experts, along with some or all members of the system analysis team.
System Analysis Team
This team builds and maintains the system analysis model, including each of the views. In addition, this team carries out joint flowdown activities to derive the system use-case survey and services, survey of hosted services for each locality, and so on. This team looks after the integrity of the architecture, resolves interface issues, and addresses discovered needs for changes as the development evolves.
This team includes the lead architect(s) and some of the business analysts or domain experts. Over time, the lead architects of the design and development team, the build and integration team, and the test team will join the system analysis team.
Design and Implementation Teams
These teams create the modules that are integrated by the build and integration team. Once the architecture is reasonably stable, the elements of the analysis model are partitioned to the design and development teams. In particular, some teams (subsystem teams) are given one or more UML subsystem(s) to design and develop in code modules. Other teams (locality teams) are assigned localities to design; then they either develop these localities or acquire hardware modules for them.
The teams are organized around core competencies. Good logical and physical decompositions are generally aligned with technical competencies.
Subsystem Teams
Note that the derivation of requirements for subsystems results in a clean set of specifications (requirements and interfaces) that permits subcontracting of work if necessary.
Subcontracting is frequently necessary for large systems projects, and IBM RUP SE allows for independent development that maintains synchronization with other development plans. In many instances the subsystems are software based, but in others the work of UML subsystem development teams could be instantiated as firmware (e.g., EPROM-hosted code for an embedded controller) or hardwired into an ASIC. In still other cases, these teams may work with VHDL9 designers for a full hardware implementation.
In the case of UML subsystems, teams develop the subsystem context diagrams, and the detailed class design and code modules. They need to maintain coordination with the locality teams to ensure the code modules are suitable for compilation and deployment on the target hardware platforms. The subsystem teams conduct unit tests.
Locality Teams
The locality teams take into account the derived supplemental requirements and surveys of hosted services to determine the needed hardware resources for deployment of the logical services. This team will then develop the hardware specifications and look after the delivery of the needed components.
Build and Integration Team
The development teams develop modules for integration, and the build and integration team assembles them to create versions of the system. Note that IBM RUP SE employs iterative builds to manage content and technical risk. The build and integration team is responsible for the ongoing system integration effort and includes build environment experts. Each of the development teams has liaisons who are responsible for coordination with this team.
This team develops and maintains the make files, and -- working with the configuration management system -- creates the labeled software builds.
If hardware is not available, the development teams may need a simulated or scaffolded hardware platform to build interim system iterations. The build and integration team, working with the locality development teams, are responsible for providing those resources.
System Test Team
This team plans, executes, and reports on the system tests for each of the iterations.
Operation and Maintenance Team
This team tracks field experience, prioritizes change requests, and performs other similar activities.
Project Management Team
A key project management tool is the evolving iteration plan. As we will discuss below, IBM RUP SE iteration planning consists not only of creating and maintaining a system-level iteration plan, but also of deriving iteration plans for each of the teams. The project management team, consisting of the system development project manager, the lead architects/engineers, and the development, integration, and test team leads, is responsible for iteration plans and standard project management tasks such as staffing and status collection and reporting.
Next: Planning Ahead >>
More Development Cycles Articles
More By The Rational Edge
/ 10 
