Category: C++

C++ Lambda Story: Everything you need to know about Lambda Expressions in Modern C++!

Author Bartłomiej Filipek
Format PDF
Price free

This book is an adapted version, made for Embarcadero’s C++ Builder.

This book shows the story of lambda expressions in C++. You’ll learn how to use this powerful feature in a step-by-step manner, slowly digesting the new capabilities and enhancements that come with each revision of the C++ Standard.

We’ll start with C++98/03, and then we’ll move on to the latest C++ Standards.

  • C++98/03 – how to code without lambda support. What was the motivation for the new
    modern C++ feature?
  • C++11 – early days. You’ll learn about all the elements of a lambda expression and even
    some tricks. This is the longest chapter as we need to cover a lot.
  • C++14 – updates. Once lambdas were adopted, we saw some options to improve them.
  • C++17 – more improvements, especially by handling this pointer and allowing

Additionally, you’ll find techniques and handy patterns throughout the chapters for using lambda in your code. Walking through the evolution of this powerful C++ feature allows us not only to learn lambdas but also to see how C++ has changed over recent years. In one section you’ll see a technique and then it will be “iterated” and updated in further chapters when new C++ elements are available. When possible, the book cross-links to other related sections of the book.

Continue reading

C++: A Dialog

  • Author: Steve Heller
  • Format: online HTML
  • Price: free

Is this book for you? If you’re a programmer in a language other than C++ and you want to upgrade your skills, then you shouldn’t have much difficulty figuring that out for yourself by reading a few pages. But what if you have no previous programming experience? In that case, here’s a little quiz that may help you decide:

1. Do you want to know how the programs in your computer work inside and how to write some of your own?
2. Are you willing to exert yourself mentally to learn a complex technical subject?
3. Do you have a sense of humor?

If you’ve answered yes to these questions and follow through with the effort required, then you will get a lot out of this book.

Chapters include:

  • Introduction to Programming
  • Hardware Fundamentals
  • Basics of Programming
  • More Basics
  • Functional Literacy
  • Taking Inventory
  • Creating a Homegrown string class
  • Finishing Our homegrown string class
  • Inheritance
  • Polymorphism
  • The Home Inventory Project
  • More on the Home Inventory Project
  • Analyzing the Home Inventory Project

Read: C++: A Dialog

Download the example code from the author’s current website.


This book is quite old and uses a very old compiler, which is still available here, for free (free registration may be required). I am not sure if that compiler will run, or if the executables it generates can run on a modern version of Windows, though. You’ll just have to give it a try to find out.

If you have any troubles with it, you can try this free compiler instead, or even the free C++ Builder Community Edition.

Personally, I’d try the very old compiler first, followed by the newer one, and only use the full blown C++ Builder as a last resort, since there may be compatibility issues with the example code provided for the book, and each step up in compiler complexity and version upgrade just increases the chances that you’ll never be able to get the example code to work with the compiler, or you’ll get lost with trying to use the compiler while following the book.

Unfortunately, the debugger used in this book is no longer available. 🙁

Another thing to keep in mind is that this book is no longer available for free on the author’s website, so I am linking to a mirror of a previous version of his website, instead. The formatting of the book’s HTML text is rather ugly, with an uncomfortable to read mixture of text sizes, and a confusing link layout (due to being an mirror). If you encounter any dead links in the Table of Contents, try accessing a different link within the same chapter and just scroll up or down the page accordingly, till you get to the content section that you are looking for.

I am keeping the listing for this book available, despite all the issues that may be involved, because the text is still quite good and it has a lot to offer the reader, with regards to understanding how things work under the hood, with a depth not found in very many other beginner books. So, even if you never actually do any coding while following this book, you’ll still learn a lot of the kind of essential base knowledge that can help make you a better programmer.

So, the best use of this book might be as a prequel brain fertilizer, before using another book to do your actual hands on learning.

C++ Programming for Scientists

My image
  • Author: Roldan Pozo and Karin Remington
  • Format: Postscript, PDF (by chapter)
  • Price: free

NIST Course on C++ Programming for Scientists.

Chapters include:

  • Lecture 1: ANSI C
  • Lecture 2: C++ as a better C
  • Lecture 3: C++ Classes and Objects
  • Lecture 4: Objects in Scientific Computing
  • Lecture 5: Inheritance & Polymorphism
  • Lecture 6: Templates, Exceptions & Observations
  • Programming Examples
  • Scientific Library Examples

C++ In Action: Industrial Strength Programming

  • Author: Bartosz Milewski
  • Format: online HTML
  • Price: free

There aren’t that many books that teach C++. You can find good C++ reference books and technical books for advanced C++ programmers, but precious few books that actually teach programming in C++. Among them C++ In Action presents a unique approach–teaching the language from the perspective of a professional programmer.

In this book you won’t find examples of boring payroll applications or programs for grading students. Instead you’ll witness the development of a simple parser and a symbolic calculator from a simple command-line program to a GUI Windows application. In the process you’ll learn how to use C++ like a real pro.

Chapters include:

  • Introduction
  • Language
  • Techniques
  • Windows Techniques
  • Software Project

Read: C++ In Action: Industrial Strength Programming

A Beginners C++

  • Author: Neil Gray
  • Format: Postscript, PDF (by chapter)
  • Price: free

This book is primarily intended to be a text for the programming component in an introductory two semester computer science course (some materials are a little advanced and might postponed to later semesters). This intent shows in terms of references to “students”, “assignments” and “later studies in computing”. However, the book should be equally suited to an individual who wants to learn how to program their own personal computer. If used as a text for an introductory computer science course, the contents of this book would normally be supplemented by a variety of other materials covering everything from “ethics” to “Turing machines”.

It is assumed that you are “computer literate”. In your school or college, or at work, you will have used word processing packages, and possibly other packages like spreadsheets and data bases. Although most schools do provide at a limited introduction to programming (usually in Pascal or possibly a dialect of Basic), this text does not rely on such past experience.

Note: this text was completed in 1996. C++ has been revised quite a bit since then! When the examples were written, C++’s “namespace” feature had been defined but was not supported on available compilers; so the examples don’t use namespace. (Of course, in modern C++ they should.)

Further, the iostream library has been updated. Some of the functions have changed their signatures; some features have been added, others removed.

So, be cautious with the code – it is well a little out of date.

Chapters include:

  • Computer Hardware
  • Programs: Instructions in the Computer
  • Operating Systems
  • Why have “high-level” languages?
  • C++ development environment
  • Sequence
  • Iteration
  • Selection
  • Simple use of files
  • Functions
  • Arrays
  • Programs with functions and arrays
  • Standard algorithms
  • Tools
  • Design and documentation
  • Enum, Struct, and Union
  • Examples using structs
  • Bits and pieces
  • Beginners’ Class
  • Dynamic data and pointers
  • Collections of data
  • A World of Interacting Objects
  • Intermediate class
  • Two more “trees”
  • Templates
  • Exceptions
  • Example: Supermarket
  • The Power of Inheritance and Polymorphism
  • Reusable designs
  • Frameworks for understanding

Read: A Beginner’s C++

Taligent’s Guide to Designing Programs: Well-Mannered Object-Oriented Design in C++

My image
  • Author: Taligent Inc.
  • Format: online HTML
  • Price: free

A quick overview of Object-oriented program design, with special regard for operating-system development, this book will be of the greatest interest to those developers who are working with Taligent and its operating partners, as well as many other C++ programmers who are interested in a provocative summary of good OOP techniques.

Chapters include:

  • Architectural goals
  • Object-oriented architecture
  • All interfaces are expressed through objects
  • Commonality is managed through inheritance
  • Objects are leveraged wherever possible
  • Frameworks provide the foundation
  • Let resources find you
  • Putting it all together
  • Reflect the client’s view
  • Let resources find you
  • Express all interfaces through objects
  • Preserve class invariants
  • Object-oriented design with C++
  • C++ doesn’t express full object interface
  • C++ requires definition of special member functions
  • Use type inheritance to share protocol
  • Useimplementation inheritance to override behavior
  • Design the interfaces between the base and derived classes
  • Guarantee use of derived classes as arguments
  • Implement full protocol in derived classes
  • Preserve semantics in a derived class
  • Avoid deep nesting in lightweight objects
  • Be aware of problems with virtual bases
  • Avoid multiple occurrences of a base
  • Design performance in
  • Conduct performance analysis
  • Perform controlled experiments
  • Use static objects instead of temporaries
  • Use chunky iteration for performance
  • Use cache objects
  • Object bloat
  • Lost object focus
  • Hardening of the architecture
  • Structification
  • Modulitis
  • Managers are not objects
  • Collections of functions are not objects
  • Encapsulation leakage
  • Empty base classes
  • Overeducated base classes
  • Overachieving base classes
  • Distinguish is-a from has-a relationships
  • Include copyright notices
  • Use comments
  • Include function prototypes
  • Do not use code names in filenames
  • Enclose definitions in header files
  • Include only related classes in one file
  • Use specific names
  • But use generic names for abstract base classes
  • Avoid abbreviations
  • Use special names for copy, create, and adopt routines
  • Use global names only for classes
  • Follow member function conventions
  • State explicit use of public, private, and protected
  • Use separate class definition sections
  • Avoid raw C types with dimensions
  • Use dimensionless raw C types
  • Avoid type casting
  • Silent coercion
  • Cast operators
  • Use consistent return types for assignment operators
  • State typedef class names before specifications
  • Pass variables when possible
  • Use array arguments instead of pointers
  • Limit default arguments
  • Avoid functions with unspecified arguments (…)
  • Avoid returning pointers without allocation
  • Use pointers to make multiple references
  • Use references for a one-time reference
  • Allocate storage only if you must
  • Pretend everything is a primitive
  • Use const instead of #define constants
  • Use enum instead of sets of constants
  • Use inlines instead of function macros
  • Use templates for specialized functions and classes
  • Don’t use goto
  • Avoid magic numbers
  • Avoid bit flags (& and |)
  • Avoid using arrays as local variables or object fields
  • Avoid homegrown utility classes
  • Use the Name Server
  • Hide allocation inside a class
  • Don’t assume use of a heap
  • Clarify ownership of storage in interfaces
  • Don’t use very large local variables or members
  • Avoid static objects
  • Modifiable statics in a library
  • Consider alternatives to temporary objects
  • Binary compatibility considerations
  • Adding virtual and nonvirtual functions
  • Changing a function from inline to noninline
  • Removing private nonvirtual functions not called by inlines
  • Using classes internal to your implementation
  • Use virtual functions if overrides are possible
  • Rearranging, adding, and removing private data members with restrictions
  • Inlines that call something else
  • Inline function definitions in .C files
  • Inlines for extreme efficiency
  • Don’t write inlines in declarations
  • Inlines for exporting private and protected members
  • Empty special members
  • Virtual inline functions where the type is not known
  • Define class abstractions
  • Decide now what might be overridden later
  • When to use pure virtual functions
  • Private virtual functions to control access
  • Base class constructors cannot call virtual functions
  • Destructors are not automatically virtual
  • Switch statements indicate polymorphism
  • When to use virtual assignment
  • Exceptions checklist
  • Exceptions syntax
  • Avoid interface specification
  • Perform resource recovery
  • Automatic objects
  • Passing exceptions
  • TJanitor
  • What to subclass
  • When to subclass
  • When to signal an exception
  • When to recover an exception
  • Strive for uniform distribution
  • Do not implement Hash via member functions
  • When equality does not apply
  • Equality between different types
  • Taxonomy of surrogates
  • Explicit masters
  • Handle surrogates
  • Hidden masters
  • Surrogates that view masters
  • Follow naming conventions
  • Use copy semantics wherever possible
  • Avoid storage manipulation in open code
  • Allocate subobjects on the heap for debugging
  • Synchronization techniques
  • Synchronization and problems with memory access
  • Synchronization of global and static variables
  • Shared memory between tasks
  • Shared heaps
  • Shared memory problems with const
  • Static destructors for subsystem cleanup
  • Create objects in a valid state
  • Use flattening rather than dynamic class instantiation
  • Check for self-assignment with operator=:
  • Balance overloaded operators
  • Use static members as constructors
  • Differentiate overloaded constructors
  • Hide implementation classes
  • Use nil pointer deletion
  • Issues in overloading and overriding classes
  • Control class access
  • Language and hardware assumptions
  • Safe assumptions
  • Bad assumptions
  • Synchronization
  • Portable data
  • Assembly language
  • Nonportable code
  • Template conventions
  • Include file conventions
  • General rules for implementation classes
  • The example class: an owning stack
  • Sharing the implementation through private inheritance
  • Class definitions
  • Naming conventions
  • Instance variables
  • Type-specific methods and implementation class constructors and destructors
  • Inlining the class template’s public methods
  • Class templates that inherit from specialized classes
  • An implementation sharing example
  • Sharing the implementation by delegating to a member
  • An example of delegating to a member
  • The delegation example’s naming conventions
  • The delegating-to-a-member example

No Bugs!: Delivering Error-Free Code in C and C++

  • Author: David Thielen
  • Format: PDF
  • Price: free

Most developers know that software is inherently buggy.  And most developers also, hopefully, want to eliminate these bugs before shipping a product.  This book is written for these people.

However, writing code with no major bugs (sorry, we haven’t yet reached the point of truly bug-free code yet), is a team effort.  It takes the work of more than just the developers.  It takes testers,  managers, support personnel, and many more.  And this book is aimed at these people too.

This book is designed to solve a problem – buggy code.  Because it is aimed at the problem instead of a specific audience (ie, just developers or just testers), parts of this book may not be interesting to certain audiences.  Chapters 3 – 10 are written mainly for developers.  Chapters 11 & 12 are written mainly for testers.

Yet the book is written to be read straight through.  If you want to develop minimally buggy code, then you have to understand all of the pieces that go into getting there.  Developers need to understand the test process.  Testers need to understand what the developers will be testing on their own. Most importantly, the managers and others responsible  for insuring that the whole organization works need to understand the process.  And as important, they need to insure that the process is actually being followed.

Finally, this book is written from the Windows/DOS/PC perspective.  While most of the ideas discussed are generic to any computing platform, many of the implementations are specific to the PC.  And some of the code is specific not only to the PC, but to specific compilers (stack checking has a tendency to be that way).

If you program on a platform other than the PC, in a language other than c, you will still find this book valuable but you will also find that it leaves a lot more work for you to incorporate the ideas here.

While this is an older book, written in the Win95 era, the first 2 chapters are still very relevant to the programmers of today.

Chapters include:

  • Introduction
  • What is a bug?
  • General Principles
  • Some Basic Tricks
  • Assert the World
  • Debug Printfs
  • Watching the Stack
  • Watching the Heap
  • File I/O
  • Special Tricks for c++
  • Special Tricks for assembly language
  • The Testing Process
  • Shipping the Product
  • Useful bug-discovery tools
  • Debug Message Boxes
  • Debug Second Monitor

Get the Book: No Bugs!
Get the additional disk content

RAD Studio 2007 Help: Win32

My image
  • Author: CodeGear
  • Format: archived HTML
  • Price: free

This is a zipped HTML version of Win32 section of the original help files that were included with RAD Studio 2007 and C++ Builder 2007. It is also relevant to Delphi 2007.

A CodeGear Developer Network membership is needed in order to download the .zip file. Registration is free.

Contents include:

  • Developing Reports for Your Win32 Applications
  • Debugging C++ Applications with CodeGuard Error Reporting
  • C++ Examples
  • C++ Reference
  • Win32 Developer’s Guide
  • Developing Windows Applications with Win32 Forms
  • Windows Overview
  • Developing a Windows Application
  • Procedures
  • Database Procedures
  • Interoperable Applications Procedures
  • Reporting Procedures
  • VCL Procedures
  • Web Services Procedures
  • WebSnap Procedures
  • Developing Web Applications with WebSnap
  • Win32 Web Applications Overview
  • Building a WebSnap Application
  • Developing Web Services with Win32 Applications
  • Developing Database Applications for the Win32 Platform
  • dbGo Overview
  • dbExpress Components
  • BDE Overview
  • Getting Started with InterBase Express
  • Developing Applications with VCL Components
  • Developing COM Applications

C++ Builder 6 Developer’s Guide

  • Author: Satya Kolachina
  • Format: archived PDF
  • Price: free (free registration required)

Targeted to intermediate and advanced programmers, this guide shows developers how to get the most from C++ Builder 6, and covers most of the features of the product in addition to providing an in-depth understanding of some of the current features. Numerous examples, diagrams, and tables help the reader understand the C++Builder 6 architecture and how the use of C++ language is made easy by this Borland product. Exclusive emphasis is made on the new features and technologies to make the book a must have for owners of books published on previous versions of the product.

A CodeGear Developer Network membership is needed in order to download the .zip file. Registration is free.

Borland C++ Builder 6 Help Files

  • Author: Borland/CodeGear
  • Format: archived PDF and HTML
  • Price: free

This is the original English Help files from Borland C++ Builder 6 containing examples and documentation. They have been made available because they are a good supplement to the documentation for more recent versions of C++ Builder, Turbo C++, and RAD Studio.

A CodeGear Developer Network membership is needed in order to download the .zip file. Registration is free.

Borland C++ Builder 6 Quick Start Pack

  • Author: Borland/CodeGear
  • Format: archived PDF
  • Price: free

This is a zip file containing 3 PDF’s of the C++ Builder 6 Developers Guide, Object Pascal Language Guide, and Quick Start product documentation.

A CodeGear Developer Network membership is needed in order to download the .zip file. Registration is free.

CodeGear RAD Studio 2007 Help Files

  • Author: Borland/CodeGear
  • Format: archived CHM
  • Price: free

This is a zip file containing 3 CHM files of the original RAD Studio 2007 help files, relevant to C++Builder 2007 and Delphi 2007. These also include bugfixes since June 1 2007.

A CodeGear Developer Network membership is needed in order to download the .zip file. Registration is free.

Cross-Platform GUI Programming with wxWidgets

My image
  • Author: Julian Smart, Kevin Hock, Stefan Csomor
  • Format: PDF
  • Price: free

wxWidgets is an easy-to-use, open source C++ API for writing GUI applications that run on Windows, Linux, Unix, Mac OS X, and even Pocket PC, supporting each platform’s native look and feel with virtually no additional coding.

Now, its creator and two leading developers teach you all you need to know to write robust cross-platform software with wxWidgets. This book covers everything from dialog boxes to drag-and-drop, from networking to multithreading. It includes all the tools and code you need to get great results, fast.

From AMD to AOL, Lockheed Martin to Xerox, world-class developers are using wxWidgets to save money, increase efficiency, and reach new markets. With this book, you can, too.

Chapters include:

  • Introduction
  • Getting Started
  • Event Handling
  • Window Basics
  • Drawing and Printing
  • Handling Input
  • Window Layout Using Sizers
  • Using Standard Dialogs
  • Writing Custom Dialogs
  • Programming with Images
  • Clipboard and Drag and Drop
  • Advanced Window Classes
  • Files and Streams
  • Memory Management, Debugging, and Error Checking
  • Writing International Applications
  • Writing Multithreaded Applications
  • Programming with wxSocket
  • Working with Documents and Views
  • Perfecting Your Application
  • Installing wxWidgets
  • Building Your Own wxWidgets Applications
  • Creating Applications with DialogBlocks
  • Other Features in wxWidgets
  • Third-Party Tools for wxWidgets
  • wxWidgets Application Showcase
  • How wxWidgets Processes Events
  • Event Classes and Macros
  • Code Listings
  • Porting from MFC

C++ GUI Programming with Qt 3

My image
  • Author: Jasmin Blanchette, Mark Summerfield
  • Format: PDF
  • Price: free

This book covers all you need to build industrial-strength applications with Qt 3.2.x and C++–applications that run natively on Windows, Linux/Unix, Mac OS X, and embedded Linux with no source code changes!

The book teaches solid Qt programming practices; it is not a rehash of the documentation.

Already using Qt or just starting out? Evaluating Qt or managing it? Building open source applications–or commercial applications? Want to develop for Windows without buying an expensive compiler? Whatever your goal, this is the only book you need.

Chapters include:

  • Getting Started
  • Creating Dialogs
  • Creating Main Windows
  • Implementing Application Functionality
  • Creating Custom Widgets
  • Layout Management
  • Event Processing
  • 2D and 3D Graphics
  • Drag and Drop
  • Input/Output
  • Container Classes
  • Databases
  • Networking
  • XML
  • Internationalization
  • Providing Online Help
  • Multithreading
  • Platform-Specific Features
  • Installing Qt
  • Qt’s Class Hierarchy

Thinking in C++ 2nd Edition (Volumes 1 & 2)

  • Author: Bruce Eckel
  • Format: online HTML, archived PDF
  • Price: free

Bruce Eckel has kindly provided his books “Thinking in C++, Second Edition” free of charge to on-line readers.

Volume 1: Introduction to Standard C++

Fully revised and beefed up with plenty of new material on today’s Standard C++, the new edition of Bruce Eckel’s Thinking in C++: Volume I is an excellent tutorial to mastering this rich (and sometimes daunting) programming language, filled with expert advice and written in a patient, knowledgeable style.

The effective presentation, along with dozens of helpful code examples, make this book a standout. The text first sets the stage for using C++ with a tour of what object-oriented programming is all about, as well as the software design life cycle.

The author then delves into every aspect of C++, from basic keywords and programming principles to more advanced topics, like function and operator overloading, virtual inheritance, exception handling, namespaces, and templates.

C++ is a complex language, and the author covers a lot of ground using today’s Standard C++, but without getting bogged down in excessive detail.

Chapters include:

  • Introduction to Objects
  • Making & Using Objects
  • The C in C++
  • Data Abstraction
  • Hiding the Implementation
  • Initialization & Cleanup
  • Function Overloading & Default Arguments
  • Constants
  • Inline Functions
  • Name Control
  • References & the Copy-Constructor
  • Operator Overloading
  • Dynamic Object Creation
  • Inheritance & Composition
  • Polymorphism & Virtual Functions
  • Introduction to Templates

Volume 2: Practical Programming

Best selling author Bruce Eckel has joined forces with Chuck Allison to write Thinking in C++, Volume 2, the sequel to the highly received and best selling Thinking in C++, Volume 1. Eckel is the master of teaching professional programmers how to quickly learn cutting edge topics in C++ that are glossed over in other C++ books.

In Thinking in C++, Volume 2, the authors cover the finer points of exception handling, defensive programming and string and stream processing that every C++ programmer needs to know. Special attention is given to generic programming where the authors reveal little known techniques for effectively using the Standard Template Library.

In addition, Eckel and Allison demonstrate how to apply RTTI, design patterns and concurrent programming techniques to improve the quality of industrial strength C++ applications.
This book is targeted at programmers of all levels of experience who want to master C++.

Chapters include:

  • Introduction
  • Exception Handling
  • Defensive Programming
  • Strings in Depth
  • Iostreams
  • Templates in Depth
  • Generic Algorithms
  • Generic Containers
  • Runtime Type Identification
  • Multiple Inheritance
  • Design Patterns
  • Concurrency

online HTML Volume 1:

online HTML Volume 2:

archived PDF:

.NET Book Zero

My image
  • Author: Charles Petzold
  • Format: PDF and XPS, with downloadable source code
  • Price: free

This book is an introduction to C# and the Microsoft .NET Framework for programmers who have experience with C or C++.

Chapters include:

  • Why This Book?
  • Why .NET?
  • Runtimes and SDKs
  • Edit, Compile, Run, Disassemble
  • Strings and the Console
  • Primitive Data Types
  • Operators and Expressions
  • Selection and Iteration
  • The Stack and the Heap
  • Arrays
  • Methods and Fields
  • Exception Handling
  • Classes, Structures, and Objects
  • Instance Methods
  • Constructors
  • Concepts of Equality
  • Fields and Properties
  • Inheritance
  • Virtuality
  • Operator Overloading
  • Interfaces
  • Interoperability
  • Dates and Times
  • Events and Delegates
  • Files and Streams
  • String Theory
  • Generics
  • Nullable Types

Object-Oriented System Development

My image
  • Author: Dennis de Champeaux, Douglas Lea, and Penelope Faure
  • Format: online HTML
  • Price: free

This book is intended to help the reader better understand the role of analysis and design in the object-oriented software development process. Experiments to use structured analysis and design as precursors to an object-oriented implementation have failed. The descriptions produced by the structured methods partition reality along the wrong dimensions. Classes are not recognized and inheritance as an abstraction mechanism is not exploited.

However, we are fortunate that a multitude of object-oriented analysis and design methods have emerged and are still under development. Core OO notions have found their home place in the analysis phase. Abstraction and specialization via inheritance, originally advertised as key ingredients of OO programming, have been abstracted into key ingredients of OO analysis (OOA). Analysis-level property inheritance maps smoothly on the behavior inheritance of the programming realm.

While the book is mostly self-contained, people report that it does not serve as an introductory OO text. It helps to have had some previous exposure to basic OO concepts.

Chapters Include:

Part 1: Analysis

  • Introduction to Analysis
  • Object Statics
  • Object Relationships
  • Object Dynamics
  • Object Interaction
  • Class Relationships
  • Instances
  • Ensembles
  • Constructing a System Model
  • Other Requirements
  • The Analysis Process
  • Domain Analysis
  • The Grady Experience

Part II: Design

  • From Analysis to Design
  • Description and Computation
  • Attributes in Design
  • Relationships in Design
  • Designing Transitions
  • Interaction Designs
  • Dispatching
  • Coordination
  • Clustering Objects
  • Designing Passive Objects
  • Performance Optimization
  • From Design to Implementation