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:

• It is simpler to extend the application architecture predefined by the framework than to design it for each application from scratch. Also, the framework provides many domain-specific components that can be used 'off the shelf'.
• As pointed out above, learning your way around a given framework corresponds to a characteristic professional activity. Experience with this activity is likely to be reusable to some extent even in a non-object-oriented context.
• Beginners get a chance to learn good design by example: Frameworks by definition are designed for change. Therefore, they typically exhibit patterns that increase flexibility.
• For the organizers it is easy to define a number of similar projects and to scale the projects' complexity from moderate to reasonably hard.
• Since they are based on the same framework, all the different tasks are still comparable. If competition is desirable you can assign identical tasks to different teams (and get very different results).

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:

• basic notions (inculding encaspulation, delegation and inheritance),
• an OO language (Java) and its class library,
• an OO iterative development process (using CRC cards and UML as notations),
• patterns as proven solution to recurring problems and
• frameworks as application skeletons.

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:

• as a classroom example for frameworks and their application
• as the subject of a course on framework development and improvement

(interested parties can obtain the framework's sources for non-profit use)

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 (a few)
• Links to overviews and useful software
• Download SalesPoint programs and documentation

---

References to SalesPoint publications

 
Papers describing development, context of use, and practical experience with the SalesPoint framework:
 
1. Birgit Demuth; Heinrich Hussmann; Lothar Schmitz; Steffen Zschaler:

Using a Framework to Teach OOT to Beginners.
OOPSLA'98, Educators' Symposium, October 1998
PDF-file
 
2. Birgit Demuth; Lothar Schmitz; Steffen Zschaler: 

Verkaufsanwendungen auf Basis des Anwendungsframeworks SalesPoint.
erschienen in: Silvano Maffeis; Fridtjof Toenniessen; Christian Zeidler (Hrsg.):
Erfahrungen mit Java. Projekte aus Industrie und Hochschule.
PDF-file
 
3. Birgit Demuth; Heinrich Hussmann; Lothar Schmitz; Steffen Zschaler: 

Erfahrungen mit einem frameworkbasierten Softwarepraktikum.
in: Tagungsband des 6. Workshops Software-Engineering im Unterricht der Hochschulen, Teubner-Verlag, 1999
PDF-file
 
4. Steffen Zschaler: 

Technische Dokumentation zum Framework SalesPoint, Version 2.0.
Entwurf einer Belegsarbeit, September 1999
PDF-file
 
5. Birgit Demuth; Heinrich Hussmann; Lothar Schmitz; Steffen Zschaler:

A Framework-based Approach to Teaching OOT: Aims, Implementation, and Experience.
(submitted for publication)
PDF-file

---

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:

• On Java
• On Frameworks
• On OO Technology

Our format for presenting hooks has been adapted from a paper found on the following page:

• Hoover's papers

Both the Salespoint framework v2.0 and the FastFood tutorial have been developed using the following software

• JDK 1.2 from Sun
• NetBeans: free Java IDE for all Java platforms

For creating your own UML diagrams the following tool might be useful:

• Argo / UML: free UML-CASE-Tool  developed by University of California at Irvine

---

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):

• classes.jar

For faster access, you can download the complete english on-line documentation or parts of it (zip files):

• complete documentation (2229 KB)
• overview (179 KB) and tutorial (548 KB)
• javadoc (1374 KB) and hooks (164 KB)

Credits (organizations and persons)

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

• Software Technology Institute at Dresden University of Technology and
•   Software Technology Institute at University of the German Federal Armed Forces in Munich.


Development of versions 1.0 and 2.0 of the framework was in part financially supported by
 

• Institute for Technology of Intelligent Systems e.V. at University of the German Federal Armed Forces in Munich.




---

SalesPoint basic terminology and Smalltalk-based prototypes were developed in the early 90's by students in OO courses organized by Lothar Schmitz at the Ludwig-Maximilians-University Munich and at the University of the German Federal Armed Forces in Munich.

SalesPoint versions 0.5 ('97), 1.0 ('98) and most of 2.0 ('98) were developed by Steffen Zschaler. He created the javadoc formal documentation of the framework including the hot spots and hooks descriptions. He also authored the ticket vending machine tutorial (english) for versions 0.5 and 1.0.

Stephan Gambke and Sven Matznick contributed components to version 2.0 and created the FastFood tutorial (german version).

Organizational infrastructure including task descriptions and other documentation defining the projects was provided by the project leaders Birgit Demuth (Dresden) and Lothar Schmitz (Munich), who also supervised and directed the framework development.

Heinrich Hussmann provided the introductory course with its dense and rapid education up to the level of patterns and frameworks.

For questions and comments regarding this page please contact