Ballworld

Ballworld Design

• Fundamental Design Principle:   The Separation of the Variant from the Invariant
  • What is an abstract ball?What is an abstract ball??
    • The abstract ball, ABall
      • What methods are invariant?  
        • An object is defined by its behaviors
      • What about fields?   Does anyone on the outside care??
      • What is the process to update a ball? 
        • What needs to be done?
        • Can the entire process be described in terms of concrete processes or not?
      • Bouncing off walls
        • The problem of discrete motion -- need to reset position back inside of animation canvas.
        • Calculating the reflected position  (See homework instructions).
    • Design patterns (in approximate order of encounter):
      • Singleton  - in the supplied utility classes
      • Union - in the abstract-concrete ball heirarchy.
      • Observer-observable - in the dispatcher system
      • Template - in the ball updating method.
      • Strategy
      • Composite
      • Abstract Factory
      • Decorator
      • Command
  • Concrete ABall implementations (Inheritance-based architecture)
    
    • Union Design Pattern: Inheritance and Polymorphism
    • New ball instantiation issues 
      • dynamic class loading (see utilities in the Ballworld Provided Utilities code)
      • What needs to be specified?
• Animation technique
  • "Flipbook" animations -- create motion by diplaying different images at regular time intervals : 
    • Animation with still photos
    • Line drawing animation
  • javax.swing.Timer -- creates the "tick" that drives the animation process
  • Observer-observable -- Connects the timer tick to each ball via a "dispatching" process
    • The rest of the code does not care how the balls are notified, that is, the rest of the code is "decoupled" from the dispatching process.
    • ==> This means that the model code should delegate to something else to handle the dispatching process, i.e. delegate to a Dispatcher object to handle the updating of the balls.
    • Delegation results from the decoupling of the parts of a system.
• Implementation
  • Java generics refresher
  • Information about the Ballworld Provided Utilities code -- See the semester-specific page in Canvas for information on obtaining the provided code plus more up-to-date documentation on the library contents!
    • Generic dispatcher
  • Using Lambdas for Asynchronous Updating and Key Binding with Action Maps

Ballworld Topics:

• Inheritance-based Architecture
  • Connecting the Pieces
    • Communicating across the MVC architecture
• Composition-based Architecture
  • Faking out the GUI with Factories
    • Closures
    • 4 Pillars of Abstraction
    • Abstract Factory Design Pattern
    • Custom behaviors through currying
    • Generics for decoupling
• Command-dispatching Architecture
  • Painting:
    • Affine Transform-based Painting
      • Prototype design pattern
    • Superclasses as Service Providers
      • Template pattern extensibility hooks
      • Paint strategies
      • Prototype factories
      • Image management
  • Interactions:
    • Collisions
    • Commands as Deferred Behavior

Ballworld Demos:

• Inheritance-based Architecture
• Composition-based Architecture
  • Composition-based Architecture with Multiple Switchers --just something a little bit crazy to have fun with!
• Command-based Architecture
  • Fishworld: Composition-based Architecture with Paint Strategies and Command Dispatching
    • Fishworld Javadocs
  • Command-dispatching Architecture with Inter-ball Interactions
  • BallWar:  Command-dispatching Architecture with Inter-ball Interactions and User Interactions
• BuggerLab: A flocking and swarming simulation system -- a glimpse into the possibilities!

Recap Overview  

The effects of refining the line between variant and invariant behaviors:

• Inheritance ==> composition-based architecture
• Fixed semantics updating ==> command-based updating
• MVC architecture
• The 4 Pillars of Abstraction: -- A guide to abstract decomposition
  • Abstracted Structure
    • Polymorphic, inheritance-based structures
    • Recursive, composite-based structures
  • Abstracted Behavior
    • Strategies
    • Commands
  • Abstracted Construction
    • Factories
  • Abstracted Environment
    • Closures

Techniques for building complex systems:

• Composite patterns for dynamic composing of behaviors
• Factories for abstracted, encapsulated construction
• Communications through closures
• Template pattern processing and utilizing services provided by superclasses
• Abstract behaviors via strategies and commands
• Event-driven systems
• Prototype pattern
• Extensibility hooks

Misc. skills and topics

• Building GUIs
• Transformations as encapsulated processes
• Dynamic class loading, file loading from disks, etc.

© 2020 by Stephen Wong