=Paper=
{{Paper
|id=Vol-2019/edusymp_6
|storemode=property
|title=Teaching Software Modeling and Design
|pdfUrl=https://ceur-ws.org/Vol-2019/edusymp_6.pdf
|volume=Vol-2019
|authors=Hassan Gomaa
|dblpUrl=https://dblp.org/rec/conf/models/Gomaa17
}}
==Teaching Software Modeling and Design==
https://ceur-ws.org/Vol-2019/edusymp_6.pdf
Teaching Software Modeling and Design
Hassan Gomaa
Department of Computer Science
George Mason University
Fairfax VA 22030, USA
hgomaa@gmu.edu
Abstract. This paper describes my experience with The programs at Mason have a mix of full-time and part-
teaching courses on software modeling and design to time students. Because of the large number of part-time
undergraduate and graduate (Masters and PhD) students, in students, all graduate courses are taught as evening
addition to in-depth short courses to industry. The courses, meeting for a three hour class once a week.
undergraduate course is an introductory software
engineering course, which includes lectures on software
A. COURSE STRUCTURE AND EVOLUTION
modeling and design. The Masters course is a detailed course
on software modeling and design. The PhD and advanced Although the courses on software requirements and
Masters courses are advanced courses on software modeling design pre-dated UML, they followed a software
and design in the areas of software product line engineering
modeling approach based on Structured Analysis and
and real-time design. The in-depth industrial courses are
courses that cover essentially the same material in overview
Structured Design, with the design modeling emphasizing
(1 or 2 day) or more detailed (4 day) formats. the design of concurrent systems [2]. There was also an
advanced real-time design version of the course, which
Keywords: software modeling, software design, UML, was taught to PhD and advanced Masters students [3].
requirements modeling, use case modeling, analysis An early decision on course structure was for the
modeling, static modeling, dynamic modeling, design course to cover important design concepts, provide an
modeling. overview of various design methods, and follow this by
focusing on one design method in particular. The goal is
for students to understand typical design issues that arise
I. INTRODUCTION in designing a software system, and to work in teams to
get experience of applying the design method to a real-
This paper describes my experience with teaching courses world problem.
on software modeling and design to undergraduate and From 2000 onwards, the courses were changed to be
graduate (Masters and PhD) students, in addition to in- based on the Unified Modeling Language (UML) [4]. The
depth short courses to industry. It briefly describes the UML-based course taught requirements modeling
contents of each course, how the teaching of each course focusing on use case modeling, analysis modeling
has evolved, the teaching approach of “learning by consisting of both static and dynamic modeling, and
doing”, and lessons learned. design modeling with emphasis on the design of
My teaching in this area started with a Masters level concurrent and distributed systems. From 2011 onwards,
course in software modeling and design, followed later by the course was changed again to be a more general
advanced specialized graduate software modeling courses software modeling and design course [6] using the UML 2
in the areas of software product line engineering and real- notation, with a common approach for the requirements
time design. In parallel, I also taught several industrial modeling and analysis modeling sections of the course.
courses in these areas. Most recently, I have taught an This is followed by design modeling, which addressed the
undergraduate course in software engineering, which design of different types of software architectures, such as
includes introductory lectures on software modeling and client/server software architectures and service-oriented
design. Teaching these courses also led me to write books architectures by first considering the design patterns that
on software modeling and design [2, 4-7]. these architectures are based on.
The UML-based software modeling and design method
II GRADUATE COURSES ON taught in each course starts with requirements modeling
and progresses through to detailed design in Pseudocode.
SOFTWARE MODELING AND DESIGN The lectures are supplemented with detailed case studies
of applying the modeling method.
The first courses I taught on software modeling and
design were to graduate students in the Masters of B. TEAM PROJECTS
Software Engineering program at the Wang Institute in
1986-87, and to graduate students in the Masters and The goal of the team project is to encourage students to
graduate certificate programs in Software Engineering at “learn by doing”. Throughout the semester, students work
George Mason University from Fall 1987 onwards [1]. in teams on a hands-on design exercise, in which they
2
apply the design method to a real-world problem, such as same overall structure as the introductory graduate course
a supermarket check-out system or an inner-city traffic of covering the SPL design method in considerable detail
management system. Students use a commercially and concurrently running a team project in which students
available UML modeling tool for documenting their work on applying the design method to a SPL problem.
analysis models (with static models using class diagrams,
dynamic interaction models using sequence diagrams, and
finite state machine models using statecharts) and design IV INDUSTRIAL COURSES ON
models (both static and dynamic). SOFTWARE MODELING AND DESIGN
Student teams also have two tutorials with the course
instructor during the semester, which replace regular The industrial courses are courses that cover essentially
lectures, during which each team meets separately with the same material as the graduate courses but use a
the instructor. The first tutorial is to review the team’s different course structure. Courses are either overview (1
draft analysis model and the second to review the team’s or 2 day) courses or more detailed (4 day) intensive
draft design models. The instructor provides each team courses. The longer courses include time for industrial
with feedback, which they can use to revise the model students to work on a design problem. I have taught three
before submitting the revised version for grading. Most different industrial courses, on Software Modeling and
students find these tutorials very useful. In addition, Design, Real-Time Software Modeling and Design, and
students have the option of resubmitting the analysis SPL Modeling and Design. All three courses use the
model, after it has been graded, to address the comments UML notation.
made by the instructor, before submitting the design The overview courses are lecture oriented. The longer
model. courses have problem sessions built into the schedule for
students to work in small teams on a design problem. In
some courses, students also work in the evenings on the
III ADVANCED GRADUATE COURSES ON design problem
SOFTWARE MODELING AND DESIGN It is definitely the case that students on the four-day
courses learn a lot more about software modeling and
I also teach two PhD and advanced Masters courses on design, particularly through applying what they have
software modeling and design in the areas of software learned to a design real-world problem.
product line engineering and real-time design. Courses on
real-time modeling and design have also progressed from
the pre-UML modeling approaches [3] to a UML-based V UNDERGRADUATE COURSE ON SOFTWARE
method for concurrent and real-time design [4]. The MODELING AND DESIGN
course focuses on design concepts for real-time systems,
such as concurrent tasks, priority based scheduling, real- In the past five years, I have also developed an
time scheduling algorithms such as rate monotonic undergraduate software engineering course that features
scheduling, distributed control with concurrent state software modeling and design concepts. The course
machines, subsystem and component design. This course follows an iterative software life cycle model, so that
has been revised recently to follow the revised material introductory modeling concepts can be covered in the
provided in [7].The course follows the same overall requirements and design parts of the course. Use case
structure as the introductory graduate class described in modeling is used for the requirements phase. Simple
Section 2, thus covering the design method in analysis and design modeling is used for the design phase.
considerable detail and having a team project on the Software testing covers different testing approaches but
design of a real-world real-time problem. also covers model-based testing based on use cases, which
The second advanced course is on software product are used for integration and system testing.
line (SPL) design [5] with UML. This course covers SPL Students also work in teams on the different phases of
concepts and addresses feature modeling in considerable solving a real-world problem starting with developing use
detail as the key modeling approach for differentiating case models, a simple class diagram with entity classes,
between commonality and variability among the SPL and sequence diagrams for object interactions. The
members of a software family. The relationship between software architecture is described in terms of components
use cases and features are covered. The steps in analysis with provided and required interfaces. Since students
and design modeling also address commonality/variability have no knowledge of concurrency or user interface
analysis and how variable and optional features are design, the design assignment for the student project is for
realized in analysis and design. The course follows the a sequential server, such as a hotel reservation server. The
3
user interface is simulated by creating a file with a a) Undergraduates tend to find it more difficult to
sequence of inputs that represent online user inputs for appreciate software modeling concepts, although
making hotel reservations, checking in and checking out. working on a software project helps them
Students carry out integration testing to test object understand how these concepts can be used in
interactions and use case based system testing to test the
practice.
complete system using the simulated user interface.
The undergraduate course is the most challenging for b) Keeping lectures in sync with the project is a
teaching modeling concepts. Most students come to the particular challenge for undergraduate projects,
software engineering course having previously only taken since they span requirements through
computer science courses in object-oriented programming implementation. It also means that project
and data structures. Some students have difficulties with grading needs a quicker turnaround so that
understanding the more abstract modeling concepts. students can benefit from the comments in time
However, developing a simple hotel reservation system for the next phase of the project.
starting with use cases and progressing through to an c) As undergraduate students are less mature than
implemented working system is an interesting experience graduate students, they need to have each
for many students. concept explained very clearly, emphasized more
than once, and reinforced with examples.
d) It is essential to provide rubrics to students for
VI LESSONS LEARNED
each assignment.
General lessons:
Industrial courses:
a) Although giving a survey of different modeling
and design methods is useful, teaching one
a) The industrial courses are typically attended by
method in detail is necessary for students to
employees who need to understand software
understand the intricacies of software design.
modeling and design for the projects they are
b) Having a real-world project to work on,
working on and so are the most motivated to
“learning by doing”, is important for reinforcing
learn.
what students learn. This applies to both
undergraduate and graduate students. b) Students get the most benefit from the intensive
c) From a teaching perspective, a big challenge is to 4-day course, since they apply what they have
make sure that the lectures “are in sync” with the learned by solving design exercises.
project, so that the lectures are taught before the
concepts are needed for the project. VII CONCLUSIONS
Graduate courses: This paper has described my experience with teaching
courses on software modeling and design to
a) Students who appreciate the modeling courses most undergraduate and graduate (Masters and PhD) students,
are typically part-time graduate students who work in addition to in-depth short courses to industry. It has
in industry or full-time graduate students who have briefly described the contents of each course, how the
previously worked in industry. Many of these teaching of each course has evolved, the teaching
students have worked on large scale software approach of “learning by doing”, and lessons learned.
development projects and understand that software Teaching these courses also led me to write books on
modeling is a valuable skill for software software modeling and design [2, 4-7].
development. Although I developed all these courses, they have been
b) Graduate students are capable of working on team taught by full-time and adjunct software engineering
projects much more independently than faculty at George Mason on a regular basis. For new
undergraduate students who need much more help. course instructors, I provide all the course material to
them and mentor them over the semester on a regular
Undergraduate courses: basis.
Teaching material for the courses on Software
Modeling and Design and Real-Time Software Design are
4
available on the George Mason University web site [8].
The material includes course syllabus, sample course
schedule, presentation slides for each lecture, and course
assignments.
REFERENCES
1. P. Ammann, H. Gomaa, J. Offutt, D. Rine and B. Sanden,
“A Five year Perspective on Software Engineering
Graduate Programs at George Mason University”,
Proceedings SEI Conference on Software Engineering
Education, San Antonio, TX, January 1994.
2. H. Gomaa, “Software Design Methods for Concurrent and
Real-Time Systems”, Addison-Wesley SEI Series in
Software Engineering, ISBN 0-201-52577-1, 1993. (Also
translated into Chinese by Pearson Education Asia Ltd. and
Tsinghua Press, 2003).
3. H. Gomaa, “Courses on Software Design Methods for Real-
Time Systems”, Proceedings SEI Workshop on Real-Time
Systems Education”, Daytona Beach, April 1996.
4. H. Gomaa, “Designing Concurrent, Distributed, and Real-
Time Applications with UML”, Addison-Wesley Object
Technology Series, ISBN: 0-201-65793-7, 2000. (Also
translated into Chinese by Beijing University of
Aeronautics and Astronautics Press, 2004).
5. H. Gomaa, “Designing Software Product Lines with UML:
From Use Cases to Pattern-based Software Architectures”,
Addison-Wesley Object Technology Series, ISBN: 0-201-
77595-6, 2005.
6. H. Gomaa, “Software Modeling and Design: UML, Use
Cases, Patterns, and Software Architectures”, Cambridge
University Press, ISBN: 9780521764148, 2011. (Also
translated into Chinese by China Machine Press, 2014).
7. H. Gomaa, “Real-Time Software Design for Embedded
Systems”, Cambridge University Press, ISBN:
9781107041097, 2016.
8. H. Gomaa, “Teaching Material for Software Modeling
Courses”,
http://mason.gmu.edu/~hgomaa/