SPFTWARE ENGINEERING basics , definitions
- 1. UNIT – I - SYLLABUS Basic concepts in software engineering and software project Management Basic concepts: abstraction versus decomposition, evolution of software engineering techniques. Software development life cycle (SDLC) models: Iterative waterfall model, Prototype model, Evolutionary model, Spiral model, RAD model, Agile models, Software project management: project planning, project estimation, COCOMO, Halstead’s Software Science, project scheduling, staffing, Organization and team structure, risk management, configuration management.
- 2. Software Engineering • Software is a program or set of programs containing instructions that provide desired functionality. • Engineering is the process of designing and building something that serves a particular purpose and finds a cost-effective solution to problems.
- 3. Software Engineering • Software Engineering is the process of designing, developing, testing, and maintaining software. • It is a systematic and disciplined approach to software development that aims to create high-quality, reliable, and maintainable software.
- 4. Classification of Software • Purpose: – Software can be classified as system software (e.g., operating systems, device drivers) or application software (e.g., word processors, games). • Platform: – Software can be classified as native software (designed for a specific operating system) or cross-platform software (designed to run on multiple operating systems). • Deployment: Software can be classified as installed software (installed on the user’s device) or cloud-based software (hosted on remote servers and accessed via the internet). • License: Software can be classified as proprietary software (owned by a single entity) or open-source software (available for free with the source code accessible to the public). • Development Model: Software can be classified as traditional software (developed using a waterfall model) or agile software (developed using an iterative and adaptive approach). • Size: Software can be classified as small-scale software (designed for a single user or small group) or enterprise software (designed for large organizations). • User Interface: Software can be classified as Graphical User Interface (GUI) software or Command-Line Interface (CLI) software.
- 5. The characteristics of the software include: – It is intangible, meaning it cannot be seen or touched. – It is non-perishable, meaning it does not degrade over time. – It is easy to replicate, meaning it can be copied and distributed easily. – It can be complex, meaning it can have many interrelated parts and features. – It can be difficult to understand and modify, especially for large and complex systems. – It can be updated or modified as the needs of users change. – It can be impacted by bugs and other issues, meaning it may need to be tested and debugged to ensure it works as intended.
- 6. Components of Software Characteristics: • Functionality: • Reliability: • Efficiency: • Usability: • Maintainability: • Portability:
- 7. Components of Software Characteristics: • Functionality: – It refers to the degree of performance of the software against its intended purpose. functionality in software include: – Data storage and retrieval – Data processing and manipulation – User interface and navigation – Communication and networking – Security and access control – Reporting and visualization
- 8. Components of Software Characteristics: • Reliability is a characteristic of software that refers to its ability to perform its intended functions correctly and consistently over time. factors that can affect the reliability of software include: – Bugs and errors in the code – Lack of testing and validation – Poorly designed algorithms and data structures – Inadequate error handling and recovery – Incompatibilities with other software or hardware
- 9. Components of Software Characteristics: • Efficiency: Efficiency software that refers to its ability to use resources such as memory, processing power, and network bandwidth in an optimal way. factors that can affect the efficiency of the software include: – Poorly designed algorithms and data structures – Inefficient use of memory and processing power – High network and width usage – Unnecessary processing or computation – Unoptimized code
- 10. Components of Software Characteristics: • Efficiency: Efficiency software that refers to its ability to use resources such as memory, processing power, and network bandwidth in an optimal way. factors that can affect the efficiency of the software include: – Poorly designed algorithms and data structures – Inefficient use of memory and processing power – High network and width usage – Unnecessary processing or computation – Unoptimized code
- 11. Components of Software Characteristics: Usability: – It refers to the extent to which the software can be used with ease. – the amount of effort or time required to learn how to use the software. Maintainability: It refers to the ease with which modifications can be made in a software system to extend its functionality, improve its performance, or correct errors. Portability: A set of attributes that bears on the ability of software to be transferred from one environment to another, without minimum changes.
- 13. SOFTWARE DEVELOPMENT PROCESS 1. Analysis: Understanding the Requirements • Observation: from existing software • Interviews • Workshops: Organize workshops with users and stakeholders 2. Planning: Setting the Foundation • Objective Understanding • Task Lists • Team Responsibilities • Progress Tracking • Proactive Problem Solving • Cost Estimate
- 14. SOFTWARE DEVELOPMENT PROCESS 3. Design: Crafting the Details create detailed plans on how the custom software will work and look. System Design This is a detailed blueprint for software. • During system design, take these factors into account: – Functional Requirements: What tasks the software needs to accomplish. – Non-Functional Requirements: How efficiently it should operate and the level of security it demands. – Restrictions: Any limitations, such as technical or budgetary constraints. Software Architecture Design • Modularity and Testability: • Scalability: User Interface/User Experience (UI/UX) Design • This describes how the software will look and feel. It includes information on the layout, colors, and fonts that will be used. • UX design prioritizes: – User-Centricity: Ensuring ease of use and comprehension. – Consistency: Keeping a uniform style throughout the software.
- 15. SOFTWARE DEVELOPMENT PROCESS 4. Development: Writing the Code 5. Testing: Ensuring It Works 6. Deployment: Releasing to the World 7. Maintenance: Keeping It Running
- 16. LIBRARY MANAGEMENT SYSTEM 1. Requirements Gathering 2. Design – Database Design: • database schema to store information about books, • users, transactions, and other relevant data. – User Interface Design: • Design an user-friendly interface for librarians, administrators, and users – System Design: Define the architecture, database structure, and interactions between different modules.
- 17. 3. Development: Code the various modules, including those – for book management, – user authentication, transactions, and any other specified features. 4.Testing: – Perform unit testing for individual modules, integration testing to verify interactions between modules, and system testing to assess the overall system behavior. Feedback and Iteration: – Collect feedback from users and stakeholders during the testing phase. Iterate on the software based on the feedback to address any issues, improve usability, and enhance features. Documentation: – Create comprehensive documentation for the library management software. This should include user manuals, developer documentation, and any necessary guides for administrators. Library MANAGEMENT SYSTEM
- 18. LIBRARY MANAGEMENT SYSTEM 5. Deployment: – Description: Deploy the library management software to the target environment. • Training: – Provide training sessions for librarians, administrators, and users on how to use the software. Address common tasks, functionalities, and any new features introduced with the software. 6. Maintenance and Support: – After deployment, provide ongoing maintenance and support. • Security Considerations: – Throughout the development process, prioritize security. Implement secure coding practices, incorporate authentication and authorization mechanisms, encrypt sensitive data, and regularly update the software to patch any security vulnerabilities.
- 19. principles of Software engineering Software engineering principles are fundamental guidelines and practices that guide the development and maintenance of high-quality software.
- 20. Principles of Software Engineering Modularity : Breaking the software into smaller, reusable components that can be developed and tested independently. Abstraction : Hiding the implementation details of a component and exposing only the necessary functionality to other parts of the software. Reusability : Creating components that can be used in multiple projects, which can save time and resources. Maintenance: Regularly updating and improving the software to fix bugs, add new features, and address security vulnerabilities. Testing : Verifying that the software meets its requirements and is free of bugs. Design Patterns: Solving recurring problems in software design by providing templates for solving them. Agile methodologies: Using iterative and incremental development processes that focus on customer satisfaction, rapid delivery, and flexibility. Continuous Integration & Deployment: Continuously integrating the code changes and deploying them into the production environment.
- 21. Abstraction and decomposition • We mainly use these two fundamental principles in various forms in the different software development activities. • Abstraction and decomposition are fundamental concepts in software engineering that contribute to the design, development, and maintenance of complex software systems.
- 22. Decomposition : Def: The decomposition principle advocates decomposing the problem into many small independent parts. The small parts are then taken up one by one and solved separately. The idea is that each small part would be easy to grasp and understand and can be easily solved. involves breaking down a complex system into smaller, more manageable parts or components. popularly known as the divide and conquer principle. It helps in dividing the problem into smaller, more manageable sub-problems, making it easier to understand, design, and implement.
- 23. LIBRARY MANAGEMENT SYSTEM (Decomposition ) • User Interface (UI) Decomposition • Module Decomposition • Data Decomposition • Functional Decomposition • Hierarchical Decomposition: • Process Decomposition: • Dependency Decomposition • Testing Decomposition
- 24. Library Management System Catalog Search UI User Registration UI Book Checkout UI Cataloging Module User Management Module Borrowing Module Add New Books Update Book Info Delete Records Add New Users Update User Info Delete User Records Borrowing Module Check Book Availability Update Inventory Record Transaction BOOKS AUTHORS USERS Transactions
- 25. Student Attendance Management Attendance Tracking UI Reports and Analytics UI User Management UI Attendance Tracking Record Attendance View Attendance Report Generate Reports Analyze Attendance Add New Students Update Student Info Delete Student Records| Students Attendance DATA USERS
- 26. Decomposition : • A good decomposition of a problem should minimize interactions among various components • different subcomponents are interrelated, then the different components cannot be solved separately. • the desired reduction in complexity will not be realized.
- 27. Abstraction: Def: Abstraction is the simplification of a problem by focusing on only one aspect of the problem while omitting all other aspects. Abstraction involves hiding unnecessary details and focusing on essential functionalities, making the software more manageable, modular, and user-friendly. Abstraction refers to construction of a simpler version of a problem by ignoring the details. (popularly known as modelling or model construction).
- 28. Level 4: Library System Integration |--- Integration of book management and user accounts |--- Transaction handling Level 3: User Account Abstraction |--- User authentication |--- Account registration |--- Password management |--- Encapsulated user-related functionalities Level 2: Book Management Abstraction |--- Core logic for book operations | |--- addBook() | |--- removeBook() | |--- updateBookInformation() |--- Abstracted database interactions Level 1: User Interface Abstraction |--- UI components (search, checkout, return) |--- User-friendly interactions |--- Abstracted user workflows Level 0: Detailed Model |--- Database structures |--- Cataloging algorithms |--- book storage details |--- User authentication mechanisms LIBRARY MANAGEMENT SYSTEM (Abstraction )
- 29. ATTENDENCE MAINTAINCE SYSTEM (Abstraction ) 1. User Interface Abstraction: |--- UI components |--- User-friendly interactions |--- Abstracted user workflows 2. Attendance Tracking Abstraction: |--- Marking attendance |--- Generating reports |--- Abstraction layers for administrators |--- Abstraction layers for students 3. Integration Abstraction: |--- Abstraction layers for data exchange |--- Seamless communication with other systems 4. User Account Abstraction: |--- Registration |--- Authentication |--- Access control |--- Abstraction layers for administrators |--- Abstraction layers for students 5. Notification Abstraction: |--- Notification preferences for administrators |--- Notification processes abstraction |--- Student notification abstraction
- 30. Evolution of software engineering (From an art to an engineering discipline)
- 31. Evolution of software engineering (From an art to an engineering discipline) • In early stages of programming, the style of program development is ad hoc, (which is now variously being referred to as exploratory, build-and-fix, and code-and-fix styles. ) • which has no set of rules but guided by their own intuition, experience, whims and fancies exploratory style usually leads poor quality and unmaintainable code and also makes program development very expensive as well as time consuming.
- 33. Evolution Of Software Engineering Techniques • Early Computer Programming • High-level Language Programming • Data Structure-oriented Design • Data Flow-oriented Design • Object-oriented Design • Other Developments