Ideas for 991: Facetop

1
Ideas for 991 Facetop

• Add video recording and hyperlinking to Tablet
  Facetop
• 3-head and n-way Facetop for collaboration
• Video techniques for enhancement of images
  (outlining, background removal)
• Medical data collaborations

2
Ideas Design Patterns

• New ways of adding variance to pattern
  definitions
• Training mode create pattern definitions from
  canonical example programs
• Are patterns arbitrary? How can the MDL (Minimum
  Description Length) principle be used to explain
  patterns

3
Ideas Bioinformatics Tools

• Create tool interconnection methods using Aspect
  Oriented Programming and Java, Python
  bioinformatics tools
• Adapt tool interconnection methods to
  implementation on grids
• Adapt tool interconnections to the VCL (Virtual
  Computing Lab) clusters

4
Collaborative Software EngineeringDavid Stotts
5
(No Transcript)
6
(No Transcript)
7
(No Transcript)
8
(No Transcript)
9
(No Transcript)
10
The Basic Facetop
11
(No Transcript)
12
(No Transcript)
13
(No Transcript)
14
Dual-head Collaborative FaceTop
15
(No Transcript)
16
(No Transcript)
17
(No Transcript)
18
(No Transcript)
19
(No Transcript)
20
(No Transcript)
21
(No Transcript)
22
(No Transcript)
23
Background Clutter
24
Complex Data
25
Video Outlines
26
Assistive Technology
27
(No Transcript)
28
(No Transcript)
29
(No Transcript)
30

31

32
Design Pattern Discovery and Architecture
AnalysisDavid Stotts
33
Example Pattern

• Composite

34
In reality, they look like this
// Composite pattern -- Structural example using
Systemusing System.Textusing
System.Collections// "Component"abstract
class Component  // Fields  protected string
name // Constructors  public Component(
string name )  this.name name //
Methods  abstract public void Add(Component
c)  abstract public void Remove( Component c
)  abstract public void Display( int depth
)// "Composite"Class Composite
Component  // Fields  private ArrayList
children new ArrayList()  // Constructors 
public Composite( string name ) base( name )
 // Methods  public override void Add(
Component component )  children.Add( component
)   public override void Remove( Component
component )  children.Remove( component ) 
public override void Display( int depth ) 
Console.WriteLine( new String( '-', depth )
name )    // Display each of the node's
children    foreach( Component component in
children )      component.Display( depth 2
) 
// "Leaf"class Leaf Component //
Constructors  public Leaf( string name ) base(
name )   // Methods  public override void
Add( Component c )  Console.WriteLine("Cannot
add to a leaf")   public override void
Remove( Component c )  Console.WriteLine("Canno
t remove from a leaf")   public override void
Display( int depth )  Console.WriteLine( new
String( '-', depth ) name ) public class
Client  public static void Main( string args
)     // Create a tree structure    Composite
root new Composite( "root" )    root.Add( new
Leaf( "Leaf A" ))    root.Add( new Leaf( "Leaf
B" ))    Composite comp new Composite(
"Composite X" )    comp.Add( new Leaf( "Leaf
XA" ) )    comp.Add( new Leaf( "Leaf XB" )
)    root.Add( comp )    root.Add( new Leaf(
"Leaf C" ))    // Add and remove a leaf   
Leaf l new Leaf( "Leaf D" )    root.Add( l
)    root.Remove( l )    // Recursively
display nodes    root.Display( 1 ) 
35
Or this
// Purpose. Composite //
Strategy. Use recursive composition
// to create a
heterogeneous aggregate include ltstring.hgt
// that can be treated
homogeneously. enum NodeType FileT, DirT
// int g_indent 0
// Benefit. No more type checking and
// type casting
(coupling between Dir class File
// and File is gone, Dir is
only public //
coupled to abstract base class) File( char n
) type_ FileT strcpy( name_, n )
class AbsFile NodeType getType()
return type_ public void ls()
virtual void ls() 0 for
(int i0 i lt g_indent i) protected
cout ltlt ' ' char
name_20 cout ltlt name_ ltlt endl
static int indent_ private
NodeType type_
int AbsFileindent_ 0 char
name_20
class File public AbsFile
public class Dir
File( char n ) public
strcpy( name_,
n ) Dir( char n ) type_ DirT
void ls() strcpy( name_, n ) total_ 0
for (int i0 i lt indent_ i)
NodeType getType() return type_
cout ltlt ' ' void add( File f )
cout ltlt name_ ltlt endl
files_total_ f void
ls() class Dir
public AbsFile for (int i0 i lt
g_indent i) public cout ltlt ' '
Dir( char n ) cout ltlt
name_ ltlt "" ltlt endl strcpy( name_, n
) total_ 0 g_indent 3
void add( AbsFile f ) for (int
i0 i lt total_ i) files_total_
f if (files_i-gtgetType()
void ls() DirT)
for (int i0 i lt indent_ i)
((Dir) files_i)-gtls() cout ltlt '
' else
cout ltlt name_ ltlt "" ltlt endl
files_i-gtls() indent_ 3
g_indent - 3 for
(int i0 i lt total_ i) private
files_i-gtls()
NodeType type_
indent_ - 3 char name_20
private File files_10
AbsFile files_10 int
total_ int
total_
void main( void ) void
main( void )
Dir one("1"), two("2"), thr("3")
Dir one("1"), two("2"), thr("3") File
a("a"), b("b"), c("c"), File a("a"),
b("b"), c("c"), d("d"), e("e")
d("d"), e("e") one.add( a )
one.add( a )
one.add( (File) two ) one.add(
two ) one.add( b )
one.add( b ) two.add( c )
two.add( c ) two.add( d )
two.add( d ) two.add(
(File) thr ) two.add( thr )
thr.add( e ) thr.add(
e ) one.ls()
one.ls()

36
Or this
(defgeneric add-dependent (dm dependent
ampoptional recursivep) see below for the
optional args (documentation quotAdd
DEPENDENT as a dependent of DM. Return
DMquot)) (defgeneric delete-dependent (dm
dependent ampoptional recursivep)
(documentation quotRemove DEPENDENT from
DM. Return DMquot)) No DELETE-DEPENDENT-IF
(defgeneric map-dependents (f dm)
(documentation quotMap F over the
dependents of DM. Return DMquot)) No
cursors. (defgeneric make-collection-for-dependen
t-mixin (dm)) (defclass dependent-mixin ()
something that has dependents. We expose the
DEPENDENTS slot. ((dependents reader
dependents-of))) (defmethod make-collection-for-d
ependent-mixin ((dm dependent-mixin))
(make-instance 'simple-childed-mixin)) (defmethod
initialize-instance after ((dm dependent-mixin)
ampkey) (setf (slot-value dm
'dependents) (make-collection-for-dependent-mixin
dm))) (defmethod add-dependent ((dm
dependent-mixin) dependee ampoptional
recursivep) (declare (ignorable recursivep))
(add-child (dependents-of dm) dependee)
dm) (defmethod delete-dependent ((dm
dependent-mixin) dependee ampoptional
recursivep) (declare (ignorable recursivep))
(delete-child (dependents-of dm) dependee)
dm) (defmethod map-dependents (f (dm
dependent-mixin)) (map-over f (dependents-of
dm)) dm)
A solution must be language independent
37
Patterns Intertwingled

• All non-trivial designs
• involve many
• cross-mixed
• patterns

Same class might be a component in 4 or 5
patterns
38
SPQR System
Source code
gcc
gcc2oml
gcc parse tree
object XML
oml2otter
Source-code-specific otter clauses
Found patterns report
Rho calculus compos rules
EDP catalog
python
Otter theorem prover
Otter proofs
39
Extension via Training

• Hundreds of patterns are named and in use
• How do we get these into the formal dictionary?
  Must a programmer be a r-calculus expert?
• New patterns can be added via training
• Write a canonical program that contains the
  necessary and sufficient code components
  comprising the pattern ( and little else )

40
Other forms of Variance

• Vary by type inheritance
• Get the photo of whiteboard
• MDL explains patterns existence

41
Are Patterns Arbitrary?

• Why are patterns the way they are?
• MDL Minimum Description Length, principle from
  information theory (Occams Razor)
• MDL may explain it GoF are minimal in several
  measures that make sense for software complexity
• Software Architecture

42
Prototyping for Systems ScienceDavid Stotts
43
Information Flow in Systems Toxicology
44
Multi-media Modeling
file of int, 5 per line
Air model
file of float, one per line with 3 ints after
5 minute steps
Access DB out
Water model
Unix pipe of char in
3 hour steps
soil model
1 month steps
45
Model Federations
No scientist has expertise for the
whole Scientists must be able to develop
components individually i.e., not be software
engineers working as a cohesive team Component
models must interoperate
Air model
Water model
soil model
46
Model Federations
Mismatch management module
Air model
5 minute steps
Water model
3 hour steps
soil model
1 month steps
47
New Areas

• Human lung model biochemistry, fluid dynamics,
  protein motors and cilia mechanics, cell
  physiology for cystic fibrosis research

48
AOP Infrastructure
49
Model Federations
Mismatch management module
Air model
5 minute steps
Aspects
Water model
3 hour steps
soil model
1 month steps