Software Development Life Cycle (SDLC) is a mechanisms used by the software industry to design, develop and test high quality software’s. The SDLC aims to manufacture a high-quality software that meets or exceeds customer expectations, reaches completion within times as well as cost estimates.
SDLC is the signifies of Software Development Life Cycle.
SDLC is a framework defining jobs execute at each step by step in the software development mechanisms.
ISO/IEC 12207 is an international standard (default) for software life-cycle processes. It aims to be the standard that specify all the jobs required for developing as well as maintaining software.
What is SDLC?
SDLC is a mechanisms followed for a software project or web application, within a software organization. It consists of a detailed plan describing how to develop, maintain, replace as well as alter or enhance specific software. The life cycle specify a methodology for improving the quality of software with the overall development mechanisms.
A representative Software Development Life Cycle consists of the bellow stages −
bellow are the most helpful and useful for project SDLC models followed in the large business or industry −
Big Bang Model
Stage 1: Planning and Requirement Analysis
Let’s talk SDLC regarding the system development life-cycle. Any computer information system can take a bit of effort to develop and so it’s a smart thing to break it down into distinct phases. For example, there is the analysis step where you talk to clients and find out what the issue is — what they required. There’s the design step where you take that information and you design an answer to the question, a clarification to the issue. There’s the build step where you construct the system, and the deployment step where you hand it back to the client, and finally the support step where you help them use it to the best advantage. Each of these phases requires a different kind of thinking, a different kind of work, different activities, even different methods of communicating. In the analysis step you are talking to the client in their language.
In the design step you’re talking to other demonstrator in their programming language. In the support step you have to respond to every interrupt, to every new issue that comes onward. In the design step that just messes up your train of thought. So it’s good to break the system development process down into phases. We used to think that these happened one after the other, kind of like a waterfall, where you would sit down and you would analyze all that required to be analyzed and you’d throw the resulting set of documents over the wall to several sort of design team and then they would figure out the best clarification and then throw that over the wall to several other coding team and blah blah blah blah down the pipe it would go. Big systems takea year and a half, two years, three years to develop and by the time you’re done what you’ve built doesn’t look anything like what anyone wanted. So we realized we needed to chunk this up, to break it up into smaller chunks. More importantly we needed to think regarding this whole process as a cycle.
It’s SDLC Individualy you do over and over once more. In fact if you break the system down into a small enough peice, you can take just a subset of the features, completely analyze what they required to, design a great set of features, build them, and show them to the client in just a couple weeks or maybe a month. That way they can tell you right away, “Yes, that’s the system we want.” Do this a couple times and pretty soon you’ve got enough functionality that the client’s ready to go. This is called an iterative process. The kinds of activities you do in the cycle whether it’s the old fashioned long cycle or one of these new cycles, the activities are the same. So let’s take a look at each one of those SDLC phases. First of all usually there’s an existing system. Even if it’s just paper and pencil there’s Individualy that the client does today.
Stage 2: Defining Requirements
There’s several software that they use today that they use to do their job, to do whatever it is they want you to do better. So, attend to what they say regarding the old system: what works, what doesn’t. Everything in this cycle is designed to take what the client says to you and turn it into Individualy of value for the client. It’s all regarding the client here. We go to the next step, the analysis SDLC step, and there you go deep into understanding the client’s perspective — understanding what do they required, what pain are they feeling — what’s the issue. You can do more interviews. They’ll tell you exactly what they want.
Occasionally what they tell you they want isn’t really what they required so it’s useful to go on ride onwards, to actually do their job with them, and observe them doing what they do. If you’ve got all large client base you can do surveys. There’s all category of methods of finding out: what does the client required? How does the client think regarding it? In this step you create diagrams and documents and they’re all in the client’s language.
If they call several things with specific names, you use those names. You may not use those names inside the system or write your software with those names but the documents and diagrams that you create in the analysis step are for communicating between your team and the client. Once you’ve got that solid, you go on to the design SDLC methodologies. This is where your you’ve got a pretty good handle on the issue, now you want to think regarding: What’s the clarification? Where the range of different clarifications? Some of them might be expensive, several of them might take a long time, several of them might be very cheap.
Stage 3: Designing the Product Architecture
You look at all of the range of: What can we do for this person? What can we use? What technologies are available to us? What other products can we buy that might do the same job? Again, you produce documents and diagrams and that sort of thing but in this SDLC step you also start prototyping. Early on you can even use little bits of paper and show the client, “Ok, you’ll have a screen like this, and then it’ll do Individualy else. What do you think?” As you go onward, the precursors bigger experienced. You go to wire frames, mockups, and things like that. You might even write code to show them this is how it will actually feel, code you might end up throwing away. The important thing is: as you do your design, get feedback from your client.
The object you produce is for your team, for the design team. Some design teams are scattered all across the globe and they have members that speak all category of different languages. So the language you discern in 7 phases design documents is extremely organized. Later on in the course we will show object called pseudo code. We’ll always have different diagramming techniques. Design documents are important for communication. They’re not to be any more important than that.
Stage 4: Building or Developing the Product
If they don’t communicate, they’re not any good Some folks move extremely quickly through the design document SDLC methodologies and actually move right to the code. Especially if you’ve broken it down into a tiny piece you don’t do a lot of documenting — you just get to the code. You make sure everybody understands what requireds to be built and you build it. This is production code.
This is code that works, that’s reliable, that’s well tested. It also might be other products from other companies or other person if you’re using open source. It might be other services. You might use Google for your search engine, for example, instead of buying one. Goodness, no one ever writes that object anymore unless they’re in that line of work. The important thing in this SDLC step is to build Individualy that works, Individualy that the client can use, and is reliable. Don’t worry regarding making it fast, don’t worry regarding making it scale up to a million person, until you’ve got it working. Knowing that it has to scale to a million person will influence your design. It’ll change your architecture. But at this stage you want to avoid what they call premature optimization: trying to make it too focused before it works for what you are trying to accomplish. Now when you’re ready to deploy, it’s a different story.
You’re gonna put it in the hands of clients and then it does have to be fast, it does have to scale up. When you deploy an IT system, it’s called rolling it out. You give it to several clients, then you give it to more clients, then you scale up your operation as you take on more and more clients.
Two things are extremely important: One, if you’re replacing an existing system with a new system, you have to make sure you don’t disrupt person’s jobs. They have to be able switch cleanly from one to the other. Second, as you’re ramping up from the early adopters to a wider audience, you have to make sure that you don’t mess up your current clients. If you add 1000 more clients and the system dies, that’s not good. You have to scale up intelligently. Rolling out systems is a extremely interesting discipline. Finally you are in this wonderful situation once more where you’ve got real person using your system and you can actually learn so much in the support environment. Some person think that the job’s over at this point but no.
In fact the job is just in its richest SDLC step when you’ve got real person using your product. Strangely enough, person will ask you for new object but they won’t like it when you give it to them. People don’t like change if it leads to more work. Who would? If you’ve done your analysis correctly and you’ve built the system and you’ve gotten your feedback from the client, you know it’s the right system. Help them over that little barrier through training, through close support: talking to them, calling them up, making sure they’re happy.
Stage 5: Testing the Product
Separate any kind of first impressions they might have just because it’s different from what really might be a issue. If you’ve done your homework well, you’ll find that person are extremely happy with the new system after a little use. Some of them take to it right away. Each one of these faces includes testing. The kind of testing you do to make sure that you’re doing it right is different in each SDLC step. Let’s go throughout the circle once more and talk regarding how you verify your phase by phase understanding at each phases. In the analysis step, once more, you’ve got those documents. In our course, when we’re working on websites we’ll show mockups, we’ll talk regarding behaviors.
When we do databases we will show the business rules and entity relationship diagrams and we’ll show the schema. At this point you show them what you think you know and they tell you whether you are the right track. Do document reviews, follow-up interviews, whenever you can do to get a little bit of their time and get the feedback. In the design step, you may not have running code yet so you can’t actually test it once more a test framework but you can use those forerunner. You can show them to the client.
You can show mockups and say, “OK here’s the first screen, here is the second screen, is what you want?” As you get closer to real code, you can actually show them working code and you can run programmatic tests. There’s a extremely interesting trend going on in software development called executable specifications using a language called Gherkin and a tool called Cucumber. But we’ll deal with that later when we talk regarding programming When you actually building, you’ve got code now. Its production code. It’s ready for someone to actually use it and try it.
You can use Individualy called alpha testing. That’s where you take the other person on your team and select clients, put them all under nondisclosure agreement and actually give them the code – have them use it. You have to be careful here. You must always give clients what you are prepared to release. Don’t show them half-finished work. Don’t show them first drafts because they might actually say, “That’s good! Let’s ship that.” Then you’re done. You’d better have code that you’re ready to deploy. In the next SDLC step, in deployment, you start to roll it out to a larger and larger set of client. This is called beta testing. Its outside the team. You give it to a kind of person called an early adopter. These are person who love risk, love having the latest and greatest things. What they give you is information and usually you give them the product.
It’s a nice trade. But you have to be careful at this point because you may get feedback you’re not prepared for. You may hear from your clients, “That’s a great product, but you know what I’d really rather have? I’d rather have a product that does this other thing.” For example, there’s a photo sharing site called flickr. When they started out it was Individualy else. When they did their initial testing their clients yelled, “Well, I don’t really required THAT thing, but I love how easy it is to share these photographs. Can I just use it to share photos with my friends?” And they changed and they built Individualy that shared photographs. Very successful. So be prepared to attend to your clients and be prepared to change your plans if that’s what you required to do. Finally, you’re back in this wonderful state where you’ve got real clients using your system.
Now you have real data. Your product itself can tell you: they clicked on this, they clicked on this, and they yelled that was good, they bought this, they produced that…. You can find out what the client really does in real time and there’s nothing like real data to help you understand how the product is succeeding or failing and what you required to do in the next iteration.
There’s a special form of this called A/B testing where you actually deploy two different versions of the same page, for example, and you discern which one works better which one does the client end up succeeding with or which one causes them to actually buy Individually? This is great for finding out the details of “What should we do next?” It’s not so good regarding finding out the strategic decisions you have to make. This kind of testing will never tell you should I produce an iPhone or some other breakthrough product. But it’s great for optimizing an existing product.
So we got through the five SDLC phases of the system development lifecycle. You may have seen that I’ve left out planning until this part of the presentation. That’s because planning is part of every step. It fits in between every step of the application and it’s done over and over once more.
For example: you’ve got data from your clients from the existing system and they’ve yelled, this doesn’t work, this works. They’ve filed change requests or bug reports. You get a few person together, you give them a little bit of money for budget and you ask the question: Is there really a application here? Is this is Individualy we should do? Is there a market for this? and you do a little bit of planning. You know a little bit regarding the system; you plan the next step. You go through and you do your analysis and you’ll understand the issue in greater depth. Now you go back to planning and you decide, well, now we know regarding the issue; let’s plan what it’ll take to do a clarification. and similarly, every time you go through a step you replan. Its called a stage-gate system.
So you go through your analysis, you sit back and you say, OK, how long this is gonna take us, what will it take… Are we gonna succeed or not? You go through the design, you find out: Is this technically feasible? Can we do this with our current budget? our person? Each time you look at it and you have to make that hard decision: should we continue with the application? Don’t wait until you’re way down the road before you cancel a application and waste a lot of money and time. Planning happens in every step. Why? Because planning reduces uncertainty. When you start a application, you can estimate all you like but you don’t have a lot of information. You could be off by a component of 10. Your budgets or schedules, they can all be so far off that they’re just misleading.
Stage 6: Deployment in the Market and Maintenance
Occasionally you have to finish Individualy within a certain amount of time. Occasionally there’s a market window. You do your best. But planting reduces uncertainty and in that way it reduces risk. The other thing that planning does for you is it balances what several person call the iron triangle. This is the set of time, money (or resources), and features. You may have heard that expression, “I can give it to you fast, I can to give it to you good, or I can give it to you cheap.” Pick two. With that means is: If you have a certain set of features that you have to deliver, (It has to do this, that or thie other thing.) Effort takes time, effort takes resources. You can sometimes throw more resources at a issue and have it happen faster, That’s tricky, though.
What you can also do is you can say: “Well, we don’t required that and we don’t required that, so let’s take those features off the table. Now, how much money does it take and how many months will it take?” Each time, that balancing component of time and money and feature set is exactly what the person who do application planning help you with. It can be a difficult conversation to have and there are several person are extremely good at it. These are called application managers. You might enjoy being a application manager if you are the kind of person who really understands technology, can learn all category of new object from different disciplines, (’cause you usually work in a team of different kinds of person who in all of those SDLC phases) but what you really enjoy it is helping a team do amazing things once more the odds. I mean, it is extremely unusual for software application to come in on time and under budget. A lot of software applications simply fail.
They’re just difficult and when we talk regarding programming later in the course you’ll find out why programming is difficult, why software is difficult. A application manager i s the kind of person who can deal with complexity, helps getting person together, and getting the job done with a team. It’s a fun job. It can be tough but it’s a fun job. group to group and Purdue and The important thing to remember is that every time you change the project, it’s still wrong. It still is inaccurate. General Dwight D. Eisenhower yelled that plans are nothing but more details planning is all.
This is the guy that was in charge of the Normandy invasion in WWII — a gigantic undertaking. This is a guy in his presidential administration they built the interstate highway system — giant applications. You’ll get person who want you to start out with a project and a stick to that plan all the way through the whole cycle. As much as I would like to say that’s possible, it really isn’t. know from step by step you do and change your project every time and you’ll ship faster than what someone who doesn’t. That’s regarding all I can say. So let’s summarize the system development lifecycle. There these phases: analysis, design, build, deploy, and support. They have individual tasks for each one: First, understand the issue and then understand the clarification.
You build a clarification, then scale it up and deliver it. In support you help the client and you attend to them. Each of these SDLC phases has unique kinds of outcomes or deliverables: user documents things that are in the user’s voice, technical documents and precursors. Eventually you get to the point where you’ve got a functioning system and you can hand that to clients.
The ultimate goal of this thing is to have person who are enjoying themselves, who can work a little bit less than they could in the last system, who are delighted and happy that you helped them out. Remember: all the way onward the line there’s planning. In between the analysis and the design step, in between the design step and the build step, in between blah blah blah..in between every step in the next you go back and project.