What do you mean by a Software?
Software is more than just a program code, A program is an executable code, which serves some computational purpose. Software is considered to be collection of executable programming code, associated libraries and documentations. Software when made for a specific requirement is called software product.
Software characteristics components:
- Fault tolerance
- Test ability
- In time
- In resource
Software Engineering provides a standard procedure to design and develop a software.
Crisis in developing a Software:
- Lack of communication between Customer and developer.
- The maintenance of software was often not considered.
- Document the structure of code/ flow of data in the software.
- Changes in software can sometime require more resources.
Software Development Life Cycle:
This is the first step, to understand services/ functionality requested by the client.
Understanding the requirement given by the client, the requirements are contemplated and segregated into user requirement, system requirements and functional requirements.
Analyze the software, can it fulfill all requirements of the user and if there are any possibility of software not being useful now from financially or technological perspective.
Two types of designs are made, logical and physical design, along with Data flow diagrams and some pseudo codes.
5.Coding: Actual Implementation of code.
6.Testing: Testing all the features and functionalities of code
7.Operation and Maintenance: More efficient and less errors while operating the software along with maintaining it.
Software development Paradigm:
Select a strategy to develop the software, A software development paradigm has its own set of tools, methods and procedures which are expressed clearly and defines software development life cycle.
This SDLC model includes gradual execution of every stage completely. This process is strictly documented and predefined with features expected to every phase of this software development life cycle model.
It is a combination of the Iterative and Waterfall SDLC models with the significant accent on the risk analysis.
The main issue of the spiral model is defining the right moment to make a step into the next stage.
In the agile methodology after every development iteration, the customer is able to see the result and understand if he is satisfied with it or he is not.
This is one of the advantages of the agile software development life cycle model
For more information,
Planning and Management of Software Projects:
It is planning, organizing and managing resources for successful completion of specific project goals. It includes activities such as
- Project planing
- Estimation of the work
- Estimation of resources required
- Project scheduling
- Risk management
There are three constraints for any software project.
software metric :
Software metrics are numerical data related to software development, It quantifies a characteristic of a process or product. They relate to the four functions of management as follows:
- Planning: Cost estimation, training, planing, resource planning, scheduling and budgeting.
- Organizing: Size and schedule metric
- Controlling: Track the Software development activities
- Improving: Identify where improvement efforts should be concentrated and measure the effects of process improvement efforts.
Indicator is used to denote a representation of metric data that provides insight into an ongoing software development project. Indicators are metrics in a form suitable for assessing project behavior or process improvement. Indicators may include the compassion of actual values versus the plan, project stability metrics or quality metrics
Project Size estimation techniques:
Estimation of the size of software is an essential part of Software Project Management,
- Lines of code: Total number of lines of source code in a project.
- Total Number of processes in detailed data flow diagram.
- Function points.
1.Constructive Cost Model (CoCoMo):
Regression model based on LOC, It is a procedural cost estimate model for software projects and often used as a process of reliability predicting, the various parameters associated with making a project such as size, effort, cost, time and quality. The key parameters which define the quality of any software products,
- Effort: Amount of labor that will be required to complete a task.
- Schedule: Time required for the completion of the job.
There are different models of CoCoMo to predict cost estimation at different levels, based on the amount of accuracy and correctness required.
- Organic: Easy Problem statement
- Semi detached: Between organic and Embedded
- Embedded: Difficult Problem statement
Types of models:
1.Basic model: Can be used for quick and slightly rough calculations of software costs. Not very accurate. It assumes effort is only a function of the number of lines of code and some constraints evaluated according to the different software system.
2.Intermediate model: Various other factors are taken into account, know as Cost Drivers for evaluating effort in this model
- Required software reliability extent
- Size of the application database
- Complexity of the product
- Run time performance
- Memory constraints
- Virtual machine environment
- Turn about time
- Analyst capability
- Software engineering capability
- Applications experience
- Virtual machine
- Programming language
- Use of software tools
- Application of software engineering methods
- Required development schedule
3.Detailed/Complete model: The detailed model uses different effort multipliers for each cost driver attribute, the whole software is divided into different modules, then we apply CoCoMo in different modules. The Six phases of detailed CoCoMo are:
- Planning and requirements
- System design
- Detailed design
- Module code and test
- Integration and test
- Cost Constructive model
The effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software life cycle.
Data Flow Diagrams:
A data flow diagram shows the way information flows through a process or system. It includes data inputs, and data outputs, data stores and various sub processes.
They visually represent systems and process that would be hard to describe in a chunk of text. Visualizing each element makes it easy to identify inefficiencies and produce the best possible system. There are two types of DFD’s,
1.Logical data flow diagrams focus on,
- What happens in a particular information flow
- What information is being transmitted
- what entities are receiving that info
- What general processes occur.
2.Physical data flow diagrams focus on,
- How things happen in an information flow
- These diagrams specify the software, hardware, files, storage and people involved
For more information,
Levels of DFD:
0 Level DFD: Context level, showing only main, input and output processes.
For level 0 diagram, refer to the requirement analysis document and draw input, main process/ system and output only in the DFD. This of it as an abstract view.
1 Level DFD: Showing data stores, first division of main processes
A level 1 DFD notates each of the main sub processes that together form the complete system. Think of it as an exploded view. To construct Level 1 DFD,
- Identify processes
- Identify data stores
- Draw the data flows
- Each process should have an input and an output, each data soted should have an input and an output.
2 Level DFD: Decomposition of processes
It can be used to plan or record the specific/necessary detail about the system’s functioning.
Key benefits of project scheduling software:
- Define the project workflow and keep focused on the right tasks.
- Identify and track project’s critical path to leverage flex in the schedule
- Waste less time rescheduling with priorities and dependencies
- Free up time and energy by setting the tool to provide automatic deadline reminders.
- Easily visualize, compare, spot holes and adjust your resource availability
- Generate reports on utilization, demand and capacity.
Software risk management and assessment
It uses a variety of technological advancements and requires high levels of knowledge. Five types of risks in software project management,
- New, unproven technologies
- User and functional requirements.
- Application and system architecture
To reduce risk, we either use Monitoring or Mitigating.
1. Monitoring includes:
- Publish project status reports and include risk management issues
- Revise risk plans according to any major changes in project schedule
- Review and prioritize risks, eliminating those with lowest probability
- Brain storm on potentially new risks after changes to project schedule or scope
- Accepting the risk
- Avoiding the risk
- Control the impact of the risk
- Transfer the risk handling task
- Continue Monitoring the project for checking the impact of the risk
Requirement And Analysis
To analyze requirements unambiguously, we need:
- Types of requirements
- Software Requirement Specification
- Pictorial diagrams such as DFD, ER, use case diagram, …
Software Requirement Specification is essentially documenting all the information about the project. For more information on SRS, click the 2 nd point.
Design is not just what it looks and feels like. Design is how it worksSteve Jobs
The Design phase deals with transforming the customer requirements as described in the SRS documents into a form implementable using a programming language. It can be divided into three levels of phases of design:
Specification of the interaction between a system and it’s environment. This phase proceeds at a high level of abstraction with respect to the inner workings of the system.
Attention is focused on the dialogue between the target system and the users, devices and other systems with which it interacts including people, other systems and devices etc.
Specification of the major components of a system their responsibilities, properties, interfaces and the relationships and interactions between them.
The overall structure of the system is chosen, but the internal details of major components are ignored. Challenges to tackle,
- Gross decomposition of the systems into major components.
- Allocation of functional responsibilities to components
- Component interfaces
- Component scaling and performance properties, resource consumption properties, reliability properties and so forth.
- Communication and interaction between components
- The architectural design adds important details ignore during the interface design.
Specification of the internal elements of all major system components, their properties, relationships, processing and often their algorithms and the data structures. It may include,
- Decomposition of major system components into program units.
- Allocation of functional responsibilities to units
- User interfaces
- Unit states and state changes
- Data and control interaction between units
- Data packaging and implementation, including issue of scope and visibility of program elements.
- Algorithms and data structures.
Software Design concepts that span both traditional and object oriented software development,
1.Abstraction: There are many levels of abstraction that can be created,
- At the highest level of abstraction, a solution is stated in board terms using the language of the problem environment.
- At lower levels of abstraction, a more detailed description of the solution is provided.
2.Architecture: Structure of program components, the manner in which these components interact, and the structure of data that are used by the components. The following set of properties,
- Structural properties.
- Extra-functional properties
- Families of related systems.
3.Pattern: It describes a design structure that solves a particular design problem within a specific context. Each design patterns provides a description, that enables a designer to determine,
- Whether the pattern is applicable to the current work
- Whether the pattern can be reused
- Whether the pattern can serve as a guide for developing a similar, but functionally or structurally differ pattern.
4.Separation of Concerns: Suggests any complex problem can be more easily handled if it is subdivided into pieces that can each be solved or optimized independently.
By separating concerns into smaller, and therefore more manageable pieces, a problem takes less effort and time to solve, it further helps in
- Functional independence
5.Modularity: Software is dived into separately named and addressable components called modules, that are integrated to satisfy problem requirements. Advantages of modularity,
- Development can be easily planned
- Software increments can be defined and delivered
- Changes can be more easily accommodated
- Testing and debugging can be conducted more efficiently
- Long term maintenance can be conducted without serious side effects.
6.Information Hiding: A module is inaccessible to other modules that have no need for such information. It can be implemented by defining a set of independent modules that communicate with one another only that information necessary to achieve software function.
7.Functional Independence: A direct result of separation of concerns, modularity and the concepts of abstraction and information hiding. Independence can be evaluated by
- Cohesion: How strongly each of the functions are related within a program module.
- Coupling: How much each of the program modules are dependent on the other program modules.
8.Refinement and improvement: Refining and improving our Code, in order to reduce ambiguity in the code and optimize it.
9.Aspects: Cross cutting concern that must be accommodated as refinement and modularization occur.
10 Refactoring: Simplifying the design of a component without changing its function, to further optimize the code.
11. Object oriented Design concepts: Using OOPS concepts such as classes and objects, inheritance, polymorphism, …
12.Design Class: Refine analysis classes by providing detail needed to implement the classes and implement a software infrastructure the support the business solution. Five types of design classes,
- User interface classes
- Business domain classes
- Process classes
- Persistent classes
- System classes
For more information,
Software testing :
The three main goals of Software Testing are,
- Defect Detection: Finding bugs in the software
- Defect Prevention: Anticipate and prevent defects from occurring
- User Satisfaction
It is fundamental to ensure the software quality and t have a workable functional software at the end of the project.
A good test case design technique is crucial to improve the quality of the software testing process. This helps to improve the overall quality and effectiveness of the software.
- White box testing: It is based on the knowledge about the internal logic of an application’s code. Internal software and code working should be know for performing this type of testing. Also know as Glass box testing.
- Black Box testing: Internal system design is not considered in this type of testing. Tests are based on the requirements and functionality.
Writing Good Test cases: Ensure that all positive scenarios and negative scenarios are covered.
- Write in simple and easy to understand language.
- Use active voice instead of passive voice
- Use exact and consistent names
Characteristics of good test case:
- Accurate: Exacts the purpose
- Economical: No unnecessary steps
- Traceable: Capable of being traced to requirements.
- Repeatable: Can be used o perform the test over and over.
- Reusable: Can be reused if necessary.
Other types of testing:
- Unit testing
- Integration testing
- System testing
- Alpha and Beta testing
Two types of developments of software system:
- Program Driven Development, program is written first and then tested using various methods.
- Test driven development, test cases are written first and then the program is made to pass those test cases.
Software quality assurance (SQA): It is a process which assures that all software engineering process, methods, activities and work items are monitored and comply against the defined standards.
For more information,