Class #1

We talked about the program with the TAs for a few minutes, then we broke up. 'Nuff said.

Reading #1

Jump to:
Brooks Chapter 16
Booch Chapter 1
Horstmann Chapter 1
Horstmann Chapter 2
Horstmann Chapter 3

Notes from The Mythical Man Month, chapters 1, 16, 17.

Chapter 1

This chapter mainly deals with the concept of large systems programming. Brooks divides the system into four distinct pieces. The Program, Programming System, Programming Product, and the Programming Systems Product.

Program

The Programming System in a bunch of coordinating programs that work together in a disciplined way to perform a larger task. The System is about 3 times as costly as a program.

The Programming Product is a program that can be run, repaired, and extended by everyone. The product is about three times as costly as a program.

The Programming Systems Product is a system of programming products, in other words, it is a large modular group of programs. The Systems Product is about nine times as costly as a program.

Chapters 16 and 17

The basic theme of chapter 16 is that there is no panacea to increase the speed at which software is developed. Programming's inherent flexibility and complexity make it difficult to deal with. Tools such as object oriented design, time sharing, and high level languages help increase productivity by eliminating reoccuring errors that occur by programming in assembly, for example.

In chapter 17, brooks addresses issues brought up in responses to the essay in chapter 16. Brooks reiterates that there will be eventual increases in productivity, and such things as a quality philosophy and top down design help. But, an order of magnitude leap in productivity is not something to be expected.

Notes from Booch, Chapter 1

Booch in chapter 1 addresses the issue of complexity inherent in programming. He attributes a few main factors to the complexity. These issues are The complexity of the program domain, the difficulty of managing the development process, the flexibility possible with software, and the Problems of characterizing the behavior of discrete systems.

complexity of the problem domain

The difficulty in managing the development process stems from the fact that large projects require large amounts of people who mush communicate and cooperate. That, by itself, is a difficult task.

The problem of inherent flexibility comes from the ability of the programmer to use up large amounts of time creating a specifically tailored piece of code.

With any system, testing is a crucial step. In order to test completely, one must characterize the behavior of the discrete system. With the literally thousands of variables present in a program, testing becomes difficult.

Booch offers the tool of object oriented programming to help alleviate some of the complexity the development process. With Object Oriented design, one can better conceptualize the problem, and lead to a better solution.

Horstmann
CHAPTER 1 - OBJECTS AND CLASSES:

I. Objects and Classes

Properties of Objects:
1. stores information about an object's STATE that may change over time
2. permits certain OPERATIONS, not others
3. has its own identity
A class describes a collection of related objects. A class description lists:
1. operations allowed on the objects
2. possible states for objects of the class
A subclass or derived class INHERITS the operations of a class, and may have special additional operations.

II. The development process takes place in three steps:

ANALYSIS results in a detailed textual description - what needs to be done, not how to do it.

DESIGN results in structuring into classes and class clusters, including descriptions of classes and class operations.

IMPLEMENTATION results in coding, testing, and integration of classes and class operations.

III. Object-Oriented Design

Goal is to decompose a programming task into data types or classes and define their functionality.

Find classes (look for nouns ex: Mailbox, Passcode, Menu)

Find operations (look for verbs ex: record, play, delete)

Find class relationships:

class A USES class B (knows it exists)
class A CONTAINS certain elements of class B
class A INHERITS from class B if all objects of A are in B (implementation may differ in class A and class B)

IV. Contrast with Traditional Design Techniques

Procedural Decomposition - 2 methods:

write procedures to solve simple tasks, compose into more sophisticated procedures (bottom up method)
decompose task into subtasks, recursively decompose those subtasks until they can be implemented directly (top down method)

Module Decompositions - programming tasks broken up into modules which communicate with each other, through procdure calls, don't share data. Limitation: only 1 queue (problem if, for example, a mailbox needs to store new messages (1 queue) and saved messages (a second queue))

Opaque types - nature is hidden from user

V. Design Hints

Don't use a class to describe a single object.
Classes should be large enough to describe a significant set of objects, but should not be too large.

CHAPTER 2: CRASH COURSE IN C++

tell compiler about predefined constants, data types, and procedures.
1. <...> denotes standard header file (ex: #include )
2. "..." denotes local header file (ex: #include "chisetup.h" ) note: Horstmann supplies a header file, "chisetup.h" that defines types and functions that are commonly used in the book.

II. Comments

// like this for commenting to end of line
/* like this for commenting multiple lines */

III. Output

include #include in header file
<< operator to send data to a file
to send data to a file: #include ofstream os("output.dat"); os << "..." << endl;

IV. Types and Variables

numeric types include: int, char, float, double these can be modified with SHORT, LONG, and UNSIGNED
character constants are in single quotes (ex: '/n' )
string constants are in double quotes (ex: "apple")

V. Operators

arithmetic: +, -, *, /. Also, % for remainder, ++ or -- to add or subtract 1
relational and boolean: ==, !=, <, >,<=, >=, &&, ||, !.
assignment: = (note, 1 equal sign) assignments compute right to left

VI. Arrays

grow on demand as more elements are inserted
Array a; specifies a "smart" array of any type X.

VII. Strings

initialized with quoted strings or left uninitialized
+ operator concatenates strings
[] operator provides access to individual characters in a string
LENGTH operation returns length of the string
SUBSTR operation extracts a substring with given starting index and length (ex: t = s.substr(0,4); )

VIII. Blocks

delimited by {...}
variables can be declared anywhere within a block

IX. Control Flow

if (CONDITION) BLOCK1
else if (CONDITION) BLOCK2
else BLOCK3
while (CONDITION) BLOCK // may never execute if the condition is not met
do BLOCK while (CONDITION) // executes at least once
for (STATEMENT1; EXPRESSION1; EXPRESSION2) BLOCK;

X. Functions

function definition lists the type of the returned value, the name of the function, and the types and names of its arguments; procedures are functions with the return type "void"
use "&" to call by reference (ex: void swap(int& x, int& y) ) this allows you to change the values of the variables you are swapping
C++ functions can return a result of any type except built-in arrays return statements cause an immediate exit from the function, the result is the expression following the keyword. if return type is "void", funtions don't return anything
for longer programs, functions can be declared at the top of a program (ex: int find(String s, char ch) ) or the code can just appear before the function is called
the same name can be used for different functions as long as the function argument types are different
the "main" function processes the command line argumetns, calls other functions, and terminates the program

XI. Input (use iostream.h header)

cin >>to read in a word at a time (white space is skipped)
char ch = cin.get() (reads one character at a time)
char ch = cin.peek() (looks at next character without taking it

XII. Assertions (use assert.h) - checks if conditions "cannot" happen, program fails if they do

CHAPTER 3: IMPLEMENTING CLASSES

I. Classes

operations declared in public can be applied to mailbox objects anywhere in the program
private data fields can only be accessed by operations of its class
to define an operation, declare it in the definition of the class and define the function itself - ex:
class Date
{
public:
void advance(int nday);
// ...
};

void Date::advance(int nday)
{...}

II. Implementation of Operations

constant operations
1. mutator operations change an object
2. accessor operations read an object's data and need to be declared as const
reporting month as follows allows implementation to be changed without changing code
class Date
{
public:
int mont() const;
// ...
private:
int _day;
int _month;
int _year;
};

int Date::month() const
{ return _month;
}
Inline functions can generate access to private fields and compute things inline (ex: inline int square(int x) {return x*x; } tells compiler to compute x * x.
functions which are very close to the implementation should be implemented as private operations
class operations can access private data and functions of any object of their class

III. Object Construction

constructors are automatically invoked whenever an object is created - use to initialize private data: class Date
{
public:
Date(int d, int m, int y);
// ...
};

Date::Date(int d, int m, int y)
: _day(d),
_month(m),
_year(y)
{}
after creating a constructor, defining a Date object without arguments is an error unless there is a default constructor (there usually is)
there can be more than one constructor - the compiler checks types to decide which to use, uses default constructor for any missing variables
anonymous objects have certain properties that are the result of the construction of an object by a function
subobjects must be constructed in the same way as objects, and must be initialized, either explicitly or using a default constructor

IV. Design Hints

keep data private, use operations to read and change it
use other classes to create classes (group information appropriately)
do not reveal the settings of all fields if you don't need to
use "const" for accessor operations so you don't modify data fields
form for class definitons:
if there's not a default constructor, make one (usually, set values to 0)
use initializer list to construct fields the way you want them before the default constructor