I'm looking for a word
Locked
12
12
 
|
Steve,
C is a wonderful thing and still runs the world, don't give up hope! If it is any consolation, Prolog warped my fragile mind and ML hurt my feelings. Ah Brooklyn, life was simpler then .... -Birch -- "I have noticed even people who claim everything is predestined, and that we can do nothing to change it, look before they cross the road." -- Stephen Hawking **** Use of advanced messaging technology does not imply **** ***** an endorsement of western industrial civilization ***** On Sep 7, 2009, at 5:27 PM, Steve Smith wrote: > Birch - >> I thought Container as well (although Bag leapt to mind too) but >> Russ decided against so all that was left was the more abstract >> descriptor. Besides, LISP has a data structure or two and >> underlying types, loosely defined but they are there - IMHO "Data >> Structure" is neither procedural, declarative, nor functional. > Of course. > > I merely have my face being rubbed in this right now cuz I'm the old- > school C programmer working with some new-school C++ kids who don't > really even know what a Struct is... They will create a Class when > a Struct is what they really need. > Since I grew up in the early days of Knuth's Art of Computer > Programming (when you were still in a Brooklyn grammar school > beating up honor-roll students for their lunch money)... I tend to > the Procedural view of things... I learned all the Applicative and > Object Oriented and Concatenative ( In my NeWS days) languages > offered up to me in the g(l)ory days. I have loved my Snobol and > APL and Prolog and PostScript (*as a programming language!*) and > Objective C and Java and loved to hate LISP and Haskell and Simula, > and made peace with C++, but at heart, I love the half-step of > abstraction from hardware that good ole C provides. It's a goddamn > bit processing machine, gimme some register variables and an easy > way to do bit-shifts and I'll build the rest from raw stock! >> Of course due to my current work situation I am drawn to "bring me >> a rock" like a moth to the flame. > Does this mean you are avoiding deadlines? Or just so morbidly > fascinated with all things work-related that answering enelucidable > riddles is like mother's milk? >> >> I have a bottle of Irish Whiskey to replenish yours and Bourbon is >> always good (rot gut or not) but you know that I can't condone >> burning books for any reason! > Yes, I believe we did do some damage to a bottle of Jamesons last > time you were over. And I don't need you to condone the burning of > books, but that doesn't mean you can't warm your hands by the > woodstove while *I* do. The real sin would be to use good whiskey > as an accellerant (for the combustion, not the attitude). >> >> -Birch >> > > > ============================================================ > FRIAM Applied Complexity Group listserv > Meets Fridays 9a-11:30 at cafe at St. John's College > lectures, archives, unsubscribe, maps at http://www.friam.org ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
In reply to this post by Russ Abbott
Okay Russ, There are several options to chose from, depending on just how adaptive you'd like the functionality to be. LISP (Scheme, et alia): Allows for partial instantiation or "currying." This mechanism allows your program to build functions out of little pieces of text and then call _eval()_ on them when completed. LISP uses a list for a generic structure but does not infer type until you use something. Thus you could have a collection of objects that were all completely different with functionality created on the fly. Javascript: Which, it turns out is a functional language; makes functions first class objects and allows appending objects or replacing their methods at run-time. I believe there is a native "Collection" structure but one could be written if there is not. Javascript also has an _eval()_ function, so partial instantiation is possible. Java (and, to an extent, C++): Allow for Collections of heterogeneous objects, although the language is strongly typed and will try to dissuade the programmer from being too abstract. The smoothest way to apply different behavior is through interfaces, keeping in mind that each class can implement the interface however it chooses. The drawback here is that the interfaces must be concrete at compile time and I don't know of an easy way to modify them at runtime (I'm sure that it can be done but requires more work than the other two options.) The STL has _functors_, generally for comparison but could be extended, which can be called on arbitrary classes iffi those classes provide the requisite methods the functor needs. One would iterate over a Collection and apply the functor to each object, or each pair. However, even with cool stuff like Policy Based Templates (LOKI Libraries, Alexandrescu et al.) I think that compile time type checking will make things less flexible than you desire.) I haven't looked for functors in Java, but I imagine they are there or could be created. Additionally, Java has lent itself to the "new" paradigm of _Aspect Oriented Programming_ which I have not played with very much, but I understand that functionality can be cross-cut across classes and assembled at runtime but I would think that it would still be pretty strongly typed. IMHO, LISP and its bretheren fit what you seek although Javascript potentially offers fertile ground and may be easier to integrate with Java. As for a single term to describe this, I still like Data Structure but that's probably being purist and I could get behind active structure. -Birch -- "Humanity is acquiring all the right technology for all the wrong reasons." ~R. Buckminster Fuller **** Use of advanced messaging technology does not imply **** ***** an endorsement of western industrial civilization ***** On Sep 7, 2009, at 5:48 PM, Russ Abbott wrote: Let me bring this back to where I started with this. You may recall that a while ago I was talking about what I wanted in an ideal agent-based modeling system. I have been thinking about as a starting point. One of the things I like about Drools is that it is a forward chaining system that supports a workspace that can contain arbitrary Java objects along with rules that operate on those objects. I find that very attractive because it allows new primitives to be added at any time while at the same time providing a reasonable framework for logical operations. ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
Birch,
Written like a true computer scientist. I lived in a LISP world for a happy period between, say '85 - '90. But then the real-world encroached, and C++ began to become the only realistic way to implement large ABMS of complex systems. LISP was nice, but the virtual machine and garbage collection made it a non-player in the modern HPC computing arena. --Doug On Mon, Sep 7, 2009 at 6:33 PM, Birchard Hayes <[hidden email]> wrote:
-- Doug Roberts [hidden email] [hidden email] 505-455-7333 - Office 505-670-8195 - Cell ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
Doug, Garbage collection remains a real problem whenever it is included in a language implementation. I've been working in C#/.NET lately and I would venture to say that there is as much "bookkeeping" involved as there was with pointers and explicit destructors; only now, one must learn an entirely new set of rule and MS generated foibles. I wonder if what Russ really wants is an architecture of abstract classes that use a wide variety of interfaces and concrete classes to provide the palette of functions, i.e. an aggregate of abstractions, to provide enough variability in behavior at runtime. That could be done in C++ (STL) with Policy Based Templates and a few other patterns; lot's of heavy lifting though. -Birch -- "When I am working on a problem, I never think about beauty but when I have finished, if the solution is not beautiful, I know it is wrong." - Buckminster Fuller **** Use of advanced messaging technology does not imply **** ***** an endorsement of western industrial civilization ***** On Sep 7, 2009, at 6:41 PM, Douglas Roberts wrote: Birch, ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
No, I'm not looking for programming language features. I'm look for a term that describes a certain class of applications. Here's a revised version of what I wrote a couple of messages ago.
Let me bring this back to where I started with this. You may recall
that a while ago I was talking about what I wanted in an ideal
agent-based modeling system. I have been thinking about Drools as a starting
point. One of the things I like about Drools is that it is a forward
chaining system that supports (a) a workspace that can contain arbitrary
Java objects along with (b) rules that operate on those objects. I find
that very attractive because it allows new primitives to be added at
any time (because there is no constraint on what can be in the workspace) while at the same time providing a reasonable framework (forward chaining rules) for
logical reasoning and condition-action style agent operations.
I want a term that describes this sort of openness. In my clumsy attempts to describe it, the closest parallel I've found seems to be a general Genetic Algorithm system. The population, genetic operators, and fitness function are all left open. The parallel is that the GA population plays a role similar to the Drools workspace and the GA genetic operators and fitness function play a role similar to the Drools rules. In both cases we have an application (not a programming language or collection of programming language features) that implements a framework of operations. These are (a) forward chaining reasoning for Drools and (b) genetic algorithm evolution. These two operational frameworks don't necessarily have anything to do with each other. What is important and similar is that in both cases, these frameworks are two steps away from a collection of arbitrary Java objects: the workspace and the population. In both cases functions are provided by the user to operate on those objects. Those functions are the rules in the case of Drools and the genetic operators and fitness function in the case of a GA. The GA and Drools provides a specific and useful framework within which the user-provided functions operate on the user provided objects. I want a term that captures that sort of operational framework. -- Russ On Mon, Sep 7, 2009 at 7:14 PM, Birchard Hayes <[hidden email]> wrote:
============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
In reply to this post by Douglas Roberts-2
Douglas Roberts wrote:
> LISP was nice, but the virtual machine and garbage collection made it > a non-player in the modern HPC computing arena. I'd argue that the Lisp way, is a reasonable fit to HPC. Certainly virtual machines are not needed to implement Lisp-like languages (some systems are bytecoded, but not all), and it is *garbage* that is the problem not garbage collection. Programmers generate garbage by not paying attention to how things get allocated. If you run malloc/free thousands of times in various-sized pieces, you'll get fragmented heaps and slow performance too. Garbage collectors simply allow for poor practices, but don't require them. It's not uncommon for millions of dollars to be spent in a relatively short period on development of HPC codes. After all, the computers themselves can cost hundreds of millions. Inefficient codes, or codes poorly tuned to the used computer architectures simply waste money. Some of the people that work on these codes know the models, while others must know the details of particular computer architectures. Any black box, like a compiler, is a potential correctness or performance mistake waiting to happen. (This is of course not to say that compilers aren't crucial.) Experienced Lisp programmers, often being anti-authoritarian types, tend to hate black boxes and rigid abstractions. If a language feature like C++ templates are needed, the Lisp programmer writes Lisp macros to implement them, injecting type annotations as necessary, and tweaks the the macros interactively until the generated native code is just right. Yes -- they read and consider both their macro output, and native code the compiler generates from that. Imagine! This is in contrast to Java, where the culture is more about insulating the programmer from having to know how anything in particular works or plays out. And these days, with Domain Specific Languages all the rage (in ABM and elsewhere), it's funny that Lispers have been doing that for 40 years! Finally, most HPC codes have a set of `kernels' where all of the compute time goes, and the rest of the code could run at about any speed and not become a bottleneck. Languages like Common Lisp are fine for this, because there exist native code compilers that *can* be directed to generate fast code, but in general won't try very hard to make vague code be fast. Unfortunately, Lisp culture is a poor fit to conservative HPC culture. The latter being very focused on production capability, and fixed, clearly-communicated requirements. Marcus ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
In reply to this post by Birchard Hayes
All --
Apropos some of this, today I found myself going back and forth between the FRIAM discussion and this review/analysis of what's new in Mac OSX Snow Leopard . . . tom On Sep 7, 2009, at 7:14 PM, Birchard Hayes wrote:
============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
WRT the original quest, I realize that the trail is probably cold for
most of the list by now and that tangential discussions have now generated
more interest, but I think I have a reasonable answer.
In functional programming map and reduce are often called meta-functions. GA, GP, Ant Colony Optimization, etc. are often called meta-heuristics. Meta programming is even in Wikipedia referring to programs that manipulate other programs. Meta-programming is a bit too general for what I'm after since a compiler is a meta-program and that's not really the point. But meta-application may do the trick. Thanks for all your help. -- Russ On Mon, Sep 7, 2009 at 9:12 PM, Tom Carter <[hidden email]> wrote:
============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
The term "meta-circular" describes a language characteristic that enables meta-programming. It means that the mechanisms needed to define the semantics of a language are available to programmers _in_ the language itself. This leads to support for internal Domain Specific Languages and other higher-order techniques. In a recent interview, John McCarthy said that is was important for a language to have access to it's own parse-tree. I consider that a weak form of meta-circularity, but the right intent is communicated.
On Tue, Sep 8, 2009 at 12:24 AM, Russ Abbott <[hidden email]> wrote: WRT the original quest, I realize that the trail is probably cold for most of the list by now and that tangential discussions have now generated more interest, but I think I have a reasonable answer. ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
Again, I'm not asking for a word that describes a property of a language. I want a word that describes certain kinds of applications.
My previous suggestion of meta-application is probably not too good either in that it is currently used to refer to operating-system like software -- software that manipulates applications. So now I'm thinking about application schema. Admittedly that's moving in the direction of application template. Part of my quest is that I want a word that describes application code that can be parametrized in certain ways. Template all by itself is just too general in that it doesn't imply that the template is for an application. Lots of things can be templated in a language that supports templates. That's fine but that's not what I want to say. -- Russ On Tue, Sep 8, 2009 at 7:46 AM, Dale Schumacher <[hidden email]> wrote: The term "meta-circular" describes a language characteristic that enables meta-programming. It means that the mechanisms needed to define the semantics of a language are available to programmers _in_ the language itself. This leads to support for internal Domain Specific Languages and other higher-order techniques. In a recent interview, John McCarthy said that is was important for a language to have access to it's own parse-tree. I consider that a weak form of meta-circularity, but the right intent is communicated. ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
Russ Abbott wrote:
> So now I'm thinking about /application schema/. Admittedly that's > moving in the direction of /application template/. Part of my quest is > that I want a word that describes application code that can be > parametrized in certain ways. /Template /all by itself is just too > general in that it doesn't imply that the template is for an > application. Lots of things can be templated in a language that > supports templates. That's fine but that's not what I want to say. You might want to look to modeling or category theory to provide the descriptive term you seek. For example, a Common Lisp macro, can expand into different kinds of procedures depending on the parameterization; the full power of the language is available to macros (completely unlike the C preprocessor). A C++ template however, is simply dropping in types into fixed skeletons. The structures one expresses in C++ with different types will be isomorphic whereas with Lisp it would not need to be. Marcus ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
|
|
In reply to this post by Russ Abbott
What about "Transmogrifier"? I guess this is not word you
have been looking for, but did you that a "Transmogrifier" is indeed a small “wrapper” method used to propagate a method/property implemented in another subsidiary object? http://en.wikipedia.org/wiki/Transmogrifier_(computer_science) -J. ============================================================ FRIAM Applied Complexity Group listserv Meets Fridays 9a-11:30 at cafe at St. John's College lectures, archives, unsubscribe, maps at http://www.friam.org |
«
Return to Friam
|
1 view|%1 views
| Free forum by Nabble | Edit this page |