Software Crisis Software Domains Software Myths Elements of Software Programming Paradigms

Definition: A historical Thrust Areas (Classification of Management Myths: Technical Components: Procedural Programming:
challenge in software Software by Purpose): Myth: Adding more Hardware: Physical computing Focus: Functions and
development marked by System Software: Directly programmers speeds up devices (e.g., processors, algorithms.
failures in meeting deadlines, interacts with hardware and delayed projects. Reality: This sensors). Examples: C, Pascal.
budgets, and quality supports other software. often slows progress due to Software: Programs, data Structure: Sequence,
standards. Examples: Operating systems, training and coordination structures, and documentation. decision-making, looping.
Characteristics: compilers. efforts. Database: Structured Object-Oriented Programming
Projects ran over budget and Application Software: Performs Myth: Outsourcing will relieve collections of data accessed (OOP):
over time. user-specific tasks. Examples: management of all by software. Focus: Objects with attributes
Software was inefficient and Word processors, browsers, responsibilities. Reality: Lack Non-Technical Components: and behaviors.
often of low quality. games. of internal control leads to People: Stakeholders like Key Features:
Failed to meet initial Engineering/Scientific mismanagement. developers, users, and Encapsulation: Data and
requirements. Software: Used for specialized Customer Myths: customers. methods are bundled.
Projects became engineering and scientific Myth: General objectives are Procedures: Detailed Inheritance: Reuse and extend
unmanageable and the code tasks. Examples: CAD tools, sufficient to start development. workflows and guidelines. functionality.
was difficult to maintain. simulation software. Reality: Vague objectives lead Documentation: Manuals, help Polymorphism: Same
Some projects were never Embedded Software: to confusion; detailed files, and user guides. operation behaves differently
completed. Designed for embedded requirements are essential. for objects.
Key Issues: systems with limited Myth: Software is flexible and Abstraction: Hiding internal
Complexity: Growing intricacy resources. Examples: changes can be easily details.
of software projects. Microcontroller firmware, IoT implemented. Reality: Late Examples: Java, Python, C++.
Changing Requirements: device software. changes cause significant Functional Programming:
Frequent modifications during Web Applications: Software costs and delays. Focus: Mathematical
development. that runs over the internet. Practitioner Myths: functions, immutability.
Solutions through Software Examples: E-commerce sites, Myth: Once the code is Examples: Haskell, Lisp.
Engineering: social media platforms. running, the work is done. Logic Programming:
Reduce complexity with AI Software: Uses machine Reality: Maintenance can Focus: Problem-solving using
systematic processes. learning, NLP, or computer account for 60–80% of total logic and rules.
Enhance clarity in vision. Examples: Chatbots, effort. Examples: Prolog.
requirements and design. recommendation systems. Myth: The working program is Declarative Programming:
Improve quality and reliability. Critical Factors (Attributes for the only deliverable. Reality: Focus: Defining what the
Ensure adaptability for Evaluation): Documentation is critical for program should achieve, not
changing requirements. Functionality: Does the future updates and debugging. how.
Adopt proper tools and software perform required Examples: SQL, HTML.
methods for development. tasks?
Reliability: Can it consistently
function without failure?
Usability: Is it user-friendly and
easy to operate?
Efficiency: Does it use
resources optimally?
Maintainability: Can changes
and updates be made easily?
Portability: Can it run on
different platforms?

Q1: Evolution of Software Q2: Software Component Q3: Software Classification Q4: Software Crisis and Purpose of Prototyping
and its Importance on Thrust Areas and Critical Relevance of Software
Definition: The evolution of Factors Engineering Prototyping is the process of
software refers to the Definition: A software creating an early model of the
continuous development, component is a modular and Software Thrust Areas: Software Crisis: The term software to:
improvement, and adaptation reusable unit of code that System Software: Software refers to the difficulties faced Understand user requirements
of software systems to meet performs a specific function that manages hardware in software development clearly.
increasing user demands and and can be independently resources. Example: during the 1960s-80s due to Identify missing functionalities
changing environments. deployed. Operating systems, compilers. increasing project failures. or ambiguous requirements.
Characteristics of Software: Importance of Software Programming Language: C, Causes of Software Crisis: Gather feedback early and
Intangible: Unlike hardware, Components: Assembly. Projects ran over budget and reduce development risk.
software cannot be seen or Reusability: Components can Application Software: Software time. Improve communication
touched. be reused across different for end-user tasks. Example: Low-quality software with between developers and
Customizable: Software can projects. Word processors, many bugs. users.
be designed for specific tasks Maintainability: Changes in spreadsheets. Programming Changing requirements Types of Prototyping:
or environments. one component do not impact Language: Java, Python. mid-development. Throwaway/Rapid Prototyping:
Complexity: Software often others. Embedded Software: Software Increasing software A temporary model created
has intricate components and Scalability: Components allow for embedded systems with complexity. quickly to understand
interdependencies. incremental development and limited resources. Example: Lack of standardized requirements. Once feedback
Changeability: Software must scaling. Microcontroller firmware. development methods. is collected, it is discarded.
adapt to user needs and Reduced Development Time: Programming Language: C, Relevance of Software Example: Mockups for user
technologies over time. Speeds up development by C++. Engineering: interfaces.
Non-wearable: Software does reusing pre-built modules. Web Applications: Software Systematic Approach: Ensures Evolutionary Prototyping: A
not physically degrade but Improved Quality: that runs in browsers. organized and methodical prototype that evolves into the
requires maintenance. Standardized components Example: E-commerce sites, software development. final system through iterative
Replicability: Software can be reduce errors and bugs. social media platforms. Reduces Complexity: Breaks improvements. Example:
reproduced easily without Programming Language: software into manageable Incremental development of a
additional cost. HTML, CSS, JavaScript, components. web application.
Challenges for Designers: Python. Improves Quality: Use of Incremental Prototyping:
Rapidly Changing AI Software: Software that proper testing ensures fewer Dividing the system into
Requirements: Software users uses machine learning or data bugs. smaller parts and prototyping
often require updates and new processing. Example: Efficient Resource them individually. Combines
features during development. Chatbots, recommendation Management: Optimizes time, these parts later to form the
Scalability Issues: Ensuring systems. Programming budget, and personnel. final system. Example: Adding
software remains efficient as Language: Python, R. Scalability: Makes software one module at a time to an
the project grows. Critical Factors (Attributes): adaptable to future changes. e-commerce site.
Maintaining Quality: Avoiding Functionality: Performs Extreme Prototyping: Used for
bugs and ensuring reliability. required tasks effectively. web development, dividing into
Cost and Time Management: Reliability: Consistently three phases: Create
Keeping development within performs without failure. wireframes. Develop functional
budget and deadlines. Usability: User-friendly screens. Implement services.
Resource Constraints: Limited interface and experience. Use in Software Development:
availability of skilled personnel Efficiency: Optimal use of Prototyping is used to:
and tools. resources. Reduce misunderstandings
Maintainability: Easy to debug, between developers and
update, and enhance. stakeholders.
Portability: Works on different Enhance usability by testing
platforms. user interfaces.
Save time and cost by early
detection of issues.

Q2: Defining Quality of HMI (Human-Machine Entity: An object or concept Requirement Engineering Phases of Software
Software and ISO-9001 Interface): HMI refers to the that can have data stored Development
interaction between users about it. Example: A "Student" Definition: It is the process of
Defining Quality of Software: (humans) and systems or a "Book". identifying, analyzing, The software development
Software quality refers to how (machines). It ensures Relation: A relationship or documenting, and validating lifecycle (SDLC) has 3 main
well the software meets: usability and accessibility of association between entities. software requirements. phases:
Functional Requirements: software. Example: "Enrolled" Goal: To ensure the software Definition Phase: Collect
Correctness, completeness, Importance of HMI in Software relationship between a Student meets the customer’s needs. requirements from users.
and efficiency. Development: and Course entities. Various Models: Example: "The software must
Non-functional Requirements: Enhances user experience. Role and Importance of E-R Waterfall Model: Linear and allow users to log in with a
Reliability, maintainability, Reduces user errors through Diagram in Software sequential process (one step username and password."
usability, portability, and intuitive design. Development: at a time). Design Phase: Plan the
performance. Increases productivity and Visual Representation: Helps Prototyping: Build a rough system architecture and
Role of Designer and User: efficiency. represent the database version (prototype) -> Show it design the software
Designer: Creates the Helps meet user requirements structure graphically. to users -> Improve it. components. Example:
software architecture. Ensures effectively. Clarifies Relationships: Types: Designing the login screen
the system meets technical Precautionary Measures for Defines how entities interact System Prototype: A basic layout and database schema.
specifications. Balances System Analysis: and connect. working version of the Maintenance Phase: Fix
usability and performance. Collect user requirements Improves Design: Provides a software. issues, bugs, and improve the
User: Provides input on clearly. clear understanding of data Paper Prototype: Sketch or software after delivery.
requirements. Tests prototypes Design user-friendly flow and constraints. diagram showing the software Example: Resolving login
and gives feedback. Ensures interfaces. Simplifies Development: Acts flow. errors reported by users after
the software meets business Perform usability testing at as a blueprint for creating launch.
needs. different stages. database tables.
ISO-9001: ISO-9001 is an Ensure accessibility for all Error Detection: Helps identify
international standard for types of users. redundancy or missing
Quality Management Systems STM (Short-Term Memory) relationships early.
(QMS). Ensures software is and LTM (Long-Term Memory) Example of E-R Diagram:
developed following in HMI: Entity: Student, Course.
systematic processes. STM: Users process small Relation: "Enrolled".
Focuses on continuous chunks of information (e.g.,
improvement and customer navigation menus, tooltips).
satisfaction. Defines guidelines LTM: Information users retain
for documentation, process over time (e.g., shortcuts,
control, and testing. learned actions).
Example:
STM: Recent files in a text
editor.
LTM: Keyboard shortcuts like
Ctrl + S for saving files.

Feasibility Study Software Quality What is it?: ISO9001 Data Views (Abstract, Component-Based
Logical, Physical) Development (CBD)
A feasibility study checks Software Quality Assurance is an international standard for
whether a project is possible (QA): What it is: Focuses on Quality Management Systems Abstract View: High-level Definition: Development
and worth doing. processes to ensure quality is (QMS). representation without details. methodology focusing on
Types of Feasibility: built into the software. How: By Why it matters: Ensures the Focus on what data is stored. reusable software
Logical Feasibility: Does the defining standards, rules, and software meets customer Logical View: Describes the components.
project make sense logically? methodologies. Example: requirements and structure of data and Steps: Identify components
Example: "Does it solve the Reviewing code during expectations. Helps relationships. Example: ER (e.g., login, database
customer’s problem development to prevent errors. organizations deliver Diagrams management). Develop and
efficiently?" Software Quality Control (QC): high-quality software (Entity-Relationship). integrate components. Reuse
Technical Feasibility: Can we What it is: Focuses on consistently. Physical View: Details of how components across projects.
develop it with the available products to find and fix errors. data is stored and managed. Benefits: Reduces
technology, tools, and skills? How: By testing the software Focus on tables, indexing, and development time. Enhances
Example: "Do we have the and identifying defects. storage mechanisms. modularity. Improves
right programming tools?" Example: Running test cases maintainability.
[chunk 121] 3. Economic to check if login works
Feasibility: Will the project be correctly. Difference: QA is
profitable or affordable? about preventing errors
Example: "Does the project (process-oriented). QC is
budget fit our financial limits?" about fixing errors
(product-oriented).

Thrust Area and Critical Core Software Engineering Software Engineering Planning Practices Waterfall Model
Factors Principles Practices
Goal: Define project scope, Definition: A linear sequence
Thrust Areas: Core areas in Abstraction: Focus on key Requirements Gathering: timeline, and resources. of phases, each completed
software engineering that drive details, ignore unnecessary Collect clear and complete Key Tools: Gantt Charts. before the next.
success. Examples: complexity. requirements. PERT Charts. Work Phases: Requirements
Performance, Scalability, Modularity: Divide the system Design: Plan system Breakdown Structure (WBS). Gathering → System Design
Security, Maintainability. into smaller, manageable architecture and components. Modeling Practices → Implementation → Testing
Critical Factors: Key elements parts. Coding: Write clean, modular → Deployment →
influencing project success: Encapsulation: Protect data by code. Purpose: Represent system Maintenance.
Resource Management. Time keeping it private. Testing: Verify software works behavior and architecture. Advantages: Simple, easy to
Management. Cost Control. Reusability: Use existing as intended. Types of Models: Data Models understand, clear
components to save time. Maintenance: Fix bugs and (ER Diagrams). Process documentation.
Scalability: Design systems to update features. Models (Flowcharts, DFD). Disadvantages: Inflexible, poor
grow with increasing demands. Communication Practices Object Models (UML for complex projects, late issue
Easy Pattern: Remember Clear Documentation: Proper Diagrams). discovery.
AMERS -> Abstraction, SRS (Software Requirements Construction Practices Best Suited For: Projects with
Modularity, Encapsulation, Specification). clear, unchanging
Reusability, Scalability. Team Collaboration: Regular (Testing Principle) requirements.
meetings and feedback loops. Unit Testing: Test individual
Client Interaction: Regular components. Prototyping model
updates to ensure alignment. Integration Testing: Verify
Focus: Avoid module interactions. Definition: A model that builds
miscommunication through System Testing: Ensure the a prototype for early user
clear processes. whole system works. feedback and requirements
Acceptance Testing: Final refinement.
check by the client. Phases: Requirements
Testing Tip: Follow V-Model for Gathering → Quick Design →
testing alongside development Prototype Development →
phases. User Evaluation → Refinement
Deployment Practices → Product Development.
Advantages: Early visibility,
Definition: Deploy software to reduces misunderstandings,
production environment. improves user satisfaction.
Steps: Preparation (Configure Disadvantages:
environment). Deployment Time-consuming, potential
(Install the software). user confusion, can be costly.
Monitoring (Check system Best Suited For: Projects with
performance). unclear or evolving
Goal: Ensure smooth and requirements.
error-free software
deployment.

Incremental Model Spiral Model RAD (Rapid Application Prototyping vs Waterfall Prototyping involves creating
Development) Model an early model of software to
Definition: Software is built and Definition: A risk-driven Requirements → Design → clarify user requirements,
delivered in small, functional iterative model combining Definition: Focuses on quick Prototype → Evaluation → identify missing or ambiguous
increments. development with risk development through iterative Refinement → Implementation functionalities, gather early
Phases: Requirements analysis. prototyping and minimal → Testing → Deployment feedback, reduce risks, and
Analysis → Incremental Phases: planning. improve communication
Design → Development → Phases: between developers and
Integration → Deployment. Planning: Identify objectives, The Waterfall Model's users.
Advantages: Early working alternatives, and constraints. Requirements Planning: sequential nature makes it
product, flexibility for changes, Risk Analysis: Identify and Define scope and high-level rigid, especially with unclear Types of Prototyping:
easier testing. mitigate risks. requirements. requirements. Adding Throwaway or rapid
Disadvantages: Requires Engineering: Develop and test User Design: Create prototyping helps reduce this prototyping is a temporary
upfront planning, potential the product. prototypes with feedback. limitation by incorporating user model created to capture
integration issues, not ideal for Evaluation: Review with Rapid Construction: Develop feedback early, refining requirements, which is
tightly coupled systems. stakeholders. and refine quickly. requirements and design discarded after feedback. An
Best Suited For: Projects Advantages: Strong risk Deployment: Deliver the final before full implementation. example is UI mockups.
needing early delivery of management, flexible to product. Evolutionary prototyping is
usable software. changes, ideal for large, Advantages: Fast delivery, How Prototyping Reduces iteratively refined and evolves
complex projects. user involvement enhances Weaknesses: into the final product, such as
Disadvantages: Expensive, satisfaction, reduces time and incremental web app
time-consuming for small cost. Early Feedback: Users interact development. Incremental
projects, requires skilled risk Disadvantages: Requires with a prototype to refine prototyping divides the system
analysis, can be complex. strong user input, unsuitable requirements early. into parts, prototypes them
Best For: Large projects with for large systems, may Better Communication: individually, and combines
high risks and complex sacrifice quality. Prototypes reduce them later, like adding
requirements. Best For: Projects needing misunderstandings between modules to an e-commerce
quick delivery within short stakeholders and developers. site. Extreme prototyping,
timelines. Usability Improvements: used in web development, has
Iterative testing ensures three phases: wireframes,
user-friendly designs. functional screens, and
Flexibility: Early detection of services.
issues enables adapting to
changes. Use in Software Development:
Cost Savings: Prevents Prototyping minimizes
expensive late-stage rework. misunderstandings between
developers and stakeholders,
enhances usability through
early user testing, and saves
time and cost by detecting
issues early.