December Meeting - Ayende Rahien

We seem to have come so far this year as a new user group in the Melbourne area. And so for our last meeting of the year we will have a special guest presenter... no secrets here.. Oren Eini (aka Ayende Rahien)
Ayende is in Melbourne for the YOW Developer Conference 2010 and has been kind enough to agree to come and talk at Melbourne Alt.NET on December 1st.
Ayende is best known for his projects such as RavenDB, Rhino Mocks and NHibernate Query Analyzer as well his contributions to a number of other open source projects, namely NHibernate and the Castle project. Ayende is a tireless contributor to the developer community continually sharing his thoughts and experience through his blog and numerous presentations. If you don't already follow his blog you can find it at
This promises to be a great evening and as at posting this all places are now booked out.
Please also don't forget that this event will not be held at our usual meeting place at the Oakton offices due to numbers and a room booking clash. Instead it will be held at:

Salmat (map)
Ground Floor Training Room
33 Lincoln Sq South
Melbourne, Victoria 3053

There will also be a nerd dinner afterwards at a venue yet to be announced. This will be a Christmas/end-of-year get together.  So please RSVP at if you're coming along so that we can get an idea of numbers and where to hold it.
Look forward to seeing you there.

October Meeting - MongoDB and NoRM

This month at Melbourne Alt.NET we'll be taking a look at MongoDB and NoRM presented by Adam Schröder. The following is an outline of what Adam is going to present:

  • Brief introduction to MongoDB.
  • Working with the mongo console to perform db queries, commands.
  • Introduction to NoRM and what type of driver it aims to be.
  • Demo on basic usage of NoRM without using LINQ.
  • What LINQ support exists for NoRM.
  • Demo LINQ queries including the use of the MongoSession class.
  • Deep Dive into the LINQ provider code.
  • Questions and Answers.
Adam's Bio:

Senior Developer at Inlogik Pty Ltd
Developing in .NET for 5 years with particular interest in MVC and Jquery
Twitter: @schotime

This promises to be another great Alt.NET evening. So RSVP and come along and enjoy a few beers and some pizza with like minded people and geek out for a few hours. Also, please feel free to invite others along who you think might be interested in joining in the Alt.NET community.

September Meeting - Coding Archaeology Wrap Up

Our first Coding Archaeology evening was certainly an interesting exercise with some really detailed discussions going on during the evening. The aim of the evening was to try to understand how NSubstitute works, rather than how to actually use NSubstitute. Of course with only two hours we couldn't possibly hope to understand the whole framework, but it was quite surprising how much we did explore.

We started out with a fairly basic exploration, looking at how Substitute.For(..) returns a Castle proxy object. This was simply done by stepping into one of the basic unit tests with the debugger to follow the code path.

We then looked at the SubstituteExtensions class which provides extension methods like Recieved(...) and Returns(..) for the framework. It was interesting to find out that the following statement:


would also validate when expressed like:


After the break we decided to look at how NSubstitute deals with raising events. To do this we built a Car class to take an IEngine (part of the tests in NSubstitute) and wrote a test, as you might in the 'real world' which raised the IEngine Stopped event. We used NSubstitute to create a fake of IEngine and injected it into Car and then raised the Stopped event using:

_engine.Stopped += Raise.Event(...);

From there we dug (pun absolutely intended) into the call stack to work out how event raising was implemented.

In conclusion the choice of NSubstitute was both good and bad. On the good side was the opportunity to look through some beautiful and clean code. The flip side was that the structure of the code, Overenthusiastic OO, as Dave Tchepak calls it, was probably a bit much to tackle at the same time. It would have also been really good to have had a more detailed look at the structure of the unit tests, but in the end there just wasn't time to look at it all. Maybe another time...

September Meeting - Coding Archaeology

Boy how time flies. Believe it or not, the September meeting will be our six month milestone for Melbourne Alt.NET. And to celebrate, we'll be having pizza and beers. Dull? Surely not. Then how about a geeky coding archaeology evening? But first of all I would like to thank everyone who has been part of it and made it such a success to date. We still have a lot of ideas and some great events in the coming months to look forward to.

Based on some feedback and discussions from the previous meeting there seemed to be some interest in looking at NSubstitute for our deep dive into an open source project. This might also be a great opportunity to have a discussion around comparing mocking frameworks and unit testing more generally.

The way I see the evening working is that I will have the source for NSubstitute set up on my laptop to display up on the data projector. From there we'll have an open discussion around the code and look at various aspects that interest everyone. All questions should be asked without judgement and the whole idea is for everyone to hopefully learn something new. If at any stage during the evening someone else would like to volunteer to take the pilot's seat of Visual Studio, they will be welcome to.

Don't forget to RSVP in the voting panel. See you there.

August Meeting - Lightning Talks Wrap Up

It seems that Melbourne Alt.Net is travelling along very nicely. It has a great community spirit and a bunch of really passionate people with great ideas. And Wednesday's Lightning Talks session was no exception. Added to that is the great support we get from Oakton which is enabling us to evolve into a fantastic monthly event.

We had six presentations of 10 minutes (ok, maybe more like 15 - 20 minutes) each.  Where relevant I have included links to content and information related to each presentation.

1. Mark Trinder (@mtrinder) - MonoTouch

2. Andrew Browne (@adbrowne) - CouchDB replication and conflict detection.

3. Jimmy P. (@pjimmy) - My experiences as an agent of change.

4. Simon Le Serve - Complexity and Refactoring

5. Tarn Barford (@tarnacious) - Composing events with RxJs

6. David Burela (@DavidBurela) - Windows Phone 7 UI

A big thanks to all those who contributed to the talks. And for anyone who thought they might have liked to have presented something and weren't quite sure or just weren't ready with something, then we'll do another one in the near future no doubt.

Thanks also to David for filming the talks.
(link to Lightning Talk videos to follow when available)

Our next meeting will be our first six months of running the event believe it or not. Not quite birthday celebrations, but something to look forward to all the same.

August Meeting - Lightning Talks

The August 18th meeting will be our first lightning talks evening. The responses to do presentations has been great and looks to be an interesting mix of topics. So far we have:

1. Mark Trinder (@mtrinder) - MonoTouch
2. Andrew Browne (@adbrowne) - CouchDB replication and conflict detection.
3. Jimmy P. (@pjimmy) - My experiences as an agent of change.
4. David Burela (@DavidBurela) - A real world MEF application
5. Simon Le Serve - Complexity and Refactoring
6. Tarn Barford (@tarnacious) - Composing events with RxJs

Each presentation will run for 10 minutes and we'll leave time for questions as well as beer and pizza of course.

We probably have time for one more talk so if anyone else would like to present then just let me know at twitter @abienert or leave a comment here. We have a full agenda now. If you would have liked to present then I'm sure this won't be the last lightning talks evening.

Look forward to seeing you there and please don't forget to RSVP on the polling panel.

July Meeting - Coding Dojo Summary

I have to admit I was somewhat unsure how our first Coding Dojo evening would turn out not having ever experienced one let alone facilitated one. However the feedback has been really positive and everyone, it seems, really enjoyed the evening and got something out of it.

For the evening we had a choice of 3 kata's.

Kata Roman Numerals
Kata Word Chains
Kata Towers of Hanoi

Everyone decided to pair up which was great, and there were some good discussions going on around the tables afterwards. I had intended that groups break off into rooms based on the kata they had chosen. As it turned out all bar one pair decided to tackle the Roman Numerals problem, with the other pair doing the Word Chains problem. Interestingly, Kata Roman Numerals probably seemed to be, on the face of it, the easier challenge....oh how mistaken one can be. :) But that in no way took away from the evening. It was really encouraging to see a bunch of great developers with a dogged determination to tackle the problem at hand.

Just about everyone tackled their kata using a TDD approach and mostly using C# in VisualStudio. The only breakaway from that norm was a Python implementation. One interesting observation was that while TDD was helping to validate the algorithms people were developing (many and varied I might add) it certainly didn't guarantee that a valid solution was found. There was a bit of discussion and debate surrounding this issue at the end too.

All in all a great night and once again thanks to Oakton for putting up with us all and refreshing us with beers and pizza.

See you all on August 18th for a Lightning Talks evening.

Edit (9/8/2010): David Burela posted a blog of his experience of the Coding Dojo night.

July Meeting - Coding Dojo

For this month at Melbourne Alt.NET we'll be doing a Coding Dojo evening. This is an opportunity to have a bit of fun and try out something a bit different.

For anyone not familiar with what a coding dojo is take a quick look at the Coding Dojo Wiki. But put simply and as defined on the Coding Dojo Wiki:

A Coding Dojo is a meeting where a bunch of coders get together to work on a programming challenge. They are there have fun and to engage in DeliberatePractice in order to improve their skills.

There will be 2 or 3 challenges to choose from on the evening and we'll keep them fairly simple. If you look at the Coding Dojo Wiki site you might notice that there are only two types of meetings, the prepared kata and the randori kata. We will do an individual/paired version so that everyone is participating at the same time. Check out the Sydney Alt.NET group who did this back in March, and also the summary post from the March meeting for an idea of how things will run. Oh and no we WON'T be doing the same kata's. :-)

The only real requirements are to bring a laptop with your development weapon(s) of choice (anything you like) and an enthusiastic mind set. If you don't have a laptop, fear not, we'll get some paired teams happening as well.

Keep in mind that a coding dojo is not a competition and the only thing that matters is to give it a go.

Please use the RSVP voting panel to indicate if you're coming along so that we can get the pizza and drinks orders sorted. Look forward to seeing you there.

June Meeting - Summary of DSL's & MGrammar Talk

Last night's presentation from Simon Cuce was fantastic and a great geek-out session. A big thanks once again to Simon for coming along and sharing his knowledge and passion of DSL's and MGrammar with the group. And don't forget to keep and eye out for Martin Fowler's book on DSL's :)

The following is a list of resources provided by Simon for anyone interested in learning more:

Sample Code

More Links

Also as promised the code from Simon's presentation:

MGrammar Sample Code
  1. module ConsoleApplication2
  2. {
  3.     language Language1
  4.     {
  5.            syntax Main=  a:List(DomainName) b:List(EmailDetails)  => {Domains [valuesof(a)], valuesof(b)};
  7.           syntax EmailDetails =(a:EmailAddress b:EmailFullname => {Address {a}, Fullname {b}})
  8.            | (a:EmailAddress c:EmailAlias b:EmailFullname => {Address {a}, Fullname {b}, Alias {c}});
  10.         syntax EmailAddress = Email a:NameWithDot => a;
  11.         syntax EmailFullname = Fullname b:QuotedName => b;
  12.         syntax EmailAlias = Alias c:NameWithDot => c;
  14.           syntax DomainName = Domain a:NameWithDot =>a;
  16.         syntax List(element) = e:element | es:List(element) e:element => [valuesof(es),e];
  19.            interleave whitespace = '\t' | ' ' | '\r' | '\n';
  21.          @{Classification["Keyword"]} token Begin = "Begin";
  22.          @{Classification["Keyword"]} token End = "End";
  23.          @{Classification["Keyword"]} token Domain = "Domain";
  24.          @{Classification["Keyword"]} token Email = "Email";
  25.          @{Classification["Keyword"]} token Fullname = "Fullname";
  26.          @{Classification["Keyword"]} token Alias = "Alias";
  29.        token TextEscape = '\\"';
  30.        token TextCharacter = !( '"' ) | TextEscape | '_';
  31.        token TextCharacters = TextCharacter*;
  33.        @{Classification["String"]} token QuotedName = '"' TextCharacters '"';
  35.         token Name = ('A'..'Z'| 'a'..'z')+;
  36.         token NameWithDot = (Name | "." | DecimalDigit)+;
  37.           token DecimalDigit ='0'..'9';
  39.     }
  40. }

Compiler Code in C#
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using Microsoft.M;
  6. using System.Reflection;
  7. using System.Dataflow;
  9. namespace ConsoleApplication2
  10. {
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  16.             using (var image = MImage.LoadFromAssembly(Assembly.GetExecutingAssembly()))
  17.             {
  19.                 var language = image.ParserFactories["ConsoleApplication2.Language1"].Create();
  21.                 language.GraphBuilder = new NodeGraphBuilder();
  23.                 Node root = (Node)language.Parse(@"..\..\TextFile1.txt", ErrorReporter.Standard);
  25.                 foreach (var item in root.ViewAllNodes())
  26.                 {
  27.                     if (item.Brand.Text == "Domains")
  28.                     {
  29.                         Console.WriteLine("Domains");
  31.                         foreach (var i in item.Edges)
  32.                         {
  33.                             Console.WriteLine(i.Node.AtomicValue);
  34.                         }
  36.                     }
  37.                     else if (item.Brand.Text == "EmailDetails")
  38.                     {
  39.                         Console.WriteLine("Emails");
  41.                         foreach (var i in item.Edges)
  42.                         {
  43.                             foreach (var j in i.Node.Edges)
  44.                             {
  45.                                 if (j.Node.Brand.Text == "Address")
  46.                                 { Console.WriteLine("Address " + j.Node.Edges.First().Node.AtomicValue); }
  47.                                 else if (j.Node.Brand.Text == "Fullname")
  48.                                 { Console.WriteLine("Fullname " + j.Node.Edges.First().Node.AtomicValue); }
  49.                                 else if (j.Node.Brand.Text == "Alias")
  50.                                 { Console.WriteLine("Alias " + j.Node.Edges.First().Node.AtomicValue); }
  51.                             }
  52.                         }
  55.                     }
  57.                 }
  59.                 Console.WriteLine("Code Compiled");
  61.             }
  62.             Environment.Exit(0);
  64.         }
  65.     }
  66. }

Update (29/06/10):

David Burela who filmed Simon's presentation has uploaded the video to his blog.
Nice one, thanks for that David.

June Meeting - DSL's

This month we're having a presentation from Dr Simon Cuce on DSL's.

Simon will explore the hidden gem within the SQL Server Modelling tool (formally Olso), called MGrammer. This is a language to create languages in a similar vain as YACC and Antlr. He will cover in detail how to build a language grammar in MGrammar, including understanding tokens, white space parsing and language syntax. As part of demo, he will show how InteilliPad can be used to speed up the creation of these grammars. The final part will be to create an actual compiler, using the newly created grammar and dealing with the resulting Abstract Syntax Tree (AST). Afterwards there will be plenty of time for Q&A.

Simon's Bio:
Dr Simon Cuce is a Melbourne software developer working mainly in the .NET area. He has worked for start ups, academia and large organisations creating unique software solutions using .NET technologies. Simon was one of the few Australians involved in the early adopter program for both .NET and the Compact Framework. Some of his claims to fame include building Australia’s first commercial XML web service for Solution 6 and the first SOAP enabled web server for Mobile Devices. Simon has a Bachelor in Computing (with Honours) and a PhD and is currently undertaking an MBA.

Don't forget that we're on for the 23rd of June and not the 30th this month. And please just click on the poll on the right to indicate if you're coming along.

May Wrap Up and News

Wednesday night was a solid turn out for our second meeting with about 27 attending. Not everything went according to plan with Tarn unfortunately out of action with a basketball injury, but we managed press ahead all the same. Once again thanks to Oakton and Sara for organising the venue, pizza and beer.

Thanks to Jake for his presentation on unit testing, MVVM and IoC goodness with Autofac. The source code from Jakes presentation is available on his blog for anyone interested in drilling down a little deeper.

Oz Open Space Conference
I'd also like to announce that there is an Australian/Alt.NET Open Space conference being organised and is now taking expressions of interest. So if you are interested then jump over to and add your name to the list.

May Meeting - TDD & Unit Testing

A discussion on Test Driven Development and Unit Testing.

The evening will be split into two parts. The first part will be a presentation from Tarn Barford. Tarn will provide a general overview of unit testing, IoC and mocking .

For the second part myself and Jake Ginnivan will run a more interactive session with a full sample application, putting into practice the various elements of test driven development and unit testing. The aim for this part is to get anyone who feels like getting involved to have a go at coding and everyone else to participate with ideas as we move through the demo. Perhaps we will take pair programming to a new extreme. Borg programming anyone?

So please RSVP by clicking in the voting panel to indicate if you will be coming along.

There are a few other reminders as well:

Firstly if you haven't done so already please take a moment to fill out the topics and ideas survey.

Secondly, as those who attended the first meeting are aware, the building is locked to general access after 6pm. Unfortunately we are not able to get an exemption to this. So if you are unable to make it prior to 6pm there will be a sign posted on the glass entrance doors with a mobile number to contact. Someone from Oakton with security access will then be able to come down to let you in.

Finally please be aware, if you haven't already noticed, that the meeting for June will be on Wednesday the 23rd rather than the 30th.

Look forward to seeing you all there.

ps. I would encourage all you Alt.Netters to head on over to Talking Shop Downunder to have a listen to Richard Banks interview with Paul Batum and Liam McLennan on their experiences at Alt.NET Seattle. It was genuinely interesting to hear what Paul and Liam had to say about their time there.

Topics & Ideas Survey

As promised, we now have a web survey up based on the topics discussion from the first meeting. The idea is to gauge both where people's interest and level of expertise lie. We can briefly discuss the results of the survey at the start of the next meeting.

Thanks to Andrew Browne for getting the survey set up.

Great Start to Alt.NET Melbourne

First of all a big thanks once again to Oakton for hosting the evening and providing such a great venue as well as the pizza and beer.

The turnout was really great with about 30 people attending. And the feedback so far has been fantastically positive. There was plenty of input from people and some great ideas.

Nick Josevski even managed to post up a great review of the night on his blog even before I had managed to get home. Very keen Nick!

The general theme running through all the discussions relating to the proposed topics, was that people really wanted to get as hands on as much as possible. So whether that be through Coding Dojo evenings, Hands-On-Lab style sessions and even one great suggestion of Coding Archaeology evenings, where as a group we pick an open source project and deep dive into the code just to see how it works. So I think where possible we will try to get a practical focus to as many of the meetups as possible.

The evening was also fairly productive in terms of coming to some agreement of what we will be doing over the next few months:

May : TDD
June: Domain Specific Languages
July: Coding Dojo

More details of these sessions will follow closer to the dates. There will also be a poll set up shortly which will allow people to vote on a list of other topics and ideas which were discussed during the evening to help us prioritise what to run with over the coming months.

To keep up to date with the latest announcements follow #altnetmelb or me @abienert on Twitter, or just simply subscribe to this blog.

Thanks everyone for coming along and contributing your ideas, and I look forward to seeing you all there again in May.

April Meeting - Agenda

With only a week to go until the first Melbourne Alt.NET we now have an agenda outline for the meeting.

6:00 pm - Introductions.
6:15 pm - Overview of Alt.NET. What's it all about?
6:30 pm - Discussion of future topics to be presented and meeting formats. What do you want from it?
7:00 pm - Break and refreshments.
7:15 pm - Open discussion on software development and building better software.
8:00 pm - Finish.

This is really all about setting the scene and agenda for future meetings and contributing to the broader discussion of software development, while keeping a .NET perspective. So bring along your ideas to add to the discussion.

If you haven't already please click on the voting panel to indicate if you will be attending so we can get a good idea of numbers for catering and room configuration purposes.

It would be great to hear any feedback or thoughts you might have. Tweet me @abienert or leave a comment here if there is anything you'd like to add. 

I look forward to seeing you there and please continue to tell others that Melbourne Alt.NET is starting.

Edit: Due to building security considerations it would be advisable people endeavor to arrive prior to 6:00pm. After this time there is no access to the main entrance without a security pass. In the event that you arrive after 6:00pm there will be a sign posted somewhere near the front entrance with a contact number to call/text to let you in.

Melbourne Alt.NET has a time and place

I am pleased to be able to announce a time and place for the first Melbourne Alt.NET user group meeting.

We have been fortunate enough to be offered a venue to hold our meetings in the city offices of Oakton. This is a fantastic offer and a big thanks to Oakton for their generosity and support to allow us to use their premises.

The details are:
Venue: Oakton, Level 8, 271 Collins Street. Melbourne.
Date: Last Wednesday of the month.  (first meeting to be held Wednesday 28th of April)
Time: 6pm - 8pm

The board room can accommodate over 40 people and will also have a data projector available for presentations. In addition to this Oakton has very kindly offered to supply refreshments (pizza and beer).

I have also created a new poll to indicate if you will be attending the meeting on the 28th of April as we will need to know numbers.

Update and Meeting Ideas for Melbourne Alt.NET

This is just a quick update to let everyone know that I have been discussing the use of a venue today with a corporate sponsor who is city based. We have discussed holding the first meeting at the end of this month and I hope to have the details sorted out in the next few days.

In the mean time I've compiled a quick, and by no mean exhaustive, list of some topic ideas for discussions and presentations. This is just a bunch of stuff to throw on the table to get discussions going for now. Please feel free to contribute so we can start getting an idea of what we all want from this.

  • C# 4
  • VB.Net
  • Java
  • Ruby
  • Python
  • F#
  • Boo
  • General discussions of Dynamic Languages and Domain Specific Languages
General Framework and Platform stuff
  • .NET 4
  • CLR
  • NHibernate
  • MEF
Testing Frameworks and Tools
  • xUnit
  • NUnit
  • MS Test
  • Rhino Mocks
  • Moq
Dependency Injection/IoC
  • Unity
  • Autofac
  • Structure Map
Agile Methodologies and Practices
  • TDD and BDD (and any other xDD for that matter)
  • Pair Programming
  • Extreme Programming
  • Scrum
  • Continuous Integration
Version Control
  • TFS
  • Subversion
  • Git
  • Mercurial
Design Patterns
  • MVVM
  • MVC
  • DI and IoC
  • Service Locator
  • Open discussions of design patterns du jour. Opinions and experiences - perhaps not for the first meeting :)
A few other random ideas:
  • Parallel computing
  • DirectCompute
  • Refactoring
  • "The Cloud"
  • LINQ
  • Coding Dojos and Coding Katas
That should do it for now. Please put forward your ideas and don't forget to keep spreading the word.

Welcome to the Melbourne Alt.NET group

Welcome. This is intended to be the home of the Alt.NET group for Melbourne. While Brisbane, Perth and Sydney have all had groups for some time now, Melbourne has gone without. So finally we will attempt to get Melbourne Alt.NET up and running.

So what is Alt.NET all about? The following is from the global Alt.NET site:
  • The type of developer who uses what works while keeping an eye out for a better way.
  • You reach outside the mainstream to adopt the best of any community: Open Source, Agile, Java, Ruby, etc.
  • You’re not content with the status quo. Things can always be better expressed, more elegant and simple, more mutable, higher quality, etc.
  • You know tools are great, but they only take you so far. It’s the principles and knowledge that really matter. The best tools are those that embed the knowledge and encourage the principles 
We are a group of people who are passionate about improving the way we develop software. We recognise there is no single solution, but instead there are multitudes of alternatives that can be applied to different situations. Our community is a place for sharing these alternatives, so that together we can learn, teach, and encourage new ideas.

Generally I foresee the group running much like the other Australian groups, with particular themes, topics and various presenters. This would involve monthly evening meetings, at a time and venue to be decided. For anyone interested in attending and making this happen in Melbourne, please just indicate your interest using the poll provided.

If you have any ideas or suggestions I'd love to hear from you. Just leave a comment here or find me (Andrew Bienert) at Twitter. As things progress I will post further details, so just subscribe to keep up to date.