Matthew Podwysocki's Blog

Update:  Catch Dave Laribee on Hanselminutes discussing ALT.NET here.

It's almost a month away until ALT.NET Open Spaces, Seattle and things are coming along nicely.  As you may have noted, we filled up rather fast while keeping some spots open for some pre-invites.  We have a great crowd of people not only from inside Microsoft, but outside as well.  We've put a bit of effort into getting this off the ground, and I can admit I've spent a bit of time doing so.  But to see names like Ward Cunningham, Jim Shore, Martin Fowler from the Agile spaces, folks from Microsoft such as Scott Guthrie, Scott Hanselman, Phil Haack, John Lam, Jim Hugunin, Brad Abrams, Charlie Calvert, Brad Wilson, P&P, Microsoft Research folks such as Rustan Leino and Peli, the CodeBetter guys, the Israeli crowd (Ayende, Osherove, Dahan) just warms my heart.  To give you an idea, I'll put the list at the end.

In case you missed it, Jeremy Miller had a great article in the latest MSDN magazine called "What Is ALT.NET?" which sums up my thoughts exactly on the topic.  Very nice stuff!  And I think Ayende might be onto something with these ALT.NET logos here.  Something tells me t-shirts need to be made.

But where will we go from here?  Dave Laribee and others, myself included, have been kicking around the idea of a RailsConf, QCon, Spring Experience, No Fluff Just Stuff kind of conference.  I really do like that idea and I want an active learning conference where we in the ALT.NET community can learn from each other, but also spread the message outside.  Dave set four basic criteria that I think were well worth noting for parameters for such an event:

1. It would be longer: four or five days.
2. It would start 2-3 days of workshops or classes upfront on advanced topics: DDD, T/BDD, Agile, Patterns, SOA/Messaging, etc.
3. The final days would lead into a kind of "dream conference" with talks given by well-known speakers.
4. It would cost money, not a lot, but some...

I've held off recently announcing the DC ALT.NET meeting due to scheduling issues.  Anyhow, that has been resolved and we are good to go.  We will be holding it on March 19th from 7-9PM.  The meeting this month will bring ALT.NET to Arlington, Virginia.  I want to thank Kevin Hegg for offering his office as our get together. 

At our last meeting, Stelligent hosted our event in which we discussed a lot of great topics.  You can read a wrapup of our last meeting here.  This time, we're going to have Jay Flowers to discuss Continuous Integration and CI Factory.  It should be a great discussion as it's been weighing on my mind lately.  Our format is as follows, the first hour or so is the topic at hand and then the second hour or whenever the talk is done is for Open Spaces.

Looking for Sponsors

As always, we're looking for sponsors for our events.  We bring a lot of passionate developers to your site and we feel we can bring a lot.  Sponsorship opportunities are always appreciated!

Who We Are

Are you a developer who always keeps an eye out for a better way? Do you look outside the mainstream to adopt the best practices of any development community, including Open Source, Agile, Java, and Ruby communities? Are you always looking for more elegant, more simple, more maintainable solutions? If so, then you might be an ALT.NET practitioner!
 
This group follows the Open Space Technology model.  In Open Space, a facilitator explains the process and then participants are invited to co-create the agenda and host their own discussion groups.  So, we'll take a vote and present the topics.  We're in the pub-club mind occasionally, so it's not surprising to find us geeking out a bar...
 
This model follows the four basic principles:

• Whoever comes are the right people
• Whatever happens is the only thing that could have
• Whenever it starts is the right time
• When it's over, it's over

Update:  If you want the .iso I used for the VPC, check it out here on my SkyDrive.

During my research and posts about Design by Contract and Spec# and my interactions with folks from Microsoft Research, I came across Singularity OS, an operating system written in an offshoot language based upon C#.  In that time, I realized that the Singularity team extended Spec# and the Design by Contract and static verification pieces of it into a new language called Sing#. 

Fast forward to last Tuesday.  Almost five years after the start of development, it has finally been released onto CodePlex as an open source non-commercial academic license and can be found here.  After reading about it and talking with some Microsoft Research folks about it, I had to give it a shot.  That's one of the things I love about working at Microsoft is the fact that I can interact with people like these on a periodic basis.

History of Singularity

During my long commute to and from work, I have the pleasure of listening to many podcasts.  Although I like the ones in the .NET space with Hanselminutes and DotNetRocks, I also like to venture into the Ruby and outside community where I'm pretty comfortable as well.  So, one of my absolute favorites is Software Engineering Radio for the serious talk and geeking about languages and architecture.  Lo and behold, the latest episode, Episode 88, covers Singularity with Galen Hunt where he talks with Markus, the host about the history and features of the OS.  I suggest you listen to that before we go any further.  Also, a good overview can be found here in PDF format.

If you think about most operating systems we run today, the essence of what they are is dated back in the 1970s and C and Assembly based.  Back in 2003, Galen and team started this effort to write an operating system in managed code.  Over 90% of the system is written in a language called Sing# which is an extension of Spec# which I will get into shortly.  But, Singularity consists of three major parts, Software Isolated Processes (SIPs), contract-based channels, and manifest-based programs.

SIPs are interesting parts of Singularity.  They provide a sandbox as it were for program execution free from meddling from outside processes.  This includes its own memory space, threads and so on.  In fact, memory and threads cannot be shared from one SIP to the other, so the vectors for malicious code are cut way down. 

Contract-Based Channels are another interesting aspect of Singularity.  It's a built-in feature of the Sing# language which I will get to in the next section.  In short, what it provides is a quick and verifiable way of communicating between processes with messages.  To support this, the Spec# language had to be extended to support this.

Lastly, manifest based programs are interesting because it defines the code that runs within the SIP and its behaviors.  In Singularity, there really is no such thing as Just In Time Compiling (JIT) as all code needs to be loaded into memory and statically verified before it can be executed, which is something a JIT cannot do.  But on the other side of this, it makes dynamic languages and late binding impossible as well.  So, to work around this, they devised a plan called Compile Time Reflection, so you know your dependencies beforehand and uses Dependency Injection in a way to inject the appropriate dependencies.  Really slick stuff!

Sing#

Rustan Leino and others in Microsoft Research had already begun an effort called Spec# to provide Design by Contract features to the C# language and a static verifier to prove that code is in fact working as the contracts were written.  Just a quick aside, we're going to be lucky enough to have Rustan at ALT.NET Open Spaces, Seattle to talk about it and Design by Contract (Shameless Plug).  Anyhow, back to the topic at hand.  Spec# didn't have enough for the static verification that needs to happen.  So, instead, Sing# brings us Contract Based Channels for creating message declarations and a set of named protocol sets.  Any communication that crosses processes must use contract based channels.  These messages that it passes have declarations that state the number and types of arguments for each message and an optional message direction. Each state specifies the possible message sequences leading to other states in the state machine. 

I just want to dig through some code to see exactly what that looks like:

    class DirectoryServiceWorker
    {
        private TRef<DirectoryServiceContract.Exp:Start> epRef;
        private DirNode! dirNode;

        private DirectoryServiceWorker(DirNode! dirNode,
                                      [Claims] DirectoryServiceContract.Exp:Start! i_ep)
            requires i_ep.InState(DirectoryServiceContract.Start.Value);
        {
            epRef = new TRef<DirectoryServiceContract.Exp:Start>(i_ep);
            this.dirNode = dirNode;
            base();
        }

If you notice from above, you can see some Spec# goodness in there including NonNull types using the ! keyword and also requires preconditions.  It's pretty well written and a lot of fun to dig through.  If you want to learn more about compilers and operating systems, now is the time to sift through the source code and get your geek hat on.

Building the Image

If you want to actually run Singularity, the team has provided as part of the zip file, a way to build the operating system.  You'll simply need the following:

• Windows Debugging Tools
• .NET Framework 1.1
• Virtual PC 2007
• MSBuild

I was able to get the results in about 10 minutes or so for the build process.  Then again, if you're running Vista, you need to be sure to launch the configure.cmd as an elevated process in order to kick things off properly.  That was the first hurdle.  But once I got that going, the rest was easy.  And I got a pretty cool result as well when I ran the VPC image.  Look at the goodness:

Well, I've had the urge to find all the videos I could and watch them to find out all the goodies I missed while not at MIX08.  If you missed any of the main sessions, you can find out more about them here.   Note that there are 88 sessions recorded here, so it's a lot of good viewing material. 

Best of all are Scott Hanselman's MVC Videos can be seen here.  He also covers the MVC Mock Helpers which better allow for unit tests using various Mock frameworks including Rhino Mocks, TypeMock.NET and Moq.

Dave Laribee was great on Twitter to make sure we were all kept up to date with all the good things that were happening.  Brendan Tompkins supplied Dave with a video phone so that he could capture impromptu videos and such.  But, best of all they were broadcasted live.  He was able to talk to guys like Rob Conery, Phil Haack, Steve Harman, Miguel, John Lam, Scott Hanselman and Josh Holmes.  Very cool stuff!  They were pretty good and entertaining, although the video wasn't always superb and sometimes you needed motion sickness pills.  But, the sessions of note are:

• Phil Haack interview
  
• Capturing Hanselminutes
• Rob Conery and Steve Harman interview
• Miguel de Icaza interview
• Pablo Castro interview
• John Lam interview
• Microsoft Surface demo
• Josh Holmes interview

The Rockville .NET User Group (RockNUG) will be holding their next meeting on Wednesday, March 12th, 2008 from 6:30PM-9:00PM.  This month, they'll be having a pretty interesting topic on refactoring in C# with Jonathan Cogley.  I've had my refactoring and agile boots on lately, so I can definitely relate.  I don't know what I would do though without my Resharper 4.0 Nightly Builds...  I've had a few issues here and there, but nothing to discourage me from continuing usage.

Anyhow, here are the details:

Location:
Montgomery College, Rockville
Humanities Building - Room 103

Refactoring in C# - Bad code to better code
presented by Jonathan Cogley

What could be more fun on a Wednesday evening than critiquing some bad
code and making it better? :) Come along to learn how to clean code like
the Thycotic team. What do we look for? How do we take small steps to
keep it working? What tips and tricks make it easier? This session
will be code, code and more code (and a few unit tests of course!).

Jonathan Cogley is the founder and CEO of thycotic - a software
development company operating in the Washington DC Metro Area with
offices in Vienna, Virginia. Jonathan has worked for many interesting
companies over the last decade as a software consultant in both the UK
and the USA. His company has released various .NET projects and APIs
including an implementation of Remote Scripting for .NET, a database
platform independent data access layer for ISVs and various tools for
the Test Driven Developer. Test Driven Development (TDD) is the
cornerstone of the thycotic approach to software development and the
company is committed to innovate TDD on the Microsoft .NET platform with
new techniques and tools. Jonathan is also a columnist and editor for
the popular ASP.NET Web site, ASPAlliance. He is an active member in the
developer community and speaks regularly at various .NET User Groups,
conferences and code camps across the US. Jonathan is recognized by
Microsoft as an MVP for C# and has also been invited to join the select
group of the ASPInsiders who have interactions with the product teams at
Microsoft.

The schedule for the event is as follows:

IUnityContainer container = new UnityContainer();

For all those interested in the information and the latest bits from the ASP.NET Team, here are the latest links.

Downloads:

• ASP.NET MVC Preview 2
  
• Silverlight tools including ASP.NET Server Controls
• ASP.NET 3.5 Extensions Preview from December
  

• ASP.NET Home Page Announcement
• ASP.NET 3.5 Extensions Download Page
• ASP.NET 3.5 Extensions Quickstarts
• ASP.NET Preview 2 (MIX) readme
• ASP.NET Updated Forums
• ASP.NET Server Controls for Silverlight Forum
• ASP.NET 3.5 Extensions Videos

#light