Framework Design Using Framework Design Using Function GeneralizationFunction Generalization

H. Conrad Cunningham H. Conrad Cunningham 11 Pallavi Tadepalli Pallavi Tadepalli 1 1

Yi Liu Yi Liu 22

11 Computer & Information Science Computer & Information Science University of MississippiUniversity of Mississippi

22 Electrical Engineering & Computer Science Electrical Engineering & Computer Science South Dakota State UniversitySouth Dakota State University

22

OutlineOutline

Software frameworkSoftware framework MotivationMotivation Function generalizationFunction generalization Cosequential processingCosequential processing Binary tree traversalBinary tree traversal ConclusionConclusion Future workFuture work

33

Software FrameworkSoftware Framework

Generic application allowing creation Generic application allowing creation of members of family of related of members of family of related programsprograms

Reusable design expressed as set of Reusable design expressed as set of abstract classes and way they abstract classes and way they collaboratecollaborate

Common and variable aspects known Common and variable aspects known as as frozen spotsfrozen spots and and hot spotshot spots

FrameworkFramework

library

User-supplied code(application specific)

Hot spots

Frozen spots

44

MotivationMotivation

Nontrivial to identify needed hot spot Nontrivial to identify needed hot spot abstractionsabstractions

Difficult to specify hot spot behaviorsDifficult to specify hot spot behaviors

Need systematic generalization methodology Need systematic generalization methodology ExploreExplore function generalization function generalization

– incrementally generalize functional structure of incrementally generalize functional structure of specification to produce general applicationspecification to produce general application

– executable specification expressed as set of executable specification expressed as set of functions in Haskellfunctions in Haskell

55

HaskellHaskell

Purely functional languagePurely functional language– forces explicit consideration of computational forces explicit consideration of computational

effects (no implicit state)effects (no implicit state) Polymorphic, higher-order, first-class Polymorphic, higher-order, first-class

functions & user-defined algebraic data functions & user-defined algebraic data typestypes– enables generic programming enables generic programming

Concise, equational notationConcise, equational notation– allows convenient mathematical manipulationallows convenient mathematical manipulation

66

Function GeneralizationFunction Generalization

Create executable specification for a Create executable specification for a concrete application as Haskell programconcrete application as Haskell program

Define scope of familyDefine scope of family Identify frozen spots and hot spotsIdentify frozen spots and hot spots Analyze and design each hot spot systemAnalyze and design each hot spot system

– generalize Haskell program for hot spotgeneralize Haskell program for hot spot– transform simple function to generalized function transform simple function to generalized function

(e.g., with higher-order parameters)(e.g., with higher-order parameters) Transform generalized Haskell program to Transform generalized Haskell program to

Java frameworkJava framework

77

ExamplesExamples

1.1. Cosequential processingCosequential processing

2.2. Binary tree traversalBinary tree traversal

88

Cosequential ProcessingCosequential Processing

Coordinates processing of two input sequences Coordinates processing of two input sequences ordered by same total orderingordered by same total ordering

Create third sequence in incremental steps by Create third sequence in incremental steps by merging and matching input elementsmerging and matching input elements

Includes set operations and sequential file update Includes set operations and sequential file update applicationsapplications

A1…An

B1…Bn

CosequentialProcessing C1…Cn

Input sequences

Output sequence

99

Binary Tree TraversalBinary Tree Traversal

procedure preorder(t)procedure preorder(t)

{ if t null, then return;{ if t null, then return;

perform visit action for root of tree t;perform visit action for root of tree t;

preorder(left subtree of t);preorder(left subtree of t);

preorder(right subtree of t);preorder(right subtree of t);

}}

21

18

3 20

50

30

1

Preorder 21 18 3 1 20 50 30

1010

Cosequential Cosequential ProcessingProcessing H. C. Cunningham and P. Tadepalli. “Using H. C. Cunningham and P. Tadepalli. “Using

Function Generalization to Design a Function Generalization to Design a Cosequential Processing Framework,” In Cosequential Processing Framework,” In Proceedings of the 39th Hawaii Proceedings of the 39th Hawaii International Conference on System International Conference on System Sciences (HICSS)Sciences (HICSS), 10 pages, IEEE, January , 10 pages, IEEE, January 2006.2006.

1111

Process A1 and B1

Cosequential ProcessingCosequential Processing

Coordinates processing of two input sequences Coordinates processing of two input sequences ordered by same total orderingordered by same total ordering

Create third sequence in incremental steps by Create third sequence in incremental steps by merging and matching input elementsmerging and matching input elements

Includes set operations and sequential file update Includes set operations and sequential file update applicationsapplications

A1…An

B1…Bn

CosequentialProcessing C1…Cn

Input sequences

Output sequence

Write result C1 to

output

Process Ai and BjWrite C2 to

output

1212

Executable SpecificationExecutable Specification(Merging two ascending integer (Merging two ascending integer sequences)sequences)

merge0 :: [Int]->[Int]->[Int]merge0 :: [Int]->[Int]->[Int]

merge0 [] ys = ysmerge0 [] ys = ys

merge0 xs [] = xsmerge0 xs [] = xs

merge0 xs@(x:xs’) ys@(y:ys’)merge0 xs@(x:xs’) ys@(y:ys’)

| x < y = x : merge0 xs’ ys| x < y = x : merge0 xs’ ys

| x == y = x : merge0 xs’ ys’| x == y = x : merge0 xs’ ys’

| x > y = y : merge0 xs ys’| x > y = y : merge0 xs ys’

1313

Framework ScopeFramework Scope Process two ordered sequences of Process two ordered sequences of

values to produce third ordered values to produce third ordered sequencesequence

Use ordering to restrict to a few Use ordering to restrict to a few current values from sequencescurrent values from sequences

Include classic examples:Include classic examples:– sequential file update programssequential file update programs– set and bag operationsset and bag operations

1414

Frozen SpotsFrozen Spots

1.1. Input sequences have same total orderingInput sequences have same total ordering2.2. Input sequences are immutableInput sequences are immutable3.3. Output sequence has same ordering as input Output sequence has same ordering as input

sequencessequences4.4. Incremental processingIncremental processing

– current element from each sequence examined current element from each sequence examined – at least one input sequence advanced by one at least one input sequence advanced by one

elementelement5.5. Appropriate action taken after examining Appropriate action taken after examining

current elements from each sequence current elements from each sequence

Represented by merge function in HaskellRepresented by merge function in Haskell

1515

Hot SpotsHot Spots

1.1. Variability in total orderingVariability in total ordering2.2. Variability in record formatVariability in record format3.3. Variability of input and output sequencesVariability of input and output sequences4.4. Variability of transformations Variability of transformations 5.5. Variability of source/destinationVariability of source/destination

Represented as additional functions, types, Represented as additional functions, types, and class definitions to and class definitions to mergemerge function function

1616

Hot Spot #1Hot Spot #1(Variability in total ordering)(Variability in total ordering)

Generalizes element type of sequences and Generalizes element type of sequences and associated comparison operatorsassociated comparison operators

Restricts polymorphic type of elements to class Restricts polymorphic type of elements to class OrdOrd ( (having usual relational operations)having usual relational operations)

Results in generalized comparisonsResults in generalized comparisons

merge1 :: merge1 :: Ord aOrd a => [ => [aa] -> [] -> [aa] -> [] -> [aa]]merge1 [] ys = ysmerge1 [] ys = ysmerge1 xs [] = xsmerge1 xs [] = xsmerge1 xs@(x:xs’) ys@(y:ys’)merge1 xs@(x:xs’) ys@(y:ys’)| x < y = x:merge1 xs’ ys| x < y = x:merge1 xs’ ys| x == y = x:merge1 xs’ ys’| x == y = x:merge1 xs’ ys’| x > y = y:merge1 xs ys’| x > y = y:merge1 xs ys’

1717

Hot Spot #1Hot Spot #1(Initial prototype as special (Initial prototype as special case)case)

If If merge1merge1 type variable type variable aa restricted restricted

to to Int, Int, thenthen

merge1 xs ys == merge0 xs ysmerge1 xs ys == merge0 xs ys

1818

Hot Spot #2Hot Spot #2(Variability in record format)(Variability in record format)

Allows elements of sequences to be records with Allows elements of sequences to be records with keyskeys

Adds Adds keykey extraction function as higher order extraction function as higher order parameterparameter

Results in generalized record formatResults in generalized record format

merge2 :: Ord b =>merge2 :: Ord b =>(a -> b) (a -> b) -> [a] -> [a]-> [a] -> [a] -> [a]-> [a]merge2 merge2 keykey [] ys = ys [] ys = ysmerge2 merge2 keykey xs [] = xs xs [] = xsmerge2 merge2 keykey xs@(x:xs’) ys@(y:ys’) xs@(x:xs’) ys@(y:ys’) | | key xkey x < < key ykey y = x:merge2 key xs’ ys = x:merge2 key xs’ ys | | key xkey x == == key ykey y = x:merge2 key xs’ ys’ = x:merge2 key xs’ ys’ | | key xkey x > > key ykey y = y:merge2 key xs ys’ = y:merge2 key xs ys’

1919

Hot Spot #2Hot Spot #2(Keyless version is special (Keyless version is special case)case)

If If idid is the identity function, is the identity function, thenthen

merge2 id xs ys merge2 id xs ys == merge1 xs ys== merge1 xs ys

2020

Hot Spot #3Hot Spot #3(Variability of input and output (Variability of input and output sequences) sequences) Allows different element format in each sequenceAllows different element format in each sequence Requires separate Requires separate keykey extraction functions for each extraction functions for each Introduces transformation functions Introduces transformation functions Results in independent sequence formatsResults in independent sequence formats

merge3 merge3 kx ky tx tykx ky tx ty xs ys = mg xs ys xs ys = mg xs ys wherewhere mg [] ys = mg [] ys = map ty ysmap ty ys mg xs [] = mg xs [] = map tx xsmap tx xs mg xs@(x:xs’) ys@(y:ys’)mg xs@(x:xs’) ys@(y:ys’) | | kx xkx x < < ky yky y = = tx xtx x : mg xs’ ys : mg xs’ ys | | kx xkx x == == ky yky y == tx xtx x : mg xs’ ys’: mg xs’ ys’ || kx xkx x >> ky yky y = = ty yty y : mg xs ys’ : mg xs ys’

2121

Hot Spot #3Hot Spot #3(Multikey version is special (Multikey version is special case of case of single key version) single key version)

If If xsxs and and ysys have the same have the same type, thentype, then

merge3 key key id id xs ys merge3 key key id id xs ys

== merge2 key xs ys== merge2 key xs ys

2222

Hot Spot #4Hot Spot #4(Variability of transformations)(Variability of transformations)

Enables use of more general Enables use of more general transformations on inputtransformations on input

Introduces explicit Introduces explicit state state to record to record ongoing computation ongoing computation

Adds accumulating parameter to Adds accumulating parameter to maintain local state throughout maintain local state throughout processingprocessing

Transforms Transforms statestate to output at end of to output at end of input sequence processinginput sequence processing

2323

Variable Sequence Variable Sequence TransformationsTransformationsmerge4b kx ky merge4b kx ky tl te tg nex ney ttx ttytl te tg nex ney ttx tty

res sres s xs ys = mg xs ys = mg ss xs ys xs ys

wherewhere

mg mg ss [] ys = [] ys = res (foldl tty s ys)res (foldl tty s ys)

mg mg ss xs [] = xs [] = res (foldl ttx s xs)res (foldl ttx s xs)

mg mg ss xs@(x:xs’) ys@(y:ys’) xs@(x:xs’) ys@(y:ys’)

| kx x < ky y = mg | kx x < ky y = mg (tl s x y)(tl s x y) xs’ ys xs’ ys

| kx x == ky y = mg | kx x == ky y = mg (te s x y)(te s x y)

(nex s xs) (ney s ys)(nex s xs) (ney s ys)

| kx x > ky y = mg | kx x > ky y = mg (tg s x y)(tg s x y) xs ys xs ys

2424

Hot Spot #4Hot Spot #4(Progress requirement)(Progress requirement)

For each call of For each call of mgmg if (kx x == ky y) thenif (kx x == ky y) then

(length (nex s xs) < length xs) || (length (nex s xs) < length xs) ||

(length (ney s ys) < length ys)(length (ney s ys) < length ys)

else Trueelse True

2525

Hot Spot #4Hot Spot #4(Backward recursive version (Backward recursive version special special case of forward recursive case of forward recursive version)version)merge4b kx ky merge4b kx ky (\ss x y -> ss ++ [tx x])(\ss x y -> ss ++ [tx x]) -- tl-- tl (\ss x y -> ss ++ [tx x])(\ss x y -> ss ++ [tx x]) -- te-- te (\ss x y -> ss ++ [ty y])(\ss x y -> ss ++ [ty y]) -- tl-- tl (\ss xs -> tail xs)(\ss xs -> tail xs) -- nex-- nex (\ss ys -> tail ys)(\ss ys -> tail ys) -- ney-- ney (\ss x -> ss ++ [x])(\ss x -> ss ++ [x]) -- ttx-- ttx (\ss y -> ss ++ [y])(\ss y -> ss ++ [y]) -- tty-- tty ss xs ys ss xs ys

== ss ++ merge3 kx ky tx ty xs ys== ss ++ merge3 kx ky tx ty xs ys

2626

Hot Spot #5Hot Spot #5(Variability of (Variability of source/destination)source/destination) Allows diverse sources for inputs and Allows diverse sources for inputs and

destination for outputdestination for output No changes to No changes to merge4bmerge4b except its use except its use

– sequences already represented as sequences already represented as pervasive polymorphic list data typepervasive polymorphic list data type

– supply different input sequence argumentssupply different input sequence arguments– use result by different functionuse result by different function

2727

Transformation to Java Transformation to Java FrameworkFramework Drive using shape of Haskell program Drive using shape of Haskell program Use design patterns (Template, Strategy, Use design patterns (Template, Strategy,

etc.)etc.) Construct cosequential frameworkConstruct cosequential framework

– recursive legs become main while looprecursive legs become main while loop– nonrecursive legs become post-loop codenonrecursive legs become post-loop code– interfaces and classes represent various hot interfaces and classes represent various hot

spot generalizationsspot generalizations java.lang.Comparablejava.lang.Comparable for for OrdOrd KeyedKeyed for key extraction functions for key extraction functions

2828

Cosequential Processing Cosequential Processing Framework in JavaFramework in Java

public final void merge() // template methodpublic final void merge() // template method{ { advXs(); advYs();advXs(); advYs(); // uses Interators and Keyed // uses Interators and Keyed while(xsNotEmpty && ysNotEmpty)while(xsNotEmpty && ysNotEmpty) { int cmpxy = xKey.{ int cmpxy = xKey.compareTo(yKey);compareTo(yKey); // Ord as Comparable // Ord as Comparable if (cmpxy < 0) if (cmpxy < 0) { { transLt();transLt(); advXs(); } // tl advXs(); } // tl else if (cmpxy == 0)else if (cmpxy == 0) { { transEq(); advEqXs(); advEqYs();transEq(); advEqXs(); advEqYs(); } // te, nex, ney } // te, nex, ney elseelse { { transGt();transGt(); advYs(); } // tg advYs(); } // tg }} while (xsNotEmpty) { while (xsNotEmpty) { transYsEmpty();transYsEmpty(); advXs(); } // ttx advXs(); } // ttx while (ysNotEmpty) { while (ysNotEmpty) { transXsEmpty();transXsEmpty(); advYs(); } // tty advYs(); } // tty finish();finish(); // res // res}}

2929

Applications of Applications of Cosequential FrameworkCosequential Framework

Implemented master-transaction file Implemented master-transaction file update program (bank account)update program (bank account)

3030

Binary Tree Binary Tree TraversalTraversal H. C. Cunningham, Y. Liu, and P. Tadepalli. H. C. Cunningham, Y. Liu, and P. Tadepalli.

“Framework Design Using Function “Framework Design Using Function Generalization: A Binary Tree Traversal Generalization: A Binary Tree Traversal Case Study,” In Case Study,” In Proceedings of the ACM Proceedings of the ACM SouthEast ConferenceSouthEast Conference, pp. 312-318, March , pp. 312-318, March 2006.2006.

3131

Binary Tree TraversalBinary Tree Traversal

procedure preorder(t)procedure preorder(t)

{ if t null, then return;{ if t null, then return;

perform visit action for root of tree t;perform visit action for root of tree t;

preorder(left subtree of t);preorder(left subtree of t);

preorder(right subtree of t);preorder(right subtree of t);

}}

21

18

3 20

50

30

1

Preorder 21 18 3 1 20 50 30

3232

Executable SpecificationExecutable Specification

data BinTree a data BinTree a

= Nil | Node(BinTree a) a BinTree a= Nil | Node(BinTree a) a BinTree a

preorder :: BinTree a -> [a]preorder :: BinTree a -> [a]

preorder Nil = []preorder Nil = []

preorder (Node l v r) preorder (Node l v r)

= v : preorder l ++ preorder r= v : preorder l ++ preorder r

3333

Framework ScopeFramework Scope

Standard kinds of depth-first Standard kinds of depth-first traversalstraversals

Flexible visit actions that are Flexible visit actions that are functions of accumulated state functions of accumulated state along traversalalong traversal

Other traversals orders (e.g. level Other traversals orders (e.g. level by level)by level)

Binary search trees, but not Binary search trees, but not multiway trees or graphs multiway trees or graphs

3434

Frozen SpotsFrozen Spots

1.1. Structure of tree (Structure of tree (BinTreeBinTree) not ) not redefined by clientsredefined by clients

2.2. Traversal accesses every node once Traversal accesses every node once (unless stopped early) (unless stopped early)

3.3. Traversal performs one or more visit Traversal performs one or more visit actions on access to node of treeactions on access to node of tree

Represented by a traversal function Represented by a traversal function in Haskellin Haskell

3535

Hot SpotsHot Spots

1.1. Variability in the visit operation’s Variability in the visit operation’s actionaction

2.2. Variability in ordering of visit action Variability in ordering of visit action with respect to subtree visitswith respect to subtree visits

3.3. Variability in tree navigation technique Variability in tree navigation technique (not just left-to-right, depth first)(not just left-to-right, depth first)

Represented as additional functions, Represented as additional functions, types, and class definitions to traversal types, and class definitions to traversal functionfunction

3636

Hot Spot #1Hot Spot #1(Generalizing the visit action)(Generalizing the visit action)

Represent visit action by update-state Represent visit action by update-state function (function (usus) passed into traversal ) passed into traversal functionfunction

Accumulate state along traversal pathAccumulate state along traversal path

gaPre :: gaPre :: (a -> b -> b) -> (b -> b) -> b(a -> b -> b) -> (b -> b) -> b

-> BinTree a -> b-> BinTree a -> b

gaPre gaPre us un isus un is t = po t is t = po t is

where po Nil s = un swhere po Nil s = un s

po (Node l v r) s po (Node l v r) s

= po r (po l (us v s))= po r (po l (us v s))

3737

Hot Spot #1Hot Spot #1(Initial prototype as special (Initial prototype as special case)case)

The following identity holds:The following identity holds:

gaPre (\x y -> y ++ [x]) id [] tgaPre (\x y -> y ++ [x]) id [] t== preorder t== preorder t

3838

Hot Spot #2Hot Spot #2(Generalizing the visit order)(Generalizing the visit order)

Allow visit actions at three points (Euler Allow visit actions at three points (Euler tour traversal)tour traversal)– first arrival (left)first arrival (left)– between subtree traversals (bottom)between subtree traversals (bottom)– before final departure (right)before final departure (right)

gvTraverse :: gvTraverse :: (a -> b -> b) -> (a -> b -> b) -> (a -> b -> b) -> (a -> b -> b)(a -> b -> b) -> (a -> b -> b) -> -> (b -> b) -> b -> BinTree a -> b(b -> b) -> b -> BinTree a -> bgvTraverse gvTraverse ul ub urul ub ur un is t = tr t is un is t = tr t iswherewhere tr Nil s = un str Nil s = un s tr (Node l v r) s tr (Node l v r) s = ur v (tr r (ub v (tr l (ul v s))))= ur v (tr r (ub v (tr l (ul v s))))

3939

Hot Spot #2Hot Spot #2(Single visit action as special (Single visit action as special case)case)

The following identity holds:The following identity holds:

gvTraverse us id id un is t gvTraverse us id id un is t

== gaPre us un is t == gaPre us un is t

4040

Hot Spot #3Hot Spot #3(Generalizing the tree (Generalizing the tree navigation)navigation) Pass in tree navigation function (Pass in tree navigation function (navnav)) Navigation function generates a list of Navigation function generates a list of

update functions update functions Folding (composition) of list from initial Folding (composition) of list from initial

state generates traversalstate generates traversal

traverse traverse nav nav ua ub ud un is tua ub ud un is t

= compose = compose (nav ua ub ud un t)(nav ua ub ud un t) is is

where compose fs s where compose fs s

= foldl (flip (.)) id fs s= foldl (flip (.)) id fs s

4141

Hot Spot #3Hot Spot #3(Euler tour traversal as special (Euler tour traversal as special case)case)

euler ua ub ud un t = doEuler teuler ua ub ud un t = doEuler t

where doEuler Nil = [un]where doEuler Nil = [un]

doEuler (Node l v r)]doEuler (Node l v r)]

= [(ua v)] ++ doEuler l = [(ua v)] ++ doEuler l

++ [(ub v)] +++ [(ub v)] ++ doEuler r + doEuler r

++ [(ud v)]++ [(ud v)]

The following identity holds:The following identity holds: traverse euler ua ub ud un is t traverse euler ua ub ud un is t

=== gvTraverse ua ub ud un is t= gvTraverse ua ub ud un is t

4242

Transformation to Java Transformation to Java FrameworkFramework Drive using shape of Haskell program Drive using shape of Haskell program Use design patterns (Composite, Strategy, Use design patterns (Composite, Strategy,

Template, Visitor, etc.)Template, Visitor, etc.) Construct binary tree traversal frameworkConstruct binary tree traversal framework

– use Composite pattern to represent treeuse Composite pattern to represent tree– use Strategy pattern to encapsulate higher use Strategy pattern to encapsulate higher

order parameters of functions (i.e. state order parameters of functions (i.e. state update functions)update functions)

– use Visitor pattern to separate tree use Visitor pattern to separate tree navigation from the application of state navigation from the application of state updatesupdates

4343

Transformation to Java Transformation to Java FrameworkFramework

public class Node extends BinTreepublic class Node extends BinTree{ public Node(Object v, BinTree l, BinTree r){ public Node(Object v, BinTree l, BinTree r) { value = v; left = l; right = r; }{ value = v; left = l; right = r; } … … // accept a Visitor object// accept a Visitor object public void accept(BinTreeVisitor v) public void accept(BinTreeVisitor v) { v.visit(this); }{ v.visit(this); } … … private Object value; // instance dataprivate Object value; // instance data private BinTree left, right;private BinTree left, right;}}public interface BinTreeVisitorpublic interface BinTreeVisitor{ abstract void visit(Node t); { abstract void visit(Node t); abstract void visit(Nil t);abstract void visit(Nil t);}}

4444

Transformation to Java Transformation to Java FrameworkFramework

public class EulerTourVisitor implements BinTreeVisitorpublic class EulerTourVisitor implements BinTreeVisitor{ public EulerTourVisitor(EulerStrategy es, Object ts){ public EulerTourVisitor(EulerStrategy es, Object ts) { this.es = es; this.ts = ts; }{ this.es = es; this.ts = ts; } public void setVisitStrategy(EulerStrategy es) public void setVisitStrategy(EulerStrategy es) { this.es = es; }{ this.es = es; } public void visit(Node t) // Visitor hook implementationspublic void visit(Node t) // Visitor hook implementations { ts = es.visitLeft(ts,t); // upon first arrival{ ts = es.visitLeft(ts,t); // upon first arrival t.getLeft().accept(this);t.getLeft().accept(this); ts = es.visitBottom(ts,t); // upon return from leftts = es.visitBottom(ts,t); // upon return from left t.getRight().accept(this);t.getRight().accept(this); ts = es.visitRight(ts,t); // upon completion of nodets = es.visitRight(ts,t); // upon completion of node }} public void visit(Nil t) { ts = es.visitNil(ts,t); }public void visit(Nil t) { ts = es.visitNil(ts,t); } public Object getResult() { return ts; } public Object getResult() { return ts; } private EulerStrategy es; // encapsulate state change opsprivate EulerStrategy es; // encapsulate state change ops private Object ts; // traversal stateprivate Object ts; // traversal state}}

4545

ConclusionConclusion

Framework construction followed Framework construction followed function function generalization generalization

Each transformation produced an executable Each transformation produced an executable specificationspecification

Appropriate hooks (hot spot abstractions) Appropriate hooks (hot spot abstractions) defineddefined

Constructed cosequential processing Constructed cosequential processing framework with better understanding of hot framework with better understanding of hot spot behaviorsspot behaviors

Constructed general binary tree traversal Constructed general binary tree traversal framework with better understanding of hot framework with better understanding of hot spot behaviorsspot behaviors

4646

Future WorkFuture Work

Develop better guidelines for Develop better guidelines for generalizing Haskell programsgeneralizing Haskell programs

Investigate usage of Haskell features like Investigate usage of Haskell features like modules, classes, and monadsmodules, classes, and monads

Develop better guidelines for creating Develop better guidelines for creating Java frameworks from Haskell programsJava frameworks from Haskell programs

Conduct case studies of larger programsConduct case studies of larger programs Investigate usage of Scala instead of Investigate usage of Scala instead of

Haskell and Java Haskell and Java ☺☺

4747

AcknowledgmentsAcknowledgments

Cuihua Zhang (Northeast Lakeview Cuihua Zhang (Northeast Lakeview College)College)

Acxiom Corporation Acxiom Corporation University of MississippiUniversity of Mississippi South Dakota State University South Dakota State University

4848

DiscussionDiscussion

Any questions or comments?Any questions or comments?