Instructor	Prof. Don Batory	batory@cs.utexas.edu
	TA
	Office Hours	Batory	ACES 5.252
	Room
	Time	TTh 11:00 to 12:15
	Unique#	54355
	Ground Rules	Rules of Conduct and Academic Honesty
	Your Grades	EGradeBook
	Final Exam

This course is now under construction --the name was originally "software system architecture" but "software design" is more accurate. Whatever the name, the contents are shaping up.

Prerequisites: Minimum C grade in CS 310 or 310H, 336 or 336H, and M 408D or 408M.  You must know how to program in Java; if Java is new to you, don't take this course!

Overview. Software design and construction is not hacking; it is governed by fundamental principles. Model driven design (MDD) gives us a general way to think about software design and construction -- not as a giant mass of hacked code, but  as a principled collection of concepts architected in a thoughtful  way. MDD deals with the creation of models and transformations of these models to other models, eventually yielding executables (yet other models).

Now, this is pretty abstract, but if you think about it, we express a program in the Java language (that's our concrete model of this program).  The javac compiler transforms source code to bytecode (i.e., it maps a Java representation of a program to a corresponding representation of that program in bytecode). That's pretty familiar transformation to us all. javadoc, as another example, maps Java source to html (both the input and output are models).  Refactorings map source code to refactored source code.  There are even refactorings that map bytecodes to bytecodes.

These are just a few examples of software engineering representations of programs and the tools that transform them from one representation to another. But virtually *all* of software design deals with the creation of models (program representations) and their transformation into other representations. Note that most work in Engineering (with a capital "E") deals with model development -- ex. Boeing creates and analyzes models of aircraft long before they actually build a physical plane. Similarly, the software next generation Space Shuttle is being built solely from models; no one is writing code! (These models are transformed to ugly C++ by commercial tools and then commercial C++ compilers transform source into executables).

The goal course is to give students a big picture of what we as programmers, system architects are doing, and how to reason about program design and construction.  This course will:

• teach you basic skills in reasoning and software design,

• give you experience in writing programs that exercises these skills,

• expose you to the principles of software design,

• provide an insight on where software design technology is headed, and

• give you a framework for understanding what Software Engineering will become in the future.

The course will include lectures on the following topics: Basic UML models and modeling, Categories, Refactorings, Object Oriented Design Patterns, Architectural Patterns, Incremental Design of Architectures, Service Oriented Architectures, and (if there is time) Software Product Lines. And of course, concepts from Model Driven Design which all of the above are seen as special cases.

As this is gateway course to further undergraduate courses in CS on Software Development, you should expect many small programming assignments,  written homework assignments, and a course project. The course is intended to be both hands-on practical and to expose you to principles of software design.

Preliminary Course Outline (updated every few weeks until January)

Numbers in [brackets] indicates the estimated number of lectures on a topic. The number indicated is a lower-bound, as there may be class room discussions to work on problems and review of homework assignments.  There will be (at least) one midterm and a final.

• Introduction [1]

  • model driven design, models, transformations, automated software development

• Unified Modeling Language [2]

  • class diagrams, cardinalities, associations, Object Constraint Language (OCL), object diagrams, meta-models and meta-modeling

• Categories [2]

  • domains, instances, arrows and model transformations, arrow composition, recursion, cones of instances, Meta Object Facility (MOF) architecture

• Object Oriented Refactorings [2]

  • rename, extract method, substitute, template, replace-constructor-with-factory, pull-up, push-down, move, delegate,

  • singleton, method object, command, extract class (normalization, partition), extract superclass, extract interface

  • meta-programs, and refactoring components

• Design Patterns [6] (click here for design patterns summary)

  • facade, adapter, flyweight

  • frameworks, template, factory, singleton, abstract factory

  • [2] grammar patterns, composite, interpreter, decorator

  • visitors, command, memento

  • separation of concerns, observer, model-view-controller, mediator

• Midterm [1]

• Architectural Patterns [3]

  • architectural styles, sequence diagrams, blackboard, registry refactoring

  • layers, multi-tiered (and 3-tiered) architectures, object-oriented virtual machines, symmetric vs. asymmetric layers

  • pipe and filter architectures, components and connectors, Java pipes, sockets

• Incremental Development of Architectures [2]

• map reduce, Liskov substitution principle, byzantine fault tolerant designs, parallel architectures, parallel hash join architectures, architectural correctness

• Service Oriented Architectures [3]

• Guest Lecture [1]

• Software Product Lines (if there is time)

  • collaborations, features or concerns, composition

• Course Recap and Final [1]