[IronPython] My Farewell to IronPython and Microsoft

Jim Hugunin ironpy at hugunin.net
Fri Oct 22 01:12:25 CEST 2010

Today marks the end of a crazy six year journey for me at Microsoft. I
clearly remember my brutal first 8 months at this company as I worked with
lawyers, marketing folks and execs to figure out if and how we could release
IronPython as an open source project from Microsoft. The final approval for
that release came the night before I was slated to give a keynote talk at
the annual Python conference – with no backup plan. That talk was immense
fun and I appreciated the willingness of the Python community to consider
IronPython on its merits – and also to join me in my fantasy that getting to
this point had only taken a reasonable two months rather than the actual
eight. That first conference started many conversations with the community
about what it meant to be true to the Python language. We made some major
changes to how .NET methods were exposed based on just those first
conversations. Since then we’ve done our best to perform a balancing act
between being true to Microsoft and .NET and true to the Python community.

That first release of IronPython was clearly broken in many ways. It was
released under an "open source" license that was specific to Microsoft and
not trusted by the community. Over the years that evolved into an OSI
approved license and finally into the well-known and trusted Apache license.
Similarly, that first version had huge technical holes such as the fact that
all the dynamically generated code it created could never be garbage
collected leading to a huge memory leak. This particular issue was fixed by
adding powerful DynamicMethods to the .NET 2.0 framework. Through the years,
we’ve been making steady progress on these technical and community
engagement issues.

The culmination for me of the work on IronPython was the creation of the
Dynamic Language Runtime (DLR) which brought many of the ideas we developed
for IronPython deep into the .NET platform. The coolest part for me is the
ability for different languages to interoperate with each other by building
on a common layer. I love being able to use IronRuby to call into my
favorite Python libraries. The greatest joy was working with the team that
added support for the new "dynamic" keyword to C#. I’ve always been a
neutral in the ongoing war between the proponents of dynamic and static
typing and it was really satisfying to add optional dynamic typing to C# by
building on top of its rich static type system. Best of all, I don’t think
I’ll ever get over the kick I get out of talking about the static type
called "dynamic".

Microsoft’s decision to abandon its investment in
a catalyst but not the cause of my leaving the company.  While most of
you know that I haven't been directly involved in IronPython for quite some
time, the decision still provided a spur to cause me to reflect on my time
at the company and realize that it was time to explore other career options.
There would be something emotionally satisfying about leaving Microsoft in a
fit of rage – preferably involving the illegal deployment of an emergency
escape slide. However, I leave feeling respect for the many great people and
products produced here. I will suffer some pain when I have to write code in
Java now that I’ve learned to love the elegance of C#. I will suffer some
frustrations when I have to use Google Docs instead of the finely polished
UI in Microsoft Office. More than anything, I will always value the chance
that I had to work with and learn valuable lessons from some truly great

As I leave Microsoft, I’m incredibly excited to be going to work for Google.
I like to build projects with small talented teams working on quick cycles
driven by iterative feedback from users. I like to have a healthy
relationship with Open Source code and communities, and I believe that the
future lies in the cloud and the web. These things are all possible to do at
Microsoft and IronPython is a testament to that. However, making that happen
at Microsoft always felt like trying to fit a square peg into a round hole –
which can be done but only at major cost to both the peg and the hole. I’m
excited to be going somewhere that fits my natural instincts for how to
build great software and has demonstrated how successful this approach can
be. I’m even pretty sure that I’ll grow to love Google Docs as it continues
to rapidly improve through great engineering combined with continuous
iterative feedback.

Given my new employer, I will be throwing my lot in with the Java side of
the virtual machine world. I think that C# has truly evolved into a nicer
language than Java and that .NET has some cool features that the JVM is
missing. However, I also see great things in the Java world both technically
with features like the adaptive compilation in HotSpot and more
significantly in terms of the vibrant community it has managed to create
that adds huge value to the platform. When I weigh them both in the balance,
neither side has a clear advantage. I respect Google’s decision to
standardize on a uniform set of primary programming languages with Python,
JavaScript, Java and C++. I don’t see any reason to push against that set –
particularly if it means I get to consider Python a primary language!

This also means that I am leaving the IronPython project. The four people
named as initial coordinators are fantastic and it would be a pleasure to
work with them. It would also be very satisfying to work on IronPython
outside of the corporate constraints I’ve been living in for the past six
years. I have great hope for this project in these new hands and look
forward to watching their future successes.

So long and thanks for all the fish - Jim Hugunin

(original of this message is posted at
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/ironpython-users/attachments/20101021/3064b8ed/attachment.html>

More information about the Ironpython-users mailing list