Lambda the Ultimate The Programming Languages Weblog - join today!

XML icon






(new topic)

Language Evaluation

PL Courses

Research Papers

Design Docs


Genealogical Diagrams

Join Now



Nemerle is a new hybrid (functional, object-oriented and imperative) programming language for the .NET platform.

Key features of the language include:

  • simplicity,
  • C#-like syntax,
  • easy to use object system (derived directly from the .NET),
  • easy access to both functional and imperative features,
  • powerful code-generating macros,
  • variants,
  • pattern matching,
  • static and on-demand dynamic typing,
  • type inference

I am not sure being .NET compatible qualifies as "easy to use", but the rest sounds interesting. ;^/
Posted to object-functional by Patrick Logan on 2/20/04; 6:32:55 AM

Discuss (7 responses)

Frappe: Functional Reactive Programming in Java
I found no reference to this in the annals of LtU. Given the recent Scheme implementation of FRP, this one seems timely. It may be of interest to other OOP hackers as well... Smalltalk, Python, Ruby would have less boilerplate to deal with than JavaBeans do.

This paper presents Frappe, an implementation of FRP in the Java progam- ming language. The primary contribution of Frappe is its integration of the FRP event/behavior model with the Java Beans event/property model. At the interface level, any Java Beans component may be used as a source or sink for the FRP event and behavior combinators. This provides a mechanism for extending Frappe with new kinds of I/O connections and allows FRP to be used as a high-level declarative model for composing applications from Java Beans compo- nents. At the implementation level, the Java Beans event model is used internally by Frappe to propagate FRP events and changes to FRP behaviors. This allows Frappe applications to be packaged as Java Beans components for use in other applications, and yields an implementation of FRP well-suited to the requirements of event-driven applications (such as graphical user interfaces).
Posted to object-functional by Patrick Logan on 12/4/03; 5:49:45 PM

Discuss (6 responses)

JavaScript with Continuations and its use in Apache Cocoon
From the discussion group an interesting development for JavaScript.

Posted to object-functional by Dan Shappir on 8/3/03; 1:23:51 AM


Using, Understanding, and Unraveling The OCaml Language
These course notes are addressed to a wide audience of people interested in modern programming languages in general, ML-like languages in particular, or simply in OCaml, whether they are programmers or language designers, beginners or knowledgeable readers ---little prerequiresite is actually assumed.

They provide a formal description of the operational semantics (evaluation) and statics semantics (type checking) of core ML and of several extensions starting from small variations on the core language to end up with the OCaml language ---one of the most popular incarnation of ML--- including its object-oriented layer.

A very approachable description of the OCaml language by one of its creators.

Posted to object-functional by Manuel Simoni on 6/30/03; 3:02:13 AM

Discuss (1 response)

Language Features for Executable Patterns
(via lemonodor)

A objectified Scheme is used for illustration.

Seems quite a few guys found this interesting. Since I know some of them read LtU, maybe they'll want to share their views.

Posted to object-functional by Ehud Lamm on 2/14/03; 2:33:15 PM

Discuss (1 response)

Project Timber
Time as a basis for embedded real-time systems Project Timber is a research project at the OGI School of Science & Engineering at OHSU, and is part of the DARPA program on Program Composition for Embedded Systems (PCES).


  • Facilitate construction and analysis of high-assurance, and portable real-time systems from high-level descriptions
  • Allow dynamic adaptation: replace outright failure by Graceful Degradation
  • Reduce development and maintenance costs through reuse and composition
  • Exploit OGI expertise and experience in both:
    • QoS-aware, adaptive systems
    • Domain-specific languages: "language middleware"

Project Timber is host to several sub-projects, most notably the Timbot, a robot that they program with the Timber language, which seems to be a direct descendant of O'Haskell.
Posted to object-functional by Bryn Keller on 12/30/02; 12:41:20 PM


From the "things we ought to have references to but somehow don't" department:

O'Haskell is
    * the purely functional language Haskell,
        conservatively extended with
          o subtyping
          o monadic objects
    * an object-oriented imperative language,
        enhanced with
          o parameteric polymorphism
          o automatic type inference
    * a concurrent language, with
          o a reactive communication model
          o asynchronous and synchronous message-passing
all at the same time. The O in O'Haskell should be interpreted as standing for both Objects and what remains of IO when the Evil I is removed.

O'Haskell is currently being developed at Oregon Graduate Institute and Chalmers University of Technology by Johan Nordlander, Magnus Carlsson, and Bjorn von Sydow.
Posted to object-functional by Bryn Keller on 12/27/02; 12:15:42 PM

Discuss (1 response)

The Needle Programming Language
Another Needle talk. The interesting part here is the discussion of the type inferencing mechanism (slides 20-34).

I wonder how problematic is the lack of principal types.

Posted to object-functional by Ehud Lamm on 12/8/02; 8:59:11 AM

Discuss (9 responses)

Needle, An OO FP Language

Needle is a new language that was discussed at LL2. The feature list reads like everything I've ever wanted in a language: multiple dispatch, continuations, macros and static typing plus the all usual features you'd expect. Impressive piece of work created by someone who's obviously got a great understanding of modern programming languages.
Posted to object-functional by Noel Welsh on 11/14/02; 9:45:25 AM

Discuss (10 responses)

Moby is an experiment in language design and implementation. Our goal is to combine support for class-based object-oriented programming and higher-order concurrency with the desirable features of ML-like languages: advanced module systems, parametric polymorphism, inductive datatypes, pattern matching, and first-class functions. The Moby project started out as a testbed for the design of ML2000.

Moby is primarily a collaboration between Kathleen Fisher and John Reppy. Much of the work on Moby was done while John Reppy was an MTS at Bell Labs in the Computing Sciences Research Center.

Thought we'd discussed this here before, but I can't seem to find it in the searches. The Moby site seems to be be showing some new signs of growth, including a downloads page which mentions the compiler's implementation language (SML/NJ), though you still can't actually download the compiler. For a long time the Moby page just said "we're working on a compiler" without being more specific, so maybe this is progress.

I haven't had time to read any of the papers on the site, but there are several. Thought we ought to have a reference to the site here on LTU even if it's perhaps a bit premature.
Posted to object-functional by Bryn Keller on 10/31/02; 3:00:10 PM


Developing Applications with Objective CAML
On the mixed use of the object-oriented and functional programming paradigms in OCAML:

Many problems necessitate recursive data types and operations which manipulate values of these types. It often happens that the problem evolves, sometimes in the course of implementation, sometimes during maintenance, requiring an extension of the types and operations. Neither of these two models permits extension in both ways. In the functional/modular model, types are not extensible, but one can create new functions (operations) on the types. In the object model, one can extend the objects, but not the methods (by creating a new subclass on an abstract class which implements its methods.) In this respect, the two models are duals.

The advantage of uniting these two models in the same language is to be able to choose the most appropriate model for the resolution of the problem in question and to mix them in order to overcome the limitations of each model.

"Comparison of the Models of Organisation" (Chapter 16) briefly discusses mixing the two paradigms. In the example given, the conclusion is that, "the extension of data and methods is easier in the object model when it is combined with the functional model." To what extent is the approach taken here applicable to functional .NET languages? You can download the book in a variety of formats.
Posted to object-functional by jon fernquest on 7/13/02; 7:48:13 AM

Discuss (2 responses)

Using Functional Objects in various languages
Functional Objects are non-mutable objects. When you modify an object it returns the modified object instead of doing it in place.

A problem occurs in statically-typed languages because you can't specialize the return value as wanted/needed.

Also talking about multi-methods...

I tried this after some discussion on comp.lang.functional. I couldn't find a good C++ solution. Some help anyone?

(I hesitated between OOP and functional category, maybe we could choose more than one? :p)
Posted to object-functional by pixel on 5/10/02; 1:36:02 PM

Discuss (4 responses)

The Nice Programming Language
(via Frank)
Nice is a new object-oriented programming language based on Java. It incorporates features from functional programming, and puts into practice state-of-the-art results from academic research. This results in more expressivity, modularity and safety.

Since we're talking about multimethods lately - Nice adds multimethods, parametric polymorphism, first-class functions, and an MLish type system to Java. Allows easy interop with Java (though it's harder to use Nice from Java than Java from Nice).
Posted to object-functional by Bryn Keller on 5/10/02; 1:18:45 PM

Discuss (5 responses)

Object Functional Patterns
A category page over on Wiki.

Contains some interesting things like a continuation pattern.and call by need semantics.

I chose to put this in the OOP department, because these ideas are basically ways to get functional advantages in an OO language.

19 Dec. 2002: I moved this to the newly created object-functional department
Posted to object-functional by Ehud Lamm on 3/20/01; 7:57:20 AM


Logs: Hack The Planet ; JavaLobby ; Daily Python-URL ; xmlhack ; PHP everywhere ; (more)
Wikis: WikiWiki ; Erlang ; Common Lisp ; Haskell ; Squeak ; Tcl ; Program Transformation
Print-Friendly Version
Create your own Manila site in minutes. Everyone's doing it!