Lambda the Ultimate - LtU Forum

Scala Lift Off Unconference review

Mon, 12 May 2008 13:33:16 -0400

I was just a gadfly, so LtU folks who actually presented etc. at the unconference can talk more in-depth, but it seemed to me that Scala is getting serious momentum. More power to it, we could stand to have a "better" Java.

[Edit: I am promoting this to the front page. Click to read more details, as they are posted to the discussion group. -- Ehud]

service course in logic and logic programming: crazy?

Sat, 10 May 2008 13:11:18 -0400

This coming fall, I'm teaching our department's service course for non-majors. The topic is open, and in the past I've offered a version using Mark Guzdial's Python-based image processing course and another surveying algorithms and algorithm analysis (a la David Harel's Algorithmics).

For this fall, I'm thinking about offering a course introducing programming from the logic programming point of view. The students will, for the most part, have the mathematical maturity of Oregon high school graduates who are afraid of math, which is to say, essentially nothing. Almost none of them will have any background in either programming or logic, and I'll have the standard "fear factor" to overcome, as well.

At a minimum, then, I'll have to include a few weeks on propositional logic before diving in to actual programming. My inclination for programming is to use Prolog, probably the SWI compiler, for its fairly rich standard library. Beyond that, however, I'm pretty much at sea, and would really appreciate some suggestions. I've never taught a logic programming course before (other than as a component in a senior-level PL class), certainly not at such a low level, and this is not, in general, an area of expertise for me.

If you were to teach such a course (or if you have already), what would you consider an appropriate range and ordering of topics? Any ideas for cool applications? Sudoku solvers are a neat possibility: I'd love other ideas. Do you know of similar courses that have been successfully deployed?

Is this idea insane?

OO via first class enviroments: Bla

Fri, 09 May 2008 19:10:59 -0400

(Since SHEEP isn't out yet) The programming language Bla

"breaks with referential transparency and allows use of assignment as well"

and/but

"[via] '1st class environments', Bla integrates functional and object orientedness in a tiny language, in an elegant and natural way. However, on top of this core language, Bla adds quite a few concepts to make programming practical."

FringeDC informal meeting Saturday May 10th

Thu, 08 May 2008 08:40:26 -0400

FringeDC is a group in the Washington DC area interested in fringe and
functional languages (Lisp, Haskell, Arc, Prolog, etc.)

If you're in the DC area, please join us this Saturday over a beer!

http://www.lisperati.com/fringedc.html
http://www.lisperati.com/may10th.html

In what case a system doesn't benefit from MapReduce? Do you know any example which doesn't benefit from MapReduce

Tue, 06 May 2008 23:36:55 -0400

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

Statistical Defect Detection?

Sun, 04 May 2008 14:01:25 -0400

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?

programming languages and facial hair

Tue, 29 Apr 2008 20:56:11 -0400

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.)

A Cybernetics DSL?

Tue, 29 Apr 2008 13:48:48 -0400

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.

is there anybody knows about the origin "Dope Vector"?

Sun, 27 Apr 2008 14:35:43 -0400

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

Is Halting Problem Valid for P?

Sat, 26 Apr 2008 16:00:20 -0400

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?

Dao 1.0 preview version is released

Fri, 25 Apr 2008 18:26:42 -0400

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

Resume using continuations

Fri, 25 Apr 2008 12:49:50 -0400

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?

2nd Revision of "Thoughts about the Best Introductory Language"

Fri, 25 Apr 2008 01:35:08 -0400

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.

On Presenting Operational Semantics

Thu, 24 Apr 2008 12:32:39 -0400

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.

Tom 2.6 released : matching constraints, strategic programming with java objects

Thu, 24 Apr 2008 05:59:43 -0400

Tom 2.6 was just released, and includes a whole lot of interesting things.

Among them, there are :
- the introduction of constraints in the matching algorithm, improving the readability of programs
- strategies now work with zero efforts on any java data structure, all you have to do is provide the tom mapping, which you already did since you use %match
- a much better integration of the antlr parser generator
- term graph rewriting

have fun !

The complete announce:
-------------------------------------------------------------------------
Tom 2.6 announcement

It is our great privilege and pleasure to announce the availability of
Tom version 2.6 .

This release continues our work on the integration of pattern matching
and rule based programming facilities into Java and C.

Tom is a pattern matching compiler developed at INRIA. It is
particularly well-suited for programming various transformations on
trees/terms and XML based documents. Its design follows our research on
the semantics and the efficient compilation of rule based languages.

Many applications have been developed in Tom, both in academia and
industry. Among them, let us mention:
- the Tom compiler itself
- languages semantics, interpreters and program transformation tools
- a generator of canonical abstract syntax trees (Gom)
- a proof assistant for supernatural deduction
- a compiler algorithm for anti-pattern matching and disunification

Tom is a complex compiler which adds powerful constructs to Java and C:
rewrite rules, strategies, non linear syntactic matching, associative
matching with neutral element (a.k.a. list-matching), XML based pattern
matching, string matching, and equational rewriting.
This offers the possibility to analyze and transform any kind of
data-structure. Tom can be used for large scale developments and
applications. It comes with a detailed documentation, as well as with
programming and debugging support.

This new release contains many improvements and new features:

- new alternative syntax for '%match', based on atomic constraints
that can be combined with '&&' and '||' operators. This gives a
higher expressiveness and conciseness. Works also in '%strategy'

- hand-written strategies became easier to write. No more 'Forward'
class is needed.

- strategy support for hand-written mappings

- new tool based on ANTLR 3 for implementing parsers that
directly output Gom terms: GomAntlrAdapter.

- term-graph rewriting support in Gom

- Gom's lists now implement the interface Collection. Consequently,
Java's classic iteration techniques can be employed.

- several speed-ups of the compilation process as well as for the
generated code.

- a lot of new features for the Eclipse plug-in, including the
availability of all the functionalities of the Java editor for
".t" files ( a complete list is available on the plug-in page:
http://tom.loria.fr/plugin.php )

Tom is available, in open source (GPL/BSD License), from the web page:

http://tom.loria.fr/

Best regards,
Tom's development team