SDLC or software Development Life Cycle is the set of activities needed to transform a user’s requirements into a software system. The process defines Who is doing What, When, as well as How to reach a certain goal.
The SDLC is very important as most projects fails are due to poor planning and non respect of schedules. SDLC is also an abbreviation for Synchronous Data Link Control and system development life cycle
UML (Unified Modeling Language) is a standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems. UML was created by the Object Management Group (OMG) and UML 1.0 specification draft was proposed to the OMG in January 1997. The artifacts of the SDLC are UML diagrams.
RUP
Stands for "Rational Unified Process." RUP is a software development process from Rational, a division of IBM. It divides the development process into four distinct phases that each involve business modeling, analysis and design, implementation, testing, and deployment. The four phases are:
Inception - The idea for the project is stated. The development team determines if the project is worth pursuing and what resources will be needed.
Elaboration - The project's architecture and required resources are further evaluated. Developers consider possible applications of the software and costs associated with the development.
Construction - The project is developed and completed. The software is designed, written, and tested.
Transition - The software is released to the public. Final adjustments or updates are made based on feedback from end users.
The RUP development methodology provides a structured way for companies to envision create software programs. Since it provides a specific plan for each step of the development process, it helps prevent resources from being wasted and reduces unexpected development costs.
Is the SDLC Important?
Software Engineering is a relatively new and fast growing discipline. Scientific models to structure the practice of building software emerged because of the relatively high failure rates of projects in the late 70's. There was a need to improve the quality of software while integrating new programming paradigms that were emerging (Like Object Oriented programming) and that would eventually emerge. Experts and researchers in this industry worked hand in gloves to achieve this breakthrough, the result was the integration of all the good development practices into a well documented and consensual process called the SDLC that would guide future developers and Engineers in their jobs.
Also, the SDLC is not very technical, it is an easy process whose steps are well documented and so doesn't need a high technical expertise in the field but that has made us save a lot of resources when it comes to building successful software.
SDLC Models
Many methodologies have been developed to structure the process of software development, some of which include
Waterfall model
Rapid Application Development
Joint Application Development
The fountain model
Build and fix
Synchronize and Stabilize
Agile Unified Process (AUP)
Agile Unified Process (AUP) is a simplified version of the Rational Unified Process (RUP) developed by Scott Ambler. It describes a simple, easy to understand approach to developing business application software using agile techniques and concepts yet still remaining true to the RUP.
Over the time, Agile programming has imposed itself as the best option to go with. As its name implies, it is agile meaning it is highly responsive and flexible, we can easily integrate the other models and practices into it to form a hybrid methodology. Note that, each company has its own customized form of agile programming that fits into its business model and the nature of the project. What matters is that, the steps should be well documented and easily applicable.
Agile Key Principles
Active user involvement is imperative
The team must be empowered to make decisions
Requirements evolve but the timescale is fixed
Capture requirements at a high level; lightweight & visual
Develop small, incremental releases and iterate
Focus on frequent delivery of products
Complete each feature before moving on to the next
Apply the 80/20 rule
Testing is integrated throughout the project lifecycle –test early and often
A collaborative & cooperative approach between all stakeholders is essential
Stages of the Object Oriented Analysis and Design RUP processes in as a SDLC
The first step in a project is to understand the problem to be solved or the opportunity to be realized. This is accomplished by System Analysts in conjunction with stakeholders. This step is known as Problem Analysis. Performing this analysis requires sufficient knowledge of the domain. The problems to be solved must be agreed upon by all stakeholders of the system.
1. Planning and Requirement Analysis
Inception and elaboration are been carried out here. The result of which are
The main elements of a RUP Software Requirements Specification:
use case models
supplementary specifications,
glossary
A use case is a sequence of actions performed by an actor interacting with the system to achieve a goal, showing how the goal might succeed or fail to be reached.
Use cases are described in terms of flows and scenarios. A scenario is a single path through a use case. A flow is a set of scenarios that result in the same sort of outcome (e.g., success vs failure flows). This information is well structured and documented in what is known as the Software Requirement Specifications (SRS) Document, it helps the stakeholders involved in the project have a clear insight on what will be done and how it will be done.
The Planning and Analysis stage is the most important stage of SDLC. Many companies only spend 10-15 % on these two phases and in the end they fail because they didn’t plan and analyze the product that was needed to invent. Spending more time on this phase would decrease the failing overtime and reduce expenses. This stage MUST NOT be ignored to generate more business and desired results.
2. Architectural Analysis
Here, we understand how use-cases are developed, structured, and used. We understand how use-cases integrate and drive the entire software lifecycle.
The artifacts of Architectural analysis are
System Architecture : Here, we decide if we are building a Stand-alone desktop application, Enterprise System, Web application, Client-server application, Distributed System (e.g. RESTful or SOAP solution) Or some combination of the above.
Analysis Mechanisms: A project’s architectural mechanisms are standards for how common design problems are to be solved, this promotes uniformity of solutions and increases possibility of reuse, ease of maintenance and minimizes entropy of multiple solution strategies. An architectural mechanism is really an architectural pattern for the project.
Key Abstractions: Key abstractions are concepts identified during requirements analysis.The goal is to come out with "analysis classes" common across the use cases. These will be refined and fleshed out as the project evolves. Architects will come up with these based on; the problem statement, Requirement, Past experience with similar systems, the business domain.
3. Use case Analysis
RUP takes the point of view that the designer or architect should do the "obvious" things at each step in the process, and details become apparent in due course. In Use Case Analysis, objects are classified, responsibilities assigned and attributes discovered, all in a relatively effortless manner by following our rules for using boundary, controller, and entity classes. Sequence diagrams are suggested by the UC descriptions; collaboration diagrams can be automatically generated, and a VOPC (View of Participating Classes) diagram for a use case basically just "falls out" of the collaboration diagram.
4. Architectural Design
Architects make system-wide preparations that guide and coordinate the design activities of individual designers. The main Architecture Design Activities:
First, transform analysis classes to design classes
Second, do we see any reuse opportunities from the class to the system level?
Third, identify subsystems and specify their interfaces
Finally, identify our Design Mechanisms - That is, our Enterprise Architecture and Frameworks
5. Use Case Design
All designers/developers will complete the following steps for their VOPC and Sequence diagrams:
Change analysis classes to design classes and refine class interactions.
Incorporate any inheritance hierarchy
Incorporate our Enterprise Framework
Incorporate any subsystems needed
6. SubSystem Design
The activities of SubSystem Design include
Step 1: Specify detailed operation of subsystems that is, a sequence diagram for each subsystem method defined in our subsystem interface
Step 2: Specify the static associations between all the classes in the subsystem that is, multiple VOPCs for a large subsystem or one for our smaller subsystems.
7. Class Design
Here, We add additional classes and relationships needed to support implementation , we identify Mechanisms , Patterns , Environment and language constraints. We also refine operations (Methods), attributes and relationships as needed for implementation. The class diagram is the main artifact we want to come out with. A well structured class diagram leads to a well implemented project that can last for long require minimum expenditure on system maintenance and update.
Guides for Implementation and Testing
Use Scrum to keep track of what each person is doing and delivering for their use cases
Each person in the group must have the whole project running on their development machine.
Have one person be the owner of integration of code
Use Github for source versioning (VCS).
Add code in small increments, build and test on your machine before pushing to the group Github project.
Do daily integration of your group code and each person pull to their development machine and build on that code.
Watch out for rebase! You don’t want to lose your latest changes
You now have a general idea on how to to follow the SDLC and RUP processes to produce good software. For more information, see the UML website.