IronPython in Action News

Jeff Hardy is the creator of NWSGI. This is a .NET implementation of the Web Server Gateway Interface protocol; a Python protocol for web applications. His goal is to be able to use Python applications and frameworks like Trac and Django from IronPython with the Microsoft IIS server. He also blogs about his progress in getting Django and setuptools to run under IronPython.

As with other recent entries on this news blog, he is featured here because he has posted a review of IronPython in Action:

• IronPython in Action

He says:

I wasn't really sure what to expect when given this book. Having read it, I now see that it is exactly what it says it is – IronPython, in action. For any serious work with IronPython (more than just using it as an alternative Python interpreter), than this book will save you a ton of learning time. The examples are clear, concise, and – most importantly – realistic. Even if you already know Python and .Net inside and out, but are new to IronPython, this book will save you some headaches learning about how they interact.

This was exactly our goal, so we're pleased!

The manuscript for IronPython in Action really is in the final stages. I've just received the typeset versions of chapters 6 to 10 for me to give the final once over. We're still on schedule, which means that the book is likely to actually head to the printers one week from today and the final ebook version be available a few days after that.

In the meantime Rob Oakes has been reading IronPython in Action (the Early Access version) and has posted a review online:

• Rob Oakes Reviews IronPython in Action

He has a very interesting reaction to the book. He does seem generally positive, here is his final conclusion:

In case it isn’t clear, I heartily recommend that anyone interested in learning Python or .Net purchase this book. It certainly has its idiosyncrasies, but it still manages two roles very successfully: 1) introductory text and 2) reference manual. While novice readers (like myself six months ago) will find tremendous value in reading the book from cover to cover, more experienced hands will find value in skimming individual chapters. As someone who has written technical documentation, I can testify that such a feat is extremely difficult to pull off.

What is unusual is that he took away something from the book that was quite unanticipated by Christian and myself: While I initially set out with a desire to learn a skill, I instead received an education. In the process, I got excited about programming, Python, and OpenSource. Rob feels that instead of just showing how to use IronPython, the book caused him to examine his approach to programming. In fact he starts his review by asking: Is IronPython valuable for people who are new to Python or .Net programming? More to the point, can it be used to teach a novice “how to fish?”.

This reaction wasn't as a result of a deliberate agenda on our part, we simply wanted a book that would be relevant to both Python programmers interested in .NET and .NET programmers interested in dynamic languages. Naturally this meant that the book needed to start with a Python tutorial (chapter 2) and an introduction to .NET (chapter 3) that also shows how IronPython integrates with the underlying platform.

It is however no secret that I'm particularly enamoured of the lightweight approach to object-oriented programming that Python affords. Although the main goals of chapters 4-6 are to introduce new Python features to .NET programmers (lambdas, properties, first-class functions, etc) and new .NET libraries to Python programmers (XML, Windows Forms, .NET serialization, etc), there is a reason I chose a structured application using several object-oriented design patterns as the example.

Developers who have mainly worked with statically typed languages often have an odd idea about dynamic languages, that they make it harder to create large scale maintainable applications. Meanwhile, developers who mainly use dynamically typed languages like Python think the opposite - and feel that creating large projects in more verbose languages is a maintenance nightmare waiting to happen! (Even though the IDE will help you write the code, you typically spend more time reading code than writing code - so verbosity imposes a cognitive burden even if you can write the stuff just as fast.) By showing off the features of both Python and the .NET framework through building a well structured (if rather small) example, I hoped to demonstrate that dynamic languages make clean and elegant designs possible.

Rob ends the review with:

To answer my own question: Can IronPython in Action be used to teach a novice how to “fish?” Most definitely.

SD Times has an interesting article by .NET developer Larry O'Brien.

• Windows & .NET Watch: Python: Arbitrarily Interesting

For a .NET developer he starts by saying some interesting things about Python: Python is the easiest language in which to do interesting things. As a .NET developer he naturally goes onto talk about IronPython and then discusses IronPython in Action

For fellow dilettante Python programmers, I recommend the book “IronPython in Action” by Michael Foord and Christian Muirhead. Soon to be published by Manning (I reviewed a preprint), the book is particularly strong in providing simple-but-not-simplistic illustrations and tables that clarify behind-the-scenes structural elements. Visual Studio screenshots may be a little more common than I’d like, but for those new to the VS environment, these may be welcome.

The cheek, there's maybe four or five screenshots of Visual Studio in total - making it one every hundred pages or so! They're mainly showing the IronPython integration and the designers, but if that is his worst criticism of the book then we've not done too badly. Anyway, he continues:

A common challenge for books involving technologies ported to new environments is balancing viewpoints. A strength of the Foord/Muirhead book is just such a balance, providing “Pythonic” topics such as test-driven development, mocks and metaprogramming, along with clear discussions of .NET’s CLR structure, Windows Presentation Foundation, and even programming PowerShell with Python.

Larry is also a fan of Resolver One, the Python powered spreadsheet created by Resolver Systems. I've been working with Resolver Systems for nearly three years, and it is how I got involved in IronPython, so it's nice to hear people say good things about it:

I can’t praise enough the combination of spreadsheet and programming models embodied in Resolver One: I truly believe that this is one of the best ways to do exploratory programming. Although it’s been 15 years since I’ve worked with fuzzy logic, I was able to put together the not-entirely-rudimentary building blocks of a fuzzy manifold editor (a tool for visualizing the response curve of a fuzzy system) in a matter of hours.

Maurice De Beijer is a Microsoft MVP, and one of the organisers of the Software Developer Network events in Holland. He has also reviewed a pre-release copy of IronPython in Action.

• Maurice De Beijer on IronPython in Action

At the start of the review he explains his interest in Python:

So why am I interested in a book about IronPython? Well I used to do some Python programming a number of years ago and found the language kind of nice to work with. Working with dynamic languages like IronPython relieves you from a lot of the code you have to write just to keep the compiler happy.

The rest of the review presents a quick summary of the four parts of the book, with commentary. And his conclusion:

This book is a good read for all .NET developers who want to know about the new trend towards the dynamic languages and IronPython in particular. You get a good explanation what IronPython can do for you and how to go about solving every day programming problems. With the current push towards dynamic behavior, even in languages like C#, every experienced .NET developer should read this book!