I have some confusion about the terms SDLC and Software Process. With respect to these (and more or less similar) terms, a have a few question.
What is the difference between SDLC and Software Process ? (I understand SDLC is not just Waterfall).
Can we map SDLC with Unified Process ?
About the activities- Analysis in tradition waterfall model, Do we do Analysis in Unified Process (Any unified process- Agile or Rational) ?
SDLC stands for System Development Life Cycle, and it is a more or less generic term to describe whatever standard life cycle that you have implemented is.
SDLC is essentially your software process, but in my experience, most people associate it more directly with waterfall processes, as you indicated and more specifically, CMMI standards.
Typically with the SDLC, you will find that different groups have different methodologies to express it.
Since I don't recall the exact definition, there may be more linking it to the waterfall methods than just semantics. For instance, I believe Agile methodologies could be considered a type of SDLC, but I could be wrong about that.
I hope this helps.
SDLC in shortcut for software development life cycle for a software product that contains the process for a product the software from requirement software.. maintenance
the SDLC that contain viruses methodologies like waterfall ,scream,agile that follow each the process software from the requirement , design, implementation, testing, maintains but
different to how to apply this process some methodologies as agile do the multi-process in same time as implementation with design in want to write Document.
in a waterfall, methodology cont go to apply the next process until the previous process finish cont do mult process at the same time example cont be go implementation with the design in the same time you should be complete the design process cont be execution 2 process at same time
Software Process - is a set of activities and associated results that produce a software product. There are 4 fundamental process activities that are common to all software processes
Software Specification
Software Development
Software Validation
Software Evolution
SDLC - is the oldest and the most widely used approach in software engineering.It follows a number of sequential phases and partitioned set of activities. Based in an engineering/construction/production new.
Problem exploration
Feasibility Study
Requirement Gathering
Analysis
Design
Construction
IS implementation
Operation and Maintenance
Evoluation
- Phase out
I very much agree with you, SDLC dates back to the 1950s and it was the first framework introduced at the time. However, I have a few notes on the SDLC phases - I'd say that there are 7 stages of the SDLC:
1.Planning
2. Requirements Analysis
3. Design
4. Development
5. Testing
6. Deployment
7. Maintenance and improvement.
Today, there are a lot of SDLC models, Waterfall being the most popular one. Though, Agile is becoming quite popular lately - yet, I find a lot of teams to be highly disappointed of Agile. "We are constantly changing things that we never get anything done" - that's the most common phrase I hear.
What is the difference between SDLC and Software Process ? (I understand SDLC is not just Waterfall).
Ans: SDLC is the development lifecycle that is used in each and every project.SDLC defines all the standard phases which is very useful in software development. Software Process defines all the activities/phases to improve the quality of the product.
Software process is the testing lifecycle as it includes all the phases even the basic phases.
Can we map SDLC with Unified Process?
Ans: Yes you can map but only methodologies not the life cycle
Let's clear these queries one by one.
The difference between SDLC and Software Process:
Software Process or Software Development Process and Software Development Life Cycle - both are the concepts with a similar goal to develop a software.
There are multiple strategies or models available to develop a software. Like, Waterfall, agile, etc.
SDLC provides set of phases for the developers to follow. Each phase is a result of the privious phase.
The Unified Software Development Process or Unified Process is an iterative and incremental software development process framework.
For more details:
software process: https://www.geeksforgeeks.org/software-processes-in-software-engineering/
Software development life cycle: https://www.tatvasoft.com/outsourcing/2022/09/sdlc-best-practices.html
Yes, we can map SDLC with unified process.
You can go through this link for more details: https://www2.cdc.gov/cdcup/library/framework/mapping.htm
Unified Process, like most agile techniques, does not expect the general project plan defines when each use case is going to be implemented. So, object oriented analysis is required for the disign of the Information System.
For more details, use this reference: https://www.sciencedirect.com/topics/computer-science/unified-process
Related
I was reading about software development model and life cycle, where I learned about waterfall model and Unified process. However both the process involves requirement gathering, design phase, development testing and deployment (inception, elaboration, construction and transition phase in unified process).
Can any one help me out with the difference between the two?
You haven't specified 'which' Unified Process or 'which' Waterfall Process - there were many variants of both, so some of the comparison will be lost in generalization.
Taking for example the Rational Unified process, which differs from waterfall processes in that the disciplines (Analysis, Design, Coding, Testing etc) are done iteratively and concurrently, whereas in waterfall processes, the disciplines are generally done sequentially (e.g. Coding only starts once Requirements have been finalized and Design has been accepted).
In RUP, the term phases (inception, elaboration, construction, transition) are NOT dedicated to a single discipline or single deliverable - RUP phases are all multi disciplinary - e.g. although Inception is primarily about requirements and analysis; some design and prototype coding are also encouraged to reduce risk and improve estimates for future phases, and even in the construction phase, further analysis may be required.
RUP uses the term 'generation' to indicate another full cycle of development e.g. for a "version 2" of a project, where new work on generation 2 would begin at the inception phase.
Another major difference was that RUP pushed the concept of Visual Models (especially UML) as deliverable artifacts which described the requirements, high and class level design (and in some cases code generation was possible from detailed UML models), whereas Waterfall artifacts were typically very document heavy (e.g. the ESA / IEEE processes)
Another difference was in the approach to commercial engagement. Waterfalls typically promoted the concept of a 'contractual' Software Requirement or Software Specification document, which defined the deliverable (functionally, and non-functionally), and from which a project budget or fixed price transaction would be based. Instead, RUP promoted budgeting at a per-phase basis, e.g. and the effort / cost for the following phase would be known / iterated / improved as one of the deliverables of the preceding phase had been delivered.
In many software development operations, Agile processes have superseded both Waterfall and RUP, although many of the artifacts and learnings of Waterfall and RUP remain. Agile has the primary benefit of breaking work down into much smaller chunks (typically 2 week sprints, instead of months-long RUP phases or year-long waterfall projects). This quick turnaround allows features to be delivered on a cost vs priority basis, is better adapted to ever-changing requirements, and allows obstacles to success to be identified much sooner than either Waterfall or RUP. Agile also cuts out a lot of the waste - lets face it, only a small percentage of developers ever read detailed specification documents or pore over detailed UML diagrams.
Is it possible to have a custom template/workflow to manage a project that follows Waterfall methodology and use JIRA for managing such projects?
Is there a plugin or way to customize the default flow?
Wow, it is really hard to believe that someone is still using the Waterfall model...
Anyway I guess you can just have separate projects for each step of the model:
So for example if your project is called X then you can have:
X_Requirements
X_Design
X_Implementation
X_Verification
X_Maintenance
as projects in JIRA. Then create consecutive issues for all tasks.
As a summary I'd like to strongly encourage shifting away from the Waterfall model in Software Development. Things have changed a lot for the last 10-15 years - not mentioning that the Waterfall is much older than that period.
Modern agile (or not) methodologies provide a far better view of the iteration process in Software Development.
Yes switching may be hard initially (depending on the size of the company and what not) but the implications after are far more advantageous. You will experience a ton of optimizations and the most important factor - more communication with the client means a happier client!
I wanted to know if there are any open source tool for load testing any web application.
Is LoadRunner a perfect tool from an enterprise perspective for this purpose?
Could you clarify your question a bit? Are you looking to take the queries generated by the web application and then to reproduce them with a performance testing tool directly against the database or are you looking to exercise the web app and then analyze the database?
As far as what is best, this is a very subjective item and it comes back to that most dangerous of concepts, "requirements." The requirements for one organization may point the way to one tool over another depending upon the technical needs of the application, the available skills within the existing/planned performance testing team and budget. Mercury certainly made the case for the ROI for LoadRunner on the enterprise level long before it became part of HP's software offerings with market responding by giving it the largest overall market share. However, as evidenced by it's non-monopoly position the requirements of other organizations have lead to the adoption of different tools.
Build your requirements; technical, skills required and business; then evaluate the various market offerings to see which one works for you. The more interfaces you add the more compelling a commercial tool becomes over an open source one. The greater your skills depth in your performance team the more flexibility you have in using an open source tool as you will need to build out some of the analytical pieces that a commercial tool includes by default. ...
Can you please give a methodology that stands to alleviate the disadvantages of waterfall model?
The problem with Waterfall is that it consists of monolithic stages, each building on the previous stage. So the code is developed in one chunk after the entire system has been designed, which in turn happened after all the requirements have been gathered and signed off.
This is problem because any change has to be ratified by a complex procedure and rippled through all the stages. But the lesson of history is: change happens. The requirements are always incomplete, or mis-specified or simply out-of-date by the time we get to coding. Too often design and build proceed on the basis of assumptions which are nullified when the system gets to UAT. This leads to frantic re-work and slippages.
The truth is not many customers are good at the sort of abstract thinking required to envisage a working software software system. And too many IT professionals lack the experience necessary to understand business logic. Waterfall refuses to accept these truth.
The only honest requirement specification is "I'll know it when I see it". So it is crucial to get working software in front of real users as soon as possible. Any methodology which focuses on delivering working software incrementally in short iterations will "alleviate the disadvantages of waterfall model".
Originally that was RAD or DSDM. Then XP tok up the banner. Now there is Agile and related things like Scrum and Kanban.
So why do people persist with the Waterfall method?
There is a common perception that Agile is just a cover for cowboy hackers to ditch all the boring process stuff and get on with what they enjoy most: writing code. The branding of "Extreme Programming" certainly encourage this thought, and, let's be honest, it is not an unfounded allegation. That is, some coders pretend to be agile as an excuse not to plan, design or document. This does not reflect the actual practice of Agile, which require just as much rigour as any other methodolgy.
Also Agile requires a much greater commitment of time from the customer's staff, which many organizations are loath to accept. Also the people footing the bill may be unwilling to empower their junior staff to make decisions. There is an important distinction between Customer and User.
When it comes to outsourcing the waterfall model provides an easy framework for matching deliverables to staged payments. Indeed the contractual aspect maybe stronger than that: in the EU Waterfall is mandated for all projects valued at EUR 100m or more.
Finally, there are projects where Waterfall works well. These projects have knowledge domains which are stable and well-understood by both the customers and the developers.
last word
Despite its failings Waterfall has delivered many projects successfully. This is because hard work, aptitude and integrity are more important than methodology.
The waterfall model was documented in 1970 by a Dr Winston Royce in a paper titled 'Managing the development of large Software Systems'. Basically outlining his ideas on sequential development. His idea was that software could be produced in a similar fashion to an automobile, where the vehicle is pieced together in sequential/linear phases.
This linear approach doesn't really allow for changes in a piece of software once it begins. There is no tight relationship with the end user/client so its harder to outline possible problem areas.
Its worth noting some phases of the waterfall model allow for 'splashback' whereby there is enough time in the development period to go back and make small changes. Time constraints and the amount of work involved and budgets don't really allow for much change if any to be made using this model.
The waterfall model is old, as time goes by software paradigms themselves change. Object Oriented programming is popular, back then it was barely alive. Through the use of the waterfall model its obvious that the flaws have been spotted and this has lead to the alternative development methodologies.
Ok, so now for alternatives. Incremental model is described by Alistair Cockburn(2008) as a staging and scheduling strategy in which various parts are developed at different times or rates and integrated upon completion of that specific part.
Basically incremental looks a lot like this:
Analysis->Design->Code->Test
Analysis->Design->Code->Test
Analysis->Design->Code->Test
Number of benefits include lifecycle being flexible and allowing for change from the get go.
Working software or rather parts are generated quickly and early on. Code produced is earlier to test and manage due to the small iterations of progress. Not all of the requirements of the system are gathered up front, just an outline. This allows for a quick start, however it might be a disadvantage in some systems as things like the system architecture being supported might be missed.
Iterative on the other hand allows parts of the system to be reworked and revised to improve the system. Time is set aside to allow for this. Iterative does not start with a full specification of requirements. Development is done by specifying and implementing just part of the software. Software is reviewed in order to identify further requirements.This is more of a top down approach. Disadvantages with this methodology are making sure all the iterations are compatible. As each new iteration is approved, developers may employ a technique known as backwards engineering, which is a systematic review and check procedure to make sure each new iteration is compatible with previous ones.A major benefit with the constant iterations is that the client is kept in the loop and the final product should meet the requirements.
Iterative approach diagram.
Other methodologies include Prototyping. Evolutionary and Throwaway. These are also deemed as more of a top down approach. Both process are borrowed from engineering.In engineering it is common to construct scale models of objects to be built. Building models allows the engineer to test certain aspects of the design. The software development prototyping methodology provides the same ideology. Prototyping is not seen as a standalone, complete development methodology but rather an approach to handling selected portions of a larger, more traditional development methodology.
Throwaway Prototyping - Throwaway prototyping does not preserve the prototype that has been developed. In throwaway prototyping there is never any intention to convert the prototype into a working system. Instead the prototype is developed quickly to demonstrate some aspect of a system design that is unclear. It can also be developed to help users or clients decide between different features or interface characteristics. Once any problems or uncertainty has been addressed the prototype can be ‘thrown away’ and the principles learned used in the design and documentation of the actual product.
Evolutionary Prototyping - In Evolutionary prototyping you begin by modeling parts of the target system and if the prototyping process is successful you evolve the rest of the system from those parts. One key aspect of this approach is that the prototype becomes the actual production system. This process allows for difficult parts of the system to be modeled successfully in prototypes and dealt with early on in a project.
Other areas to look into will include Agile-> SCRUM, Extreme programming, Paired programming etc.
Tried to keep it short but people write books on this sort of stuff and there is so much to discuss.
Might be worth having a look at:
Incremental and Iterative
The alternative to the waterfall method is "doing it the correct way".
Waterfall seems to make sense if you are on a factory floor assembly line. But I've never seen it work as part of the design process...and sofware development is ALL a design process. And so the waterfall method never really works in the sense that it doesn't help facilitate the creation of high quality product, but rather focuses on process. Process can be great, but what's the point if the product it produces is second rate?
Kanban and Scrum are two of the most commonly used alternatives to Waterfall. I tried to give a good overview and comparison of the different SDLC approaches.
Waterfall relies heavily on massive monolithic phases as mentioned by APC. This is a huge weak point because trying to determine the end product from the start is a fruitless endeavor.
Kanban is slightly cowboy, but I find if you couple it with standups it certainly still has it's place.
Scrum is great for putting pressure on the team and getting ownership on tickets. I've found most places have been going with this one but the downfall of it is some people go overboard with having meetings for everything. Sprint planning meetings, sprint kickoff meetings, daily standup meetings that last 1 hour with 20+ people present, demo meetings, and then finally the post-mortem.
Remember that agile is only as good as you make it and you can easily sink any methodology if you go wild with unrestrained meetings which aren't adding value. Keep it as lean as you can without it being chaotic.
From the top of my head, I can think of ways to palliate the shortcomings of the waterfall model:
Have the coder concentrate on automating the process itself. Automate the transitions between one step and another, so that changes will flow more or less automatically.
Make the process more bidirectional. One principal characteristic in the waterfall model is that changes flow from top to bottom. This is a unidirectional process, and that is part of the problem.
Another thing which would help is (as someone mentioned in an earlier answer) is for the developer to gain a better understanding of the business logic involved, and of what the customer wants, and for the customer to gain knowledge about the characteristics of the development process.
Here are some links about Waterfall model:
http://www.cs.odu.edu/~zeil/cs451/Lectures/01overview/process2/process2_htsu2.html
http://www.buzzle.com/editorials/3-13-2005-67039.asp
We are currently evolving our development processes in an effort to become CMMI compliant (we will start with level 2, and move up from there). We are trying to locate a tool that is inexpensive (or free) that will allow us to develop requirements in the spirit of CMMI. In other words, we need to be able to enter our requirements, track changes to them, provide alerts to individuals when requirements change, perform traceability, etc. Our projects are typically small (typically 3 - 7 developers and a tester or two).
We have looked at many of the commercial tools, but they cost more than we are able to afford. We looked at a few on SourceForge (OSRM and others) but could not find anything that was sufficiently mature that also had the features that we needed.
We are looking for suggestions for a tool that meets the above requirements.
INCOSE is an excellent resource for this sort of question. They maintain a Tools Database that indexes COTS and GOTS System Engineering tools. Some of the tools that perform requirements management also have high-level System Eng functionality (CORE, for example) whereas others are more narrowly-focused (i.e. RequistePro).
Most of these tools will cost money, but may provide some limited free functionality. Workspace.com, for example, provides some free functionality. I would recommend against rolling your own solution, or adapting a tool that is not specifically intended for requirements management, because the hidden cost of getting it going, as well as inefficiency at the intended task could become burdensome.
If you absolutely can't afford to spend any money on a requirements tool, it would be better to use the free functionality from a commercial tool. But don't do that... pony up the cash for RequisitePro and sleep better knowing that you're getting the right tool for the job.
How about starting of with a Wiki? We use TWiki but there are many others available. The wiki we uses
sends an email when any pages change
stores the history of changes to each page
by using the auto-linking of wikis you can create a hierarchy of requirements
This seems to cover most of your items. Wikis like TWiki have plugins which may also help you.
If you only have 3-7 developers on a project using one of the big commercial tools may be far too complex for what you need.
We're heavily into CMMI at our company, but all of our tools are developed in-house.
All I can recommend is to develop your own tools. You will at least have the advantage that it will reflect your business process.
In general, for a new tool, we start off with a tool developed on a project, which is then shared with the rest of the company, if it has been successful. Don't be afraid to use Excel to trace your requirements along with a statuts, which along with a good change control system, such as subversion, gives you a lot of traceability.
A team in the company I used to work for was working on customizing Visual Studio Team System work item templates to handle requirements tracking. One goal, which you should consider as well, was to enable traceability from requirements through to developer work items and then defects. This enables some powerful analysis of which requirements are tied to the most defects.