Software Engineering (SE)

From CS2001 Wiki

Jump to: navigation, search

Software Engineering (SE)

Software engineering is the discipline concerned with the application of theory, knowledge, and practice for effectively and efficiently building software systems that satisfy the requirements of users and customers. Software engineering is applicable to small, medium, and large-scale systems. It encompasses all phases of the life cycle of a software system. The life cycle includes requirements analysis and specification, design, construction, testing, deployment, and operation and maintenance.

Software engineering employs engineering methods, processes, techniques, and measurement. It benefits from the use of tools for managing software development; analyzing and modeling software artifacts; assessing and controlling quality; and for ensuring a disciplined, controlled approach to software evolution and reuse. Software development, which can involve an individual developer or a team of developers, requires choosing the tools, methods, and approaches that are most applicable for a given development environment. The SE toolbox has evolved over the years; for instance, the use of contracts (such as a ‘requires’ clause, an ‘ensures’ clause, class invariants, etc.) is now regarded as good practice.

The elements of software engineering are applicable to the development of software in any computing application domain where professionalism, quality, schedule, and cost are important in producing a software system.


Contents

SE/SoftwareDesign [core]

Minimum core coverage time: 8 hours

Topics:

  • Fundamental design concepts and principles
  • The role and the use of contracts
  • Design patterns
  • Software architecture
  • Structured design
  • Object-oriented analysis and design
  • Component-level design
  • Design qualities
    • Internal including low coupling, high cohesion, information hiding, efficiency
    • External including reliability, maintainability, usability, performance
  • Other approaches: data-structured centered, aspect oriented, function oriented, service oriented, agile
  • Design for reuse
  • Use of open-source materials

Learning objectives:

  1. Discuss the properties of good software design including the nature and the role of associated documentation.
  2. Evaluate the quality of multiple software designs based on key design principles and concepts.
  3. Select and apply appropriate design patterns in the construction of a software application.
  4. Create and specify the software design for a medium-size software product using a software requirement specification, an accepted program design methodology (e.g., structured or object-oriented), and appropriate design notation.
  5. Conduct a software design review of open-source materials using appropriate guidelines.
  6. Evaluate a software design at the component level.
  7. Evaluate a software design from the perspective of reuse.


SE/UsingAPIs [core]

Minimum core coverage time: 3 hours

Topics:

  • Programming using APIs
  • Design of APIs
  • Class browsers and related tools
  • Debugging in the API environment Introduction to component-based computing

Note: see also SE/RequirementsSpecifications and SE/ComponentBasedComputing

Learning objectives:

  1. Explain the value of application programming interfaces (APIs) in software development.
  2. Use class browsers and related tools during the development of applications using APIs.
  3. Design, implement, test, and debug programs that use large-scale API packages.

SE/ToolsAndEnvironments [core]

Minimum core coverage time: 3 hours

Topics:

  • Programming environments
  • Requirements analysis and design modeling tools
  • Testing tools including static and dynamic analysis tools
  • Tools for source control, and their use in particular in team-work
  • Configuration management and version control tools
  • Tool integration mechanisms

Learning objectives:

  1. Select, with justification, an appropriate set of tools to support the development of a range of software products.
  2. Analyze and evaluate a set of tools in a given area of software development (e.g., management, modeling, or testing).
  3. Demonstrate the capability to use a range of software tools in support of the development of a software product of medium size.


SE/SoftwareProcesses [core]

Minimum core coverage time: 2 hours

Topics:

  • Software life-cycle and process models
  • Software process capability maturity models
  • Approaches to process improvement
  • Process assessment models
  • Software process measurements

Learning objectives:

  1. Explain the concept of a software life cycle and provide an example, illustrating its phases including the deliverables that are produced.
  2. Select, with justification the software development models and process elements most appropriate for the development and maintenance of a diverse range of software products.
  3. Explain the role of process maturity models.
  4. Compare the traditional waterfall model to the incremental model, the agile model, and other appropriate models.
  5. For each of various software project scenarios, describe the project’s place in the software life cycle, identify the particular tasks that should be performed next, and identify measurements appropriate to those tasks.


SE/RequirementsSpecifications [core]

Minimum core coverage time: 4 hours

Topics:

  • Systems level considerations
  • Software requirements elicitation
  • Requirements analysis modeling techniques
  • Functional and non-functional requirements
  • Acceptability of certainty / uncertainty considerations regarding software / system behaviour
  • Prototyping
  • Basic concepts of formal specification techniques

Learning objectives:

  1. Apply key elements and common methods for elicitation and analysis to produce a set of software requirements for a medium-sized software system.
  2. Discuss the challenges of maintaining legacy software.
  3. Use a common, non-formal method to model and specify (in the form of a requirements specification document) the requirements for a medium-size software system.
  4. Conduct a review of a software requirements document using best practices to determine the quality of the document.
  5. Translate into natural language a software requirements specification (e.g., a software component contract) written in a formal specification language.

SE/SoftwareVerificationValidation [core]

Minimum core coverage time: 3 hours

Topics:

  • Distinguishing between verification and validation
  • Static approaches and dynamic approaches
  • Validation planning; documentation for validation
  • Different kinds of testing – human computer interface, usability, reliability, security, conforman to specification
  • Testing fundamentals, including test plan creation and test case generation black-box and white-box testing techniques
  • Defect seeding
  • Unit, integration, validation, and system testing
  • Object-oriented testing; systems testing
  • Measurements: process, design, program
  • Verification and validation of non-code (documentation, help files, training materials)
  • Fault logging, fault tracking and technical support for such activities
  • Regression testing
  • Inspections, reviews, audits

Learning objectives:

  1. Distinguish between program validation and verification.
  2. Describe the role that tools can play in the validation of software.
  3. Distinguish between the different types and levels of testing (unit, integration, systems, and acceptance) for medium-size software products and related materials.
  4. Create, evaluate, and implement a test plan for a medium-size code segment.
  5. Undertake, as part of a team activity, an inspection of a medium-size code segment.
  6. Discuss the issues involving the testing of object-oriented software.


SE/SoftwareEvolution [core]

Minimum core coverage time: 3 hours

Topics:

  • Software maintenance
  • Characteristics of maintainable software
  • Reengineering Legacy systems
  • Refactoring
  • Software reuse

Learning objectives:

  1. Identify the principal issues associated with software evolution and explain their impact on the software life cycle.
  2. Discuss the challenges of maintaining legacy systems and the need for reverse engineering.
  3. Outline the process of regression testing and its role in release management.
  4. Estimate the impact of a change request to an existing product of medium size.
  5. Develop a plan for re-engineering a medium-sized product in response to a change request.
  6. Discuss the advantages and disadvantages of software reuse.
  7. Exploit opportunities for software reuse in a given context.
  8. Identify weaknesses in a given simple design, and highlight how they can be removed through refactoring.

SE/SoftwareProjectManagement [core]

Minimum core coverage time: 3 hours

Topics:

  • Team management
    • Team processes
    • Team organization and decision-making
    • Roles and responsibilities in a software team
    • Role identification and assignment
    • Project tracking
    • Team problem resolution
  • Project scheduling
  • Software measurement and estimation techniques
  • Risk analysis
    • The issue of security
    • High integrity systems, safety critical systems
    • The role of risk in the life cycle
  • Software quality assurance
    • The role of measurements
  • Software configuration management and version control; release management
  • Project management tools
  • Software process models and process measurements

Learning objectives:

  1. Demonstrate through involvement in a team project the central elements of team building and team management.
  2. Prepare a project plan for a software project that includes estimates of size and effort, a schedule, resource allocation, configuration control, change management, and project risk identification and management.
  3. Indicate an approach to risk that will help to secure the on-time delivery of software.
  4. Compare and contrast the different methods and techniques used to assure the quality of a software product.


SE/ComponentBasedComputing [elective]

Topics:

  • Fundamentals
    • The definition and nature of components
    • Components and interfaces
    • Interfaces as contracts
    • The benefits of components
  • Basic techniques
    • Component design and assembly
    • Relationship with the client-server model and with patterns
    • Use of objects and object lifecycle services
    • Use of object brokers
    • Marshalling
  • Applications (including the use of mobile components)
  • Patterns as used in analysis and design; context of use including enterprise architectures
  • Architecture of component-based systems
  • Component-oriented design
  • Application frameworks
  • Event handling: detection, notification, and response
  • Middleware
    • The object-oriented paradigm within middleware
    • Object request brokers
    • Transaction processing monitors
    • Workflow systems
    • State-of-the-art tools

Learning objectives:

  1. Explain and apply recognized principles to the building of high-quality software components.
  2. Discuss and select an architecture for a component-based system suitable for a given scenario.
  3. Identify the kind of event handling implemented in one or more given APIs.
  4. Explain the role of objects in middleware systems and the relationship with components.
  5. Apply component-oriented approaches to the design of a range of software including those required for concurrency and transactions, reliable communication services, database interaction including services for remote query and database management, secure communication and access.


SE/FormalMethods [elective]

Topics:

  • Formal methods concepts
  • Formal specification languages
  • Model checking
  • Executable and non-executable specifications
  • Pre and post assertions
  • Formal verification
  • Tools in support of formal methods

Learning objectives:

  1. Apply formal verification techniques to software segments with low complexity.
  2. Discuss the role of formal verification techniques in the context of software validation and testing, and compare the benefits with those of model checking.
  3. Explain the potential benefits and drawbacks of using formal specification languages.
  4. Create and evaluate pre- and post-assertions for a variety of situations ranging from simple through complex.
  5. Using a common formal specification language, formulate the specification of a simple software system and demonstrate the benefits from a quality perspective.


SE/SoftwareReliability [elective]

Topics:

  • Software reliability models
  • Redundancy and fault tolerance
  • Defect classification
  • Probabilistic methods of analysis

Learning objectives:

  1. Demonstrate the ability to apply multiple methods to develop reliability estimates for a software system.
  2. Identify and apply redundancy and fault tolerance for a medium-sized application.
  3. Explain the problems that exist in achieving very high levels of reliability.
  4. Identify methods that will lead to the realization of a software architecture that achieves a specified reliability level.


SE/SpecializedSystems [elective]

Topics:

  • Real-time systems
  • Client-server systems
  • Distributed systems
  • Parallel systems
  • Web-based systems
  • High-integrity systems


Learning objectives:

  1. Identify and discuss different specialized systems.
  2. Discuss life cycle and software process issues in the context of software systems designed for a specialized context, including systems that may have to operate in a degraded mode of operation.
  3. Select, with appropriate justification, approaches that will result in the efficient and effective development and maintenance of specialized software systems.
  4. Given a specific context and a set of related professional issues, discuss how a software engineer involved in the development of specialized systems should respond to those issues.
  5. Outline the central technical issues associated with the implementation of specialized systems development.


SE/RiskAssessment [Elective]

Topics:

  • Definition of terms: in security, vulnerability, threat, security breach; in safety, hazard.
  • The concept of risk; hazard and risk identification
  • Risk analysis including evaluation
  • Need for a system-wide approach including hazards associated with tools
  • Risk and immature technologies
  • Cost/benefit analysis
  • Principles of risk management


Learning objectives:

  1. To define the concepts of hazard and risk, hazard
  2. To recognize common security risks in at least two operating systems
  3. To describe the categories of threats to networked computing systems
  4. To display a systematic approach to the task of identifying hazards and risks in a particular situation
  5. To apply the basic principles of risk management in a variety of simple scenarios including a security situation

PF/RobustAndSecurity-EnhancedProgramming [elective]

Topics:

  • Defensive programming
  • Principles of secure design and coding:
    • Principle of least privilege
    • Principle of fail-safe defaults
    • Principle of psychological acceptability
  • How to detect potential security problems in programs
    • Buffer and other types of overflows
    • Race conditions
    • Improper initialization, including choice of privileges
    • Checking input
    • Assuming success and correctness
    • Validating assumptions
  • How to document security considerations in using a program

Learning objectives:

  1. Rewrite a simple program to remove common vulnerabilities, such as buffer overflows, integer overflows, and race conditions
  2. State and apply the principles of least privilege and fail-safe defaults.
  3. Write a simple library that performs some non-trivial task and will not terminate the calling program regardless of how it is called
To give feedback on this area of revision, go to here and use your ACM user name and login.
To give feedback on the security section of this area of revision, go to here and use your ACM user name and login.

Copyright © 2008, ACM, Inc. and IEEE, Inc.

Personal tools