IronPython in Action News

Three new reviews for IronPython in Action have been posted online. One is by Benjamin Peterson, a Python developer, one by Dror Helper, a .NET developer, and uhm... a third one. The final review is particularly interesting, but you'll have to go and read it to see why.

Links to all three reviews, along with extracts, can be found on the IronPython-URLs Blog:

• IronPython-URLs: IronPython in Action Reviews

Dror Helper is a developer who has been exploring IronPython. He has just posted a review of IronPython in Action on his blog:

• Book Review: IronPython in Action

  If you’ve been reading my blog for a while you might have noticed that I’m in the process of learning IronPython, Half way through my IronPython project I felt I was missing something, Although I have read Dive Into Python I had a feeling that I’m actually writing Python and that I need a more IronPython focused book that will teach me how to write dynamic code that uses .NET as well, luckily for me I stumbled upon IronPython in Action and found exactly what I was looking for.

  The book is a good read and manages to transfer the authors (Michael Foord and Christian Muirhead) experience and knowledge on IronPython.

  So if you’re a .NET developer that wants to learn what dynamic programming is all about or a CPython developer looking for a way to enter the .NET world you really want to read this book.

Brett Cannon is one of the core Python developers, and despite not developing on Windows he has a keen interest in alternative implementations of Python and has reviewed IronPython in Action:

• IronPython in Action review

  To the point: if you need to program for Windows and you want to use Python, you should get IronPython in Action. The book does a good job of walking you through examples covering all the major APIs and tools a Windows programmer will end up using for whatever project they are working on.

  I actually read this book while I ate breakfast most mornings. Now that's nothing special, but considering I actually continued to read/skim this book even though I have not actively used a Windows box since 2001 should tell you something. This book is clearly written, and does a good job to point out gotchas you might run into through example. But it also does a good job of not overloading you with extraneous info that you could get from other reference sources (every computer book should have something like Appendix C that is nothing more than a list of URLs for reference material). And as an added perk the authors try to be humorous when possible and are even willing to poke fun at Windows.

Jonathan Hartley is a colleague of mine at Resolver Systems where we have been working full time with IronPython for the last few years. I finally managed to blackmail him into actually reading IronPython in Action. Despite this he seemed to genuinely enjoy it and has posted a glowing review. The first paragraphs of the review have some interesting things to say about the place of IronPython in the Python world, which is the section I've quoted below:

• Jonathan Hartley Reviews IronPython in Action

  Having spent some years working with .NET, and with a series of intriguing personal experiments in Python under my belt, I originally approached IronPython some years ago with a modicum of of trepidation. I feared that the weld between the two would be intrusively visible, forming distracting differences from regular Python. I feared for the execution environment, the data types, and perhaps even the syntax itself.

  Experience with IronPython showed these worries were needless. I have found IronPython to be a remarkably pleasant marriage – the same elegant language we know and love, given first-class status in the .NET runtime. Gifted with seamless interoperability with other .NET languages, the dowry from such an alliance turns out to be all the .NET libraries in the world, including the substantial and highly capable .NET standard libraries themselves.

  IronPython is, to some extent, a niche implementation of a niche language. However, its position seems to potentially be one of importance and strength. Not only does it allow Python programmers to use .NET libraries – and does so admirably, but it also allows the existing legions of .NET programmers to be introduced to the joys of Python. They will fall in love with it, and will be able to introduce it into their workplaces in a way that is politically acceptable. After all, it is now simply another .NET language. Since .NET is orders of magnitude more popular than Python, this could yet turn out to be the most important source of future Python adoption.

Darrell Hawley is a Microsoft C# MVP and Python enthusiast, which makes IronPython an obvious attraction to him. He has posted a review of IronPython in Action to his blog:

• Book Review: IronPython in Action

  Pythonistas will find the book offers quick introductions to a number of Microsoft technologies such as Windows Forms, WPF and ASP.NET. .NET developers will get the chance to see technologies they’re already familiar with expressed in a completely new fashion.

  IPIA avoids the trap of simply being a brochure of Microsoft technologies using “IronPython” in place of “C#” and “VB.NET”. Instead, the authors mix in chapters on development techniques ranging from the familiar - such as unit testing and mocking – to the more exotic such as metaprogramming. As .NET developers wind their way through the book, they’ll begin to appreciate the differences between the static and dynamic worlds – a crucial step toward wide ranging acceptance.

  If you’re curious about what IronPython can do for you, IronPython in Action is well worth your time.

In the last week or so several new reviews of IronPython in Action have been posted online. Here is a very brief overview of them:

• Jason Baker on IronPython in Action

  Jason Baker is a Python developer for Zeomega:

  "In summary, if you’re a developer wanting to work with Windows technologies using Python there’s no question: go and buy IronPython in Action. Right now. If you’re wanting to develop IronPython applications for various platforms or don’t want to tie yourself to just Microsoft technology… still go and buy IronPython in Action. There are still some holes that can be filled, but all in all, this is a pretty solid book."

• Mike Hadlow on IronPython in Action

  Mike Hadlow is a well known .NET developer from the UK:

  "It’s a very well written and crafted book, with an easy to read conversational style. I find many programming books quite hard work, but this one was a pleasure."

• Mark Bloodworth on IronPython in Action

  Mark Bloodworth is a Microsoft Architect Evangelist with an interest in dynamic languages:

  "If you’re interested in the DLR and IronPython, this book is worth reading. It’s a very good introduction – and will serve as a useful reference when you come to start your next foray into IronPython. And if you’re not interested in the DLR and IronPython, reading this book may just change your mind."

• Doug Hellmann on IronPython in Action

  Doug Hellmann is a well known Python programmer and blogger:

  "I recommend this book for any Windows developer interested in learning about Python, and for Python developers looking into deploying an application under Windows. If you don't fall into either of those groups, I can still recommend that you pick up a copy for some excellent advice on general programming topics and the solid example code."

Ted Neward is a well known .NET developer. He has been reading IronPython in Action and posted a review of it.

• Interoperability Happens

Ted Neward doesn't have unqualified praise for the book, but he seems to like it - even getting over his prejudice for 'the whitespace issue' (block structure by indentation in Python).

Here are some things he liked about IronPython in Action:

• The focus is on both .NET and Python, and doesn't try to short-change either the "Python"-ness or the ".NET'-ness by trying to be a "Python book (that happens to run on .NET)" or a ".NET book (that happens to use Python for code samples)". The authors, I think, did a very good job of balancing the two, making this the book to get if you're in that area on the Venn diagram where "Python" overlaps with ".NET".
• Part 2, "Core development techniques", starts down the "feed you the Python Kool-Ade" pretty quickly, heading straight into Chapter 4 ("Writing an application and design patterns with IronPython") without much of a pause for breath. The authors get into duck typing, protocols, and Model-View-Controller within the first four pages, and begin working on a running example to highlight some of the ideas. (Interestingly enough, they also take a few moments to point out that IronPython on Mono works, and include a couple of screen shots to that effect as we go, though I personally wonder just how many people are really going down this path.) I like the no-holds-barred, show-you-the-code style, but only because they also take time throughout the prose to talk about some of the concepts at work underneath and laced throughout the code. "Show me then tell me" is a time-honored tradition, but too many authors forget the "tell me" part and stop with code. These guys do a good job of following through.
• The chapters in Part 3, "IronPython and advanced .NET", form an interesting collection of how IronPython can fit into the rest of the .NET stack, demonstrating how to use IronPython with WPF, ASP.NET, and IronPython's crowning glory, Silverlight. If you're into front-end stuff, this is the section where I think you're going to have the most fun.
• The chapters in Part 4, "Reaching out with IronPython", is I think the most important part of the book, showing how to extend IronPython (chapter 14) with C#/VB extensions (similar to how a C-Python developer would extend Python by writing C code, but much much simpler) and the opposite—how to embed IronPython inside of existing C#/VB applications (chapter 15), which is really an exercise in using the DLR Hosting APIs. While the discussion in chapter 15 is good, I wish it'd had a bit more thorough discussion of how the DLR could be hosted regardless of the scripting language, though I admit that's pretty beyond the scope of this book (which is focused, after all, entirely on IronPython, and as a result should stay focused on how to host IPy).

Guido van Rossum is the creator of Python and its Benevolent Dictator for Life (BDFL). He is employed by google and not known for his love of the Windows platform. That aside I sent him a copy of IronPython in Action and he has reviewed it. As you can tell from the title of his blog entry it isn't a typical review, but he does say some very nice things about the book:

• IronPython in Action and the Decline of Windows

  Seeing a book like IronPython in Action, by Michael Foord and Christian Muirhead, is another milestone for IronPython. This is a solid work in every aspect, and something nobody using IronPython on .NET should be without. The book is chock full of useful information, presented along with a series of running examples, and covers almost every aspect of IronPython use imaginable.

  There are some introductory chapters -- some fluff about .NET and the CLR, an introduction to Python, and an introduction to with .NET objects from IronPython. The Python introduction has a slight emphasis on differences between IronPython and CPython, though there aren't enough to fill a chapter. This is a good thing! The chapter does a pretty good job of teaching Python, assuming you already know programming. In general, the book is aimed solidly at professional software developers: unless you are paid to do it, why would anyone want to get intimate with Windows?

Unfortunately reading the early chapters that go through developing a simple Windows Forms example application seems to have given Guido terrible flashbacks to a brief period of C++/Win32 development and the rest of the article becomes somewhat a rant about the Microsoft / Windows programming experience. I think Guido is a little unfair to Windows Forms, it's certainly no worse than other GUI toolkits I've used, and whilst a little verbose in places is generally quite good. Ironically the only examples of pixel positioning in the book (that I can recall anyway...) is to demonstrate how much easier the visual designer can make some aspects of GUI development... Anyway, it's good that Guido liked the book - whatever he may think of Windows development.