Unified Software Process

So.. what´s unified software process?

Let´s say you own a small clothing line company where you make and design custom clothes for your clients. To improve your income and expand your costumer base you decide to take your business online, so now you hire a web development company to build an E-commerce for you. In the process of making your webpage, as a costumer, would you like to receive your project right away all at once in a specified time limit or rather delivered in stages, so that you can take a look of the “process” itself and request, in case of doing so, any modifications at that precise “phase”?

Clothes shop
Clothes shop flickr photo by bakfliper

It would be reasonable to go for the second approach as you get to see how your website is getting in place and also ensure that the developers were proceeding for the right direction. This is the same approach that you take if you are building a software product on the basis of an unified software process model.

Taking this into account, we can define the unified process model as an iterative, incremental, architecture-centric, and use-case driven approach to software development. Later on another blog, we are going to define what exactly a use-case is.

An architecture-centric approach will help us create a blueprint of the organization of the software system, this is taking into account the different technologies, programming languages, operating systems, development and release environments, server capabilities and other such areas for developing the software.

Using an iterative and incremental approach means treating each iteration as a mini-project. Therefore, you’d develop the software as a number of small mini-projects, working in cycles. You’d develop small working versions of the software at the end of each cycle. Each iteration would add some functionality to the software according to the requirements specified by the customer.

X
X flickr photo by Alyssa Meredith

Now that we recgonized the distinctive chracteristics of the inified process model, let´s take a look at the steps involved:

Inception:

The inception phase is similar to the requirements collection and analysis stage of the waterfall model of software development(You can find more about the waterfall cycle and other cycles here). In this phase, you’d collect requirements from the customer and analyze the project’s feasibility, its cost, risks, and profits.

Inception
Inception flickr photo by theomi

Elaboration:

 In this phase, you’d be expanding upon the activities undertaken in the inception phase. The major goals of this phase include creating fully functional requirements (use-cases) and creating a detailed architecture for fulfillment of the requirements. You´d also prepare a business case document for the costumer.

Elaborate

Construction:

In this phase, you´d be writing actual code and implementing the feature for each iteration. You´d be rolling out the first iteration of the software depending on the key use-cases that make up the core functionalities of the software system.

#code
Code flickr photo by George Postoronca

Transition:

In this phase, you´d be rolling out the next iterations to the customer and fixing bugs for previous releases. You would also deploy builds of the software to the customer.

Transition...
Transition… flickr photo by Léa_86

Rational Unified Process (RUP)

The Rational Unified Process created by the company Rational(later bought by IBM) is the most known unified process up to date being as a standard for analysis, design, implementation and documentation in object oriented systems. The principal objective for RUP is to produce quality software in a timely manner. Nevertheless, RUP is not for every type of development but certainly has generic processes.

Some distinctive characteristics for RUP are:

  • Team productivity regarding knowledge
  • Use of UML (Unified Modeling Language)
  • Creates and maintains models
  • Tool supported that helps automate processes.
  • Configurable
  • Captures many good practices applicable to most projects

Six good practices RUP

  1. Develop software iteratively
    • plan iterations according to user´s needs and priorities
  2. Manage requirements
    • Explicitly document the client´s requirements and keep abreast of changes.
  3. Component based architectures
    • Easy changes, specific operations.
  4. Visually model software
    • Use UML to represent software´s dinamic and static views.
  5. Verify software quality
    • Ensure that software meets organizational quality standards.
  6. Controls software changes
    • Use a change and procedure management system.

Agile

Agile Scrum is also a common unified software process which originates from the waterfall model cycle where the planning must be completed before moving on to the next stage.

Some distinctive characteristics for RUP are:

  • The project is divided into small pieces that are handled in cycles.
  • Each cycle lasts from one to two weeks.
  • Each cycle is known as Sprints.

Some artifacts used in Agile are:

  • Product backlog: list of product characteristic priorities also known as User Stories; allows to estimate the size of the task.
  • Sprint backlog: this is where high priority User Stories go through the process of estimating its size y divide everything into tasks.
  • Burndown charts: Shows the Sprint progress according to the completion of the Sprint backlog tasks.

Some ceremonies present in the Agile Scrum process are:

  • Sprint planning: User Stories´discussion and estimation.
  • Daily scrum: scheduled meeting regarding questions like: what did you do yesterday? what are you going to do today? Is there any obstacle in your way?
  • Sprint review and retrospective: last Sprint phase; show final work and discuss possible improvements.

It also exists other types of unified process methodologies where the variations are minimum in contrast with these mention earlier, such as:

  • Essential Unified Process (EssUP).
  • Open Unified Process (OpenUP).
  • Enterprise Unified Process (EUP).

Summary:

In a nutshell, the unified software process  is an iterative and incremental software development framework, from which a customized process can be defined. The most common procedures for this unified process are RUP and Agile. We can say that RUP can be used for long and rigid projects with all terms defined since its initiation in comparison with Agile where flexibility as to the project´s delivery is key.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Blog at WordPress.com.

Up ↑

Create your website at WordPress.com
Get started
%d bloggers like this: