Final Project Proposal

1
Final Project Proposal

• By Jian Zhang
• ICS 665
• Fall 2001

2
Project Objective

• This project aims to use advanced technology to
  develop a small program for education.
• Application Motivation
• Existing problemsMost students who major in
  computer science have problems in write the
  program because they do not understand the logic
  of the code and what does each line of the source
  code do.
• How to solve the problem By using advanced
  hypermedia and appropriate user interfaces,
• students can easily understand the source
  code and trace how the program works.

3
Project Design

• I will add heapsort algorithm and one more
  sort(eg. Insert sort) to the model.
• The structure of the model will follow Dr. Jan
  Stelovskys basic framework.
• The extension work includes animation and other
  futures that appropriate with the objective of
  the project.

4
Project Description I

• The program will be used for teaching purpose.
• The project was an applet which should be
  capable to teach students the principles of the
  HeapSort sorting algorithm.
• Step I JMF will be employed in the introduction
  part. The students can hear the audio and read
  the text on the screen, and get a basic idea
  about heapsort.
• Step II After the intuitive brainstorm, the
  students need to practice and virtualize the
  process of heapsort. That goes to animation part.

5
Project Description II

• Basic structure of GUI(see graph later)
• On the right side you can see a binary tree which
  is the imaginary representation of the heap
  structure.
• On the bottom left side, you will find the real
  array(BarShape) that has to be sorted. And on the
  top left, the used algorithm in a real code
  notation will be shown.
• Two heapsort in both panels(one is barsort, the
  other is animation of heapsort) are
  synchronized.

6
Project Description III

• Implementation
• First, an introduction of the heapsort, which
  includes the algorithm,UML, instruction, user
  manual, documentation( source code, Complexity of
  the algorithm)..
• This part will be implemented by Java Media
  Framework(JMF). Users can listen introduction
  part
• of heapsort algorithm. A pop up window will
  be employed
• Second, let the user to see the animation of the
  heapsort algorithm. This part will be implemented
  by Java Sound, Swing, XML, DTD,JAXP. Multiple
  thread will be used to demo two heapsort shows.

7
Project Description VI

• The applet can be controlled with the buttons
  below the windows. The start" button runs the
  algorithm step by step, with the speed given with
  the scrollbar on the left. If you want to run it
  at your command you should choose "Next".
• The Algorithm will only move at your command.
• Pressing the "Restart" button will allow you to
  restart the Applet with a variable number of
  items (between 2 to 15) which can be randomly
  created or set by yourself.

8
Project Description V

• The program has more functions like the direction
  can be vertical and horizontal. We can have
  alignment bottom, top and center.we also can
  chose random, increase, decrease and constant to
  sort the value.

9
Technology employed

• XML, DTD, XML BINDING
• JAXP
• JMF
• SWING
• JAVA SOUND
• UML

10
Interface (part I)
11
Interface (part II)
12
Interface Final combination (blue print)
Heapsort source code (text format) (part I left
side)
Heapsort animation Demo (part II left side)
Bar chart animation demo (part I right side)
13
UML Diagram Design Pattern
14
Design Pattern-Mediator

• Mediator
• Define an object that encapsulates how a set of
  objects interact. Mediator promotes loose
  coupling by keeping objects from referring to
  each other explicitly, and it lets you vary their
  iteration independently.

15
Design Pattern-mediator (UML)
16
Sequence Diagram(Mediator)
17
UML and Design PatternArray/variable extension
18
UML Diagram Design Pattern Array/action2
extension
19
UML Diagram Design Pattern Array/main extension
20
One of the Pattern-Visitor
21
UML Diagram Design Pattern

• What Patterns that we have used so far?
• Abstract factory(util)
• Chain of responsibility
• Factory method(util)
• Iterator(array/array)
• Prototype(array/applet, array/action)
• Visitor(util)

22
UML Diagram Design Pattern

• What patterns I may plan to employ?
• Structure patterns
• Composite
• Decorator
• Flyweight(b-tree)
• Behavioral Patterns
• Chain of responsibility(handler)
• Mediator(listbox, textpane,button)
• Observer(multiple concrete observer)

23
Potential Problems

• May not have enough time to implement JMF
• May have problems to synchronize multiple thread
• Other technical problems?

24
Appendix Design Pattern creational Pattern

• Creational Pattern They help make a system
  independent of how its objects are created,
  composed, and represented.
• Prototype Specify the kinds of objects to create
  using a prototypical instance, and create new
  objects by copying this prototype.
• Abstract Factoryprovide an interface for
  creating families of related or dependent objects
  without specifying their concrete classes.
• BuilderSeparate the construction of a complex
  object from its representation so that the same
  construction process can create different
  representation.

25
Appendix Design Pattern Creational Pattern

• SingletonEnsure a class only has one instance,
  and provide a global point of access to it.
• Factory Define an interface for creating an
  object, but let subclasses decide which class to
  instantiate

26
Appendix Design Pattern Creational Pattern

• Creational Pattern They help make a system
  independent of how its objects are created,
  composed, and represented.
• Prototype Specify the kinds of objects to create
  using a prototypical instance, and create new
  objects by copying this prototype.
• Abstract Factoryprovide an interface for
  creating families of related or dependent objects
  without specifying their concrete classes.
• BuilderSeparate the construction of a complex
  object from its representation so that the same
  construction process can create different
  representation.

27
Appendix Design Pattern -Structural Patterns

• Structure patterns are concerned with how classes
  and objects are composed to form larger
  structures. Structure class patterns use
  inheritance to compose interfaces or
  implementations.
• AdapterConvert the interface of a class into
  another interface clients expect. Adapter lets
  classes work together that could not otherwise
  because of incompatible interfaces.
• Bridge Decouple an abstraction form its
  implementation so that the two can vary
  independently.
• Composite Compose objects into tree structures
  to represent part-whole hierarchies. Composite
  lets clients treat individual objects and
  compositions of objects uniformly.

28
Appendix Design Pattern -Structural Patterns

• Decorator Attach additional responsibilities to
  an object dynamically. Decorators provide a
  flexible alternative to subclassing for extending
  functionality.
• Façade Provide a unified interface to a set of
  interfaces in a subsystem. Façade defines a
  higher-level interface that makes the subsystem
  easier to use.
• Flyweight Use sharing to support large numbers
  of fine-grained objects efficiently.
• Proxy Provide a surrogate or placeholder for
  another object to control access to it.

29
Appendix Design Pattern -Behavioral
Patterns(object)

• Behavioral patterns are concerned with algorithms
  and the assignment of responsibilities between
  objects. It describe not just patterns of objects
  or classes but also the patterns of communication
  b/w them.
• Chain of Responsibility Avoid coupling the
  sender of a request to its receiver by giving
  more than one object a chance to handle the
  request. Chain the receiving objects and pass the
  request along the chain until an object handles
  it.(eg. Handler)
• Command Encapsulate a request as an object,
  thereby letting you parameterize clients with
  different requests, queue or log requests and
  support undoable operations.

30
Appendix Design Pattern -Behavioral
Patterns(object)

• Interpreter Given a language, define a
  representation for its grammar along with an
  interpreter that uses the representation to
  interpret sentences in the languages.
• Iterator Provide a way to access the elements of
  an aggregate object sequentially without exposing
  its underlying representation.
• Mediator Define an object that encapsulates how
  a set of objects interact. Mediator promotes
  loose coupling by keeping objects from referring
  to each other explicitly, and it lets you vary
  their iteration independently.

31
Appendix Design Pattern -Behavioral
Patterns(object)

• Memento Without violating encapsulation, capture
  and externalize an objects internal state so
  that the object can be restored to this state
  later.
• Observer Define a one-to-many dependency between
  objects so that when one object changes states,
  all its dependents are notified and updated
  automatically.
• State Allow an object to alter its behavior when
  its internal state changes. The object will
  appear to change its class.
• Strategy Define a family of algorithms,
  encapsulate each one, and make them
  interchangeable. Strategy lets the algorithm vary
  independently from clients that use it.

32
Appendix Design Pattern -Behavioral
Patterns(class)

• Template Method Define the skeleton of an
  algorithm in an operation, deferring some steps
  to subclasses. It lets subclasses redefine
  certain steps of an algorithm without changing
  the algorithms structure.
• Visitor Represent an operation to be performed
  on the elements of an object structure. Visitor
  lets you define a new operation without changing
  the classes of the elements on which it operates.