2005-10-22T23:06:00.000+02:00

Using Nemerle and Boo in ASP.NET

Mono aims to be a really multi-language platform. And as way to check it, we will learn how to include Boo and Nemerle scripts (from my two favorites languages :-) inline in ASP.NET pages, that can be used then with XSP, mod_mono or even IIS, I think.
First of all, in your machine.config file or web.config one, depending if you want a global change or a per-web application change, locate a section called <compilation> or <compilers>. The Nemerle.Compiler or Boo.CodeDom assemblies should be in the GAC, so it can be easily located. However, you can also add a directive into the <assemblies> section of web.config; (this is recommended for Boo). The directive should look like

<add assembly="Boo.Lang.CodeDom" />

Finally, in the compilers section, you must add this for Nemerle:

<compiler language="n;nemerle;Nemerle" extension=".n" warningLevel="1" compilerOptions="" type="Nemerle.Compiler.NemerleCodeProvider, Nemerle.Compiler, Version=0.9.0, Culture=neutral, PublicKeyToken=5291d186334f6101" />

or this for Boo:

<compiler language="Boo" extension=".boo" type="Boo.Lang.CodeDom.BooCodeProvider, Boo.Lang.CodeDom" />

From then, you can use Nemerle or Boo direclt in ASPX pages just changing the Language directive on Page to "Boo" or "Nemerle". This is the "Hello World!" ASPX page that comes with Boo examples:

<%@ Page Language="Boo" %>
<script runat="server">
def Page_Load(Sender as Object, E as EventArgs) :
HelloWorld.Text = "Hello World From Boo in ASP!"
</script>
<html>

<head>
<title>ASP.NET Hello World</title>
</head>
<body bgcolor="#FFFFFF">
<p><asp:label id="HelloWorld" runat="server" /></p>
</body>
</html>

and this is the same in Nemerle:

<%@ Page Language="Nemerle" %>
<script runat="server">
Page_Load(_ : object, _ : EventArgs) : void {
HelloWorld.Text = "Hello World From Nemerle in ASP!";
}
</script>
<html>

<head>
<title>ASP.NET Hello World</title>
</head>
<body bgcolor="#FFFFFF">
<p><asp:label id="HelloWorld" runat="server" /></p>
</body>
</html>

As you can see, using C#, VB or Nemerle is just a matter of a directive. Now you can start even coding your AJAX applications in Boo!

2005-09-05T12:57:00.000+02:00

Compiling Nemerle SVN on Mono SVN

Compiling Nemerle from a Subversion repository is an easy task. You need Mono 1.1.9, but we will also talk about getting it from SVN. This is not intented as the ultimate guide for builders, but as a quick guide for people who, like me, come from a Windows environment and aren't used to using tools such as patch or svn.
You should create a directory to work. In my case, I used /root/mono-svn.
Well, let's start. Open a terminal and change to the folder using cd. First of all we need to check-out Mono and MCS sources, so let's use the svn command.

svn co svn://svn.myrealbox.com/source/trunk/mono

Then we have to go to the mono folder that svn created. You know, cd mono. Finish getting mono sources by using:

svn co svn://svn.myrealbox.com/source/trunk/mcs

Getting mcs sources will take much longer than mono ones, because it includes the entire Base Class Library sources plus Mono additions to it. The final directory structure on the folder should be:

mono/
  libgc/
  mono/
  data/
  docs/
  ...
  mcs/
    class/
    bmcs/
    mcs/
    gmcs/

(UPDATE: Patching Mono is not longer neccessary as the pacthes have been finally accepted. You can skip this section.) Until Nemerle creators patches to Mono are accepted, we have to use them by hand. Get mono-all.patch from http://nemerle.org/~malekith/temp/mono-all.patch and copy it in the top level mono directory (be careful, because there exists another mono/mono/ folder, as you can see). Do the same with http://nemerle.org/mailman/pipermail/devel-en/attachments/20050905/e147cce6/monop.obj, saving it as monop.patch. Now apply the patches: go to the top level mono, and run these commands:

patch -p0 < mono-all.patch
patch -p0 < monop.patch

In a not very long time these patches won't be neccessary. Even at the moment of this writing, some patches have been approved, so patch asks you this:

Reversed (or previously applied) patch detected! Assume -R? [n] n
Apply anyway? [n] n

Answer both "n", as you don't want to reverse or either apply the patch in a newer version.
It shouldn't ask you about a location. If it does, check you've copied the file in the correct folder.
(UPDATE: Continue from here if you have skipped patching section)

Now it's time to compile mono. First of all use ./autogen.sh. This small script ensures you've all the dependencies needed to build Mono. By default, Mono builds to the system library folder, but if you are running it from SVN, you will sure want to build it in a directory apart from your normal applications, so you need to provide a "prefix". In my case, I'll use /devel/mono, so my autogen command will look like this:

./autogen.sh --prefix=/devel/mono

If autogen tells some dependency or file is needed try using yum, apt-get or whatever package manager ships with your distro. The real compilation will start when you type

make

and press Enter.
If make complains about a not usable mcs installation, try using make get-monolite-latest and then running make again.
Finally, if everything it's OK (it doesn't end with any error), install Mono in the desired "prefix" running the command.

make install

Note: there's also a make check command that will check good compilation, but it not neccessary to run it, furthermore if you're in a hurry. Indeed, in SVN versions it fails most of times.

Now let's compile Nemerle. First of all, get the sources. I suggest using a different folder for this svn, so everything doesn't come mixed up. In my case, I'll use /root/nemerle-svn. So I change to its parent folder using cd, and then check out the sources (the last parameter, nemerle-svn, is the folder where I want the sources to be saved):

svn co http://nemerle.org/svn/nemerle/trunk nemerle-svn

Subversion will tell you the revision you have got. Then go to the newly created folder and run ./configure. You can pass some other arguments to this scripts

--mono-from=path: if you compiled Mono with a prefix, use it here. But be aware you must tell the bin directory, not the base one.
--prefix=path: as on Mono, if you don't want the compiler to live in the standar library directory, specify where you want to install it here.

So in this case, the command will be like here:

./configure --mono-from=/devel/mono/bin --prefix=/devel/nemerle

Then compile and install the sources using:

make
make check (optional, as in Mono)
make install

Nemerle compilation has 4 stages. The first three build the compiler and the main libraries that contains macros and special Nemerle types, such as lists. In the last stage, some additional tools as nemerlish (Nemerle Interactive Shell).

Note: of course, you can also leave out prefixes, so use of Mono and Nemerle will be easier. If you don't care so much about your data and apps (and both Mono and Nemerle should not make anything to them). But use it at your own risk (the only thing I can say is that I use them this way and I have no problems).

Serras Blog