This paper describes my experience with teaching courses on software modeling and design to undergraduate and graduate (Masters and PhD) students, in addition to in-depth short courses to industry. The undergraduate course is an introductory software engineering course, which includes lectures on software modeling and design. The Masters course is a detailed course on software modeling and design. The PhD and advanced Masters courses are advanced courses on software modeling and design in the areas of software product line engineering and real-time design. The in-depth industrial courses are courses that cover essentially the same material in overview (1 or 2 day) or more detailed (4 day) formats.
This paper describes my experience with teaching courses on software modeling and design to undergraduate and graduate (Masters and PhD) students, in addition to indepth short courses to industry. It briefly describes the contents of each course, how the teaching of each course has evolved, the teaching approach of “learning by doing”, and lessons learned.
My teaching in this area started with a Masters level
course in software modeling and design, followed later by
advanced specialized graduate software modeling courses
in the areas of software product line engineering and
realtime design. In parallel, I also taught several industrial
courses in these areas. Most recently, I have taught an
undergraduate course in software engineering, which
includes introductory lectures on software modeling and
design. Teaching these courses also led me to write books
on software modeling and design [
The first courses I taught on software modeling and
design were to graduate students in the Masters of
Software Engineering program at the Wang Institute in
1986-87, and to graduate students in the Masters and
graduate certificate programs in Software Engineering at
George Mason University from Fall 1987 onwards [
Although the courses on software requirements and
design pre-dated UML, they followed a software
modeling approach based on Structured Analysis and
Structured Design, with the design modeling emphasizing
the design of concurrent systems [
An early decision on course structure was for the course to cover important design concepts, provide an 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 in designing a software system, and to work in teams to get experience of applying the design method to a realworld problem.
From 2000 onwards, the courses were changed to be
based on the Unified Modeling Language (UML) [
The UML-based software modeling and design method taught in each course starts with requirements modeling and progresses through to detailed design in Pseudocode. The lectures are supplemented with detailed case studies of applying the modeling method.
The goal of the team project is to encourage students to “learn by doing”. Throughout the semester, students work in teams on a hands-on design exercise, in which they apply the design method to a real-world problem, such as a supermarket check-out system or an inner-city traffic management system. Students use a commercially available UML modeling tool for documenting their analysis models (with static models using class diagrams, dynamic interaction models using sequence diagrams, and finite state machine models using statecharts) and design models (both static and dynamic).
Student teams also have two tutorials with the course instructor during the semester, which replace regular lectures, during which each team meets separately with the instructor. The first tutorial is to review the team’s draft analysis model and the second to review the team’s draft design models. The instructor provides each team with feedback, which they can use to revise the model before submitting the revised version for grading. Most students find these tutorials very useful. In addition, students have the option of resubmitting the analysis model, after it has been graded, to address the comments made by the instructor, before submitting the design model.
III ADVANCED GRADUATE COURSES ON
SOFTWARE MODELING AND DESIGN
I also teach two PhD and advanced Masters courses on
software modeling and design in the areas of software
product line engineering and real-time design. Courses on
real-time modeling and design have also progressed from
the pre-UML modeling approaches [
The second advanced course is on software product
line (SPL) design [
The industrial courses are courses that cover essentially the same material as the graduate courses but use a different course structure. Courses are either overview (1 or 2 day) courses or more detailed (4 day) intensive courses. The longer courses include time for industrial students to work on a design problem. I have taught three different industrial courses, on Software Modeling and Design, Real-Time Software Modeling and Design, and SPL Modeling and Design. All three courses use the UML notation.
The overview courses are lecture oriented. The longer 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 design problem
It is definitely the case that students on the four-day courses learn a lot more about software modeling and design, particularly through applying what they have learned to a design real-world problem.
V UNDERGRADUATE COURSE ON SOFTWARE
In the past five years, I have also developed an undergraduate software engineering course that features software modeling and design concepts. The course follows an iterative software life cycle model, so that introductory modeling concepts can be covered in the requirements and design parts of the course. Use case modeling is used for the requirements phase. Simple analysis and design modeling is used for the design phase. Software testing covers different testing approaches but also covers model-based testing based on use cases, which are used for integration and system testing.
Students also work in teams on the different phases of solving a real-world problem starting with developing use case models, a simple class diagram with entity classes, and sequence diagrams for object interactions. The software architecture is described in terms of components with provided and required interfaces. Since students have no knowledge of concurrency or user interface design, the design assignment for the student project is for a sequential server, such as a hotel reservation server. The user interface is simulated by creating a file with a sequence of inputs that represent online user inputs for making hotel reservations, checking in and checking out. Students carry out integration testing to test object interactions and use case based system testing to test the complete system using the simulated user interface.
The undergraduate course is the most challenging for teaching modeling concepts. Most students come to the software engineering course having previously only taken computer science courses in object-oriented programming and data structures. Some students have difficulties with understanding the more abstract modeling concepts. However, developing a simple hotel reservation system starting with use cases and progressing through to an implemented working system is an interesting experience for many students.
and design methods is useful, teaching one method in detail is necessary for students to understand the intricacies of software design. Having a real-world project to work on, “learning by doing”, is important for reinforcing what students learn. This applies to both undergraduate and graduate students.
From a teaching perspective, a big challenge is to make sure that the lectures “are in sync” with the project, so that the lectures are taught before the concepts are needed for the project.
a) b)
Students who appreciate the modeling courses most are typically part-time graduate students who work in industry or full-time graduate students who have previously worked in industry. Many of these students have worked on large scale software development projects and understand that software modeling is a valuable skill for software development.
Graduate students are capable of working on team projects much more independently than undergraduate students who need much more help. Undergraduate courses: a) Undergraduates tend to find it more difficult to appreciate software modeling concepts, although working on a software project helps them understand how these concepts can be used in practice. b) Keeping lectures in sync with the project is a particular challenge for undergraduate projects, since they span requirements through implementation. It also means that project grading needs a quicker turnaround so that students can benefit from the comments in time for the next phase of the project. c) As undergraduate students are less mature than graduate students, they need to have each concept explained very clearly, emphasized more than once, and reinforced with examples. d) It is essential to provide rubrics to students for each assignment.
Industrial courses: a) The industrial courses are typically attended by employees who need to understand software modeling and design for the projects they are working on and so are the most motivated to learn. b) Students get the most benefit from the intensive 4-day course, since they apply what they have learned by solving design exercises.
This paper has described my experience with teaching
courses on software modeling and design to
undergraduate and graduate (Masters and PhD) students,
in addition to in-depth short courses to industry. It has
briefly described the contents of each course, how the
teaching of each course has evolved, the teaching
approach of “learning by doing”, and lessons learned.
Teaching these courses also led me to write books on
software modeling and design [
Although I developed all these courses, they have been taught by full-time and adjunct software engineering faculty at George Mason on a regular basis. For new course instructors, I provide all the course material to them and mentor them over the semester on a regular basis.
Teaching material for the courses on Software
Modeling and Design and Real-Time Software Design are
available on the George Mason University web site [