I have written much lately, I guess I haven’t felt that I have had anything relevant to post or perhaps micro blogging is just too convenient.

I’ve been learning different programming languages over the past few weeks rather than working on writing C# in my spare time.  I’ve spent a couple of weeks with Ruby, then a week with Scala, and now a few days with Clojure.  The interactive nature and quick feedback that REPL gives you is just awesome for learning a new programming language.

Each language definitely has it’s niche, but I feel like there’s something I’m missing that allows me to fully grasp the underlying niche that each language provides.  I have no trouble picking each language up, but I want to get into the guts of the language and try to understand it from the perspective of the person who wrote it.

For instance, I spent several hours pouring over the Clojure source code and found that it was nothing like I had expected. A programming language written in Java!  The nerve.  That was laughable only a few years ago (unless you’re a DBA, then you probably find the entire JVM laughable).  When did we graduate from writing languages in C to Java?  I find it absolutely fascinating.

Not to pick on people smarter than myself, but the source code for Clojure is far messier than I expected.  I’m sure at a high level its very well designed, but the low level source code wasn’t as well abstracted as I expected and with commented out code all over the place.  It made me wonder how it actually worked without bugs seeping out from every corner of the code base.

But the more I learn about these languages, and how they’re written, the lower down in the stack I want to go.  Dragon book lower.  Although understanding BNF and other compiler lingo isn’t required for understanding the Clojure compiler, I think it would answer the question of how it works so well without bugs seeping out from every corner.

I've been playing around with Visual Studio 2010, and of course the latest ReSharper, version 5. Unfortunately my NUnit tests wouldn't run inside the ReSharper runner. Instead they would spin for a second then turn grey, like nothing happened.

Running the tests under the debugger turned up an interesting exception in the VS output window: BadImageFormatException. I also noticed a bunch of DLLs being loaded out of the v2.0 framework GAC, and not .NET 4. Shouldn't my .NET 4 app be using the .NET 4.0 GAC?

Of course it should. There's an easy fix to this. ReSharper shells out to another exe that actuall runs the unit tests JetBrains.ReSharper.TaskRunner.exe. If we modify the JetBrains.ReSharper.TaskRunner.exe.config in the ReSharper installation directory we can force the test runner to run under the .NET 4.0 framework. At the bottom of the file you'll find the associated startup element already there, just commented out and with the .NET 4.0 beta 1 framework version. To fix it, just incomment it and change the version to the .NET beta 2 framework version.

<!-- Needed in dev10, not needed in dev9/8 --> <startup> <requiredRuntime version="v4.0.21006"/> </startup>

Now you can run unit tests via ReSharper in VS 2010 beta 2.

Most every language has a sweet spot, something it does better than any other language around it.

C and C++ are really good for writing console video games because of its speed, portability, and deterministic finalization.  Perl is really good at string manipulation. Java has a gazillion OSS frameworks and application servers. Ruby is damn pretty and has a couple of really super productive web frameworks.

Erlang has a very succinct and elegant syntax, a syntax that is highly optimized for writing recursive functions. One could argue that’s just a property of being a functional language, but I think there’s more too it than just being functional.

C# 3 has a decent functional syntax that is clearly more succinct than Java or C# 2, but it just doesn’t stack up to Erlang.

Warning: don’t use these code samples in production code! They use Ω(n) extra storage space and are toy functions.

For example, take this Erlang quick sort function:

qsort([]) -> [];
qsort([Pivot|T]) ->
	qsort([X || X <- T, X < Pivot])
	++ [Pivot] ++
	qsort([X || X <- T, X >= Pivot]).

That is, IMO, beautiful code.  Small, compact, succinct, powerful, readable. On the other hand, what does a comparable implementation look like in C# 3? 

          static IEnumerable<int>
Qsort(IEnumerable<int> list) { if (list.Count()
<= 1) return list; int pivot
= list.First(); var tail = list.Skip(1).Take(list.Count() - 1); var result = new List<int>();
result.AddRange(Qsort(tail.Where(o => o < pivot))); result.Add(pivot); result.AddRange(Qsort(tail.Where(o
=> o >= pivot))); return result; }

It works, it doesn’t contain any loops and only one if statement (the initial C# 2 version was even longer and uglier), but its still very much lacking in the beautiful code department.  Did you also notice it was more than twice as long as the Erlang function? Perhaps you can improve the syntax?

I don’t have numbers to prove this, but the Erlang implementation can also be made faster with a lot less effort since each recursive call can be run in parallel.  Try that in C# without writing extra threading code. Even if you did, your threads are probably going to be a lot slower than the light weight threads in Erlang.

Recursive functions in Erlang are definitely a sweet spot.

Sometimes you need a paradigm shift, a different way to look at the same set of problems. Erlang I hope will give me that paradigm shift. Hopefully I can add another a screwdriver to my toolbox, if not, hopefully something besides a hammer.

I just bought a copy (on PDF) of Programming Erlang Software for a Concurrent World. I’ve only gotten through the first few pages of chapter 1, and so far I’m impressed. I guess its no surprise as the book is published by Pragmatic Programmers.

I finally understand why mathematicians like functional languages.  Its so obvious now, and it has a lot to do with immutability. From the book:

When I went to school, my math teacher said, “If there’s an X in several different parts in the same equation, then all the Xs mean the same thing.” That’s how we can solve equations: if we know that X+Y=10 and X-Y=2, then X will be 6 and Y will be 4 in both equations. But when I learned my first programming language, we were shown stuff like this:
X = X + 1
Everyone protested, saying “you can’t do that!” But the teacher said we were wrong, and we had to unlearn what we learned in math class. X isn’t a math variable: it’s like a pigeon hole/little box.... In Erlang, variables are just like they are inmath.When you associate a value with a variable, you’re making an assertion—a statement of fact. This variable has that value. And that’s that.

I guess mutability is a strange beast for most people when learning to program, forcing a lot of them to quit while in their first year of CS.  Well, that and pointers. Its an odd way to think of things for people living in a concrete world. I wonder if first year CS students wouldn’t have an easier time learning a functional language?

I found another reason to love open source NUnit over MSTest, NUnitEx. NUnitEx provides a fluent DSL to write NUnit assertions where Visual Studio intellisense is your guiding friend. I’m sure you’re thinking, “Yeah whatever, show me some code.”

[Test]
publicvoid AdjacencyGraph_is_directed_by_default()
{ var graph = new AdjacencyGraph<Task, TaskDependency>(DoNotAllowParallelEdges);
graph.IsDirected.Should().Be.True(); }

Nice eh? graph.IsDirected is the property I want to test.  Everything after that is the NUnitEx extension methods. I know I find it much more readable than this:

[Test]
publicvoid AdjacencyGraph_is_directed_by_default()
{ var graph = new AdjacencyGraph<Task, TaskDependency>(DoNotAllowParallelEdges);
Assert.IsTrue(graph.IsDirected); }

I would also like to add that this syntax is likely to be included in NUnit 3, which would be excellent!

Ive spent the last couple of days writing visual studio web tests to create a load test scenario for a critical section of application. Unfortunately i find it repetitive and boring.

The web tests recorder in VS doesn't capture everything and additionally it hurts to look at the produced code. I did find fiddler much better at recording tests but they still needed serious cleaning up.

I wish there was a more polished tool for this kind of test. I doubt other tools like JMeter are much better, and for .NET their probably worse because of viewstate and other platform specifics.

I just found another useful thing that resharper does for you, it can generate code to check for null method parameters.

Just put the cursor on the parameter….

Nice huh!?