Deduction Rules Unleashed

To do that, I had to figure out...

What makes spreadsheets

efficient

What limits

spreadsheets

Does it work ?

and...

So I thought:

?

Studies even proved this

Multiple object

relationships

complications

Quick Rules

Access control

is limited to

cell locking

No need to

stop and compile

Could I bring the development speed of spreadsheets in the realm of objects

The rule just runs when required

No need to create listeners or event handlers

Joining tables isn't exactly easy

A single line of code can do what would take dozens of OOP lines

B5=A2+B2

What? I have to lock each cell one by one ? Give me a break...

Good luck trying to model that graph

source : xkcd.com

In 1997, a study calculated the average source statement per function point

based on tools

• Java and C++

• Spreadsheets

53

Formulas need to

be manually copied

6

Your Data

is your View

I love spreadsheets

Welcome to the copy-paste festival.

Hope you enjoy the ride.

Wow, spreadsheets require almost 10 times less code to get the job done !

they get the job done so fast

All my data is right there in front of me. Now that makes things easy to debug.

I love objects oriented programming

(OOP)

Oh, and I hope you didn't make a mistake in your original cell.

it's so powerful

The deduced framework started two love stories

So...

The Deduced Framework

How can we get the best of both worlds ?

Unleash the power of deduction

http://deduced.org

by Steve McDuff

Objects

This is Java code...

No new language to learn !

A single line of code gets the job done !

Unless you don't know java...

Object Deduction Rules

• Defines relationships between object fields
• Easily traverse the object graph
• Executed automatically when the data changes

Define and change rules dynamically

No need to stop the application to compile !

Simple Deduction Rules are used to assemble all the layers.

Dynamic Rules

Layered Architecture

Dynamic Environment

The schema defines the model structure and rules.

The model contains the data the user wants to use.

Debug compilation error directly with the code.

The view defines how we want to visualize our data.

The control layer grants or denies access to the model

Schema

Model

Control

Dynamic Schema

Define new rules on the fly.

View

Dynamic View

No need to stop and recompile.

Added fields show up instantly

Change The View Layer and see instant results.

Change your schema dynamically.

Spreadsheets

Sample Applications

Before Deduction Rules

Converted the tree view from hardcoded event handling to deduction rules

Agile Project Tracking Application

Required over 2000 lines of code.

# of defects was proportional to the amount of code

Had to handle all events manually

• Update
• Create
• Delete

Required only 14 lines of code !

After Deduction Rules

# of defects was much lower

40 times less code

to get the same job done

• return maximumCollection(workEventList, dateInstance);
• return formatDate(date);
• return date;
• return createObjectsMatchingAllValues ( taskList,timedTaskBreakdownList, matchingProperty, createType, true, context);
• return sum(timeLeftList);
• Integer retVal = workEventTimeLeft;if( retVal == null ) {retVal= new Integer(0);} return retVal;
• return maximumCollection( filter( workEventList,bigger( dateInstance,date )), dateInstance);
• return createObjectsMatchingAllValues( createDateIncrementList( sprintStart,sprintStop,increment), timedSprintBreakdownList, propertyToMatch, typeToCreate, true, context);
• return sprint;
• fillList(chartValueList,breakdownList,true);return null;
• return selectedSprint;
• return findParentOfType(selection, sprintType, false);
• return selection;
• return filterList(treeSelectionList,true);

50

Required only

lines of code.

Reaching 100% code coverage with TDD was much easier !

Try it out !

http://deduced.org

It's free !