Software
Software is a set of programs, instructions, and data that tell a computer how to perform
tasks. Unlike hardware, software is intangible and is developed rather than
manufactured. It enables hardware to function and perform useful work.
Software can be classified into different types based on its purpose and usage.
Types of Software
1. System Software:
System software helps manage computer hardware and provides a platform for running
application software.
Examples include Operating Systems (Windows, Linux), device drivers, and utility
programs.
It ensures smooth operation of hardware and other software.
2. Application Software:
Application software is designed to perform specific tasks for users.
Examples include Microsoft Word, Photoshop, Excel, or mobile apps.
It helps users complete personal, business, or educational tasks.
3. Programming Software:
Programming software is used to create other software.
Examples include compilers, interpreters, IDEs (Integrated Development
Environments).
It helps programmers write, test, and debug code efficiently.
4. Utility Software:
Utility software is a type of system software that helps maintain, manage, and optimize
a computer.
Examples include antivirus programs, disk cleanup tools, file compression tools.
It improves performance, protects data, and fixes issues.
Software Requirements
● A
complete description of what the software system will do without
describing how it will do it is represented by software requirements.
● S
oftware requirements are complete specifications of the desired
external behavior of the software system to be built.
Functional Requirements
unctional requirements describe what the system should do. They
F
define the feature, action, and operation the software must perform simply.
● Input: What data it should take from the user.
● Output: What the system should show or return.
● User Interaction: How the user will use the system.
● System Behavior: How the system reacts to user action.
● Data Handling: How the system stores, updates, and deletes data.
Non-Functional Requirements
on-functional requirements are those requirements that describe how a
N
system should work, not what the system should do. They focus on
quality, performance, security, and the overall user experience of the
system.
Types of Non-Functional Requirements
1. Product Requirements
2. Organizational Requirements
3. External Requirements
1. Product Requirements:
roduct requirements describe the qualities and features of the actual
P
software product. They explain how the system should behave, how fast it
should work, and how secure or usable it must be.
● sability: Easy to use.
U
● Efficiency: Use minimum resources.
● Reliability: System should work without errors.
● Portability: Works on different devices or OS.
● Performance: How fast the system works.
2. Organizational Requirements:
rganizational requirements are rules that come from the company's
O
internal policies. They control how the software should be developed,
documented, and maintained.
tandard Requirements: These are company rules about coding style,
S
naming rules, documentation format, and quality standards.
Implementation Requirements: These tell which tools, technologies,
methods, or frameworks must be used for development.
elivery Requirements: These define how and when the software will be
D
delivered to the client or team.
3. External Requirements:
xternal requirements come from outside the company, like government
E
laws, client policies, or industry rules.
Interoperability Requirements: These requirements say that the system
must work with other external systems or devices.
thical Requirements: These requirements ensure the system follows
E
moral rules and does not harm or cheat users.
egislative Requirements: These are government laws and rules that the
L
software must follow.
rivacy Requirements: These requirements protect the user's personal
P
data and keep it safe.
afety Requirements: These requirements ensure the system is safe to
S
use and does not cause harm.
What is SDLC (Software Development Life Cycle)? Explain its phases
with examples.
SDLC (Software Development Life Cycle) is a step-by-step process used to develop software in
a systematic and organized way. It helps ensure that the software is high quality, completed on
time, and meets user requirements. SDLC divides the software development process into
several phases, where each phase has a specific purpose.
The main phases of SDLC are:
i. Requirements Analysis:
Requirements analysis is the first phase of SDLC. In this phase, developers collect and
understand what the user or client wants from the software. All functional (what the system
should do) and non-functional (performance, security, speed, etc.) requirements are identified.
The development team talks to clients, users, or stakeholders through meetings, interviews,
questionnaires, or surveys. The goal is to clearly understand the problem and write it down in a
document called the Software Requirement Specification (SRS).
Example: For a school management system, requirements like recording student attendance or
generating report cards are collected.
ii. System Design:
System design is the phase where the overall structure of the software is planned based on the
requirements gathered.
In this phase, developers decide how the system will work. This includes:
● System architecture
● Database design
● User interface design
Hardware and software requirements
Design documents are prepared to guide developers during coding.
Example:
Creating a diagram showing how student data flows from the registration form to the database.
iii. Implementation:
Implementation is the phase where actual coding of the software takes place.
Developers write code according to the system design. The software is usually divided into
smaller modules, and each module is coded separately. Programmers use specific
programming languages and tools to build the system.
Example:
Writing code to add student details into the database when a teacher submits a form.
iv. Testing:
Testing is the phase where the software is checked for errors or bugs.
Testers ensure that the software works as expected and meets all requirements. Different types
of testing are done, such as unit testing, integration testing, system testing, and user
acceptance testing.
Example:
Checking if the report card is generated correctly for every student and no data is missing.
v. Deployment:
Deployment is the phase where the software is delivered and installed for actual use by users.
Once testing is complete and the software is approved, it is released to the production
environment. Users can now start using the software in real life.
Example: The school management system is installed on school computers, and teachers start
using it.
vi. Maintenance:
Maintenance is the final and ongoing phase of SDLC.
After deployment, the software may need updates, bug fixes, or improvements. Maintenance
ensures the software continues to work smoothly and adapts to new requirements or changes.
Example:
Adding a feature to send SMS notifications to parents or fixing a bug in grade calculation.
Professional Software Development (PSD):
Professional Software Development (PSD) refers to a systematic and disciplined
approach used to design, develop, test, and maintain software systems. The main goal of PSD
is to produce high-quality software that is reliable, maintainable, and meets customer
requirements.
Introduction:
Professional software development focuses on:
● Quality: Ensuring the software works correctly and efficiently.
● Reliability: Making sure the software performs consistently without failure.
● Maintainability: Allowing easy updates, fixes, and improvements in the future.
Characteristics of Professional Software Development:
Planned Approach:
Software development is carried out using proper planning, schedules, and defined steps to
avoid errors and delays.
Team Collaboration:
Developers, testers, designers, and managers work together to achieve project goals.
Use of Tools and Standards:
Professional tools, programming standards, and best practices are used to ensure consistency
and quality.
Focus on Customer Requirements:
Customer needs are clearly understood and implemented to ensure satisfaction.
Importance of Professional Software Development:
● It reduces project failure by following proper planning and processes.
● It ensures a high-quality product with fewer bugs and errors.
● It meets customer expectations by delivering required features.
● It saves cost and time by avoiding rework and mistakes.
● It makes the system easy to use and maintain.
Software Engineering Process – Inputs and Outputs
The software engineering process is a systematic and organized set of activities used to
develop high-quality software. It takes different inputs (information, needs, and
constraints) and transforms them into clear outputs that guide the design and
development of the system.
Inputs of Software Engineering Process
1. Existing System Information:
This includes complete details about the current or old system, such as its functions,
data, performance, and limitations.
Studying the existing system helps developers understand current problems, identify
missing features, and improve efficiency in the new system.
2. Stakeholder Needs:
Stakeholders are individuals or groups who are directly or indirectly affected by the
system.
Their needs and expectations define what the system should do (functional
requirements) and how well it should perform (non-functional requirements). Clear
understanding of stakeholder needs reduces misunderstandings during development.
3. Organizational Standards:
These are internal rules, policies, guidelines, and development practices followed by an
organization.
They include coding standards, documentation formats, testing procedures, and
security policies. Following these standards ensures consistency, quality, and
maintainability of the software.
4. Regulations:
Regulations are legal and government rules that must be followed during software
development.
They ensure that the system meets safety, privacy, and ethical requirements.
Compliance with regulations is important to avoid legal issues and penalties.
5. Domain Information:
Domain information refers to knowledge about the specific field or industry in which the
system will operate.
Understanding the domain helps developers design a system that matches real-world
processes and user expectations.
Outputs of Software Engineering Process
1. Agreed Requirements:
These are the finalized and approved requirements that all stakeholders accept.
They clearly describe what the system must achieve and serve as a foundation for
design and implementation.
2. System Specifications:
System specifications provide a detailed technical description of the system.
They explain system architecture, components, interfaces, and constraints, guiding
developers during coding and testing.
3. System Models:
System models are graphical or structured representations of the system’s structure and
behavior.
They help in understanding, analyzing, and communicating system design before actual
implementation.
Nature of Software
1. Intangible:
Software is intangible, which means it cannot be seen or touched physically. It exists in
the form of programs, data, and documentation. Unlike hardware, software has no
physical shape.
2. Developed, Not Manufactured:
Software is developed through programming and design, not manufactured like
hardware. Once created, multiple copies can be made at very low cost. The main effort
is in development, not production.
3. Does Not Wear Out:
Software does not wear out with use like hardware. However, it may become outdated
due to new technologies or changing user needs. Errors may appear because of
updates or changes.
4. Highly Complex:
Software systems are highly complex due to many components and interactions.
Managing logic, data, and functionality makes development difficult. Complexity
increases with system size.
5. Custom-Built:
Most software is custom-built to meet specific user or organizational needs. It is
designed according to particular requirements rather than mass-produced. This makes
each software system unique.
6. Easily Modifiable:
Software can be easily modified compared to hardware. Features can be added,
removed, or updated through changes in code. This flexibility is a major advantage of
software.
7. Requires Maintenance:
Software requires regular maintenance to fix bugs, improve performance, and adapt to
new requirements. Maintenance continues throughout the software’s life. It ensures
reliability and usability.
8. Evolves Over Time:
Software evolves as user needs and technologies change. New versions are released
with improvements and additional features. Continuous evolution keeps software useful
and relevant.
Software Engineering Practice:
1. Communication:
Communication is the first step in software engineering practice. Developers interact
with clients and stakeholders to understand requirements clearly. Good communication
reduces misunderstandings and ensures correct project goals.
2. Planning:
Planning involves defining project scope, schedule, cost, and resources. Risks are
identified and tasks are organized properly. Proper planning helps complete the project
on time and within budget.
3. Modeling:
Modeling means creating diagrams and designs before coding. It includes system
design, data models, and architecture planning. Modeling helps developers understand
how the system will work.
4. Construction:
Construction is the phase where coding and testing are done. Developers write source
code according to design specifications. Unit testing ensures that each part of the
software works correctly.
5. Deployment:
Deployment is the process of delivering software to users. The system is installed and
made operational in the real environment. User training and support may also be
provided.
6. Quality Assurance:
Quality assurance ensures that the software meets standards and requirements.
Testing, reviews, and inspections are performed to find errors. It improves reliability and
performance.
7. Maintenance:
Maintenance involves fixing bugs and updating the software after deployment. It helps
improve performance and adapt to new requirements. Maintenance ensures long-term
usability of the system.
Software Developer Ethics
[Link]:
A software developer should be honest in all professional activities. They must provide
true information about project progress, skills, and limitations. Honesty builds trust
between developers, clients, and organizations.
2. Protect User Personal Information:
Developers must protect users’ personal and sensitive data. They should follow privacy
laws and implement security measures to prevent data misuse. Protecting user
information ensures safety and trust.
3. Deliver Reliable Work:
A developer should deliver software that works correctly and efficiently. Proper testing
and quality checks must be performed before release. Reliable work increases
customer satisfaction and professional reputation.
4. Avoid Plagiarism:
Developers must not copy others’ code or ideas without permission. Original work
should be created, or proper credit must be given. Avoiding plagiarism maintains
professional integrity and respect for intellectual property.
5. Follow Standards:
Software developers should follow industry standards and coding guidelines. Standards
ensure quality, consistency, and maintainability of software. Following rules and best
practices reflects professionalism.
Developer Skills
1. Technical Skills:
A software developer must have strong technical skills in programming languages,
tools, and technologies. Knowledge of databases, frameworks, and software
development concepts is important. Technical skills help in building efficient and correct
software.
2. Problem Solving Skills:
Developers should be able to analyze problems and find effective solutions. Logical
thinking helps in debugging errors and improving system performance. Good
problem-solving skills are essential in software development.
3. Communication with Team Members:
Effective communication with team members is very important. Developers share ideas,
discuss problems, and coordinate tasks with others. Good communication improves
teamwork and project success.
4. Time Management:
Time management helps developers complete tasks within deadlines. Proper planning
and prioritization of work reduce delays. Managing time efficiently increases productivity
and project quality.
Waterfall Model:
The Waterfall Model is a linear and sequential software development model. Each
phase must be completed before the next begins. It is simple to understand and suitable
for projects with clear requirements.
Phases
[Link] Study:
In this phase, the project’s technical, financial, and operational feasibility is analyzed. It
determines whether the project is possible and worthwhile.
[Link] Analysis:
Detailed requirements of the software are collected from clients and users. These are
documented clearly to avoid misunderstandings during development.
[Link]:
System architecture, database structure, and interface designs are created. This phase
prepares blueprints for the development team.
[Link]:
Actual programming of the software is done according to the design. Developers write
source code and perform unit testing for individual modules.
[Link]:
All modules are combined, and system-level testing is done. This ensures that the
complete software works correctly as a whole.
[Link]:
After deployment, the software is monitored for errors and updated as needed.
Maintenance ensures long-term usability and reliability.
Activities
● Requirement gathering and documentation.
● Designing system architecture and components.
● Writing and testing code.
● Integrating modules.
● Deploying software and providing support.
Advantages
● Simple and easy to understand and use.
● Well-structured and disciplined approach.
● Each phase has clear deliverables.
● Easy to manage due to sequential flow.
Disadvantages:
● Not flexible; difficult to accommodate changes.
● Errors in early phases are costly to fix.
● Customer feedback is received late in the process.
● Not suitable for complex or long-term projects.
Agile Model
The Agile Model is an iterative and incremental approach to software development. It
focuses on flexibility, collaboration, and rapid delivery of functional software in small
parts. Customer feedback is incorporated continuously to improve the product.
Phases
[Link] Gathering:
Requirements are collected in small, manageable chunks called user stories. Changes
are welcomed, allowing the software to evolve with user needs.
[Link]:
A flexible and simple design is created for the current iteration. Designs are lightweight
and can be modified in later iterations.
[Link]:
Developers write code for the current iteration. Coding is done in small increments to
quickly deliver working software.
[Link]:
Testing is performed simultaneously with coding to detect and fix errors immediately.
This ensures each increment is reliable and functional.
[Link]:
Completed software increments are deployed to the user. Users can start using the
software while further development continues.
[Link]:
User feedback is collected after each iteration. It helps refine requirements, improve
features, and adapt the next increment to real needs.
Activities:
● Iterative planning and requirement prioritization.
● Coding and testing in short cycles (sprints).
● Continuous integration and delivery.
● Regular meetings with the team and clients
● Incorporating user feedback in each iteration.
Advantages:
● Flexible and adaptable to changes.
● Frequent delivery of working software.
● Improved customer satisfaction due to continuous feedback.
● Errors and issues are detected early.
Disadvantages:
● Requires active customer involvement throughout the project.
● Less predictable due to frequent changes.
● Documentation may be limited.
● Not suitable for very large or complex projects without strong coordination.
V-Model (Verification & Validation Model):
The V-Model is a sequential software development model where each development
phase is directly associated with a corresponding testing phase. It is called “V” because
its diagram forms the shape of the letter V, showing development on the left side and
testing on the right.
Phases:
[Link] Gathering and Analysis:
Detailed requirements are collected from clients and analyzed. They are documented
clearly to guide both development and testing.
[Link]:
System and architecture designs are prepared. High-level design focuses on overall
system architecture, while low-level design focuses on modules and components.
[Link]:
Developers write code according to the design specifications. Each module is built and
prepared for testing.
[Link]:
Testing is done at multiple levels: unit testing, integration testing, system testing, and
acceptance testing. Each testing phase corresponds to an earlier development phase.
[Link]:
After successful testing, the software is deployed to the client’s environment. Users start
using the system for real operations.
[Link]:
After deployment, the software is monitored, updated, and maintained. Errors are fixed,
and updates are applied as needed.
Activities
● Requirement documentation and analysis.
● Designing system architecture and modules.
● Coding and unit testing.
● Integration and system testing.
● Deployment and maintenance.
Advantages:
● Clear and disciplined structure.
● Testing is planned early, reducing defects.
● Each development phase has a corresponding test phase.
● Easy to manage due to well-defined stages.
Disadvantages
● Not flexible; changes are difficult once the process starts.
● Early requirement errors can be costly.
● Less suitable for projects where requirements evolve frequently.
● Requires strict planning and documentation.
Spiral Model
The Spiral Model is an iterative software development model that combines elements of
both Waterfall and Prototyping. It focuses on risk management and repeated refinement
through multiple cycles (spirals) until the final product is complete.
Phases
[Link]
Project objectives, requirements, and resources are identified. A plan is created for the
upcoming iteration of the project.
[Link] Analysis
Potential risks are identified, analyzed, and mitigation strategies are planned. This
reduces the chances of project failure.
[Link]:
Actual software design, coding, and testing are carried out in this phase. Each spiral
produces a prototype or a refined version of the software.
[Link]:
The software is evaluated by stakeholders and users. Feedback is collected to improve
the next iteration of the spiral.
Activities:
● Requirement gathering and planning.
● Risk assessment and mitigation
● Design, coding, and testing.
● User evaluation and feedback.
● Repeating spirals until the final system is developed.
Advantages:
● Focus on risk management and early detection of issues.
● Flexible and adaptable to changes in requirements.
● Continuous user feedback improves software quality.
● Works well for large and complex projects.
Disadvantages:
● Can be expensive and time-consuming.
● Requires highly skilled project management.
● Complexity increases with multiple iterations.
● Not suitable for small projects with fixed requirements.
