Month: February 2007

When is Microsoft going to get off of this “without writing any code” kick? I am sick of sitting through Microsoft presentations where someone writes some XAML or ASP.NET and makes a bunch of changes and says “Look, we did all this without writing any code!” Should I try to coin a new term which is only 1 vowel different from the term which comes to mind? BILLSHIT!!!

XML is code. The Java world has known this for years. XML Hell is a very real thing in the Spring, Struts, Hibernate past of Java. Many of the new things in Java have been a move away from the XML hell of a few years ago.

So when I see a blog post about InfoPath saying “…without code!” that has a snippet like this…

[code]
concat(substring(concat((sum(../my:group1/my:group2/my:TotalMinutes) –
sum(../my:group1/my:group2/my:TotalMinutes) mod 60) div 60, “:”,
sum(../my:group1/my:group2/my:TotalMinutes) mod 60), 1,
(sum(../my:group1/my:group2/my:TotalMinutes) mod 60 > 9) *
string-length(concat((sum(../my:group1/my:group2/my:TotalMinutes) –
sum(../my:group1/my:group2/my:TotalMinutes) mod 60) div 60, “:”,
sum(../my:group1/my:group2/my:TotalMinutes) mod 60))),
substring(concat((sum(../my:group1/my:group2/my:TotalMinutes) –
sum(../my:group1/my:group2/my:TotalMinutes) mod 60) div 60, “:0”,
sum(../my:group1/my:group2/my:TotalMinutes) mod 60), 1,
(sum(../my:group1/my:group2/my:TotalMinutes) mod 60 < 10) *
string-length(concat((sum(../my:group1/my:group2/my:TotalMinutes) –
sum(../my:group1/my:group2/my:TotalMinutes) mod 60) div 60, “:0”,
sum(../my:group1/my:group2/my:TotalMinutes) mod 60))))
[/code]

…it makes me want to kill Microsoft employees and the idiot managers who buy into this BILLSHIT. It must be geared toward managers and inexperienced developers. It is all lies. Please stop the lies.

What is wrong with the above? Well, it looks like code to me. If it walks like a duck and talks like a duck… we get python duck typing. If it looks like code and smells like code (and yes, it is major code smell) … it must be code!

Why is this code smell? Well can I just look at that insane expression and know what it does? Nope. It is a fine example of dailywtf worthy unreadable code.

It is code. It is bad code.

 

I am totally excited to see the wheel reinvented again. I’m so happy that
Microsoft has put their huge workforce of programmers to go and create
something which already exists.

The first blog post I read this morning is a link from Sam Gentile’s New
and Notable on Entity
Client. What an utter waste of time this is shaping up to me. I
get it. Microsoft wants LINQ to be awesome. Guess what? It
already is! So what is this Entity Client that has got me all worked
up? Well, in an nutshell, Microsoft REALLY likes NHibernate. But
NHibernate is OMG VIRAL LGPL Open
Source. This kind of open source gives Microsoft open sores. So
what is the north west Vatican(Redmond)
response when someone doesn’t agree with your religion? Call them a
heretic and if it is a really good idea incorporate it into your own religion.
Microsoft can’t use NHibernate. Why? … Here is a list of
reasons why:

• Microsoft has a serious case
  of NIH syndrome
• NHibernate sounds like
  Hibernate and that is Java and Microsoft isn’t allowed to do anything
  Java. Remember that law suit?
• Hibernate Query Language
  doesn’t look enough like SQL Server’s SQL implementation
• Adopting something great from
  the .NET community is a sign of
  weakness. Microsoft must pollute and confuse the solution space
  instead. See NUnit vs. MSTest, Nant vs. MSBuild, NDoc vs.
  Sandcastle.

Ok, so the above is a bit over the top, but I think I make
my point. The world would be a better place if Microsoft stopped
reinventing the wheel and just embraced existing libraries as the standards
they are. What really set me off was this bit of the blog post

EntityClient employs its own language, Entity SQL. An
Entity SQL query needs no change in order to work over different store
implementations of the same model. That is achieved through EntityClient’s
pluggable architecture.

 

This sound exactly like NHibernate to me.

While NHibernate doesn’t seem to have nearly the usage of NUnit, Nant or NDoc,
I have no doubt that the NHibernate community will continue to thrive, even
with the release of excellent tools from Microsoft for use with
EntityClient. NHibernate already has many excellent tools and it is here
today.

One huge difference between EntityClient and NHibernate is that EntityClient is
not a full ORM. It seems to be only the Dialect and Driver part of
NHibernate. From the same post

EntityClient does not attempt to materialize objects out of
the result set. Instead, it returns a plain DbDataReader for which those
applications may implement their own specialized object materialization, or
consume the DbDataReader directly.This does still sow confusion into the Data
Access space. My recommendation: Just ignore it. Go use
NHibernate (or CastleProject’s ActiveRecord).

I love going to the Michipug meetings. I don’t use python on a day to day basis, but I find that talking to those who do really helps me to think about things differently.

Thursday, even before going into the Michipug meeting, I was reading a python blog or something in anticipation of the meeting that night. Something I read triggered me to think about python’s filter, map, and reduce built-in functions. I wondered what .NET has to correspond to these. Well, List.FindAll and List.ConvertAll and their Array counterparts do the work of filter and map. That left reduce.

I couldn’t find reduce, so I whipped up an implementation. I started with just an integer implementation. Again, Func<T,T,T> is a delegate definition straight out of System.Query in the LINQ preview, or Rhino.Commons or wherever.


public int Reduce( Func<int,int,int> function, List<int> list )
{
IEnumerator<int> enumerator = list.GetEnumerator();
enumerator.MoveNext();
T result = enumerator.Current;
while(enumerator.MoveNext())
{
T item = enumerator.Current;
result = function( result, item );
}
return result;
}


Once I had this running, I just made it generic.


public T Reduce<T>( Func<T,T,T> function, IEnumerable<T> list )
{
IEnumerator<T> enumerator = list.GetEnumerator();
enumerator.MoveNext();
T result = enumerator.Current;
while(enumerator.MoveNext())
{
T item = enumerator.Current;
result = function( result, item );
}
return result;
}


I also changed the List<T> to IEnumerable<T> so that it would work with Arrays, Lists, or anything Enumberable.

So what is the point? Well, I don’t have one, other than “its cool!”

Its nice to write factorial as simply as this:


var res = Reduce( ( x, y )=> x * y, list );


or sum a list like this:


var res = Reduce( ( x, y )=> x + y, list );


Its very strange when string.Join(“, “…) doesn’t use Join


Reduce( (x,y) => string.Format("{0}, {1}",x ,y) , message)


And even stranger when you can reverse the join order


Reduce( (x,y) => string.Format("{1}, {0}",x ,y) , message)


What else can you do with reduce?

Well, I don’t know. Give a google for python reduce and you will see that Guido is even getting rid of filter, map, and reduce from Python in the future. So .NET just got filter and map in the form of Array and List member methods which take delegates as arguments, and python is removing filter and map in favor of its list comprehensions and generator expressions.

So what? Well, I don’t really think it means much. In the same article Guido talks about adding two functions, Any and All. .NET already has these in the form of Exists and TrueForAll as Array and List members.


// python: any(x > 42 for x in S) # True if any elements of S are > 42

S.Exists( x => x > 42 );

// python: all(x != 0 for x in S) # True if all elements if S are nonzero

S.TrueForAll( x => x != 0 );
I don’t see much of a difference in readability between the Python and the C#. They are merely different.

One of the very strange things about the .NET implementation is that Exists and TrueForAll aren’t members of the Array class, rather they are static members. So the invocation of the same thing on an Array is slightly different.


Array.Exists( S, x => x > 42 );
Array.TrueForAll( S, x => x != 0 );


C# 3.0 extension methods don’t help. Array inherits from IEnumerable. Nothing about its type is known for use by the compiler at compile time. You could try to implement Exists and TrueForAll, but you end up having to invoke like this:


S.Exists<int>( x => x > 42 );
S.TrueForAll<int>( x => x != 0 );


All this because I think about python. I should just write more boo, but alas, boo still doesn’t support Generics. Boo is great, but not for interoperating with Generic types from other .NET libraries.

Richard Hale Shaw at the Ann Arbor Computer Society meeting on Wednesday gave a good, detailed overview of the C# 2.0 features that are getting used to build interesting things in C# 3.0.

Everything came back to CodeMash. The topic reminded me of Bill Wagner’s CodeMash talk, and the talk he gave at Ann Arbor Dot Net Developers back in December. I had just converted my application from log4net to NLog and ran into a case where I didn’t want to execute some code unless I was logging it. NLog and log4net recommend putting your logger statement in an if block like

if (logger.IsLogErrorEnabled)
log.Error( "oh no!"+ SomeLongRunningFunctionWhichReturnsString() );


I prefer to have my log statements on one line, I find it clutters my source code less. Afterall, logging is NOT the primary concern of my code. I want to focus on the task and hand and obey single responsibility as much as I can.

It turns out C# 2.0 anonymous delegates provide a nice solution (and of course C# 3.0 lambdas make it more readable).

Lets assume our logger has an override with a signature of

public void Error( Func<string> function );


Where Func is straight out of System.Query or Rhino.Commons or wherever.

public delegate TR Func<TR>();


Now the overriden Error method on the Logger class accepts a method as input. If we turn logging off, this method never needs to be executed. Using it is not too ugly.


logger.Error(delegate() {return "oh no! " + SomeLongRunningFunctionWhichReturnsString(); } );


C# 3.0 brings lambdas to the syntax of the language and makes this a whole lot easier to write.


logger.Error( () => "oh no!" + SomeLongRunningFunctionWhichReturnsString() );


And that was only WEDNESDAY!!! WOW.

Thursday followed up strongly with a Michipug meeting where we talked python templating libraries. The format was awesome. We broke into little groups and each group explored the template library. I took a look at twiddler and it is very simple and elegant. I really feel like I grasp the whole thing and I only looked at it for a very short period of time. I don’t use enough python to really comment on any of the libraries we looked at. After looking at them, each group presented an overview of the template library. I think everyone enjoyed the format and learned a lot.

At both of these meetings everyone talked about CodeMash. All of the comments were positive. What a great event. I mentioned that my favorite thing was the presentations on Selenium and Niel Ford’s Productive Programmer presentation. These topics really transcend the CodeMash language barriers. The concepts being The Productive Programmer are really things that EVERY programmer should know. It doesn’t matter if you do Java, Ruby, C, C++, Python, Perl, C#, PHP, whatever. I found it so valuable because at any other language or technology specific conference you wouldn’t get panels like that. It simply wouldn’t fit. It fit perfectly at CodeMash.