Comments on Moserware: OMeta#: Who? What? When? Where? Why?

"this output C# file" should now point a...

2010-08-27T15:50:32.566-04:00

"this output C# file"
should now point at:
http://ometasharp.codeplex.com/SourceControl/changeset/view/12094#264623

Harry Pierson: Thanks for stopping by! I checked o...

2008-07-03T22:48:00.000-04:00

Harry Pierson: Thanks for stopping by! I checked out your Lang.net presentation on PEG's in F# (and linked to it in this post) as we share similar excitement about them.

You're right that it seems a bit odd for choosing C# and not something more language friendly like F#. I did this intentionally for a few reasons. The main reason was to eliminate dependencies. I didn't want to require a F# (or SML/ML or the like) library DLL or requiring someone to download the F# compiler. Another reason is that I'm not as good at writing code in F# as I am in C#. This is a poor reason, but true for now.

One subtle reason that I alluded to in this post is that by doing it in C#, it makes it easier to "sneak" it into the build process of real projects if it ever takes off. That is because most people have C# compilers in their build process. By compiling just C# code and not having to introduce something new, it makes it that much easier.

However, I have planned from the beginning to create the possibility of code emitters be in any language, including F# and Boo. F# has an amazing ability to handle trees and thus could be of use in some more intense phases. The point is that code emiters will just have to implement some known interface. I'd like to have one for common languages like VB.NET as well.

I'm sure OMeta/JS could probably get up and running on .NET with the new Managed JavaScript compiler being built with the DLR. However, it'd be limited to JavaScript's type system. The point with OMeta# is that it uses native .NET 2.0 (generic) data structures that can be used in a wide array of languages and thus interoperate nicely across the .net/clr platform (including the dynamic languages).

As reflected in my check-ins so far, I'm still in the experimenting phase. The design is really rough and has some bad code smells. I'd love it if smart guys like yourself wanted to help out and offer constructive criticism and suggestions on the design :) There is a ton of work in order to achieve the vision.

Thanks again for the encouragement and comment!

I first learned of oMeta after delivering the PEGs...

2008-07-03T18:16:00.000-04:00

I first learned of oMeta after delivering the PEGs in F# talk at Lang.NET. I haven't had time to play with it, but your implementation certainly is exciting.

I'm surprised you didn't look @ implementing oMeta# in F#. You praise the pattern matching feature of ML, but then you used a implementation language (aka C#) that doesn't support it.

I also wonder if the oMeta-js would work w/ .NET, either the old JScript.NET compiler or the newer Managed JScript that's being built on the DLR?

Speaking of the DLR, I tried geting pyMeta to work with IronPython, but we haven't implemented the built-in parser module yet so it won't work.

Keep up the good work!

leppie: First off, I want to say that I think your...

2008-07-02T08:11:00.000-04:00

leppie: First off, I want to say that I think your IronScheme project is really interesting and I have a lot to learn from it.

All I know about macro hygiene is what I just read about it on Wikipedia. However, from what I understand, I think OMeta as a language handles this in a sort of straightforward way.

The language is grammar based. Grammars can inherit from other grammars. The main unit of work is the rule. Rule names must be unique in an inheritance chain (although overriding is freely permitted). The important thing from a hygiene perspective is that rules can call out to foreign grammars. Those foreign grammars can then use rules with the same name to mean entirely different things. This is specifically mentioned in the 2007 paper. It's not perfect, but it's similar to how people think in most mainstream languages like C# and Java.

I can't speak for Nemerle because I don't have experience with it. Maybe someone else can?

Did that answer your question?

How do you (and Nemerle for that fact) handle macr...

2008-07-02T05:25:00.000-04:00

How do you (and Nemerle for that fact) handle macro hygiene?

greg: It would be a bit tricky since the function ...

2008-07-01T08:05:00.000-04:00

greg: It would be a bit tricky since the function would essentially take in another variable. However, since it makes the code look nicer, it might be special-cased in some compilers.

A good ML compiler would optimize that to tail-rec...

2008-07-01T01:36:00.000-04:00

A good ML compiler would optimize that to tail-recursive form though, wouldn't it?

anonymous: Hopefully we'll get to the level of int...

2008-06-29T22:40:00.000-04:00

anonymous: Hopefully we'll get to the level of interactive debugging like that of Visual Studio with C#, but I'm sure it's a lot of work. Interesting on getting pymeta up on python.net. Let me know if you build some languages with it.

i have sucseeded running pymeta on python.net.
...

2008-06-27T07:19:00.000-04:00

i have sucseeded running pymeta on python.net.

python.net is a seamless integration solution between python and .net
check the site for more details:
http://pythonnet.sourceforge.net/

i have tried to work with pymeta on ironpython . c...

2008-06-26T20:22:00.000-04:00

i have tried to work with pymeta on ironpython . could'nt import the string library. it's hard for me to estimate how much work it would take to port it to ironpython , since i have no experience in ironpython.

regarding debugging: since the idea of dsl is to enable writing very little code , the basic debugging model of scripting languages (commandshell +print instructions ) could be pretty usefull and relativly simple to implement.

alexey: Thanks again for keeping me honest :)
<...

2008-06-25T19:55:00.000-04:00

alexey: Thanks again for keeping me honest :)

anonymous: I've heard of PyMeta and meant to link to PyMeta's How and Why explanation because the author had the same sort of feeling to defend why the world needs another way of expressing a language like I did.

I think PyMeta is definitely neat, but the aims are different from OMeta#. PyMeta seems to take a string and do a parse whereas I'd like to make OMeta# more of a front end compiler and simplified language studio (with debugger support, syntax highlighting, etc.)

All that said however, let me know if you have success getting it up on IronPython.

have you heard of pymeta?
it's a python impleme...

2008-06-25T09:50:00.000-04:00

have you heard of pymeta?
it's a python implementation of ometa .
i could probably run on iron python , and by doing so , offer ometa on the clr.
http://washort.twistedmatrix.com/2008/04/pymeta-is-more-than-just-parsing.html

Yes, this is the correct version.

2008-06-25T09:05:00.000-04:00

Yes, this is the correct version.

alexey: Great catch! You're right, I said it was t...

2008-06-25T08:17:00.000-04:00

alexey: Great catch! You're right, I said it was tail recursive, but I was absolutely wrong for the reason you mentioned. I need to make sure that the last call is to itself. I made an assumption without taking a second to think about it. Oops :(

An updated function would need to pass in the result so far as an accumulator. How about something like

fun fastReverse([], acc) = acc
| fastReverse(x::xs, acc)=fastReverse(xs, x::acc)

That way the last call in the function is to itself and thus can be tail recursive. We assume that the accumulator (acc) is reversed. Then, we pop the head off of what we need to reverse "x" and prepend it to the already reversed part. The initial conditions would be "fastReverse(myList, [])"

Unfortunately, your reverse isn't tail recursive. ...

2008-06-25T05:30:00.000-04:00

Unfortunately, your reverse isn't tail recursive. It also appends to an immutable list.

So yes, it will be very slow.

Someone asked me in an email if the reverse functi...

2008-06-24T23:13:00.000-04:00

Someone asked me in an email if the reverse function I demonstrated would be really slow or cause a stack overflow. This is a good question, especially coming from a traditional language like C++. However, the good news is that it will be just as fast as a for loop since functional language like ML do tail call optimizations. For more information, check out this link.

cory: Thanks! I agree, the Viewpoints guys are doi...

2008-06-24T22:41:00.000-04:00

cory: Thanks! I agree, the Viewpoints guys are doing some awesome stuff. My hope is that even bringing a tiny fraction of their ideas to the code I work with daily would be a huge gain.

anonymous: Nemerle definitely lookings interesting. It seems to have support for some nice Lisp-like things such as macros. However, it still seems a bit too much heavy on the syntax side to do what OMeta can do in a clear fashion. Maybe I'm missing something though?

harry mcintyre: OMeta isn't a silver bullet, but I do think that it does pattern matching really well and could help you get going on a domain specific language quickly.

mwatts: My hope is that as a community we can work together to get the vision of OMeta# up on .NET to continue to make steps towards the VPRI goals.

jason: As mentioned by rektide, the ANTLR approach is the traditional way of doing things. It works, but tends to (in my experience at least), produce solutions that aren't reusable or composable. At least not nearly in the way that OMeta would allow.

eric: Thanks for the kind words!

anonymous: OMeta doesn't try to be LISP. However, as demonstrated by http://jarrett.cs.ucla.edu/ometa-js/#Lisp , it does make it possible to *implement* the language in roughly the half page of mathematics that McCarthy used to describe it in http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf

I agree that a lot of cool things happened in the 1960's. As a matter of fact, OMeta's roots go back to Meta II which was developed in that era. However, it was not as fleshed out as the VPRI guys have done so. I think the OMeta vision is helping us get back to the excitement that was there in CS in the 60's.

rektide: I hadn't heard about MetaBoo, but agree that PEG is a nice way to express it. Thanks for including the links as well. I'd like to get OMeta# to the point where you could use Boo as a host language some day. I think that way would allow the best of both worlds.

@Jason, that DLR article at bitwisemag you ...

2008-06-24T12:24:00.000-04:00

@Jason, that DLR article at bitwisemag you linked uses ANTLR, like almost every other project that needs a parser on the planet. PEGs are usually written in the language you are trying to extend. For example, Boo uses ANTLR, and is hoping to self-host its parser by switching to a PEG implementation written in Boo.

Boo author Rodrigo B. De Oliveira is hard at work ...

2008-06-24T12:22:00.000-04:00

Boo author Rodrigo B. De Oliveira is hard at work writing a PEG system for Boo (a "wrist friendly python inspired .net language"), which will then be used to re-write Boo's parser as a PEG. Boo-written-in-boo has been a long term desire for the Boo project (MetaBoo), and PEGs will almost certainly be the tool used to make this happen.

His initial blog entry on PEGs is at:
http://blogs.codehaus.org/people/bamboo/archives/001688_towards_extensible_parsing.html
And he links a pretty good paper on PEGs:
http://citeseer.ist.psu.edu/643425.html

Skimmed your article; its good and I look forward to spending some real quality time with it tonight at home.

nice way of reinventing LISP.

"most interes...

2008-06-24T10:10:00.000-04:00

nice way of reinventing LISP.

"most interesting thing happening in computer science right now" indeed, think 1960 instead.

That's a great analysis of the power of OMeta! Th...

2008-06-24T10:00:00.000-04:00

That's a great analysis of the power of OMeta! Thanks!

Immediately reminds me of:

http://www.bitwi...

2008-06-24T09:35:00.000-04:00

Immediately reminds me of:

http://www.bitwisemag.com/2/DLR-Build-Your-Own-Language

Which is using antlr to target the .NET dynamic language runtime, which makes me think you could just use OMeta# to do the same.

This is great news! I have already downloaded the...

2008-06-24T09:26:00.000-04:00

This is great news! I have already downloaded the source and am looking at it now.

I only recently became aware of the work being done at VPRI, and like Cory, believe that this work is probably the most interesting thing happening in computer science at this time. While we are a long way from having a full working App-to-hardware system in < 20K lines of code, having SOME of that technology available on .NET will be very nice.

To Anonymous and the comment about nemerle: nemerle is a very nice language but the goal of OMeta and the larger VPRI effort is to move the entire computing stack to a higher level of abstraction than is available with current languages, not just extend them with new syntax although that is a side-effect. Take a look at some of the documents available at http://www.vpri.org/html/writings.htm like http://www.vpri.org/pdf/steps_TR-2007-008.pdf where they describe a TCP/IP stack implemented in less than 200 lines of code, or a version of Prolog in about 90 lines of code. The ability to express solutions in such very different problem domains in so few lines of code is not something that can be done in any other language that I am aware of.

This looks awesome. I've recently implemented a pa...

2008-06-24T04:36:00.000-04:00

This looks awesome. I've recently implemented a parser for allowing users to control my application using sms, and I have ended up with an insane mishmash of extension methods and classes, when all I wanted was to feed a nicely defined grammar into something.

While I was doing it, I realised that by writing the requirements out in a structured version of english, all the information required to generate the c# for my application layer existed, just I didn't have a tool to do the conversion. This looks like it could be the tool.

look at

http://nemerle.org

http://n...

2008-06-24T03:44:00.000-04:00

look at

http://nemerle.org

http://nemerle.org/Macros_tutorial

for exmaple, adding "for" operator to language
--------------------
macro for (init, cond, change, body)
{
<[
$init;
def loop () : void {
if ($cond) { $body; $change; loop() }
else ()
};
loop ()
]>
}

-----------
using it

for (mutable i = 0, i < 10, i++, printf ("%d", i))

Comments on Moserware: OMeta#: Who? What? When? Where? Why?

"this output C# file" should now point a...

Harry Pierson: Thanks for stopping by! I checked o...

I first learned of oMeta after delivering the PEGs...

leppie: First off, I want to say that I think your...

How do you (and Nemerle for that fact) handle macr...

greg: It would be a bit tricky since the function ...

A good ML compiler would optimize that to tail-rec...

anonymous: Hopefully we'll get to the level of int...

i have sucseeded running pymeta on python.net....

i have tried to work with pymeta on ironpython . c...

alexey: Thanks again for keeping me honest :)<...

have you heard of pymeta?it's a python impleme...

Yes, this is the correct version.

alexey: Great catch! You're right, I said it was t...

Unfortunately, your reverse isn't tail recursive. ...

Someone asked me in an email if the reverse functi...

cory: Thanks! I agree, the Viewpoints guys are doi...

@Jason, that DLR article at bitwisemag you ...

Boo author Rodrigo B. De Oliveira is hard at work ...

nice way of reinventing LISP."most interes...

That's a great analysis of the power of OMeta! Th...

Immediately reminds me of:http://www.bitwi...

This is great news! I have already downloaded the...

This looks awesome. I've recently implemented a pa...

look at http://nemerle.orghttp://n...

i have sucseeded running pymeta on python.net.
...

alexey: Thanks again for keeping me honest :)
<...

have you heard of pymeta?
it's a python impleme...

nice way of reinventing LISP.

"most interes...

Immediately reminds me of:

http://www.bitwi...

look at

http://nemerle.org

http://n...