I wrote Firefox and Chrome extensions to get rid of it.

Unfortunately, I will not be joining Xamarin.

I’ve worked on Mono for a long time (nine years I think) and there are a lot of people on the team I consider good friends. I wish everyone at Xamarin the best of luck. They’ve got a great group of talented people.

(This was a tough blog entry to write, I could barely muster the energy to find a funny cat picture)

As for me, I am looking for exciting new opportunities. Either fulltime positions or contract work. So please email me if you know of anything.

Lots of people have been asking me about the future of Manos. As of right now its hard for me to make any promises. Manos has been getting a lot of awesome contributions from other people. So I am sure it will live on.

UPDATE: Just a couple updates regarding my employment situation: * Unfortunately, because my fiancee is in medical residency I can’t leave Boston for the next three years * I leave for my wedding/honeymoon in a couple of weeks and wont be back in the states until July 15th. * I don’t necessarily care if the technology I work on is .NET or not. I like most programming languages. What’s more important to me is what is being done with the technology.

I recently read this awesome article on coming up with product names. The article details how Lexicon, a boutique naming firm, comes up with product names.

The basic process used by Lexicon is something like this:

• A team learns about the product
• The team lists concepts they’d like to convey with the name
• A number of teams with no knowledge of the product are asked to come up with words/phrases that convey those messages

Not having knowledge of the product is the key. When you have an intimate knowledge of something its hard to come up with those unique names instead of just describing the product. This is why software engineers often come up with names like File Saver Pro or Dog Picture Uploader.

As a single developer working alone its really hard to detach yourself and find those words/phrases. Asking friends doesn’t really work either because they often have background knowledge or want to have more info.

That’s where Fancy Hands comes in. As an experiment I tried using Fancy Hands to rename Manos de Mono. I’m not going to rename it, but I just wanted to see how it would work.

I sent a number of requests to fancy hands like “Please list the first 15 things you think of when I say the word ‘fast’” or “Name 15 activities that are performed at highspeed”. I also asked things like “List ten fast animals”.

That first round of questions led to some pretty good names. In fact they even came up with tornado, which is the name of the project Manos was originally based on.

In the second round of questions I asked for things related to tornados. They came up with Marvel which I think is a pretty cool name.

You might not use any of the names that Fancy Hands comes up with but I think at the very least it’s a really cheap way to help get the creative juices flowing.

Less than an hour after I blogged an ugly editor UI last week Jonathan Pobst sent me a nicer looking version. This is what it looks like now:

We decided to keep the save/cancel as real form buttons so you can still easily tab to the save button after editing.

We have a saying around the office that Mono is about making “happy developers” and we feel a big part of that is having excellent documentation. High quality documentation has become increasingly crucial now that we have so many of our own APIs and can’t just rely on MSDN. Things like MonoMac, MonoTouch and MonoDroid all require their own documentation.

So one of the things I’ve been working on for the last couple of months is productizing Kipunji and getting it to fit in better with our documentation structure. As we did this we realized that online editing of documentation would be a killer feature and allow us to create more and better docs.

Last night I pushed online documentation to monomac-docs. There are only a few of us that are authorized to edit docs, but we are planning on enabling a system that will allow non-authorized users to edit and submit docs soon.

Here’s a peek at what it looks like:

Over the weekend a totally awesome contributer was nice enough to get Manos running on Windows.

Here are the instructions he supplied:

Install Mono 2.8 (Optional)

Follow the Windows specific instructions on http://www.mono-project.com/download to install Mono 2.8.

This step is optional but you will need the Mono.Posix.dll and PosixHelper.dll when you want to compile a single Manos dll for both Windows and Linux/MacOS.

Install libev

Download the libev package from: http://software.schmorp.de/pkg/libev.html

Extract it and place it next to the libev in the source dir, so both libev-4.00 and libev are in the same directory.

Install Manos

Checkout Manos from github at http://github.com/jacksonh/manos/ and build/install it using Visual Studio.

If you do no have Mono installed you can define DISABLE_POSIX to remove the Mono.Posix dependency.

First off, for those that don’t know what Manos is: Manos is an easy to use, easy to test, high performance web application framework that runs on Mono. You can read more about it here.

Lately it seems like everyone is trying to install Manos on OS X, so I spent some time last night trying to install it on my macbook.

I think I’ve fixed most of the issues so its a relatively smooth process now. There are a few more steps than I’d like, but remember this is just alpha software.

So here we go.

Install Mono 2.8

Grab the Mono 2.8 OSX package from the Mono Downloads Page.

You need to have Mono 2.8 installed on your system. An older Mono install wont cut it. Also, if you’ve install Mono from source on your Mac, things might work, things might not work. This guide assumes you have it installed from packages.

Install libev

libev is Manos’s one native dependency. I installed this guy using macports:

sudo port install libev +universal

The key part of this is that we are installing the universal build of libev. If you leave that part out you could get a 64bit version and Mono won’t be able to load it.

You should now have a libev.dylib in /opt/local/lib/ to make sure Mono knows where to find that library, update your DYLD_FALLBACK_LIBRARY_PATH.

export DYLD_FALLBACK_LIBRARY_PATH=/opt/local/lib

Install libev-sharp

libev-sharp is a managed wrapper around libev. The best way to install it is to grab it from my github:

git clone https://jacksonh@github.com/jacksonh/libev-sharp.git
cd libev-sharp
./configue
make
sudo make install

This will install libev-sharp.dll into your /usr/local/lib/libev-sharp directory and will also install a pkg-config file.

Install Manos

Now that all the dependencies are installed you should be able to build and install Manos.

git clone https://jacksonh@github.com/jacksonh/manos.git
cd manos
./configue
make
sudo make install

This will install Manos.dll, manos.exe and libev-sharp.dll into /usr/local/lib/manos. As well as a .pc file and a manos script for invoking manos.exe

Confirm your installation

You should now be able to run the manos documentation server:

manos -docs

and navigate to http://localhost:8181/ in your browser.

Trouble Shooting

1. If your build fails because libev-sharp isn’t found, you can manually copy it into your manos/build/ directory.

   erp:manos jackson$ cp /usr/local/lib/libev-sharp.dll* build/.

Note that you want to cp libev-sharp.dll* not just libev-sharp.dll. That way you’ll get the .mdb debugging file copied over also.

1. If you are getting a type load exception, make sure you have the universal libev installed:

   erp:~ jackson$ cd /opt/local/lib

   erp:lib jackson$ file libev.dylib

   libev.dylib: symbolic link to libev.3.0.0.dylib
   

   erp:lib jackson$ file libev.3.0.0.dylib

   libev.3.0.0.dylib: Mach-O universal binary with 2 architectures
   
   libev.3.0.0.dylib (for architecture x86_64):    Mach-O 64-bit dynamically linked shared library x86_64
   
   libev.3.0.0.dylib (for architecture i386):      Mach-O dynamically linked shared library i386
   

Another trick is to use Mono’s logging to see where Mono is looking for libev.dylib

 MONO_LOG_MASK=dll MONO_LOG_LEVEL=debug manos -docs

Hopefully all this works for you, if you notice any problems please let me know. Its my first pass at getting Manos running on OS X so its very possible I’ve missed something.

And remember there is a Manos de Mono Google Group

And you can follow the github project here: http://github.com/jacksonh/manos

Special thanks to Geoff Norton for answering all my ‘i dont get the mac’ questions.

I just pushed a Manos update that switches all the event handling over to using libev. libev is a powerful event loop and is used in projects like node.js. Previously Manos had its own event loop, calling directly into epoll itself. So this switch has a nice benefit of dropping some rather complex code from Manos. The main benefit of this switch is that libev is a cross platform library that runs on Linux, OS X and Windows. So this removes the main blocker for running Manos on the Mac and on Windows. As another side benefit we can be confident that Manos is built on the same foundations as other high performance servers.

To make this switch I created a managed wrapper around the libev library. Its source repo is here:

http://github.com/jacksonh/libev-sharp

and you can find openSUSE 11.3 packages here:

http://software.opensuse.org/search?q=libev-sharp&baseproject=openSUSE%3A11.3&lang=en&exclude_debug=true#

So that is the good news.

The bad news is that this introduces a dependency in Manos and if you want to build Manos you’ll need to install libev-sharp. Hopefully Ubuntu packages will be available soon.

I am hoping OSX can now run Manos out of the box. Windows will take a little more time as I have to remove the sendfile call. However, I think windows will still work as long as you don’t try to serve any static content. Right now Manos serves static content with the unix sendfile call which isn’t available on windows.

Before pressing the Publish Now button on my the Manos de Mono Manifesto, I mentally prepared myself for a beat down. I figured the redditors would tear it apart for using Mono, the hackernews guys would tear it apart for not being rails and the .net people would be angry about some missing enterprise feature. Oh yeah, and then there are the free software people.

I think the redditors scared me the most. You know that scene in every zombie movie, where the annoying guy that you want to die is sneaking through a group of distracted zombies. Inevitably he drops something, it makes a loud noise, and dozens of zombies turn, stare for a second, moan and attack. Thats what having your article submitted to reddit feels like.

But reddit feedback was awesome. Here are a couple quotes:

Very cool, as a full time C# .NET(ASP.NET & Winforms) developer I 
have only recently tried Mono with a console application I'm writing
and have loved it so far. I was reluctant to delve into running an 
ASP.NET application through but with this I'm definitely going to 
give it a go.

and

Hell yes, this saves me from having to learn node.js

The article also made it up to the top of Hackernews. Over there @averyj of TekPub fame did a nice job of summarizing what he felt were the cool features in Manos.

Just from reading through it quickly it includes the following 
things I believe are absent in all of the above (although I have 
only worked with ASP.NET MVC and MonoRail).

1) It has a built in web-server. This is hugely awesome, 
    especially since it is based on Tornado. No mucking with 
    Apache or Nginx, CGI, etc.

 2) It includes command line app generation and compilation
    - missing from at least ASP.NET MVC.

 3) Simple Routing - did you look at the route and lamba? 
     That is awesome.

  Some of what is here is similar to what exists, but this looks 
  much improved. Pipes looks to be an improvement over the 
  current HttpModules of ASP.NET. The view engine looks like 
  an improvement over .aspx. The HTML5 template looks like an 
  improvement over the crappy templates that MVC creates.

The ‘this is awesome’ posts are nice, but things like this are really cool, because you can tell javery really understands why Manos is going to be awesome.

On top of all that, Manos now has around 160 github watchers. Thats more than any of the projects in the mono repository, including mono itself.

Probably the biggest endorsement of all came last night. While I was working away, I received an email from someone who wanted to give me money to buy domain names for the project. Boom, 20 minutes later he paypal’d me the money.

So it seems like people like the idea.

Renewed Vigor

This makes hacking on Manos late at night much more exciting. Its cool to know people actually want to use Manos or at least play with it.

I’ll be working on Manos full time for the first two weeks of October. This should give me enough time to get a fairly polished release out. It should include a bunch of fixes to the core pieces and some new features based on feedback. I’ve also got some ideas for a new IO setup that will significantly improve performance.

The big piece is the template engine though. I’ve been agonizing over what to do here and after talking to some friends, I think I’m just bike shedding. The template engine I have now is pretty awesome, I just need to rework some things. So there should be a nice template engine in the release too.

I’ve also done the work to get Manos packaged properly once Mono 2.8 is out. I’ve setup RPM spec files for Suse and I think I have sufficiently bribed Jo Shields for Ubuntu packages.

So thanks for all the feedback guys. And remember if you want to get involved with the project you can watch/fork it on github at http://github.com/jacksonh/manos and you can subscribe to the google group here: http://groups.google.com/group/manos-de-mono

Although I’ve spent the last five years working on desktop technologies like Windows Forms and Moonlight, my real interest is on the web. I get more excited about requests per a second than smooth scrolling and I don’t really care about grid controls. Whenever possible I like to used web based applications like gmail, tumblr and prezi.

I’ve always enjoyed using and developing web applications but I’ve never been a huge fan of asp.net. To me, writing apps with Django or Tornado has always been much more enjoyable. MonoRail and MVC were big improvements over webforms, but still they felt difficult to me, especially if you aren’t using an IDE. Mono and web development just never meshed for me.

Because I love the web and I love Mono, there was only one thing I could do.

I had to put them both in a room. Poke them repeatedly with sharp sticks. And deprive them of sunlight until they could learn to love each other. After a few months of forced love, they gave birth to their first child. Her name is Manos de Mono, and this is her story.

So what is Manos de Mono?

Manos is a a lightweight web application framework that runs on Mono. The goal of Manos is to simplify the entire web application development process. It should be easy to prototype, design, develop, test, debug and deploy Manos applications. The focus isn’t just on getting you up and running quickly, the focus is on the entire process of creating, managing and updating a web application.

"Simple things should be simple. Complex things should be possible"
-- Alan Kay

Manos aims to be Simple, Testable, High Performance, Reusable and Flexible.

C# sucks for web apps, why bother?

Many web developers don’t consider C# and Mono as a viable language for web application development. However, I feel that there hasn’t been a web app framework built that takes advantage of Mono.

• C# is a great programming language. It allows for clean, expressive code. It bends nicely to your programming style. I think most people that have actually used C# find the language quite enjoyable.

• The core class libraries in .NET and Mono are very nicely polished. For the most part the API is clean, discoverable and easy to use. The API documentation on msdn.com is also top notch.

• .NET is also really nice for multicore/multiprocessor programming. Often all you need to do to take advantage of all of a machines cores is use the AsParallel function.

The problem though isn’t the language or the platform. The problem are the frameworks.

There has been an infection of over engineering and me-too technologies in this space. We have abandonded the Unix/AT&T style of simple programming and have replaced that with layers upon layers of goo.

So Manos is my attempt at getting back to simplicity. Web frameworks really don’t need to be that complicated. For the most part websites get requests and return either HTML or JSON. Is this really that complicated a task?

A closer look at Manos

Here are some of the main features of Manos, from the bottom up:

• A scalable non-blocking HTTP server. Manos includes its own high performance web server based on friendfeed’s tornado web server (http://tornadoweb.org). Having an integrated server simplifies deployment and allows the underlying server to be customized to meet the needs of the higher level framework.

• An HTTP “pipes” system, that allows you to hook into and process all http requests and responses before/after they get to the main routing framework.

• Simple routing. There are a number of easy ways you can route requests to methods in Manos. Using properties to route to other modules, convention based method signatures to implicitly add methods, attributes on methods to explicitly route to them or by using the HTTP methods to add a delegate for a route. All these routes can be defined with string matching, regular expressions or a simple named group matching syntax that looks like this: “/Articles/{title}/{page}/”.

• Named parameter conversion on methods. If you create a method Foo (IManosContext ctx, string bar, int idx). Manos will find those parameters in the request data and automatically type convert them for you.

• HTML5 Boilerplate. When you create a new Manos project you get a layout based on the HTML5 boilerplate project (http://html5boilerplate.com/). This gives you a rock solid place to start for your front end development.

• A wicked fast, html-centric template engine. The Manos template engine is designed to be designer and developer friendly. You can easily edit the template files without the help of an IDE and if a designer sends you html files, you can easily convert them into templates. To maximize performance the templates are compiled, not interpretted but they can still be generated at runtime.

• A simple command line tool for creating, building and hosting your apps. No IDE needed. Creating a new project is as simple as typing manos -init.

• Reusability: The success of todays popular web application frameworks is not just in their API or performance, its in the wealth of community developed libraries that can be easily plugged into your application. To facilate this, Manos is designed with shareable modules in mind. The framework is designed to encourage modular systems design and code reuse.

To get a better look at Manos, you should checkout the tutorial here:

http://github.com/jacksonh/manos/blob/master/docs/tutorial/page-1.md and http://github.com/jacksonh/manos/blob/master/docs/tutorial/page-2.md

So who is this for?

I’d like to defer to my good friend and close business associate, COURAGE WOLF on this one.

I don’t want Manos to be just for small apps, or enterprise app or a cute web framework for the iphone. I’d like for Manos to kick ass equally across all platforms.

The Beginning

Manos will be awesome. Enough of it is done for me to know.

Unfortunately this is going to be a big change for some people. .NET haters might have to shut up. And .NET developers are going to have to get used to the fact that web application development isn’t a pain in the ass.

Follow the project at http://github.com/jacksonh/manos Sign up for the mailing list at http://groups.google.com/group/manos-de-mono