Plugin Based ArchitecturesElvira: Problems and SolutionsAndrés R. Masegosa

Department of Computer Science and A.I.

Univerisity of Granada

Puerto Lumbreras, June 2008

Why extends is evil?[javaworld.com]

James Gosling (Java’s inventor):“If you could do Java over again, what would you

change?”

“I’d leave out classes”

The real problem is the inheritance.

“You should avoid implementation inheritance whenever possible”:

Interfaces versus Classes

Interfaces versus ClassesThe flexibility Issue

“You start programming before you fully specified the problem”: Incorporate newly discovered requirements into the existing code

as painlessly as possible

No Interface Use Interface CollectionLinkedList

Interface CollectionHashSet

Interfaces versus ClassesThe NodeList Case: Unsorted and Sorted NodeList

Firstly, a linear time for searching in a NodeList is acceptable.

But… gene expression data appears (thousand of variables), so we need logarithmic access time (sorted).

Sorted NodeList inclusion suppose a complexity introduction:

“One class has to manage the two versions”

Solution: NodeList as Interface SimpleNodeList manage the simple version. SortedNodeList manage the sorted version. No changes in the rest of the code (except at the constructors!!!!!!!).

CouplingConfiguration and ContinuousConfiguration

Configuration of Continuous Variables seems a subclass of Configuration.

ContinuousConfiguration inherits from Configuration.

Hard to change the implementation: HashTable or Ordered version

(There aren’t interfaces)

CouplingConfiguration and ContinuousConfiguration: Problems Some methods are valid for Configuration and not for Continuous

Configuration, but they are active and can’t be used: public int getValue(FiniteStates var)

void setValue(FiniteStates var, int value)

Some methods are implemented in Configuration and not overwritten in ContinuousConfiguration, but they can’t be used:

public isCompatible(Configuration conf)

void double hashCode()

All of them provokes runtime errors not compiling time errors. As more more funcionalities are added as stronger these problems becames.

CouplingConfiguration and ContinuousConfiguration: Solution Configuration represents a set of assigments

or instatations of a set of random variables.

Everything is Discrete: FiniteStates, int…

X1 X2 X3 X4 Vector

1 0 0 1 Vector

Interface Configuration

void setVars(Collection Vars) void setValues(Collection Values) void setVar(FiniteStates var) void setValue(FiniteStates var, int v) FiniteStates getVar(int pos) int getValue(int pos)

Class SimpleConfigurationimplements

CouplingConfiguration and ContinuousConfiguration: Solution A new Interface is defined:

Incompatible methods are removed:void int getValue(FiniteState node)

Not defined methods are removed:void int possibleValues()

Interface Configuration

void setVars(Vector Vars) void setValues(Vector Values) void setVar(FiniteStates var) void setValue(FiniteStates var, int v) FiniteStates getVar(int pos) int getValue(FiniteStates var) int possibleValues()

Interface ContinuousConfiguration

void setVars(Collection Vars) void setValues(Collection Values) void setVar(Node var) void setValue(Node var, int v) Node getVar(int pos) double getValue(Node var)

CouplingConfiguration and ContinuousConfiguration: Solution

X6 X7 X8 X9 Vector Continuous

1.5 1.3 1.2 1.5 Vector Doubles

Class SimpleContConfigurationimplements

Configuration conf = new SimpleConfiguration()

Interface ContinuousConfiguration

• void setVars(Collection Vars)• void setValues(Collection Values)• void setVar(Node var)• void setValue(Node var, int v)• Node getVar(int pos)• double getValue(Node var)

void setVar(Node var) { if (var.isDiscrete()) conf.setVar(var) else varCont.insert(var)}

double getValue(Node var) { if (var.isDiscrete()) return (double) conf.getValue(var) else return valCont.elementAt(index(Var);}

CouplingConfiguration and ContinuousConfiguration: Solution Advantages:

It is easier to change the underlying implementation.

We can even have several implementations: Configuration using HashTable. Configuration using Ordered List.

We would only need to change the constructor. Disadvantages:

Introduction of some duplicity in source code.

Agglomeration of FuncionalitiesDataBaseCases Class DataBaseCases manages the input, storage and

output of the data. Complexity of the class (without inheritance):

8 different constructors. >80 methods

Very different methods: divideIntoTrainAndTest Classification getPotentialTable Learning logLikelihood Clustering

Confusion in the class and for the programmer.

Agglomeration of FuncionalitiesNode Class Node represents a generic random variable. Complexity of the class (without inheritance):

35 different fields. >90 methods

Very different methods: getChildren GUI, Inference, Learning getNeighbourAt Inference getVisited Learning, Classification

Again, confusion in the class and for the programmer.

Agglomeration of FuncionalitiesNodeList Class NodeList represents a list of nodes. Complexity of the class (without inheritance):

7 different constructors. >50 methods

Very different methods: subSetsOfSize, randomOrder Learning getNodeString GUI isIncluded Inference

Again, more confusion in the class and for the programmer.

Agglomeration of Funcionalities Strange Classes There are many classes that are only used in a

mininum part of the code: NodeQueue ProbabilityTree ContinuousCaseListMem Learning RelationList Inference

Many different classes creates confusion and delay development times.

Very differents requirments among some modules: learning, inference, classification, influence diagrams, gui…

Agglomeration of FuncionalitiesConfusion in Concepts What’s a Node is?

Node in an Aciclic Graph. Node in a Decision Tree. A simple random variable of a data base.

Tracking an important error: NodeList copy():

copy.insertNode(node.copy()) OR copy.insertNode(node) node.copy() removes parents and child information. node without copy made a shallows copy of NodeList.

Solution: Create two different methods but complexity is added to the code.

Plugin Based ArchitecturesIntensive use of Interfaces

Based on several principles: Hollywood’s: “Don’t call us, we’ll call you’ Inversion of Control:

When Library Methods calls User Methods

Basically, you firstly define what you need and after you find out how you can implement it.

It is very generalized among important software programms: Eclipse Almost an standard for plugin development. Firefox, Thunderbird, Microsoft Outlook, IE Explorer… Some research tools: Bioclipse (biological data analysis), Spamato

(spam filtering), GumTree (scientific experiment platform),…

Plugin Based ArchitecturesPlugin Definition

What is a plugin? .jar File + plugin.xml

… and the key concepts: Extension Point:

An Interface + XML When a plugin wants to allow other plugins to extend or

customize some funcionalities. Extensions:

A class that implements the interface of some extension point

Plugin Based ArchitecturesPlugin Definition: An example

Let’s see an example:

Classifier and Evaluation would be the extension point:

public interface Classifier { void learn (DataBaseCases training, int c); Vector classify (Configuration instance, int c); }

Cla

ssif

ier

Classification PluginTreeClassifier Plugin

Weka Plugin

Eva

luat

ion

Evaluation Plugin

public interface Evaluated { String objectName (); double evaluate (DataBaseCases database, int c);}

Plugin Based ArchitecturesPlugin Definition: An example Classification

How to use an special data base for classification:

public interface ClassifierImprove { public void learn (DBClassifiy training); public Vector classify (Configuration instance); }

public interface DBClassifiy { DataBaseCases getData() int getClassIndex() void setData (DataBaseCases db) void setClassIndex (int index)}

public class ExtensionDBClassifiy { DataBasesCases case=null; int classIndex=-1 DataBaseCases getData() int getClassIndex() void setData (DataBaseCases db) void setClassIndex (int index)}

public interface EvaluatedImprove { String objectName (); double evaluate (DBClassifiy database);}

Plugin Based ArchitecturesPlugin Definition: An example Classification

The solid line indicates a common import…

Cla

ssif

ier

TreeClassifier Plugin

Weka Plugin

Eva

luat

ion

ClassifierImprove

Evaluation Plugin

Evaluation Improved

DBClassify

Classification Plugin

Elvira Core Plugin

Configuration

SimpleConfigurationHashConfiguration

Plugin Based ArchitecturesAdavantages

You can specify what you need before it is implemented.

You reduce the coupling among classes with Interfaces.

You allow external plugins to create their own classes (DBClassify) without introduce complexity in the basic plugins.

You can have different implementations of a core funcionality (i.e. Configuration normal or Hashtable or Ordered) at the same time. You just change the extension

Very flexible and easily extended by third-parties.

Plugin Based ArchitecturesDisadvantages

Suppose a change in our programming habits.

There will be appear duplicated source code.

It could be hard to decide what is included in one plugin and what is included in another plugin.

It could be hard to decide what is a simple class and what is an interface or an extension point.

Introduce some complexity in the source code.

We would need to choose a plugin framework: eclipse, java plugin-framework…

ENDAny questions?