Great news!  Mono has made it to .NET 3.0 support and this includes some of the latest stuff like LINQ expressions.

I am pleased to announce that Mono C# compiler (gmcs) has now full C# 3.0 support. Most of the features has been available since Mono 1.2.6 release. However, with the upcoming Mono 2.0 release we will also support complex LINQ expressions and mainly expression trees which is fairly overlooked new feature with a lot of potential.

For anyone interested in compiling and running this LukeH’s slightly extreme LINQ example I have good news. It compiles on Mono and it runs as fast as on .NET.

Sun has been on a rampage lately. They recently purchased MySQL (which has some questions with InnoDB) but they also are supporting Python and integrating it into the VM offerings with Jython.

So now we have Google (They employ Guido), Microsoft (IronPython) and Sun (Jython) all turning into Python-istas. Does this mean Python is destined for greatness in the near future? Well I recommend learning it. It is a great language and it has a high productivity rate. Time will tell if it has the ability to be in extremely large code bases. I think it is just a matter of the architecture and organization as with any project.

Jonathan Schwartz at Sun mentioned also taking the “J” out of “JVM” to just make a VM much like a .NET framework. So Microsoft copied Java with C# the JVM and added multiple languages. Then Sun comes back and added multiple byte code compiled languages. And then they both focus on dynamic engines to implement versions of Python, Microsoft doing this within their DLR.

Many times the larger market languages that end up running business or “enterprisey” are heavily influenced by companies, in addition to the other demands from consumers, which here is programmers. So when the big three are all banking on Python as a draw there is a definite market draw there and a tell on the future. But I think it is apparent that Python is becoming a standard market baseplane language.

It is great to be able to use other libraries from .net with IronPython and java libraries with Jython. It has found a way to integrate with the current infrastructure and the language has low bar entry but deep benefits. Python is snaking its way into the market.

Python is so non verbose…

import sys
import clr
from System.IO import Path, Directory, FileInfodir = Path.Combine(sys.prefix, 'DLLs')

if Directory.Exists(dir):
    sys.path.append(dir)
    files = Directory.GetFiles(dir)
    for file in files:
        if file.lower().endswith('.dll'):
            try:
                clr.AddReference(FileInfo(file).Name)
            except:
                pass

This sample is from IronPython showing adding dynamic references to all dlls loaded.

Check out this HTML/XHTML parser in pure Python.

from HTMLParser import HTMLParserclass MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print "Encountered the beginning of a %s tag" % tag
def handle_endtag(self, tag):
print "Encountered the end of a %s tag" % tag


It is a well known fact that humans are thrown into an abyss without much information given or input, they are simply thrown in and latch onto platforms and something to start relative understanding. This is why so many belief systems, points of view and general human pathing exists (more on pathing in future philosophy topics), when it is all trial and error it what works might be different for everybody.

So programmers or creators are the same, once they are thrown into the software world abyss, especially without theory or computer science, the programmer usually latches onto the closest, most low-entry-bar technology/platform/company/language for their use (whatever provides the cash money – you can apply this to any market/industry really).

Once that skill is mastered, they reach to others in the same space, they reach to some standards that mix with other platforms. Then, eventually, they reach the walls of the platform just like on the Truman Show (maybe a 2-5 year run), they realize it is a box not a baseplane. Once the abstraction of the platform to the solution and design inputs and outputs as a whole it becomes clear this is a power of 10 abstraction removed from a programmer stuck in platform-like religious battles, still latching on to a particular platform or language over general solution making. The programmer that rises above all this is the true master of the skill or talent if you want to call it, this is when they become an engineer.

Programmers are the ones doing the hard work to make it easier. As a programmer you have already committed to doing the hard work.

Consuming systems as the input and simplifying them as the output, the ultimate goal of a programmer.

Oh, and all programmers eventually become philosophers, it is a side effect that is spawned from an input of understanding users. Or in particular, how the human works and interacts with your system through HCI – Human Computer Interaction and the interface for which they do so.

Power of Ten Reference