The Rational Unified Process ( RUP ) is a recurring software development framework created by Rational Software Corporation, a division of IBM since 2003. RUP is not a single concrete prescriptive process, but more is an adaptable framework, intended to be tailored by development organizations and software project teams that will select the process elements that suit their needs. RUP is a specific implementation of Integrated Process.
Video Rational Unified Process
Histori
Rational Software originally developed a rational integrated process as a software process product. This product includes a hyperlink knowledge base with examples of artifacts and detailed descriptions for different types of activities. The RUP is included in the IBM Rational Method Composer (RMC) product that allows process adjustment.
Philippe Kruchten, an experienced Rational technical representative assigned to lead the original RUP team. This journey began with the creation of a Rational Process of Honesty (ROP) in 1996, when Rational obtained a Target Process that had been written by Ivar Jacobson and the company. It was renamed to Rational Unified Process (RUP) in the next release, partly to align the name with that of the Unified Modeling Language.
This initial version incorporates the broad experience of Rational Software's organization that builds an object-oriented system (referred to by Rational Field staff as a Rational Approach) with Objectory guides on practices such as use cases, and includes extensive content from Jim Rumbaugh's Object Modeling Technology (OMT) ) approach to modeling, Booch Grady Booch method, and UML 0.8 newly released.
To help make this growing knowledge base more accessible, Philippe Kruchten is tasked with assembling an explicit process framework for modern software engineering. This effort uses an HTML-based process submission mechanism developed by Objectory. The "Rational Unified Process" (RUP) result completes a strategic tripod for Rationale:
- built tailored process
- tool that automates the app from that process
- services that accelerate the adoption of processes and tools.
This guide is added in the next version with knowledge based on Rational's experience.
In 1997, requirements and discipline tests were added to the approach, many additional materials sourced from the Requirements College method developed by Dean Leffingwell et al. in Requisite, Inc., and the SQA Process method developed at SQA Inc., both companies have been acquired by Rational Software.
In 1998 Rational Software added two new disciplines:
- business modeling, most of this content already exists in the Goal Process
- a discipline of Configuration and Change Management, sourced from the acquisition of Pure Atria Corporation.
This addition leads to a set of principles defined by Rational and articulated in the RUP as the six best practices for modern software engineering:
- Develop repeatedly, with risk as a primary iteration drive
- Manage requirements
- Use component-based architecture
- Extend software visually
- Continue to verify the quality
- Change controls
This best practice is closely aligned with the Rational product line, and both encourage the ongoing development of Rational products, and are used by Rational field teams to help customers improve the quality and predictability of their software development efforts.
Additional techniques include performance testing, UI Design, inserted data engineering, and updates to reflect changes in UML 1.1.
In 1999, project management disciplines were introduced, as well as techniques to support software development and real-time updates to reflect UML 1.3. In addition, the first book to describe the process, the Integrated Software Development Process (ISBN: 0-201-57169-2), was published in the same year.
Between 2000 and 2003, a number of changes introduced guidance from Rational's ongoing field experience with repeated development, in addition to tool support for enforcing RUP instances and for customization of the RUP framework. These changes include:
- the introduction of concepts and techniques from approaches such as eXtreme Programming (XP), which will later be known collectively as an agile method. These include techniques such as pair programming, first-test design, and papers that explain how the RUP enables XP to scale for use on larger projects.
- a thorough examination of the testing discipline to better reflect how testing work is done in the context of different repeatable developments.
- the introduction of the support guides - known as "mentor tools" - to enforce RUP practices in various tools. It basically provides step-by-step method support for Rational tool users.
- automates RUP customization in a way that will allow customers to select parts of the RUP process framework, customize their selection with their own additions, and still include improvements in the next release of Rational.
IBM acquired Rational Software in February 2003.
In 2006, IBM created a customized RUP subset for Agile project delivery - released as an OpenSource method called OpenUP through the Eclipse website.
Maps Rational Unified Process
Rational integrated topics topics
RUP building blocks
The RUP is based on a set of building blocks and content elements, explaining what will be generated, the necessary necessary skills and a step-by-step explanation explaining how specific development goals should be achieved. The main building blocks, or content elements, are as follows:
- Roles (which) - Roles define a set of related skills, competencies, and responsibilities.
- Work product (what) - The work product represents something that results from the task, including all documents and models generated while working on the process.
- Tasks (how) - Tasks describe defined work units for Roles that give meaningful results.
In each iteration, tasks are categorized into nine disciplines:
- Six "engineering disciplines"
- Business modeling
- Terms
- Analysis and design
- Deployment
- Test
- Deployment
- Three supporting disciplines
- Configuration and change management
- Project management
- Environment
Four phases of the project's life-cycle
The RUP has determined a four-phase project life cycle. These phases allow the process to be presented at a high level in the same way that the waterfall project can be displayed, although at its core the process key lies in the development iterations that are in all phases.. Also, each phase has one goal and a major milestone at the end that indicates the goal achieved. Visualization of RUP phases and discipline over time is referred to as RUP hump graph.
Inception Phase
The main purpose is to measure the system adequately as a basis for validating initial costs and budgets. In this phase of the business case that includes the business context, success factors (expected earnings, market recognition, etc.), and financial forecasts set. To complement the business case, basic use case models, project plans, initial risk assessments and project descriptions (core project requirements, constraints and key features) are generated. Once this is done, the project is checked against the following criteria:
- Conclusion of stakeholders on the definition of scope and cost/schedule estimates.
- Understanding requirements as evidenced by the loyalty of major use cases.
- Credibility of cost/schedule estimates, priorities, risks, and development process.
- The depth and breadth of all developed architectural prototypes.
- Define baselines to compare actual spending versus planned expenses.
If the project does not pass through this milestone, called a milestone achievement milestone, it can be canceled or repeated after redesign to better meet the criteria.
Elaboration phase (Ortner)
The main purpose is to mitigate the key risk items identified by the analysis to the end of this phase. The elaboration phase is where the project begins to take shape. In this phase, domain problem analysis is created and the project architecture gets its basic shape.
The results of the elaboration phase are:
- The use-case model in which use cases and actors has been identified and most use case descriptions are developed. The use-case model should be 80% complete.
- Description of software architecture in software system development process.
- An executable architecture that realizes significant architectural usage cases.
- Business case and revised risk list.
- Development plan for the entire project.
- Prototypes proven to reduce any identified technical risk.
- Initial user guide (optional)
This phase must pass through the milestone criteria of life cycle architecture answering the following questions:
- Is the product vision stable?
- Is the architecture stable?
- Do executable demonstrations show that key elemental elements are addressed and resolved?
- Is the construction phase plan detailed enough and accurate?
- Do all stakeholders agree that the current vision can be achieved by using the current plan in the context of the current architecture?
- What is actual vs. resource expenditure? which is planned to be acceptable?
If the project can not pass this milestone, there is still time for it to be canceled or redesigned. However, after leaving this phase, the project shifts to high-risk operations where changes are much more difficult and harmful when created.
The key domain analysis for elaboration is system architecture.
Construction phase
The main purpose is to build a software system. In this phase, the main focus is on developing components and other features of the system. This is the phase when most of the coding takes place. In larger projects, several construction iterations can be developed in an effort to divide use cases into manageable segments resulting in demonstrable prototypes.
Transition phase
The ultimate goal is to 'move' the system from development to production, making it available and understood by the end user. This phase activity includes training end users and managers and system beta testing to validate against end-user expectations. The system also passes through the evaluation phase, any developers who do not generate the required work are replaced or deleted. This product is also checked against the quality level specified in the Inception phase.
If all goals are met, product release milestones are reached and the development cycle is completed.
IBM Rational Method Composer Products
The IBM Rational Method Composer product is a tool for creating, configuring, viewing, and publishing processes. See the IBM Rational Method Composer and the open source Eclipse Project Framework (EPF) project for more details.
Certification
In January 2007, a new RUP certification exam for IBM Certified Solution Designer - Rational Unified Process 7.0 was released that replaced the previous version of a course called IBM Rational Certified Specialist - Rational Unified Process . The new examination will not only test knowledge related to RUP content but also to process structure elements.
To pass a new RUP certification exam, one must take IBM Test 839: Rational Unified Process v7.0 . You are given 75 minutes to follow 52 exam questions. The passing rate is 62%.
Six best practices
The six best practices as described in a rational integrated process are the paradigms in software engineering that include six ideas to follow when designing any software project to minimize errors and increase productivity. These practices are:
- Develop iteratively
- It is best to know all the requirements first; However, this often does not happen. Several software development processes exist that deal with providing solutions on how to minimize costs in terms of development phase.
- Manage requirements
- Always pay attention to user-defined requirements.
- Use the component
- Breaking down a follow-up project is not only recommended, but in reality it can not be avoided. It promotes the ability to test individual components before they are integrated into larger systems. In addition, code reuse is a big plus and can be solved more easily through the use of object-oriented programming.
- Model visually
- Use the diagram to represent all the major components, users, and interactions. "UML", short for Unified Modeling Language, is one tool that can be used to make this task more feasible.
- Verify the quality
- Always make the test as the main part of the project at any point in time. Testing becomes heavier as the project progresses but should be a constant factor in any software product creation.
- Control changes
- Many projects are created by multiple teams, sometimes in different locations, different platforms can be used, etc. As a result, it is important to ensure that changes made to the system are synchronized and constantly verified. (See Ongoing Integration).
See also
- Macroscope (suite of methodologies)
- Agile Model (AM)
- Unified Agile Process (AUP)
- Disciplined agile delivery (DAD)
- Dynamic Systems Development Method (DSDM)
- Computer programming
- Feature-based development (FDD)
- Project life cycle
- Quality assurance
- Frame Scale Somewhat - a RUP derivative that incorporates Agile software development methods like Extreme (XP) programming
- Software Architecture
- Software components
- Software development process
- Software engineering
- Software testing
- Test-driven development (TDD)
References
Further reading
- Ivar Jacobson, Grady Booch, and James Rumbaugh (1999). Integrated Software Development Process
- Gary Pollice, Liz Augustine, Chris Lowe, and Jas Madhur (2003). Software Development for Small Teams: RUP-Centric Approach
- Per Kroll, Philippe Kruchten (2003). The Unified Rational Made Made Process, The: Practitioner's Guide to RUP
- Per Kroll, Bruce Mac Isaac (2006). Agility and Discipline Made Easy: Practice of OpenUP and RUP
- Philippe Kruchten (1998). The Rational Unified Process: An Introduction
- Ahmad Shuja, Jochen Krebs (2007). RUP Reference and Certification Guide
- Walker Royce, Software Project Management, Integrated Framework
External links
- IBM Rational Unified Process Web Site
- Rational Software at IBM
- Global Rational User Group Community
Source of the article : Wikipedia
0 Comments