Data Driven Programming - academic basis?

Hello,

it is always a challenge to collect an overview of scientific works on some topic, as many researchers have different approaches and names for it. Google is usually not the best option for this; you'd better go with using search engines specifically for scientific journals.

Some suggestions:
CiteSeer
ACM
DBLP

Usually the university also has support for searching articles; check with your local secretary or IT or library and the website for this. Where I used to do my research they had a brochure listing all engines and subscriptions to journals.

Through ACM I found a few items vaguely in the direction but it takes lots of time to follow the citings as well until you stumble onto something -- I leave it to you.

Good luck. Kind regards,

Illco

Quote:

Original post by Illco you'd better go with using search engines specifically for scientific journals

The problem here, as you mentioned, is that people have different names for things. I've yet to find a paper via a ACM/CiteSeer/ScienceDirect search for "Data Driven" that actually refers to what I call DDP.
Although I'm usually used to following references, it can be difficult when there isn't a DDP-related reference trail to follow.

Quote:

Through ACM I found a few items vaguely in the direction

Was this a recent search? If so, would you mind sharing the reference? [smile]

Many thanks for the reply.

Jones.

Sure. I'm not sure how much it relates to what we are calling DDP though.

Thanks for the link, but my university subscription doesn't cover the publication - I'll have to see if I can arrange access later.

Quote:

I'm not sure how much it relates to what we are calling DDP though

It's difficult (impossible?) to find DDP-related materials outside the gaming community, which leads me to believe that there is no academic (i.e. non-games technology) equivalent.

When I read papers about data driven this and that, they're talking about simple object parameterisation, which in turn drives run-time behaviour.

What I call DDP (data-driven specification and logical composition of class heirarchies) is slowly emerging in academia via developments in the use of scripting languages, but I have yet to see it applied elsewhere.

...I guess this means that my upcoming paper might be interesting after all... [grin]

Hello.

I am actually looking at starting work on a PhD project within the next year myself.

From my understanding, DDP is used and has been used for over 20 years in functional programming extensively.

In contemporary, imperative languages, you may say that DDP is pulling mappings from config files or using PL data structures for control structures. You won't find anything like this in purely functional/mathemtical languages because it's part of the language.

Like haskell:

f(x) = x * 2f(2) = 4f(3) = 65f(10) = 100f(20) -> 40f(2) -> 4

This is very basic, but it's esentially DDP. I like python as a pseudo(imperative) language, so.

def f(x):   if x == 2:      return 4   elif x == 3:     # ... you get the idea   else:      return x * 2

And then to a (more convential) DDP implementation:

vmap = {   2 : 4,   3 : 65,  10 : 100  'd': lambda z: z*2}def f(x):   try:      return vmap[x]   except KeyError:      return vmap['d'](x)

Of course, look at the haskell and it would definately be "more elegant". If you asked a snoody functional language programmer, he would say this is just the rest of the world trying to catch up to what they discovered doing AI research in the 70's. The thing is, in functional programming, programmers see code AS data a lot of the time, so it's becomed so ingrained that it's not really anything to talk about anymore.

I don't think that there's a lot of foundational information on DPP because DPP is more of an "applied" approach then a theoretical foundation approach. Many people have been using it in one way or another for many years with no name really given.

The real question to ask is, is the data that you're using to drive your program mutable or not mutable?

If it is immutable, then you can think of your data as constructions of functions. The act of accessing the data entry in your program is "applying function semantics". As such, you can reduce DDP into standard lambda-calc with an "applied" feel to it. Basically invent some words to classify the different categories of functions. This one is a "data provider" and this one is not.

If it's mutable, then you're going to have a lot of fun. Because what you're essentially doing is indirectly changing the flow of execution. In which case, you loose all referential transparency and the problem becomes very, very generalized.

I'm yet to clear things up precisely, but in my mind DDP is "in the mix" with the bottom-up programming and declaritive programming.

If you're looking for mathematical underpinnings, you may have some luck looking into category theory and primitive set theory for grounding and then possibly looking into functors.

I'd check out: http://math.ucr.edu/home/baez/week73.html

I believe there are some good theoretical foundations to approach decision making, functional combination and configurable logic by mapping a applying the "data" in DDP to a functor's state.

A place where you would probably get some really useful conversation going would be over at http://lambda-the-ultimate.org

This place has a lot of smart cookies and if you ask your question the right way, you might just strike up an enriching conversation filled will all kinds of resources people use to back themselves up.

Hope my ranting helps.