Profile for J. Hartley > Reviews

Browse

J. Hartley's Profile

Customer Reviews: 4
Top Reviewer Ranking: 945,626
Helpful Votes: 117




Community Features
Review Discussion Boards
Top Reviewers

Guidelines: Learn more about the ins and outs of Your Profile.

Reviews Written by
J. Hartley "tartley" RSS Feed (London)
(REAL NAME)   

Show:  
Page: 1
pixel
Test-Driven Development with Python
Test-Driven Development with Python
by Harry J.W. Percival
Edition: Paperback
Price: $29.44
46 used & new from $25.32

2 of 2 people found the following review helpful
5.0 out of 5 stars The best book on testing I've ever read., September 15, 2014
I was a technical reviewer on the book, and have worked with the author. But it REALLY is the best book on TDD I've read - I'm not just saying that!

Throughout, I was impressed that it doesn't skip over the hard bits, but follows it's chosen example application down every avenue of problems you might encounter doing TDD on your own projects. Difficult to test code? Learn how to fix it. Find it hard to differentiate between unit and system level tests? This is made easy. Problems interacting with slow or unreliable I/O? It's covered. Integrating asynchronous components? No problem. Introducing javascript to your Python web project? Explained in patient and loving detail. Running tests on your production or testing servers when you deploy? Demonstrated in detail.

All of this is done in a lively & endearing style that keeps engagement & enthusiasm high while sticking to the point.


Invent Your Own Computer Games with Python, 2nd Edition
Invent Your Own Computer Games with Python, 2nd Edition
by Al Sweigart
Edition: Paperback
Price: $21.08
44 used & new from $18.43

88 of 89 people found the following review helpful
5.0 out of 5 stars From zero knowledge to programming your own games : brilliant, May 16, 2010
This book is totally appropriate for someone who has never programmed before. Everything is explained, right from the ground up, in a lively, interesting style which doesn't dumb things down.

In terms of the language Python, not all aspects of the language are described - only the parts that are absolutely necessary to know to create games. A reader who wants to learn more about programming should definitely start off with this book first, and then supplementing that with other books specifically about Python (or other programming ideas) if they find they have an interest in that direction.

Topics covered
--------------
The first ten chapters do a brilliant job of leading the reader through the creation of many small games in the text console, which cumulatively cover all the basics of programming: variables, datatypes, expressions, strings and their methods, booleans and if statements, loops, functions, variable scope, lists, dictionaries, string formatting, ASCII. You will use these to create text games such as hangman and choose your own adventure.

Chapter 11 explains Cartesian co-ordinates and some arithmetic that will be used later on.

Chapter 12 to 15 then create one new game per chapter, using the techniques learned so far, adding a great description of how to create simple but effective artificial intelligence.

Chapters 16 to 18 then break out of the text console, using the pygame library to display a window with coloured rectangles, polygons, circles and bitmaps. It then covers methods of animating these images, reading the keyboard, basic 2D collision detection, reading the mouse, bitmaps and scaled sprites, and creating music.

The final chapter caps the whole thing off with a final big game that incorporates all the techniques discussed, with music and the works.

Overall, I can wholeheartedly recommend this book for it's target market: Kids who want to learn to program, specifically so they can create their own games. Adults who have never programmed before will also find it very useful, although there may be a couple of chapters they can skim over.

Inspirational and brilliant.
Comment Comments (2) | Permalink | Most recent comment: Feb 20, 2013 4:41 PM PST


IronPython in Action
IronPython in Action
by Michael J. Foord
Edition: Paperback
Price: $32.49
41 used & new from $19.98

10 of 10 people found the following review helpful
5.0 out of 5 stars If you are a .NET person who is curious about Python, or a Python person who has an interest in .NET - you need this book, July 18, 2009
This review is from: IronPython in Action (Paperback)
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.
[...]

What are you still doing here?


Expert Python Programming: Best practices for designing, coding, and distributing your Python software
Expert Python Programming: Best practices for designing, coding, and distributing your Python software
by Tarek Ziadé
Edition: Paperback
Price: $40.49
42 used & new from $22.42

17 of 17 people found the following review helpful
4.0 out of 5 stars Made concrete improvements to the way I work with Python every day, January 11, 2009
[Publisher Packt were nice enough to send me a copy of this, so I'm completely biased, but fortunately I really liked it.]

I've been using Python for a couple of years now, but only on a single project, so while there are parts of it that I know very well, there is doubtlessly a lack of cross-fertilisation in the things I am exposed to. So I was looking forward to this book.

Surprisingly, for such a straightforward-sounding title, it is not at all what I expected.

What I expected was analyses and illustrations of using Python's more powerful features: dynamic designs; creating classes on the fly; functional programming styles; closures and metaclasses.

Sure enough, there is an early couple of chapters devoted to advanced language features. First up, iterators, and generator expressions, and then the .send, .throw and .close methods on a generator, which induce the yield statement to return values or raise exceptions. This is then used to handily illustrate coroutines as a method of co-operative multi-tasking without the calamity involved with getting all multi-threaded. It's exactly the sort of feature I'd pondered writing for myself for a personal project, oblivious that the language provides it out of the box.

Other low-level topics covered include the indispensable itertools module, interesting uses of function decorators, best practices for subclassing built-in types, sensible use of descriptors and properties, understanding method resolution order and using super, the often-overlooked slots, and finally meta-programming and metaclasses.

Interestingly, this list has only one item of overlap with my expectations. Tarek has done a good job of choosing important but sometimes overlooked topics, and while, inevitably, I was very familiar with some of the things he talked about, other sections were complete revelations for me.

However, this is only chapters 2 and 3! The rest of the book expands in scope beyond Python the language, to look at the environments and tools that make up the Python ecosystem. In a way, this sounded less intriguing to me than the computer-science oriented exploration of language features that I had expected. But having finished the book, I now realise that it was exactly what I needed.

The opening chapter goes through installing Python - a topic which I didn't think needed discussion. But Tarek goes on to cover using MinGW and MSYS to set up a credible command-line environment under Windows. I've always used Cygwin for this in the past, and trying out MSYS (coupled with the project Console) is a breath of fresh air.

This cross-platform development environment is then rounded out a little by installing and using things like setuptools, and some thoughtful notes on integrating Python development into editors like Vim and Emacs, or an IDE like Eclipse.

The rest of the book covers some of the major tools in the Python world.

I've never previously been forced to get to grips with Distutils. Applying lessons from the book to a personal project got me completely up to speed with using Distutils to create packages, making source and binary distributions, using eggs, and distributing dependant packages that together make up an application. The only thing really missing from this is maybe generating stand-alone executables using py2exe (for Windows) or py2app (for Macs), although this idea is mentioned in passing.

The following chapters give competent overviews of a wide variety of topics:

8. Version control systems: centralised, illustrated by Subversion, or distributed like Mercurial. Continuous integration using Buildbot. Presumably you will either already know these inside-out or else will lap them up hungrily.

9. Waterfall, spiral and iterative project life cycles. I'm not sure that waterfall is really used by anyone except in case studies of `what not to do', and I'm also not sure how you could be a developer without being aware of this, but maybe that's precisely the point: You can't be a developer if you don't do this. This chapter then covers setting up an instance of Trac and using it to manage a project's deliverables, defects, and milestones.

10. Documenting a project using ReStructuredText and Sphinx, and including hints on good technical writing. This caused me to completely revamp the content of my small personal project's documentation, and as a result it is both much improved, and shorter to boot. Wins all round.

11. Test-Driven Development. This chapter would be a superb overview of the topic for someone who didn't know about TDD. Although I use TDD extensively at work, I've never used nose, fearing that getting to grips with it might be too intrusive or disruptive. In fact, it is seamless to begin using it in a small way and slowly extend into its more advanced features as and when you need them.

12. Optimisation : General principles (ie. don't) and profiling techniques. I had never used the cProfile module described here, having just whipped up homespun profilers on-the-spot whenever I needed them, and it's a valuable addition to my arsenal.

13. Optimisation : Solutions. Big O notation. Correct use of different collection types. Multi-threading, multi-processing, caching. Not much that is tremendously new to me here, but it is obviously a huge topic to cover in a a single chapter, and it covers the bases competently.

14. Design Patterns, and how they apply (or don't) to Python. It has been said that design patterns, as fundamental and necessary as they are to a software engineers mindset, are a symptom a language's lack of expressivity. You shouldn't have to write huge gobs of code to express simple conceptual relationships. Although Tarek never explicitly says this, to some extent it is born out by this chapter. Trivial (and much-maligned) ideas like the Singleton, after a page or two of alternate implementations, boil down to simply `use a module', i.e. zero lines of code. Slightly more complex patterns such as Visitor, are only a few lines. It is still useful to discuss and name patterns, but on the whole reference implementations are so trivial as to be unnecessary, except perhaps as the most concise and precise method of illustration.

The book overall, then, is a grab-bag of different topics. Each chapter could clearly be expanded into one or more whole books. As a result, no part can be covered in very great depth, but Tarek does an admirable job of getting the reader up to speed enough in each area that they can be self-sufficient and direct their own learning from that point.

It's worth noting the the book is based on Python 2.x, buy because of the high-level approach, this scarcely matters. Get a different book if you need to know about the language syntax and features. Get this to find out how to create and distribute Python projects.

As as result of the broad scope of the book it serves as a brilliant annotated laundry list of `things the Python developer ought to know'. While there will doubtlessly be some sections that you are already deeply familiar with, if you have any interest in discovering your own deficiencies as a Python programmer, I can highly recommend it.


Page: 1