Lambda the Ultimate

I am making a research on MapReduce.

It's easy to find out about MapReduce. But my concern is about the systems that don't benefit from Mapreduce. Why they don't?

I want to search about a few softare systems which didn't/don't implement , benefit from MapReduce.

Any information will help.

Thank You

Okay, it's not quite the right place for this, but I'm stumped and many of you keep tabs on this kind of stuff.

A long time ago I ran into a paper on something I remember being called "statistical defect detection", wherein some clever people wrote software to record which branches were taken leading up to a crash and used those to determine, statistically, which lines of code were most likely to be responsible.

I can't find it any more. Can anyone else remember it? Maybe you can help me find it?

This is all in fun, but look at this blog...

He clearly needs a pic of John McCarthy,
and one of Ken Iverson.

(Presumably APL was successful at first becuse of Larry Breed.)

My introduction to formal systems was in a cybernetics class. The more I learn about concepts in programming language design, and the direction that hardware seems to be evolving, the more I think that a domain specific language for cybernetics would be a worthwhile experiment. Has someone done this already? I see glimmers of possibility in the pi-calculus, functional-reactive programming, dataflow languages, DSL's for audio synthesis. I was intregued, back when this old thread was posted, by Hank Thediek's comments, and some others following along his line of thinking. It has haunted me since.

I would love to be told that someone has already made such and such language and this is why it does not work to integrate cybernetic models into programming. But, if it has not been really tried, I have an instinct that tells me the results could be very interesting.

On a untested brainstorm kind of level, it seems like feedback could be a refinement of a closure variable or monad, the concept of a system that can be open or closed to energy, perturbation, information, or control seems to map well to varying levels of scoping, encapsulation and information hiding... etc. Of course, alot of the information theory and computation theory that evolved through with and leading up to cybernetcs are also ancestors of modern computer science, but it really seems like the low hanging fruit is still ripe and yet to be plucked.

The biggest rift I see between computer science and cybernetics is that cybernetics seems optimized for systems where components are unknowable or unpredictable (harsh external environments, hostile or incompetent users, incomplete or error-prone measurements, heuristic behaviors), while computer science seems to always strive for complete information, provability. To attempt what is surely an overgeneralization, but something close to what I mean: a cyberneticist adds redundancy to prevent failure, a computer scientist eliminates redundancy to simplify models (and then any reader of the daily wtf would be able to tell you: a software developer puts in redundancy in a way that increases the chances of failure).

Since cybernetics was designed for systems with heterogeneous and loosely coupled components with a minimum of (well specified) information flow, it seems like an ideal model for programming with multiple processes/computers, for human/computer interaction design, and for compiler/language design (finding the best fit of a high level formal model and a limited state machine representation of that model).

To sum up: is there a cybernetic DSL that someone made that I can try? Is cybernetics just out of fashion, or technically unsound and superseded, my teachers just those last conservative dinosaurs who never admitted they were wrong? Have cybernetic principles been tested and dismissed as a failure, integrated so sloppily that we no longer know what we knew in the '50s, or simply overlooked?

Please forgive the rambling of this post, I am trying to talk about something I have a incomplete understanding of, and would be honored to have others here help me clarify these things.

In computer programming, a dope vector is a data structure used to hold information about an array, especially its memory layout.

A dope vector typically contains information about the type of array element, rank of an array, the extents of an array, and the stride of an array as well as a pointer to block in memory containing the array elements.

It is often used in compilers to pass entire arrays between procedures in a high level language like Fortran.

from, wikipedia.org

I am questioning about the origin dope vector~ why they use "dope"?
dope has many meanings, isn't it? affix or drug..and so on..

please explain to me more clearly

Hi All

I was discussing halting halting problem with one of my friend yesterday. He asked me a good question. Here is the question:
"Let P be the class of all Pascal programs that don't use go to ,while and repeat statements, nor recursive procedure calls.Is Halting Problem Valid for P?"

Now the interesting thing is that halting problem is valid if it has infinite loop and a program can not contain a loop until it has a recursive procedure like goto, while and for loop etc. So I think we can not get halting problem for P (the class of all Pascal programs) that don't use recursive procedure.

But Still I have confusion in my mind. May be there exist a program which can contain infinite loop without using recursive procedure. I tried to find but I couldn't think any such program. So I want to know "Does anybody know any example in which halting problem is valid even if the program don't use loops and recursive procedure calls?"

OR if you don't know any example then tell me what do you think about this problem. Is Halting Problem valid for P? If yes, Why?

Hi,

This language has been introduced to this forum before in Dao, a new programming language, now I would like to bring to your attention the latest release of Dao (1.0-preview version). Dao is a simple yet powerful object-oriented programming language featured by, optional typing, BNF-like macro system, regular expression, multidimensional numeric array, asynchronous function call for concurrent programming etc.

Since the last beta release (2006 november), a number of new features have been added to the language with some significant improvements on the implementation. Here I will just list some of them:

1. Added a new typing system, so that the type of a variable can be either declared explicitly or inferred implicitly, and type checking is performed at compiling time when possible. More over the type information is used for function overloading and function specialization (with type-optimized VM instructions) according to parameter types. Some types can be compounded into new types, e.g., list, tuple...

2. A flexible macro-system that allows writting macro in a form close to BNF, and can be used to define new syntax;

3. Added Asynchronous Function Call (AFC) and Message Passing Interface (MPI) for further support for concurrent and distributed programming (still experimental);

4. Added a few new data types, in particular, among which, there is the new tuple type in which each of the items is typed independently, for example, if a tuple is consisted of an integer and a string, then the type of the tuple will be tuple; Moreover the items of a Dao tuple can have field names.

5. The internal data storage scheme is improved to reduce memory overheads for simple types.

6. Added special support for the main() function, so that the command line arguments are mapped to the function parameters, and are checked against the paremeter types of main().

7. Improved representation of C/C++ types, so that their inheritance relationships can be still valid in Dao, and they can be derived by Dao classes directly.

Moreover, this release has included a tool (tools/autobind.dao) which can do semi-automated wrapping of C/C++ libraries. In fact, many of the modules released this time are generated by this tool. Just to list the modules released this time:
DaoCamellia (image processing),
DaoCGI (CGI Web programming),
DaoCLoader (running time wrapping of C libraries, slightly similar to the ctype module of Python),
DaoDataModel (database handling, can be used to set up mappng between data tables and Dao class types),
DaoFastCGI (CGI Web programming),
DaoLapack (linear algebra library),
DaoMagick (image processing),
DaoMGL (math plotting),
DaoMySQL (database),
DaoOpenGL (3D graphics),
DaoSDL (multi-media),
DaoTCC (embedding C codes into Dao scripts),
DaoXML (handling XML documents and fetching web pages from web servers),
DaoZlib (compression),
DaoVTK (3D data and model visualization).

I believe this release has become suitable for some practical applications, and worth to be tried out. Then a formal release of the 1.0 version will be made available during this august or september. I would be very grateful, if anyone can give me some suggestions for improvement, and feature requests are of course also welcome. Thanks and

enjoy,

Limin

home page
sourceforge project
download

I am looking at a way to implement Resume in a CPS-based intermediate language. Resume allows to try again a calculation with a different value.

If I mark the resume value with ^retry I want to do:

1 + ^retry 8  (* 9 *)
retry 5       (* 6 *)

In CPS, 1 + 8 may look like:

lambda (k) (k (+ 1 8))

Then I will extract the continuation around "8" to save it in a "retry" variable:

lambda (k) ((lambda (n) (k (+ 1 n))) 8)
lambda (k) ((lambda (k') (k' 8)) (lambda (n) (k (+ 1 n))))
(* save continuation *)
lambda (k) ((lambda (k') (do ((set! retry k') (k' 8)))) (lambda (n) (k (+ 1 n))))

I could do the same transformation for an arbitrary nested variable. What I do not like is that I use a "global" variable retry which I set!, but the alternative is to pass it around as a function parameter-- not very convenient.

Is my reasoning correct? Is there a better way?

I finally got my act together and updated my "Thoughts about the Best Introductory Language" essay, with many corrections, some clarifications and several other enhancements. See the previous discussion of it here.

The licence is still CC-by.

So as I understand it, describing a language semantics in terms of execution by the SECD machine, is an acceptable presentation of small-step operational semantics. What I don't know is whether small-step operation semantics are still in fashion or considered outdated. One of the practical advantages of small-step operational semantics presented in this manner, seems to me at least, that it facilitates the verification of the language semantics, and for other people to create their own implementations. Is this the common wisdom?

Well given that, I have to wonder why not describe the small-step operational semantics using an even simpler stack machine, one without registers or environment (instead allowing first-class functions on the stack). That seems to me to offer some advantages over the SECD machine. For example, we obviously don't have to worry about environment and registers, and we also don't need to perform defunctionalization.

I am asking, because I want to formally present the semantics (without regard for types) of a simple imperative OO language with some functional features.

Some of my reading material concerning operational semantics:

• A Rational Deconstruction of Landin's SECD Machine by Olivier Danvy
• Syntax and Semantics of Programming Languages by Ken Slonneger, specifically Chapter 8
• Lecture Notes on Semantics of Programming Languages by Andrew Pitts

Please feel free to add more to my list.