The SalesPoint Framework V2.0 Homepage

SalesPoint is a domain framework for creating point-of-sale simulation programs. A point-of-sale can be as simple as a ticket vending machine or as complex as a big supermarket with many departments. The simulations comprise both business with customers like selling, buying, or hiring out goods, and administrative tasks like accounting, refilling the stores, and putting new kinds of items on sale. Examples of applications that can and have been developed using the SalesPoint framework are briefly described on the applications page.

The SalesPoint framework was conceived as technical basis for undergraduate software engineering project courses and was applied successfully several times at the partner institutions in Dresden and Munich.

This page answers the following questions:

  1. Why and how use a framework for teaching?
  2. What user documentation is there?
  3. What additional material is available?
  4. Who dunnit all?

Rationale for basing undergraduate software engineering project courses on a domain framework:

In academic as well as industrial settings beginners will often join projects that are already well in progress. Finding out enough about the project's structure to be able to do your job is similar to learning how to apply a domain framework. A practical course based on one common framework offers several advantages: For most of the undergraduates, this is the first time they work in teams (of about 5 or 6 students) and participate in a systematic software development process (from requirements definition to maintenance). In an introductory software engineering course preceding the project course, the beginners learn about object-oriented (OO) methodology: In order to get a good start into their project work, students need both introductory and comprehensive documentation (see below).

There are other ways of using the SalesPoint framework:

Documentation for SalesPoint Users

The introductory documentation consist of a technical overview and a tutorial.

The SalesPoint technical overview page describes the general architecture of the SalesPoint framework in some technical detail. The main purpose is to give application developers a general idea of how the framework is structured, which kinds of ready-made components it offers and where to find the hooks for adapting it to your own application. This page is meant to be reread a few times: On first reading, try to get a first impression of what is in the framework. When working through the tutorial the overview may help you to keep the details in their proper place. Finally, when developing your own application, use the overview as a starting point when looking for features you need.

In the SalesPoint tutorial the developement of a sample application - a FastFood restaurant - is explained in detail. The FastFood restaurant example shows how a SalesPoint application would evolve in the phases (requirements analysis, design and prototype implementation) of an evolutionary software develoment process. A few samples of documents created in this process (use cases, preliminary handbook, class and state diagrams etc.) are shown. Since the aim is to demonstrate how to use the framework, there is a natural emphasis on implementation: a substantial part of the FastFood Java program is explained in a line-by-line fashion. In order to keep the tutorial in reasonable size, only a few use cases are carried through to the implementation.  Even so, the result is a mini SalesPoint application which can be compiled and run as a demo program.

The comprehensive documentation consists of a formal javadoc hypertext including a list of hook descriptions. It is not meant to be read from start to end but rather to be used on demand when problems arise.

The javadoc documentation briefly explains every class, method and attribute. It was automatically generated from formalized comments within the framework's program text. The length of a comment indicates the importance of that feature as judged by the framework developer.

Embedded within the javadoc documentation the hook descriptions point out the 'hot spot' regions where the framework developers thought adaptations likely to occur: either to fill in 'holes' in the framework or to overrule default solutions provided by the framework. The hooks name the problem and its context. Then they list the necessary steps required for carrying out the adaptation; this may include the use of other hooks. Finally, the 'constraints' and 'comments' sections point out facts to be considered when applying the hook.

There are quite a few links between the technical overview and the tutorial and many links from the introductory part into the formal javadoc part of the documentation.

For ease of printing (use landscape format for program text), the hypertext pages of the introductory documentation are comparatively long.

Material: References, Links, Downloads

In this section you can find:

References to SalesPoint publications

References to framework publications

There appear to be relatively few publications on frameworks. A few books and papers we are aware of:
  • D.F. D'Souza; A.C. Wills:

  • Objects, Components, and Frameworks with UML.
    Addison-Wesley, 1999.
  • M. Fayad, D. Schmidt, R. Johnson:

  • Building Application Frameworks: Object-Oriented Foundations of Framework Design
    John Wiley & Sons, 1999.
  • G. Froehlich, J. Hoover, L. Liu, P. Sorenson:

  • Hooking into Object-Oriented Application Frameworks.
    Proc. 1997 Intern. Conf. on Software Engineering, Boston, Mass.
  • G. Froehlich, J. Hoover, L. Liu, P. Sorenson:

  • Designing Object-Oriented Frameworks.
    In CRC Handbook of Object Technology, CRC Press, 1998.
  • D. Govoni:

  • Java Application Frameworks.
    John Wiley & Sons, 1999.
  • T. Lewis et al.:

  • Object-Oriented Application Frameworks.
    Manning Publications, 1995.
  • W. Pree: 

  • Komponenten-basierte Software-Entwicklung mit Frameworks.
    dpunkt, 1997.

    Links to overviews and useful software

    Most comprehesive link collections on Java, Frameworks, and OO Technology in general are maintained by Cetus: Our format for presenting hooks has been adapted from a paper found on the following page: Both the Salespoint framework v2.0 and the FastFood tutorial have been developed using the following software For creating your own UML diagrams the following tool might be useful:

    Download SalesPoint programs and documentation

    For developing SalesPoint applications you need to download (and include in your Java CLASSPATH) the following file containing the compiled version of the framework (in order to avoid maintenance overhead we do not distribute the framework's source code to application developers): For faster access, you can download the complete english on-line documentation or parts of it (zip files):

    Credits (organizations and persons)

    Development and maintenance of the SalesPoint framework are a joint effort of

    SalesPoint Framework v2.0

    For questions and comments regarding this page please contact

    Dr. Lothar Schmitz

    Last modified: Thursday, November 4, 1999 at 12:59