Software Engineering with UML

Bhuvan Unhelkar

• Publisher: Auerbach Publications
• Year: 2017
• Print ISBN: 9780367657383
• eBook ISBN: 9781351235167
• Topic: Computer Science
• Subtopic: Information Technology
• Index: Computer Science

This book presents the analysis, design, documentation, and quality of software solutions based on the OMG UML v2.5. Notably it covers 14 different modelling constructs including use case diagrams, activity diagrams, business-level class diagrams, corresponding interaction diagrams and state machine diagrams. It presents the use of UML in creating a Model of the Problem Space (MOPS), Model of the Solution Space (MOSS) and Model of the Architectural Space (MOAS). The book touches important areas of contemporary software engineering ranging from how a software engineer needs to invariably work in an Agile development environment through to the techniques to model a Cloud-based solution.

Chapter 1

Software Engineering Fundamentals with Object Orientation

Learning Objectives

■Learning software engineering and adopting it in practice

■Relating modeling in user requirements, software design, and development

■Understanding the relationship between programs, classes, data, and objects

■Establishing software engineering fundamentals with object orientation: classification, abstraction, encapsulation, association, inheritance, and polymorphism

■Undertaking a brief historical perspective on modeling

■Applying UML in visualizing, specifying, constructing, documenting, and maintaining software systems

This chapter introduces software engineering (SE) with the underlying basis of object orientation (OO). Starting with a discussion on how to learn and adopt SE, this chapter argues for the importance of modeling in good software design. Object and class are conceptually separated. The six fundamentals of OO discussed are classification, abstraction, inheritance, association, encapsulation, and polymorphism. A brief historical perspective on SE follows. The chapter concludes with a discussion on contemporary UML usage.

Introduction to Software Engineering

The goal of SE is to produce robust, high-quality software solutions that provide value to users. Achieving this goal requires the precision of engineering combined with the subtlety of art. Software projects also have diverse stakeholders with competing agendas, which adds to the complexity of managing people. SE is thus as much a branch of the social sciences as it is of engineering. A good software engineer continuously manages the delicate balance between the functioning of left and right brains.1

Initially, SE built and expanded on the existing and mature disciplines of engineering such as civil and mechanical engineering. The sequential steps of the earliest software development life cycle (SDLC) reflects the procedural approach of a civil engineer constructing a building: dig to create the basement, solidify the ground, erect the walls, and place the roof—all getting translated into identifying requirements, creating designs, coding, testing, and deploying. Mechanical engineering provides the backdrop for standardizing software components and assembling them to produce a software system.

These engineering characteristics continue to evolve as SE adapts to different types of developments. For example, the sequential life cycle of SE has now evolved into an iterative and incremental approach to software design. Component-based software development assembles large chunks of reusable software and services rather than handcrafting individual classes. Principles of usability are applied in designing mobile applications and Internet of Things (IoT) sensors. Agility brings in fundamentals of collaboration and visibility and, together with iterations and increments, is now the keyword for software development approaches. Agility provides immense value in software projects by drawing upon the “right-brained” traits of software developers.2 For example, disciplined Agile development (DAD)3 balances the artistic nuances of software development with the necessary engineering rigor. The Art of Agile Practice4 further builds on the basics of agility to provide an organizational working style and a culture that provides value beyond software projects.

Software engineering, in its early days, comprised nothing but programming. Hard-earned practical lessons5 within the business environment demonstrated the need for understanding and analyzing a problem and designing it carefully before programming. Software architectural practices (in the architectural space) ensure that the detailed solution design fits with the enterprise environment before it is implemented. Agile practices further extend the requirements of a system (in the problem space) iteratively and incrementally into a solution-level design (in the solution space). Such methodical analysis and design of software solution bodes well for its implementation quality and its ability to provide value to various shareholders. The need for formal standards for SE itself could not have been greater.

SE Standards Bodies

Software engineering as a discipline is continuously acknowledged, monitored, and improved through various standards bodies. Some of the popular ones are Accreditation Board for Engineering and Technology (ABET),6 Institute of Electrical and Electronics Engineers (IEEE) Computer Society,7 Australian Computer Society (ACS),8 Association for Computing Machinery (ACM),9 and Software Engineering Body of Knowledge.10

Learning and Adopting Software Engineering

Software engineering encompasses functions, activities, and tasks, including development processes, project management, business analysis, requirements modeling, usability designs, operational performance, security, financial management, regulatory and compliance management, risk management, quality assurance, quality control, release management, and service management. Learning SE is therefore a complex process in itself that can start with learning the fundamentals of development through to the adoption of agility across project ...

Table of contents

• Cover
• Half Title
• Title Page
• Copyright Page
• Dedication
• Contents
• Foreword
• Preface
• Glossary of Acronyms
• Acknowledgements
• Author
• Unique Features
• 1. Software Engineering Fundamentals with Object Orientation
• 2. Review of 14 Unified Modeling Language Diagrams
• 3. Software Projects and Modeling Spaces: Package Diagrams
• 4. The Software Development Life Cycle and Agility
• 5. Use Case Models-1: Actors and Use Cases
• 6. Use Case Models-2: Use Case Diagrams and Requirements Modeling
• 7. Activity Diagrams, Interaction Overview Diagrams, and Business Process Models
• 8. Class Models-1: Classes and Business Entities
• 9. Class Model-2: Basic Class Diagram
• 10. UML’s Extensibility Mechanisms: Notes, Stereotypes, Constraints, and Tags
• 11. Class Model-3: Advanced Class Designs
• 12. Interaction Modeling with Sequence Diagrams
• 13. Database Modeling with Class and Sequence Diagrams
• 14. Dynamic Modeling with State Machine Diagrams
• 15. Advanced Software Engineering Design Concepts: Reuse, Granularity, Patterns, and Robustness
• 16. Interface Specifications: Prototyping
• 17. Implementation Modeling with Component, Deployment, and Composite Structure Diagrams
• 18. Quality of UML Models with Syntax, Semantic, and Aesthetic Checks
• 19. Software Testing: Plan, Design, and Execute
• 20. Nonfunctional (Operational) Requirements Specification and Application
• 21. Emerging Information Technologies and Modeling
• Appendix A: Case Study Problem Statements for Team Projects
• Bibliography
• Index