Software life-cycle modeling is the business of tracking source code as it goes through various stages throughout its life, from development to testing, release, reuse, and retirement. This document describes Perforce's support for life-cycle modeling and provides a reference model. But first, it describes life-cycle modeling the way other SCM systems support it, using the "promotion" model.
The salient feature of the promotion model is how the source code trunk is used. Contributing features are whether the model supports promoting individual files or whole projects and how branching is used.
In the promotion model, the source code trunk goes through different stages over time. The stage of each revision of each file is indicated by some attribute(s) whose definitions are worked out in advance to reflect the intended life-cycle of the source code. Typical values are "development", "QA", "released", and "retired". The various revisions of each trunk file will usually be in different stages: the tip revision might be in "development" while an older revision from a year ago may be "released."
The concept of promotion comes in to play when a revision of a file is considered ready to move to the next stage. At that time, the revision is promoted. For example, after an engineer is finished adding enhancements and is ready to have them tested, he might promote the new tip revision from "development" to "QA." Sometimes a revision can be demoted; if it fails to pass Q
It might be demoted back into development for further work. Because of this promotion/demotion notion, stages are usually referred to as promotion "levels."
SCM systems that support the promotion model always have some way of asking for the latest revision of a file at a given promotion level. The QA engineer will request the last "QA" revision of all files. The developer will work against the "development" revisions. A released product would be built from the revisions marked as "released."
Often, SCM systems assign each user one or more "roles" that defines their access to revisions at each promotion level. For example, only QA engineers will be able t
o check out files whose status is "QA", and only a release manager will be able to promote "QA" files to "released."
A tricky problem arises when someone needs to change a revision of a file other than the tip. Typically the tip will be "in development", but if QA finds a bug after a developer has made further enhancements then a non-tip revision may need updating. One solution for this is for the SCM system to make an ad-hoc branch at the revision that needs updating. ClearCase takes this approach. If a lot of activity is needed to get the code past QA the trunk can sprout quite a few branches and the final release might be quite "bushy." Another approach is to check in the updated non-tip revision as the new tip anyhow. The system must then "weave" the related revisions (those at the same promotion level) up to the trunk of the file's revision history. This essentially treats different promotion levels as separate branches in the file. PVCS® uses this approach.
Aside from these ad-hoc branches, branches off of the trunk are used largely for parallel development. There may be many branches off of the trunk for various projects, each periodically merging its contributions back. Branches themselves may go through promotion levels as well, but they usually are all considered to be at the "development" level.
Some coarser-grained SCM systems group files into "projects" and their promotion model support promoting these whole projects rather than the individual files. The advantage to this is that there is much less detail that the user must potentially remember; on the downside, it limits flexibility because the granularity of promotion is determined when the project is created, rather than when it is promoted.
Systems which support projects often limit their branching to whole projects as well. This is sometimes described as "baseline branching", because the whole baseline of a product is branched at the same time. With baseline branching comes a slightly greater capability for promotion: each project can have its own promotion levels. The trunk may remain the main line of development, with promotion levels reflecting the development cycle. At some time a baseline branch of the development project(s) can be used for a release, with promotion levels reflecting the release cycle.
The major downside to the promotion model is that important information is obscured. In addition to the file's name, the revision number and its promotion level all determine the current purpose of the file. While the file's name is always visible, the significance of the revision number and the promotion level are much less apparent. Most SCM systems use hard-coded protection mechanisms to keep (otherwise honest) engineers from modifying the wrong files.
Further, tracking history can be complicated. The history of a file's trunk may be incomplete (with ad-hoc branching) or quite confusing (with branches woven in as promotion levels).
Finally, promotion history is often not versioned as well as regular file history. If a file is promoted and then demoted, it may not be possible to reproduce a release made when the file was in its promoted level. Usually, only one revision can be at any promotion level. If a file was promoted to "released" last year and now a new revision is up for a new release, either a different promotion attribute must be created or the promotion level of the previous release will be lost. more details
Introduction - The Present Software development life cycle
The first step in our journey through Model Driven Architecture technology is to analyze why MDA must succeed in the next years. And the best way to do this is to analyze why the present software life cycle doesn’t.
Software development seems to had been highly improved since the last decades. It’s rather thought because the more complex systems we build today. However, costs, maintenance, and deadlines are still challenges in the software industry. Software is still a very expensive product.
Taking an iterative and incremental approach, the present software life cycle can be understood by the figure below.
Let’s make a quick and shallow explanation(if you feel familiarized with these concepts, you can skip the italicized text below):
The focus of the last two phases are on models and not so in implementation details, although the design model can encompass some of these ones.
the system was well specified, designed, coded, tested and (a very important issue) documented, if the software maintenance is easy to manage. When software is hard to maintain is due, among other reasons, bad technology choices, bad design, dirty code, or even due to bad documentation.
So, what’s the problem with the present life cycle?
The problem is that the first two phases are focused on modeling and the last three are focused on coding. Thus, at the time you need to make changes in your software, you will update your code, frequently letting the models and documentation become out of date. And so, ask yourself how worthy are models and documentation that don’t represent what they are supposed to and how they are supposed to? Not much, don’t you agree? And, as the models don’t follow up the software life cycle evolution, they become obsolete.
Thus, we can list some of the major bad consequences:
So, as more as code goes far models, models become not so useful as they used to be.
The most obvious troubles rely in the maintenance phase, but if we think about the implementation phase, how the code is built? Code is often written down by hand and although there are code generating tools, they do a very shallow work and the big picture is broadly painted by the programmer, so a “monkey work” has to be done. The testing phase is almost the same situation.
And what if one needs to change some issues, such as target platform or programming language for the sake of efficiency so that the chosen implementation technology should be changed? At this point, when models are not so reliable anymore, the one thing you have are the requirements… So, you have to do almost the whole work again. “Oh, my God !!! More and more costs !!!”
And what if your system now is meant to be integrated to other systems? But no interoperability solutions were thought in development time?
Well, we could spend our lives here talking about software development problems and I apologize for taking a pessimist approach… Thus, I will stop here, and in the next post, I will present you a most hopeful approach Model Driven Architecture can provide us.
Software Development Life cycle (SDLC) Notetech software
Notetech following a scientific SDLC for executing all the custom software development project here at our facility. The picture given below is the detailed graphical representation of our custom software development life cycle. Software Development Life Cycle of Notetech
Quality Assurance in the Software Life Cycle
As with any other business investment, Quality Assurance must bring value. The value expected from Quality Assurance is making the software processes more efficient while ensuring that the end-product fits customers' needs. Translated to measurable objectives, that means preventing schedule creeps and budgeting problems; reducing re-work in the requirements, design and construction areas; ensuring efficient discovery and elimination of defects before they reach the end user – in short, making the software processes better and thus making the final product better as well.
. To mention a few:
r is its ROI. Finding a problem in Requirements can cost ten or more times cheaper to fix than fixing the same issues when finding in testing: fighting a paper tiger is easier than a live one..
Life Cycle and Process Models in Software Engineering
