Cover art: Tahl Kaminer


Codecharts

Roadmaps and Blueprints for Object-Oriented Programs

Sample chapters:
Chapter 3: An overview of Codecharts
Chapter 4: UML vs. Codecharts
Chapter 7: Modelling large programs
Chapter 11: Modelling design patterns
Chapter 17: LePUS3 in classical logic

A.H. Eden, with contributions from J. Nicholson

Copyright (C) John Wiley and Sons, 2011

NEW: Complete text available online

New Modelling Language Visualizes Programs Clearly and Precisely

Popular software modelling notations visualize implementation minutiae but fail to scale, to capture design abstractions, and to deliver effective tool support. Tailored to overcome these limitations, Codecharts can elegantly model roadmaps and blueprints for Java, C++, and C# programs of any size clearly, precisely, and at any level of abstraction. More practically, significant productivity gains for programmers using tools supporting Codecharts have been demonstrated in controlled experiments.

Hundreds of figures and examples in this book illustrate how Codecharts are used to

  • Visualize the building–blocks of object–oriented design
  • Create bird's–eye roadmaps of large programs with minimal symbols and no clutter
  • Model blueprints of patterns, frameworks, and other design decisions
  • Be exactly sure what diagrams claim about programs and reason rigorously about them

Tools supporting Codecharts are also shown here to

  • Recover design from plain Java and visualize the program's roadmap
  • Verify conformance to design decision with a click of a button

The book includes two main parts:

Practice (Part I) offers experienced programmers, software designers and software engineering students practical tools for representing and communicating object–oriented design. It demonstrates how to model programs, patterns, libraries, and frameworks using examples from JDK, Java 3D, JUnit, JDOM, Enterprise JavaBeans, and the Composite, Iterator, Factory Method, Abstract Factory, and Proxy design patterns.

Sample chapters:

Theory (Part II) offers a mathematical foundation for Codecharts to graduate students and researchers studying software design, modelling, specification, and verification. It defines a formal semantics and a satisfies relation for design verification, and uses them to reason about the relations between patterns and programs (e.g., "java.awt implements Composite" and "Factory Method is an abstraction of Iterator").

Sample chapter:

Table of Contents

Guide to the reader

Acknowledgements

Prologue

Chapter 1: Motivation

Chapter 2: Design description languages

2.1 Theory vs. practice

2.2 Decidability

2.3 Abstraction

2.4 Elegance

Chapter 3: An overview of Codecharts

3.1 Object-orientation

3.2 Visualization

3.3 Rigour

3.4 Automated verifiability

3.5 Scalability

3.6 Genericity

3.7 Minimality

3.8 Information neglect

Chapter 4: UML vs. Codecharts

Chapter 5: Historical notes

PART I: Practice

Chapter 6: Modelling small programs

6.1 Modelling individual classes

6.2 Modelling individual methods

6.3 Modelling properties

6.4 * Modelling implementation minutia

6.5 Modelling simple relations

6.6 Modelling indirect relations

6.7 * Subtyping

Chapter 7: Modelling large programs

7.1 Modelling sets of classes

7.2 Modelling total relations between sets

7.3 Modelling sets of methods (clans)

7.4 * Modelling isomorphic relations

7.5 Modelling sets of methods (tribes)

7.6 Modelling class hierarchies

7.7 Modelling methods in hierarchies

7.8 Modelling properties of sets

7.9 * Case study: total vs. isomorphic

7.10 Case study: JDOM

7.11 Case study: Java 3D

Chapter 8: * Modelling industry-scale programs

8.1 Modelling sets of hierarchies

8.2 Modelling sets of sets of methods (clans)

8.3 Modelling sets of sets of methods (tribes)

8.4 Modelling total relations revisited

8.5 Modelling isomorphic relations revisited

Chapter 9: Modelling design motifs

Chapter 10: Modelling application frameworks

10.1 Case study: Enterprise JavaBeans

10.2 Case study: JUnit

Chapter 11: Modelling design patterns

11.1 Case study: the Composite pattern

11.2 Case study: the Iterator Pattern

11.3 Case study: the Factory Method pattern

11.4 * Case study: the Abstract Factory pattern

11.5 * Concluding remarks

Chapter 12: Modelling early design revisited

Chapter 13: * Advanced modelling techniques

13.1 Ad-hoc symbols

13.2 Modelling information hiding

PART II: Theory

Chapter 14: Abstract semantics

14.1 Finite structures

14.2 Abstract semantics functions

14.3 Design models

14.4 Program modelling revisited

Chapter 15: Verification

15.1 Verifying closed specifications

15.2 Verifying open specifications

15.3Verifying pattern implementations

15.4 Tool support for automated verification

Chapter 16: * Schemas

Chapter 17: LePUS3 in classical logic

17.1LePUS3 and Class-Z as first-order languages

17.2 Specifications in the predicate logic

17.3 The axioms of class-based programs

Chapter 18: Reasoning about charts

Appendices

Appendix I: The ‘gang of four’ companion

Appendix II: Formal definitions

Appendix III: UML quick reference

Appendix IV: References

Appendix V: Index