This is an incredibly influential paper. It distills many years of Brook's experiences working on OS/360 and has influenced many things that have come after it. E.g., Extreme Programming promotes the "grow, not build software" and "rapid prototyping" strategies. We will refer to this paper throughout the semester.
Given that software development is so hard, people have proposed and used many different models for developing and maintaining software. In this skill set you will gain basic familiarity with three of the more commonly used models; we will explore two of these models in more detail over the course of the semester.
Over the last few years, extreme programming has become a very hot methodology for modestly sized projects (around 30 programmers). For larger projects, organization sometimes partition the project and use extreme programming on each partition.
As software becomes increasingly complex, it becomes more and more important to reuse code and ideas. Such reuse frees up the programmer from having to conceive everything from a scratch and can therefore focus on aspects of the program that are unique. At the simplest level, we can reuse classes and methods that others have developed. For example, if we need a linked list, rather than writing on on our own, we can use the one that comes in the Java standard library. At the other extreme we can reuse designs. This is what design patterns are all about.
This pattern is use a great deal in compilers. Compilers often need to put annotations on their internal representation of the program being compiled. For example, one could imagine placing an annotation "may modify variable x" on a call statement. Different parts of the compiler may need to put different annotations; moreover some objects may have no annotations while others have many annotations. The decorator pattern is perfect for this.
This pattern is very convenient since it enables one to create objects without knowing their concrete classes. Thus, it is particularly relevant when the program follows good software engineering practices and separates interface from implementation.
This is one of the most commonly used pattern. Just about any good implementation of a collection class supports it. For example, the Java standard libraries support iterators. These were deemed so important that in the newest version of the language, there is even language support for iterators so that using them is just as convenient as a counted for loop.
This is the pattern that I have found to be awesomely powerful. In 1996, I was working on a compiler and my code kept getting really unmanageable. Then I encountered this pattern and it completely transformed the code into something that was clean and manageable. Since then I cannot think of any significant piece of software that I've written that did not use this pattern.
The observer pattern is used extensively in user interfaces. For example, whenever an event happens (e.g., mouse click) we need to identify many observers about it. Some people also call this the listener pattern since the observers are effectively listening in for events.
Refactorings play a crucial role in extreme programming: they are the steps that enable a programmer to evolve their code as needed. With refactorings, programmers do not need to worry about thinking of all possible ways in which their code will be used; instead, they can write it for their current needs and then modify it using refactorings if and when the code turns out to be inadequate.
I attended a talk by Martin Fowler last week where he listed "eliminating duplicates" as one of the most important things to do while programming. The extract method helps with that since the extracted method can be used by any number of clients, thus avoiding the need for code duplication.
We have looked at 10 refactorings this semester. In class I demonstrated how to use the refactorings to incorporate design patterns in the code. In this skill set we focus on when to apply the refactorings in order to reduce "bad smells" in the code. When doing this reading, you will find that it refers to not just refactorings that we have covered but also many that we have not. Ignore the part that refers to refactorings that we have not covered.
Regular expressions are invaluable for searching through code and for processing simple kinds of inputs.