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 IronPython was 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 people. 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