Customer Reviews

IronPython in Action

5 star:		(7)
4 star:		(2)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

Disclaimer: I'm friends with both the authors and was sent a freebie review copy by the publisher, so I'm bound to be breathlessly gushing in this review. Fortunately, that's easy to do, because the book really is great. (Except for Christian's chapters... Joke!)

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 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 turn out to be an important source of future Python adoption.

This book is aimed to satisfy programmers coming from both the Python and the .NET worlds, and in this it seems to succeed. It starts with quick overviews of concepts from each: 30 pages about Python as a language, and 17 pages about .NET as an environment (data types, events, delegates, Windows Forms, etc) - just enough to get everyone up to speed regardless of background, but without being so verbose as to turn anyone off with a surfeit of material they are already familiar with. Despite being brief, these sections are packed with detail and very pragmatic, focusing on real-world use such as inheriting from existing .NET types, and solving some common problems like creating Windows Forms applications from IronPython.

This style of practical and densely informative content is continued throughout. Straight after the opening sections, we dive right in with another rapid-fire chapter, demonstrating common IronPython techniques by writing a non-trivial application. Woven around this ongoing example, the chapter discusses many immediately important topics, including duck typing, Python protocols, MVC, using Windows Forms to build a GUI, tab pages, dialogs, menus, toolbars, images, saving text files, .NET Streams, text file encodings, Python exceptions and lambda functions. These diverse topics are covered rapidly but thoroughly, giving the reader enough information about each to be able to use them together from IronPython to create a useful project.

Having covered these foundations, the book then moves on to address some specific areas in more detail. The following chapter headings give you some idea of the topics which are explored in depth:

* First-class functions in action with XML - demonstrates pragmatic use of functions as first-class objects, and higher-order functions (functions that take other functions as arguments and return modified versions.) and of course decorators. These are shown in use, appropriately paired up with the .NET XmlWriter and XmlReader classes, demonstrating event driven parsing of XML.
* Properties, dialogs and Visual Studio - Python properties, .NET dialogs, and using IronPython in Visual Studio. This sounds like a straightforward chapter, but as you might guess, the book gets deep into the topics and is jammed full of information. By the end of the chapter you'll have added to the example application to create document observers, used BinaryFormatter to serialise objects, and touched on Python's pickle equivalent.
* Agile Testing: where dynamic typing shines - From the unittest module and creating tests, through mock objects, listeners, monkey patching, dependency injection and functional testing. This is a dense chapter in a dense book, touching along the way on Python attribute lookup rules, bound and unbound methods, asynchronous execution for functional testing. My only criticism is that it's clearly hard for developers to 'get' testing until they have hands-on experience of it, so this single-chapter, while very thorough in explaining how to test, has an ambitious remit, and doesn't have enough space to explain much of why we test. I guess this is partially my own bias shining through here - I regard testing as quite literally the most important thing to happen in computer science since the invention of the compiler, and would encourage anyone interested to go and read as much as they can about it.
* Metaprogramming, protocols and more - More Python protocols, dynamic attribute access, and metaclasses. The sorts of things that in a static language would be deep black magic, or else completely impossible, but here they are just the right sort of crazy. Read, enjoy, and unlearn. We see how to create a profiling decorator, that modifies the functions you pass to it, wrapping them in stopwatch timing calls. We also learn about some of the more advanced integration of IronPython with the .NET CLR, including static compilation of IronPython code into assemblies, and one of the very few additions to Python syntax that IronPython has been obliged to provide - the typing of .NET arrays and generics. You'll never need to use generics yourself (in Python, everything is a generic), and you'll never want to go back to typed containers if you can avoid it. However, you may need to deal with some from an existing C# API, and this is how you do it.

Whew! We're only halfway through! The remaining chapters are equally detailed, but I'm going to start skimming through them somewhat. They cover the interactions of IronPython with more advanced .NET topics such as:

* Windows Presentation Foundation (WPF) and IronPython - WPF is the DirectX user interface library that is a successor to Windows Forms. This includes XAML, an XML dialect for describing user interfaces, decoupling their implementation from application logic.
* Windows System Administration with IronPython - using IronPython as a scripting language for sysadmin automation tasks, from the simple, such as copying files, to the complex, such as Windows Management Instrumentation (WMI), administration of remote machines, and a substantial discussion on the uses of PowerShell with IronPython.
* IronPython and ASP.NET - building a web-based front end to the sample application developed earlier. Reusable controls.
* Databases and Web Services - using ADO.NET to work with databases, and using SOAP and REST.
* Silverlight: IronPython in the browser - creating Silverlight applications, and accessing the browser DOM from them.
* Extending IronPython with C#/.NET - all about creating C# class libraries for use in IronPython, calling unmanaged code from IronPython, and creating interfaces on your C# classes to provide dynamic, Pythonic behaviour. It also includes dynamic compilation of assemblies at runtime, which opens the door to advanced code-generation techniques.
* Embedding the IronPython Engine - many developers might want to provide IronPython as a scripting language within their own application, and this chapter shows you how.

Alright, that's it! There are appendices:

* A whirlwind tour of C# - in case anyone wants more guidance while looking at some of the C# code or concepts that are discussed throughout the book.
* Python magic methods - a description of all the Python magic double-underscore methods, which is a fabulous resource, one which l haven't seen collected anywhere else, and have been referring back to ever since I read the book.

So there you have it. If you haven't inferred already, I learned absolutely heaps from this book, even though it's about a language and environment I've been using every day for years. I think I can say without any equivocation that this is the best IronPython book in the world.

If dynamic languages make you break out in hives, or if .NET makes you think of Darth Vader, then you shouldn't touch this book with a barge pole. However, if you're a .NET person who is curious about Python (and believe me, you should be), or if you're a Python person who fancies .NET - maybe for DirectX or Silverlight or any number of other wonderful things, then you should absolutely go directly to the IronPython in Action book website or Amazon, right this second, and buy it.
http://www.ironpythoninaction.com/

What are you still doing here?

What I liked best about this book is that in the beginning, IronPython was discussed while looking at it from two different angles - covering what a .NET developer would get out of IronPython and a what Python developer would get out of it as well. The examples in this book were easy to follow and very applicable to everyday programming. The book flowed well, covering the fundamentals and then stepping up into more complex concepts (WPF, ASP.NET, system administration, web services, databases, and more).

I had reviewed this book before it came out, and I had mentioned that I'd buy a copy of it when it came out, even though I already have the eBook. I purchased this through Amazon.com, and I now keep it on hand as a reference while I'm coding in IronPython or when I'm giving a presentation on IronPython at the various events in the region of MI/OH/KY/TN.

Overall, I would recommend IronPython in Action for anyone wanting to learn IronPython. Even if you're an experienced IronPython programmer, this book would be great to have on hand as a reference.

Written by Python Experts who have developed complex applications with IronPython, this excellent book covers IronPython 2 and provides several code examples illustrating how faithful IronPython 2 is to Python 2.5 and how .Net and Python concepts map to each other. The diverse examples range from showing how IronPython integrates nicely with various .Net libraries such as Windows Forms, Windows Presentation Foundation and Silverlight, to how Python's advanced features can be used effectively in agile testing, and to how C# and VB.Net applications can embed the IronPython Engine to run Python code and scripts. The book also tackles areas in which the integration between IronPython and .Net is currently not straightforward, providing guidance on how to work around these issues, as well as information on how Microsoft may address these remaining issues. Overall, I think the authors did an excellent job, and even readers who may be relatively new to either Python or .Net will find the book an easy and valuable read because of the many little things that the authors did (e.g., thoughtful and concise explanations, copious code, great references, etc) to make it so!!

I've always wanted to use Python more. Mostly I use it to write little one off scripts when I want to move a bunch of files around or parse some text. I was really excited when Manning asked to to review IronPython in Action because I wanted to dive a little deeper into Python and possibly use it in some web applications. "IronPython in Action" makes it easy to get started using IronPython right away.

The book starts out with an introduction to Python itself and continues with a general description of how IronPython can use .NET types. It starts off by showing how to build a Winforms app using IronPython. If anything exposes the cruel, unnecessary complexity of .NET, it's got to be a Winforms app. The IronPython examples are easy to follow and it's always fun to create and manipulate a Winforms app using the IronPython console.

Chapter 4 talks about using Design patterns in IronPython. This is a refreshing change from most language books where patterns aren't mentioned at all. The chapter builds an IronPython application and uses the MVC pattern for the overall architecture and the command pattern for the implementation of the menu bar events.

Chapter 7 discusses agile testing and unit testing using IronPython. I almost dropped the book in amazement. Unit testing is almost never mentioned in any language book and is relegated to a niche or advanced topic. Find a book about any other .NET language that mentions unit testing that doesn't have the word "testing" in the title. This alone sets the quality of this book far above other language books I have read. It's not just enough, in my opinion, to discuss the syntax of the language. You have to teach the reader how to use the language in your everyday work.

The next section, section3, deals with a few core UI frameworks commonly used during .NET development, WPF, Silverlight, and ASP.NET, as well as showing how you can use IronPython to administer your system. Performing tedious tasks is my most common use of IronPython. I use it to automate moving files that fit a specific pattern out of my "downloads" directory to their proper places. It was great to learn a few new techniques for using IronPython in Powershell.

The last section talks about extending IronPython using C#, something which it sounds like should be avoided unless you just can't achieve decent performance with the equivalent IronPython code, and using IronPython as an embedde scripting engine. Python is used a lot in game programming because it's easy to embed. The nuts and bolts of the game engine will be written in low-level C/Assembly while the game logic and story is written in Python. I love the idea of having an embedded scripting engine in my application that will allow me to quickly extend my application at runtime. The user need to perform a new calculation on some data? Just send them an IronPython script and have them put it in a directory. It's a great idea and the book describes exactly how to do just that.

My overall feeling about this book is that it's a great book. The authors use the same humor and dry wit that Python is known for to great effect. Making the digestion of a very different language easier. I'm sure that as I continue to experiment with IronPython that I'll keep this book close at hand.

While I just got my print copy of Michael Foorde's excellent book, "IronPython in Action," I've been using it and referring to it for the better part of a year. There's a back story here, so be prepared.

I'm not a computer programmer, I'm an engineer who occasionally needs to do a bit of (rather frustrated) computer tinkering. For that, I've long used Matlab (a product of the MathWorks company). Matlab works well for most things, but it has some rather serious technical limitations. More importantly, though, it's tremendously (prohibitely even) expensive. In contrast, Python is free, OpenSource and solves many of Matlab's serious problems.

So, a little more than a year ago, I did a bit of investigation and eventually decided to try IronPython. It tied into Microsoft's .Net library, it was real python, and it worked flawlessly on Windows. There was, however, just one problem: I didn't have the time to figure out Python programmming on my own. That's when I found Michael's book. And it has been a godsend.

As I said above, I'm not a computer programmer and computer programming isn't a skill I've ever wanted to properly acquire. My idea of computer programming is to find someone else's example and then poke and prod until it does something relatively close to what I need. I don't have the attention span for most books on the subject, and I don't have a great deal of desire (or any serious motivation) to learn better skills.

Foord's book simultaneously addressed two very real problems: 1) my own ignorance, 2) my impatience for results. The book nicely balances the need to teach skills with the need to show results. And I was well satisfied. The included examples are excellent, and I was able to get up and running on my own projects quickly. More importantly, though, I picked up quite a few insights on how to properly write a piece of code. For both of these reasons, this book easily earns its five stars. If you are interested in Python or .Net, it is an excellent reference. Do yourself a favor and just buy the book.

This book excels in its discussion of both "pythonic" and ".NET / DLR" issues. IronPython is a relatively new port of Python and its interaction with Microsoft's managed platform is an important concern.

The book is well written, has some excellent "worth a thousand words" diagrams, and no technical errors jumped out (as with all development books, I am sure there are _some_ technical errors). I recommended "IronPython in Action" in my SD Times column and expect to see it among the entries for the 2009 Jolt Awards for "Best Technical Book."

This book is a must-have for all who need to get started with IronPython. A triumph of clear intelligible language with numerous examples from the world of dynamic programming, this is simply the best book on one of the best implementations of Python.

IronPython is the first dynamic language developed for the .Net plateform. At first, .Net didn't support this kind of language. This is something that keeps on coming back througout the book: you have to use some additional tricks to unleash the power of .Net dynamic and static languages.
The book starts with a general introduction to IronPython. A quick review of the language itself is followed by the use of the .Net assemblies. At the end of this part, one is comfortable enough to do some small IronPython programs.
The next part is dedicated to what IronPython offers thanks to Python and to its affiliation to .Net. The authors go through standard Python (battery included) and the somewhat associated .Net assemblies (some arguments on using one or the other could have been a big plus to the explanations), depending on what must be done. Because or (or thanks to) .Net, several pages are dedicated to XML, as it is needed to simplify the description of UIs. Also several useful designed patterns are presented with the .Net approach.
The next part starts with WPF, the official graphical interface, with several ways of using it (bridge from C#, XAML, ...). Then WMI (used for system administration) is handled, but from my point of view, it is the weirdest part. WMI has its own language which does not seem like C# or Python. Besides, PowerShell, presented as well as a way of doing system administration, has its own language. There is a book dedicated to PowerShell, so only the communication between IronPython and PowerShell is handled. So two additional languages in this chapter, perhaps too many (they are limited to this chapter).
IronPython is a .Net language, so it is possible to do ASP with it. A chapter deals with this approach, chapter well written but it needs to follow the associated example in your favorite IDE if you want to follow what's happening. Web means also web services and databases, handled in one chapter. The basis of SQL tools addressed, as well as basic webservces (mainly REST). I have to say that there are some mistakes there, as SOAP is not only used with POST HTTP requests but also with GET requests (it can be seen in the official w3c specification) and also with other transport protocols than HTTP. Perhaps these are .Net implementation's limitation, in which case it should have been mentioned. Finally Silverlight integration allows developping light clients that can interact with other langages as well as the web page.
Throughout the book, complete interaction with other .Net languages was not addressed. It is the goal of the last part to show how assemblies can be used in IronPython and how IronPython scripts can be used from .Net static languages. As I've said, the interaction does not go completely smoothly, there are several solutions to accomplish it. At least, the book does not only speak about the upcoming .Net 4.0 that will help this interaction.
As a conclusion, those who need a dynamic language (to script an application) can go for IronPython, th first dynamic language for the .Net framework, compatible with the langage Python 2.5, and in that case, go for this book that will help you for anything.

I liked the book, but I'm a web developer and all of the winforms stuff turned me off. I thought Python was a great web development language? I know it is versatile, but I would have preferred web focused examples. Not a biggie, but it was a big reason why I skipped some big sections with all the win forms setup code right in the book. How helpful is that really anyway?

A very good and useful book to start using IronPython. You only need to have an idea of programming (any language) before starting with this book. It will be useful for both the Python programmer or the .Net programmer.
The demo application is done following good programming practices and common patterns (something very much welcomed).
The book shows how to use the language in desktop and web aplications; Silverlight and embedding it into your c# apps. (Ex: as an scripting option for your users to extend the program).
It reads pretty fast. I didn't find any cruft on the book, something that is not very common with technical books. Along the chapters you will find pointers to resources in the internet to deal with subjects that are not specific to the book but they are mentioned or referenced somehow.