Software Development Practices Quiz

Software Engineering Lecture 01: Introduction

• The lecture covered software engineering, including its significance, history, key concepts, and differences between software engineering and traditional engineering. It emphasized software quality and maintenance.
• The course outline included: Introduction, Software Processes, Agile Software Development, Requirements Engineering, System Modeling, and Architectural Design.
• Software engineering is concerned with theories, methods, and tools for professional software development.
• Software costs often dominate computer system costs, and are more expensive for maintenance than for initial development.
• Software project failure is an issue due to increasing system complexity. Poor implementation of software engineering methodologies and techniques also contributes to failure.
• Professional software development refers to the disciplined process of creating software applications to meet specific quality and requirements standards

Software Engineering Lecture 02: Software Processes

• The lecture covered software process models, process activities, and coping with change (in software engineering)
• The software process is a structured set of activities to develop a software system.
• Specification, design and implementation, validation, and evolution are key aspects of the process.
• A software process model is an abstract representation of a process, showing the perspective of the process.
• Process descriptions include products (outcomes of activities), roles (responsibilities of involved people), and pre-/post-conditions (statements true before/after a process activity).
• Plan-driven processes plan all process activities in advance, while Agile processes do this incrementally.
• Waterfall, incremental, and integration/configuration models are software process models
• The waterfall model has distinct phases (requirements, design, implementation, testing and maintenance)
• It is difficult to accommodate change with the waterfall model
• Incremental development involves repeatedly creating and testing partial implementations before a fully working system, allowing more opportunities for feedback and change.
• Integration and configuration methods frequently incorporate existing components. Reusing existing components reduces development costs, however, issues of interoperability can arise,
• Architecture reuse is beneficial to deliver working software quickly.
• Refactoring, which involves optimizing existing code without changing its functionality, is important to maintain a codebase.

Software Engineering Lecture 03: Software Processes-2

• The lecture focused on software processes (continued).
• Process activities are specific tasks performed in system development
• Software Process Models provide frameworks and structures to manage these tasks. Real software processes are integrated sequences of technical, collaborative and managerial activities.
• Requirements Engineering processes define the system services and constraints, including elicitation, specification and validation. The process is important to develop the system based on customer needs
• Techniques to handle requirements changes include change anticipation (using prototypes) and change tolerance.

Software Engineering Lecture 04: Agile Software Development

• Agile development emphasizes a flexible approach to managing software requirements and development processes.
• Agile methods include practices like user stories, continuous integration, XP & minimal documentation.
• Agile methodologies focus on collaboration, iterative development, and frequent delivery of working software.
• Extreme Programming (XP) is a popular agile technique known for its emphasis on thorough testing, minimal documentation, and adaptive development.

Software Engineering Lecture 05: Agile Software Development-2

• Software design, implementation and testing are interleaved in agile development
• User stories are used for requirements specification in XP, which are recorded on cards to be included in a release.
• Refactoring is a crucial practice, where coders continually improve and adapt the code.
• Test-first development involves writing tests before implementing the code.
• Pair programming, involving two developers working together, improves code quality and knowledge sharing.

Software Engineering Lecture 06: Requirements Engineering

• Software Requirements focus on what services a customer requires from a system.
• It's important to define services and constraints under which a software system can operate.
• Defining requirements must allow flexibility for potential later changes and may be considered an iterative process.
• High-level requirements are statements like "easy to use" that are hard to measure, while lower-level requirements include precise measures such as processing time or capacity.
• Different types of requirements include user requirements (in simple language) and system requirements (detail).
• Non-functional requirements may be used to specify performance characteristics and other limitations.

Software Engineering Lecture 07: System modeling

• System modeling involves creating abstract representations of a system's functional structure and behavior.
• It aims to improve communication between stakeholders to ensure a shared understanding.
• There are models of existing systems to aid in requirements engineering.
• Context models specify system boundaries and interactions with external entities.
• Use case models represent use cases (tasks) that involve external interactions (actors).
• Sequence diagrams model detailed interactions between systems and parts of a system
• Structural models show the organization of a system. Class diagrams illustrate the model of classes and associations between the classes that compose the system.
• Behavioral models illustrate the behaviour of a system (e.g. Activity diagrams)

Software Engineering Lecture 08: System modeling-2

• Behavioral modeling models the dynamic, running aspects of a system.
• There are different types of behavioral modeling: Data-driven (processing input data and generating outputs), Event-driven (responding to external and internal events), and State machines (states, events & transitions).
• State machine models show the response of a system to internal and external events, which are often used to model real-time systems.
• Statecharts are often used to represent state machine models. (e.g., to illustrate a microwave oven)

Software Engineering Lecture 09: Architectural design

• Architectural design is about understanding how a system should be organized and designed (e.g., in a high level blueprint). It defines the main structural components and their relationships.
• Architectural design decisions (including decomposition, data flow & deployment strategies) are integral to achieving non-functional requirements (e.g. scalability, security).
• Decisions regarding reuse & architecture are important in large-scale systems.
• Different architectural views, including logical, physical, development, etc., provide comprehensive analysis of a system's structure.
• Architectural patterns (e.g., Model-View-Controller, Layered Architecture, and Pipe and Filter, and Client-Server) offer solutions to common design challenges.

Test your knowledge on software development practices and principles. This quiz covers various aspects of web applications, embedded systems, team collaboration, and software processes. Challenge yourself and see how well you understand the key concepts in software development.