Unit-3: Object Oriented Systems Development Life Cycle:
Software development is the life cycle of processes that is comprised of a well-segregated structure imposed for the development of software that might trend in the market. There are multiple processes that occur during the entirety of software development scenario. So, if you are wondering what is software development, you need to know everything about the processes involved in the same.
1-Gathering & Analysis of Requirement:
Before the team of software technicians can cough up the general idea for any software, it is essential for the team to gather the business requirements in this very first phase. At this point, the prime focus of the stakeholders and project managers is to note the exact things needed from any software under consideration. There are several questions to be asked at this stage, which include:
Who is supposed to use this software?
How will the software be used upon completion?
What type of data should be added to the software?
What should be the data output by this software?
Once these general questions are answered, a general outline is created for the software developers to focus on. This data is then analyzed to ensure its validity & any possibility for incorporation of the same. Lastly, a document for requirement specification is prepared which serves as a guideline for the next level of the software development process.
2-Design:
This is the next phase for the software development process. In this stage, the draft design is prepared for the software from the stage-1 requirement specifications. The system designs help in specifying the hardware as well as system requirements. It also helps with the definition of an overall system in software architecture.
The design specifications for the system serve as the input for the following phase of the software development model. In this particular phase, test strategies are developed by the testers by mentioning things to test and the ways to check it.
3-Coding/Implementation:
After receiving the design documents for the software to be created, the work following the design stage is divided equally into various units and modules. This is the stage where actual coding begins. The main focus of the phase is the development of perfect codes by the developers. This particular phase is the longest in the entire protocol.
4-Testing:
If you want to know what is software development; you can never skip understanding the testing stage. This particular stage is very crucial for the developers. If anything goes wrong in the testing stage or any error is noted in the codes, it can lead to the repetition of the coding process, and the cycle goes on till the completion of the same. In this stage, all variants of the functional testing such as integration testing, unit testing, system testing, acceptance testing, and non-functional testing are done.
5-Deployment Stage:
After all the errors from coding are removed during the testing stage, the next step is termed as the deployment stage. The finalized code is implemented into the software and then deployed or delivered to the customers to be used.
As the product is being given to potential customers, the first thing done to ensure that it works fine on a large scale is to go with beta testing. If there is any possibility for changes or there are possible bugs caught during implementation, it is immediately reported to the team that engineers its errors to work fine in real-time. Once the changes are implemented with all the bugs fixed, the final dispersal or deployment is set in motion.
6-Maintenance:
Once the customers start using well-developed software, the actual issues start surfacing with time. This doesn’t mean that the software will get corrupted. However, it might require occasional issues surfacing time and again. This particular process is termed as maintenance for the finalized product or software.
Developing Good Quality Software
Product Operations: The quality criteria specified in this category talks about how easy it should be to handle and how efficiently it should use the resources and give bug-free processing and expected outputs.
Product Revision: The quality criteria specified in this category say that the software should be easy enough to the teat, maintain, and make any changes if required.
Product Transition: The quality criteria specified in this category says that it must be easy to transit the software on any platforms, should be able to share its code with the other languages on the platform, and try to write the code i.e. reusable in future in any other software development.
The attributes of quality software in the above categories are as below:
Correctness: It means the required functionality and correct results. Customer satisfaction depends on the degree to which customer requirements and expectations have been met. It should provide all the functionality desired by the customer.
Efficiency: It means the efficient use of resources. Software is said to be efficient if it uses all its resources ( memory, storage, processor) inefficient manner. The software design and architecture should be such that it gives you a response in the least processing time, using the resources in the best possible way.
Reliability: It means bug-free execution i.e. assured performance, fully verified and validated processes, secured and safe to work when breaking down or power crisis. It should be reliable in all conditions. Reliability is measured in terms of the mean should be in all conditions. Reliability is measured in terms of the means time between failures, mean time to repair the equipment, and mean time to recover.
Integrity: Integrity is related to extent of access to the software by unauthorized users that can be controlled.
flexibility: The software should be developed so that if the user demands any changes in the system at the coding or testing phase. i.e. in the middle of the software development life cycle, then it should be easy to insert these challenges in the existing modules.
Usability: It means that the software must be user-friendly. The software should have hood documentation and user manual which may include the installation and the process of using the software. This makes it easy for the new to learn and operate just says studying the manual.
Testability: It should need less effort to test the program so that it performs its intended function. As the complexity of the program increase, the efforts to test the software also increase.
Portability: It means the software should have the ability to transfer the software from one environment to another.
Reusability: It gives you the concepts of write once and uses many times. For example, writing functions or subprocedures to receive variable parameters. The calling code passes the value to the parameters and the called procedure processes them as needed.
Interoperability: The software development should be so that it can interact with other products. For example, the word processor can interpolate charts from Excel or data from databases. It deals with the interface between software products over a communication network.
Cost effective: The development of the software within cost and budget depends on efficient design and a high level of project management effort.
Maintainability: For all the changes desired by the customer or the user, the developer has to respond fast. And this is possible only if the software design and its architecture are so chosen that changes can be carried out tin the shortest time without affecting the overall integrity of the software. The change could be to correct the mistake, expand its scope.
Use Case Driven Approach for Object Oriented Systems Development
Object-Oriented Analysis
This phase concerns with determining the system requirements and to understand the system requirements build a use-case model. A use-case is a scenario to describe the interaction between user and computer system. This model represents the user needs or user view of system.
It also includes identifying the classes and their relationships to the other classes in the problem domain, that make up an application.
Object-Oriented Design
The objective of this phase is to design and refine the classes, attributes, methods, and structures that are identified during the analysis phase, user interface, and data access. This phase also identifies and defines the additional classes or objects that support implementation of the requirement.
Prototyping
Prototyping enables to fully understand how easy or difficult it will be to implement some of the features of the system.
It can also give users a chance to comment on the usability and usefulness of the design. It can further define a use-case and make use-case modeling much easier.
Implementation
It uses either Component-Based Development (CBD) or Rapid Application Development (RAD).
Component-based development (CBD)
CODD is an industrialized approach to the software development process using various range of technologies like CASE tools. Application development moves from custom development to assembly of pre-built, pre-tested, reusable software components that operate with each other. A CBD developer can assemble components to construct a complete software system.
Rapid Application Development (RAD)
RAD is a set of tools and techniques that can be used to build an application faster than typically possible with traditional methods. It does not replace SDLC but complements it, since it focuses more on process description and can be combined perfectly with the object oriented approach.
Its task is to build the application quickly and incrementally implement the user requirements design through tools such as visual basic, power builder, etc.
Incremental Testing
Software development and all of its activities including testing are an iterative process. Therefore, it can be a costly affair if we wait to test a product only after its complete development. Here incremental testing comes into picture wherein the product is tested during various stages of its development.
Reusability.
In OOP, The concept of inheritance provide the idea of reusability. This means that we can add additional features to an existing class without modifying it. This is possible by deriving a new class from the existing one. The new class will have the combined features of both the classes. The real appeal and power of the inheritance mechanism is that it allows the programmer to reuse a class that is almost, but not exactly, what he wants, and to tailor the class in such a way that it does not introduce any undesirable side effects into the rest of the classes.
Fig.5 : Property inheritance
Note that each sub class defines only those features that are unique to it. Without the use of classification, each class would have to explicitly include all of its features.
No comments:
Post a Comment