The document discusses software frameworks and provides examples. Key points: - Frameworks balance reuse and specialization through foundation methods that provide common functionality and deferred methods that allow specialization. - Frameworks provide reuse of high-level abstractions rather than just low-level code. - Examples include a sorting framework, GUI framework, simulation framework, and Java applet framework. Frameworks combine many classes to provide structure that can be specialized.

1. Introduction Summary References
SOFTWARE FRAMEWORKS
Muhammad Adil Raja
Roaming Researchers, Inc.
cbna
April 22, 2015

2. Introduction Summary References
OUTLINE I
1 INTRODUCTION
2 SUMMARY
3 REFERENCES

3. Introduction Summary References
INTRODUCTION
Software frameworks are one of the primary means for
large scale software reuse, and rapid application
development.
In this chapter we will examine the technologies that make
software frameworks possible.
The Tension between Reuse and Specialization.
Reuse of Code, Reuse of Concept.
High and Low Level Abstractions.
Some Example Frameworks.

4. Introduction Summary References
TENSION BETWEEN REUSE AND SPECIALIZATION
A truly general purpose tool cannot contain features
specific to any one application.
Solving most problems requires application specific
features.
How do you bridge the gap between general purpose and
application independent tools and an application that will
solve a real problem?

5. Introduction Summary References
REUSE OF CODE, REUSE OF CONCEPT
The solution comes from the two ways we have been using
inheritance from the beginning of the book.
Reuse of code.
Certain methods, call foundation methods, are defined in a
general purpose class.
These provide functionality that is common to many
applications.
Reuse of concept.
Other methods, called specialization methods, are defined
in a parent class, but overridden in child classes.
These provide the means to specialize an application to a
new situation.

6. Introduction Summary References
A SIMPLE EXAMPLE, A GUI SYSTEM
A simple example might be a framework for user
interfaces:
Class Window: methods.
foundation: setTitle, setWindowSize, moveWindowTo,
addMenu, repaint
specialization: mouseDown, keyPress, paint
class Childwindow: methods
paint, mouseDown, keyPress
The foundation method are applicable to any type of
window.
The deferred specialization methods are appropriate only
to one type of application.

7. Introduction Summary References
DEFERRED METHODS
By working with deferred methods, the application class
views the application in one way, and the child class in
another.

8. Introduction Summary References
REUSE OF HIGH LEVEL ABSTRACTIONS
Software frameworks provide a different type of reuse:
Conventional libraries of procedures provide a means for
reuse of low level abstractions (I/O libraries, math
functions, and so on).
Software frameworks provide a means for reuse of high
level abstractions, and still allow them to be specialized for
new situations.

9. Introduction Summary References
AN EXAMPLE OF A LOW LEVEL ABSTRACTION
SORTING EMPLOYEE RECORDS
Suppose we want to sort employee records. We could write the
following.
EXAMPLE
class Employee {
public :
s t r i n g name;
int salary ;
int startingYear ;
}
void sort ( Employee ∗ data [ ] , int n ) {
for ( int i = 1; i < n ; i ++) {
int j = i −1;
while ( j >= 0 &&
v [ j +1]−>startingYear < v [ j ]−>startingYear ) {
/ / swap elements
Employee ∗ temp = v [ j ] ;
v [ j ] = v [ j +1];
v [ j +1] = temp ;
j = j − 1;
}
}
}
But what happens if we want to change it?

10. Introduction Summary References
TYPES OF REUSE
We can reuse the idea of a merge sort, but cannot reuse
the binary without modifications to the original source
code.
Might want to sort on salary, instead of starting year.
Might want to do comparisons of string (e.g., name), not
integers.
Might want to sort a different type of structure.
To create an object-oriented software framework, we must
first ask ourselves what are the likely sources of change?

11. Introduction Summary References
A SORTING FRAMEWORK
EXAMPLE
class I n s e r t i o n S o r t e r {
public :
void sort ( ) {
int n = size ( ) ;
for ( int i = 1; i < n ; i ++) {
int j = i − 1;
while ( j >= 0 && lessThan ( j +1 , j ) ) {
swap( j , j +1);
j = j − 1;
}
}
}
private :
v irtual int size ( ) = 0; / / abstract methods
v irtual boolean lessThan ( int i , int j ) = 0;
v irtual void swap( int i , int j ) = 0;
}
The part that is common in made into a foundation method, the
part that changes are made into deferred methods.

12. Introduction Summary References
SPECIALIZING THE SORTING FRAMEWORK
To apply the framework to a new problem, we subclass and
override the deferred methods:
EXAMPLE
class EmployeeSorter : public I n s e r t i o n S o r t e r {
public :
EmployeeSorter ( Employee ∗ d [ ] , int n )
{ data = d ; sze = n ; }
private :
Employee ∗ data [ ] ;
int sze = n ;
v irtual int size ( ) { return sze ; }
v irtual bool lessThan ( int i , int j )
{ return data [ i ]−>startingYear < data [ j ]−>startingYear ; }
v irtual void swap ( int i , int j ) {
Employee ∗ temp = v [ i ] ;
v [ i ] = v [ j ] ;
v [ j ] = temp ;
}
}

13. Introduction Summary References
NOT ONE CLASS
The impression that a framework is always just one class is
wrong.
Often, a framework is a collection of many classes.
For example, a typical GUI framework might have.
Window classes.
Button or scroll bar classes.
Text box classes.
All can be specialized by the combination of foundation
methods for overall structure, and deferred methods for
specialization.

14. Introduction Summary References
FLEXIBILITY AND RIGIDITY
A framework can be tremendously helpful in allowing a
programmer to rapidly create new application, but only
when the application fits into the general structure
envisioned by the creator of the framework.
If an application falls outside that framework, then it can be
very difficult to overcome the framework.
For example, if the designer of the framework has not
encapsulated the right sources of variation in a method, or
has forgotten to declare a method as virtual, then it can be
very difficult to work with.

15. Introduction Summary References
AN EXAMPLE API
THE JAVA APPLET API
The Java Applet API is one simple example of a software
framework.
init() Invoked when the applet is initialized
start() Invoked to start the application
paint(Graphics) Invoked to repaint the window
stop() Invoked when the applet is halted
destroy() Invoked when the applet is terminated
Lots of
other classes for constructing buttons and menus, and so on.

16. Introduction Summary References
SIMULATION FRAMEWORK
Here is a framework like we might use in Chapter 7 (the
billiards game).
EXAMPLE
GraphicalObject = object
(∗ data f i e l d s ∗)
l i n k : GraphicalObject ;
region : Rect ;
(∗ i n i t i a l i z a t i o n function ∗)
procedure setRegion ( l e f t , top , r i gh t , bottom : integer ) ;
(∗ operations that graphical objects perform ∗)
procedure draw ;
procedure update ;
function i n t e r s e c t ( anObj : GraphicalObject ) : boolean ;
procedure hitBy ( anObj : GraphicalObject ) ;
end ;

17. Introduction Summary References
A GENERALIZED EVENT DRIVEN SIMULATION
FRAMEWORK I
A generalized discrete event-driven simulation can be formed
based around the class Event:
EXAMPLE
class Event {
public :
Event ( unsigned int t ) : time ( t ) { }
const unsigned int time ;
v irtual void processEvent ( ) = 0;
} ;
class eventComparison {
public :
bool operator ( ) ( event ∗ l e f t , event ∗ r i g h t )
{ return l e f t −>time > r ig h t −>time ; }
} ;

18. Introduction Summary References
A GENERALIZED EVENT DRIVEN SIMULATION
FRAMEWORK II
An event is an action that will take place at a specific time.
Discrete event driven simulations were the type of
application that helped drive the design of the first
object-oriented programming language, Simula. (Early
1960’s).

19. Introduction Summary References
THE SIMULATION CLASS I
CODE
class Simulation {
public :
Simulation ( ) : eventQueue ( ) , currentTime (0) { }
void scheduleEvent ( event ∗ newEvent ) { eventQueue . push ( newEvent ) ; }
void run ( ) ;
unsigned int currentTime ;
protected :
priority_queue <vector , eventComparison> eventQueue ;
} ;
void Simulation : : run ( ) {
/ / execute events u n t i l event queue becomes empty
while ( ! eventQueue . empty ( ) ) {
event ∗ nextEvent = eventQueue . top ( ) ;
eventQueue . pop ( ) ;
time = nextEvent−>time ;
nextEvent−>processEvent ( ) ;
delete nextEvent ;
}
}

20. Introduction Summary References
THE SIMULATION CLASS II
The book continues with the development of a simulation
based on this framework.

21. Introduction Summary References
SUMMARY
A framework is a way of organizing classes so as to solve
a class of related problems
The framework balances software reuse and the ability to
specialize a tool to a new application
The framework achieves this by combining inheritance of
code and inheritance of concept (overriding).
Frameworks can be developed for any application where
you can extract and generalize the ways in which code will
change.
Frameworks are great if your new application fits the
scheme of the designed, but very inflexible if it does not.

22. Introduction Summary References
REFERENCES
Images and content for developing these slides have been
taken from the follwoing book with the permission of the
author.
An Introduction to Object Oriented Programming, Timothy
Budd.
This presentation is developed with Beamer:
Darmstadt, spruce.