| | |  | Software Engineering | Home » » » IronPython in Action | | | | | | | Description: | | In 2005, Microsoft quietly announced an initiative to bring dynamic languages to the .NET platform. The starting point for this project was a .NET implementation of Python, dubbed IronPython. After a couple years of incubation, IronPython is ready for real-world use. It blends the simplicity, elegance, and dynamism of Python with the power of the .NET framework. IronPython in Action offers a comprehensive, hands-on introduction to Microsoft's exciting new approach for programming the .NET framework. It approaches IronPython as a first class .NET language, fully integrated with the .NET environment, Visual Studio, and even the open-source Mono implementation. You'll learn how IronPython can be embedded as a ready-made scripting language into C# and VB.NET programs, used for writing full applications or for web development with ASP. Even better, you'll see how IronPython works in Silverlight for client-side web programming. IronPython opens up exciting new possibilities. Because it's a dynamic language, it permits programming paradigms not easily available in VB and C#. In this book, authors Michael Foord and Christian Muirhead explore the world of functional programming, live introspection, dynamic typing and duck typing , metaprogramming, and more. IronPython in Action explores these topics with examples, making use of the Python interactive console to explore the .NET framework with live objects. The expert authors provide a complete introduction for programmers to both the Python language and the power of the .NET framework. The book also shows how to extend IronPython with C#, extending C# and VB.NET applications with Python, using IronPython with .NET 3.0 and Powershell, IronPython as a Windows scripting tool, and much more.
| | | Features: | |
• ISBN13: 9781933988337
• Condition: Used - Very Good
• Notes: 100% Satisfaction Guarantee. Tracking provided on most orders. Buy with Confidence! Millions of books sold!
| | | Product Details: | | | Author:
| Michael J. Foord | | Paperback:
| 480 pages | | Publisher:
| Manning Publications | | Publication Date:
| April 04, 2009 | | Language:
| English | | ISBN:
| 1933988339 | | Product Length:
| 9.18 inches | | Product Width:
| 7.36 inches | | Product Height:
| 1.02 inches | | Product Weight:
| 1.84 pounds | | Package Length:
| 9.0 inches | | Package Width:
| 7.3 inches | | Package Height:
| 1.4 inches | | Package Weight:
| 1.6 pounds | | Average Customer Rating:
|  based on 10 reviews |
| | | | Customer Reviews: | |
Average Customer Review:
 ( 10 customer reviews )
Write an online review and share your thoughts with other customers.
Most Helpful Customer Reviews
8 of 8 found the following review helpful:
 If you are a .NET person who is curious about Python, or a Python person who has an interest in .NET - you need this bookJul 18, 2009
By J. Hartley
"tartley"
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?
4 of 4 found the following review helpful:
Great for learning and to have on hand as a reference!Apr 27, 2009
By Sarah Dutkiewicz
"The Coding Geekette"
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.
4 of 4 found the following review helpful:
Highly RecommendedApr 13, 2009
By Techie Evan
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!!
2 of 2 found the following review helpful:
makes it easy to get started using IronPython right away.May 28, 2009
By Scott C. Koon
"lazycoder.com"
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.
5 of 7 found the following review helpful:
Simply a Fantastic Python BookMay 05, 2009
By Robert S. Oakes
"Rob Oakes"
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.
See all 10 customer reviews on Amazon.com
| | |
* Estimated shipping rate for US 48 states. Final rate calculated at checkout. |
