The other day a colleague of mine needed to load a strongly typed ADO.NET DataTable from a LINQ to SQL query. We didn't find any good solutions using "The Google", so after a bit of hacking we came up with something similar to this:

    PeopleDataSet ds = new PeopleDataSet();
    using (PeopleDataContext context = new PeopleDataContext())
    {
        (from p in context.Persons
         select new
                    {
                        Row = ds.Person.AddPersonRow(p.Id, p.FirstName, p.LastName)
                    }).ToList();

    }

After ToList() executes we should have a DataTable populated with the results of our query.

A prevalent theme in the Volta documentation is the concept of the three “R”s. These three principles are at the heart of what Volta attempts to provide for developers.  They are retargeting, remodulating, and refactoring.

Retargeting

To me this is the coolest aspect of Volta and the feature that makes it a very interesting technology. At its core Volta is a compiler or more accurately a recompiler.  Instead of recompiling the source code Volta uses a technique called MSIL rewriting. This is what enables the developer to write client-side browser code in C#. Since all CLR languages compile to MSIL, Volta can use that as the common denominator. Volta is capable of MSIL to MSIL, and MSIL to JavaScript conversion.

Remodulating

Another goal of the Volta toolset is seamless cross-browser support. As the documentation states:

 Volta hides as many browser-specific differences as possible, but still allows developers to leverage the unique capabilities of particular browsers. Instead of targeting solely the intersection of browser capabilities, Volta targets the entire union, but makes the intersection browser-agnostic. This is browser remodulating.

Remodulating also deals with the debugging experience. Regardless of the browser platform developers will be stepping through their application code within Visual Studio. That's assuming of course that your target is either IE or FireFox which are the only browsers supported in the current release.

Refactoring

Volta refactoring is about enabling developers to create their applications while deferring decisions about what tier a particular component will run in. In my opinion this will be the most controversial feature of the toolset.  Larry O’Brien has some reservations about it:

This sounds like a bad idea to me. You can't refactor away the difference between an in-memory method call and an Internet message: one happens in nanoseconds and the other in milliseconds

I have some questions of my own about this. The docs claim that:

During development, all code runs in the client for ease of testing and debugging.

What are the implications of this? Not every .NET class is meant to run in a browser context. Does Volta offer any automatic guidance with regard to this? The notion of clicking a “Split Tiers” check box and decorating a class with a [RunAtOrigin] does seem implicitly powerful, I’m just curious to know where the model breaks down. I will try to answer these questions and others as I dig deeper into the framework.

One of my favorite sections in SICP so far has been section 1.3 Formulating Abstractions with Higher-Order Procedures.  Higher-Order Procedures are procedures that deal with other procedures.  They can take a procedure as an argument and/or return a procedure as a result.

Though it is somewhat academic, I really like the example that Abelson and Sussman use in section 1.3.1 to explain the “procedures as arguments” scenario.  To illustrate this concept they implement summation using Scheme.  They implement a higher-order procedure called “sum” that takes two procedures and a range of numbers as arguments.  One procedure is used for computing the value that is added to the sum and the other is used to determine the next value to compute.  The Scheme code can be seen here.

It’s not as useful as map and reduce, but those are not discussed until Chapter 2.

As some of you may know C# 3.0 adds a whole slew of functional/dynamic features.  Whether this is an effort to keep up with the cool kids or merely a necessity for making LINQ work is not important to me.  What I’m curious to know is if the features make it easier to implement the concepts in SICP using C# 3.0.

Implementing “Sum” in C# 3.0

Following along with the example from SICP - let’s say that you have defined the following methods.

I decided to break with the book here and use iteration instead of recursion to make the code a little more digestible.

Common to each method is the idea of iterating over a range of numbers and adding the result of each computation to the total.  If we create a higher-order procedure called “Sum” to abstract out this behavior we can then redefine each method.

The “=>” and “Func” constructs come from the new Lambda expressions feature in C#.  Lambda expressions are a great new aspect of the language and they make implementing higher-order procedures a lot easier.  In this case the "term" and "next" arguments can be passed as Lambda expressions.

I had to cheat and do some casting shenanigans because the division operation in "PiSum()" brings floating point numbers into the mix, but I feel like this code does capture the essence of the original Scheme implementation.  Implementing "Sum" as a generic method might be a way to make the code more elegant.

If subverting the type system does not appeal to you, the following JavaScript implementation might be of interest.

JavaScript is more similar to Scheme (dynamic typing/first class functions) so it makes sense that the translation is smoother.

It turns out that there are other people interested in implementing SICP in different languages.  Chris Rathman has translated parts of SICP into 19 other languages.  One disturbing thing to note about Chris’s C# translation is that it doesn’t go beyond chapter 1.  Does that mean that it is not possible to implement the code from the rest of the book in C#? 

For reasons beyond my control I recently found myself developing in classic ASP.  After years of developing in ASP.NET this was obviously a little jarring.  However, what surprised me about the experience was that there were some things about classic ASP that I actually enjoyed.  Most notably I felt I had more control with classic ASP.  Nothing was in my way.  Things that should be simple were simple.  For a moment I imagined that this is what it must feel like to be a PHP developer.  

I wondered why I felt this way.  After all, the whole the whole point of ASP.NET is to save me from having to deal with “icky” HTML, JavaScript, and CSS…right?  I really like developing in ASP.NET.  I would take ASP.NET over classic ASP any day of the week (and twice on Sunday).  ASP.NET is certainly one of most thoughtfully designed and well implemented frameworks I have ever worked with.  Scott Guthrie is a genius and he has the patents to prove it.  However, I couldn’t ignore the fact that some things were a lot easier to accomplish in classic ASP.

I realized the unfortunate truth that there are some abstractions in ASP.NET (and all frameworks for that matter) that can transform into obstacles.  In order to use these abstractions you end up having to learn a lot about the internals of the framework.  I’m talking about Reflector. You have to codify assumptions about the underlying technologies into your application.  In other words, the abstraction leaks.  I borrow this term from Joel Spolsky’s Law of Leaky Abstractions.  I think that the small sense of empowerment I was feeling when developing in classic ASP came from the fact that I wasn’t forced to dig too deep into, or worse, code around the framework in order to get the job done.  There was no framework. 

Another, even more heretical thought occurred to me during this process.  I wondered if code-behind is always necessary. Is it always essential to separate code and markup?   If you simply replaced VBScript with C# and gave yourself a set of libraries as rich as the BCL, would combining code and markup be more palatable or even more productive in some scenarios?  Can some aspects of ASP.NET be abandoned entirely?  I’m not sure, but I’m now a little more inclined to find out.

Every once in a while I find myself reading a book that makes me feel stupid. As I try to internalize the prose I can’t help but feel a strong sense of regret for not being more adequately prepared.

Then I learn that the book has long been the basis for an “Intro to Programming” course at some college. Did you say intro to programming!? This is usually the part where I start to feel a strong sense of inferiority. :-(

Is the feeling of inferiority enough to make me want to put the book down? Hell no. If anything I’m finding SICP to be one of the most compelling computer books I have ever read. Like the Scheme language itself, SICP is incredibly dense. No reading on autopilot here, folks. You need to be paying attention or you’re going to get nothing out of it. The code examples draw almost exclusively from math. In the first chapter alone the following mathematical concepts are used to “help” teach the reader about computer programming (in general) and Scheme (in particular):

• Newton’s Method
• Fibonacci
• The Golden Ratio
• Euclid’s Algorithm
• Lamé's Theorem
• The Fermat Test (Primes)
• Miller-Rabin Test
• Summation (Sigma)
• Integrals
• Simpson’s Rule
• Fixed Points (Functions)
• Lambda Calculus

The other thing that seems strange at first is that Scheme uses recursion for nearly all processing. I’ve only completed the first chapter, but I have yet to see a “for” or a “while” construct in any of the code.

I know that that some fellow .NET developers might ask “Why are you wasting your time with that?” or “Why aren’t you spending your time learning about Silverlight?” Well I couldn’t really say for sure. I’m a big fan of Paul Graham’s essays, so those are certainly what motivated me to have a look at a Lisp dialect. What’s keeping my interest is the richness and depth of the content. There’s just so much there.

I plan to post more about SICP as I wade my way through it over the next several weeks… or months. I’m going to take my time and savor every head scratching moment. 

If you are Java or C# programmer who is looking for something to expand your mind, you should certainly have a look.