Jump to content
  • Advertisement

jlowery

Member
  • Content Count

    2
  • Joined

  • Last visited

Community Reputation

136 Neutral

About jlowery

  • Rank
    Newbie
  1. 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 * 2 f(2) = 4 f(3) = 65 f(10) = 100 f(20) -> 40 f(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.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!