Profile for J. Hartley > Reviews

Personal Profile

Content by J. Hartley
Top Reviewer Ranking: 555,703
Helpful Votes: 34

Learn more about Your Profile.

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

Show:  
Page: 1
pixel
Classic Bike Horn
Classic Bike Horn
Offered by Laxzoltd
Price: 4.49

2.0 out of 5 stars Good at first, but broke after 4 months., 10 Mar 2014
Verified Purchase(What is this?)
This review is from: Classic Bike Horn (Toy)
Was initially good, but then broke after four months of occasional light use. Now no longer makes any sound, couldn't repair it, have thrown it away.


Logitech M505 Wireless Mouse - Silver
Logitech M505 Wireless Mouse - Silver
Offered by Empire Group
Price: 49.99

2.0 out of 5 stars sloppy inaccurate cursor movement, 21 April 2012
Verified Purchase(What is this?)
Impressed by the reviews, I bought two (for home and work) and I've found that the accuracy of the cursor movement is significantly affected by how close the sensor is to the mouse. 12 inches is less accurate than six. Even when very close, this mouse is produces imprecise cursor movements. For example, carefully moving a single-pixel in any direction is barely possible, but is easy with my unbranded alienware mouse the came with the PC. As a result I find this mouse annoying to use on the desktop, and disheartening for gaming. Having only bought these a couple of months ago, I'm now going to buy a replacement. :-(


Invent Your Own Computer Games With Python
Invent Your Own Computer Games With Python
by Al Sweigart
Edition: Paperback
Price: 13.32

12 of 12 people found the following review helpful
5.0 out of 5 stars Brilliant for learning how to write your own games, 16 May 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.

Incidentally, Python is a hot language that is used by many professional software developers, so this is a very useful and relevant first language to learn.

Inspirational and brilliant.


OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2.1
OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2.1
by OpenGL Architecture Review Board
Edition: Paperback
Price: 42.99

4 of 4 people found the following review helpful
3.0 out of 5 stars Covers every aspect of OpenGL - in theory, 13 May 2009
Verified Purchase(What is this?)
Written by none other than the OpenGL architecture review board themselves, this is the de facto starting point for anyone learning how to write programs to draw computer graphics using the OpenGL graphics API. As such, the entire breadth of OpenGL is described in these 800 weighty pages.

This comes with one or two questionable implications. Firstly, the authors, being the authoritative source, are obliged to cover the entirety of the OpenGL interface, even though portions of it are now obsolete, having been supplanted in practice by newer techniques. The older methods are still present, and are described here on an equal footing with the later additions.

Similarly, to avoid getting embroiled in the idiosyncrasies of any particular vendor's implementation of OpenGL, there is never more than an occasional vague allusion to the potential performance implications of using one approach over another. The concept of using vertex arrays is covered in a general-principles sort of way, as are vertex buffer objects, with the admonition to "prefer them over explicit calls to glVertex() for performance" buried in a single sentence in an appendix-like chapter near the end. The idea that rendering primitives of GL_TRIANGLES is heavily optimised on modern graphics cards receives no mention, from which I mistakenly inferred that other primitive types, such as GL_TRIANGLE_STRIPs, with their lower apparent vertex counts, are a preferable alternative.

This egalitarian presentation means that the book can rightly claim to be an unbiased description of OpenGL the interface, and is lent a long-term relevance by giving no bias towards any particular vendor, nor being subject to the fashions of rendering techniques that sweep through the industry every few years. On the other hand, it also means that the book is considerably larger than most people learning OpenGL will need, and fails to cover many of the vastly performance-enhancing techniques that have become standard throughout the industry.


Expert Python Programming
Expert Python Programming
by Tarek Ziad
Edition: Paperback
Price: 27.15

10 of 10 people found the following review helpful
4.0 out of 5 stars Made concrete improvements to the way I work with Python every day, 11 Jan 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.


Halting State
Halting State
by Charles Stross
Edition: Paperback

8 of 17 people found the following review helpful
1.0 out of 5 stars Painful, even for an ardent sci-fi and videogaming fan, 27 Sep 2008
This review is from: Halting State (Paperback)
I really loved Accelerando, also by Stross, so it was a disappointment to find Halting State to be parochial and dated. With a finale which actually involves one of the protagonists having to play an MMO (online game) session upon the outcome of which hangs serious real-world consequences, the future of the free world, yada yada. Just embarrassing.
Comment Comments (2) | Permalink | Most recent comment: May 11, 2011 3:17 PM BST


Page: 1