[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: .NET CLR? was no subject

I've been looking at the CLR, trying to decide if it can reasonably
support a Dylan/Proto-like language.  So here are some rough answers to
your questions.

For better answers, talk to David Simmons who (1) is a serious VM guru,
(2) knows quite a bit about the CLR, and (3) is on this list.

On Wed, 2002-03-06 at 11:10, Ken Anderson wrote:
> However, http://www.javalobby.org/clr.html suggests that a language, say L, 
> becomes L#, a hybrid langauge, with C# warts or performance 
> limitations.  The article even quotes David Simmons about Smallscript.

The javalobby page is of uncertain accuracy at best.  For example:

| The result: Dialects that cripple the original languages to become
| CLR-compatible. Examples are Managed C++ and Eiffel#, both not
| supporting implementation MI.

Bertrand Meyer, on the other hand, claims that current versions of
Eiffel# supports multiple inheritance, generic types, and design by


I've also ordered the following book, which claims to discuss various
approaches for implementing multiple inheritance on the CLR:


If I have time, I'll write a review of the book when it arrives.

> How good is this metadata idea?

Quite nice, actually, if your language also supports introspection. 
Here's a short code snippet from Cook Computing's XML-RPC.NET web site (
http://www.cookcomputing.com/xmlrpc/ ), demonstrating a simple XML-RPC
server.  The XML-RPC.NET runtime uses metadata to control how objects
get exported to the web: 

| public class BettyService : XmlRpcService
| {
|     [XmlRpcMethod("examples.getStateName",
|      Description="Return name of state given its number")]
|     public string getStateName(int stateNum)
|     {
|         if (stateNum == 41)
|             return "South Dakota";
|         else
|             return "Don't know";
|     }
| }

To register this service, you need only the following configuration

| <configuration>
|   <system.web>
|     <httpHandlers>
|       <add verb="*" path="betty.xmlrpc"
|          type="CookComputing.BettyService, bettyservice" />
|     </httpHandlers>
|   </system.web>
| </configuration>

The server examines the BettyService class using introspection, and
exports any methods with the XmlRpcMethod attribute.

Writing a similar program in Java requires the abuse of 'public static
final' methods to fake attributes:


Also, the Mono project ( http://www.go-mono.com/ ) uses attributes to
mark unfinished code:

| [MonoTODO]
| public override Type DeclaringType {
|     get {
|         throw new NotImplementedException ();
|     }
| }

A small C# program uses introspection to extract this information and
generate the following list of unfinished classes (IE 6 or recent
Mozilla required):


So, all in all, attributes seem like a fairly useful language feature,
especially if you want to build lots of automatic tools.

If you want to look into CLR support for Linux, check out the following
web sites:


That's more or less what I know about the CLR. :-)  Would anybody else
here like the share their experiences with CLR?