jQuery 1.3 with PHP

This is the first book sent to me from Packt where I wasn’t left dizzy from trying to understand just what it is the author was trying to get across. It looks like their proof-reader was awake for this one – totally awesome.

jQuery, as the vast majority of us already know, is a JavaScript library that simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development. In other words it does all the heavy lifting and takes care of cross-browser compatibility issues so you don’t have to and thus allows you to focus on the work that you need to do without all those distractions.

“jQuery 1.3 with PHP” is aimed “for PHP application developers who want to improve their user interfaces through jQuery’s capabilities and responsiveness”. Over the course of ten chapters Verens starts the off with an introduction, then a series of ‘Quick Tricks’ that almost immediately help you add some measure of “Web 2.0″ functionality to what I’d term a “web 0.2 application” rather sharply.
The book ends with a chapter on Optimization – some of which you are bound to already know and some which are complete gems.

In the middle are chapters with mini-projects on tabs and accordians, forms and form validation, file management, calendars (and how to make your own google-calendar-like application), image manipulation, drag and drop and data tables.
In each case, projects are analysed and the required steps for each are outlined in the simplest terms – no extraneous buzzwords are used or are the projects over-analysed for the sake of pedantry.

I was a little surprised in some places where, for example, the json encoded output was not created via json_encode; but then thought not everyone is going to have PHP 5.2 or greater installed. Thumb forward a few pages and this is mentioned. So all’s o k.

It was good to see Kae suggesting use of the PEAR Validate package (or similar) in the Forms and Forms Validation chapter (chapter 4). I had to wonder if there was a PEAR package for creating and shunting down jQuery validation rules to the client – and found that there isn’t. That’s something to consider for later on, I guess.

The rest of the book is similarly both easy to read and easy to understand – my first port of call for learning how to do something that I’d almost term exotic with jQuery and with PHP in the background is usually Google but that is going to change (actually it already has).

Honestly, I wouldn’t be surprised if this books working title was “JQuery and PHP: The HowTo” – it is that good.
Now, this book is not for learning jQuery – that is not within its remit, but I would heartily recomend “jQuery 1.3 with PHP” by Kae Verens to anyone wanting to utilise jQuery from a PHP background.

A few weeks ago I received a copy of “PHP Team Development” from Packt.
Split into seven chapters, all equally sprinkled with phrases that are disjointly written and that don’t get a point across, and some that make you think the book was written using some speech-to-text software (“Vendor locking” anybody?) , this book which “is for PHP developers who work in teams on complex projects” has given me an aversion to seeing three little words printed alongside each other (“the PHP code”).
If you have read this book you too will develop this aversion. I think Lorna Jane Mitchell and Brandon Savage who both bravely reviewed this book before me might be inclined to agree.

Published only in September of this year, I found it surprising that its section on coding standards and best practices does not suggest the use of phpCodeSniffer (for checking the adherence to coding standards, and which, incidentally, has been available in one form or the next for the last three years). Nor does Samisa suggest the use of phpUnit or SimpleTest for unit testing (Actually, nothing is mentioned for unit testing – the concept isn’t even described, nor is Test Driven Development). These tools have been around for a very long time and I was honestly startled by their ommission.

In a way that’s fine – these are only tools and the book is about team development – not about listing and reviewing each and every tool that could be used to help team members make more efficient use of their time.
But I’d rather use these tools during peer review to help highlight what a team member may be doing wrong in an efficient use of my time, than have to analyse the code myself.

So, moving on, there’s a section explaining that frameworks should also be assessed on the basis of the various open source licenses they are distributed under but the author doesn’t really explain why this is important – or discuss what the prevalent FLOSS licences are (MIT, BSD, GPL etc), or what issues they each attempt to address and what they are best suited for.

The NIH (Not Invented Here) Syndrome is mentioned and to be fair the author does give a long list of frameworks to be considered; probably the one detailed list in the book, to be honest.

PEAR had been mentioned in passing elsewhere in the book so I was expecting it to be listed in the frameworks section too, as I was expecting ezComponents to be referenced somewhere as well – but then, these are a component framework/libraries so perhaps he thought it did not belong in such a list.

To be honest, I think that is part of the problem. The book focuses on what the author thinks and his thoughts on the subject are written in such a manner, that once you put in the immense effort in trying to understand what he is attempting to communicate, that you are left with the impression that
there are no alternatives; that X & Y & Z are the true and tested ways of doing things in PHP and there are no two ways about it.

This is a complete shame.

Some other observances about this book;

• Continuous Integration is mentioned; but CruiseControl and PHP-Under-Control are not.
• Source Code Control is mentioned, and here Subversion and GIT are covered. CVS is mentioned elsewhere, under a section, and chapter, far-far-away. Mercurial, bazaar and others don’t even get a look-in.
• There is no mention of how approaches to Team Development might vary depending on whether some team members might be working remotely, Pair Programming is barely mentioned let alone suggested as one way of ensuring that each team member is learning from the other and reviewing the code that his partner has written.
• Under issue- or bug-tracking, jira and bugzilla are mentioned as two popular bug tracking tools, and although Abeysinghe states “there are numerous tools that are available, both opensource and commercial for bug tracking”, no others are listed. Fogbugz, Mantis, RT, Trac, and plenty others get left by the wayside.
  Actually, I’m wrong. Sorry. Trac is mentioned – at the other end of the book; though not in the glossary or index.

I honestly considered giving up on reading this book and not writing this review. The book truly is that bad. The thought of someone paying out close to thirty euro for a book that I’d call poorly researched, badly proof-read, woefully incomplete, badly structured at worst and self-opinionated at best did force me to reconsider.

Nobody should spend close to thirty euro on a book and get so little in return.

So my oneliner opinion of PHP Team Development by Samisa Abeysinghe?
I’d seriously suggest you give it a miss – do something more meaningful with the money and buy bread to bring your team on a duck-feeding-mission.

In a clear non-patronising and concise manner the author explains to the reader just what Joomla is (a content management system), how to install, add content, administer, design templates and write extensions for it. He touches on SEO and covers the aspects of both deploying Joomla on Windows, Linux and Mac.
Done in a gentle manner with graceful explanations along the way, he explains everything in a clear manner: how to troubleshoot not being able to access the web or database servers and even mentioning the password system differs from version 4 to version 5 of mysql, for example.

There are a few points in the book that startled me however; Rahmel informs the reader in chapter three that if XAMPP is used as a means of installing the base requirements then certain security concerns need to be addressed. In chapter two he states PHP 4.3.10 as the lowest version required – I’m surprised that a later version of PHP 4 wasn’t recommended, even though 4.3.10 may be the lowest required version – version 4.4.10 4.4.9 for example which is the very last version of PHP to ever be released. I hope this is just a typo that hadn’t been caught in time.
If it was not, then I’d have to express a certain level of professional disappointment; the security enhancements and bug fixes in PHP 4.4.10 should definitely have been enumerated. While it is true to say that most installs of Joomla are into shared hosting environments where such changes can not be implemented, I also would have expected the author to have mentioned that Apache, and by implication Joomla, performs better when configuration directives are specified in the httpd.conf files rather than .htaccess files which must first be scanned for at a directory-by-directory level.

I had been looking forward to reading the chapter on creating extensions (chapter thirteen) but was rather disappointed. I had expected Rahmel to go into much more depth, especially as the blurb on the back of the book mentions how he has coded other solutions from scratch in PHP and ASP, so surely there would be hard-learned tips and some advice that he could share? Instead he hardly mentions the Joomla API nor does he provide a reference or link to where further information on the subject could be found.

I would like to say that the second edition of “Beginning Joomla!” is well rounded but the lack of detail on creating extensions and the differing levels of detail regarding security and performance tips makes me shy from saying that.

Also, I do wish that there was a list of recommended reading and a glossary in the book too – it is invaluable to have a “cheat sheet” of what different terms mean and also to know what other bodies of work are available to help you learn more.

To summarise – “Beginning Jooma! Secong Edition” is a well-written book aimed at (surprise) people new to using Joomla – it just could be better and the section on developing plugins or components should simply be dropped as it is not adequate and probably could have an entire book devoted to the subject.

Aimed at web developers and designers with a basic understanding of HTML and CSS (and some level of comfort with Javascript), the later book is thicker than the original – it weights in at some 440 pages compared to the 360 pages that were required for the first. A new chapter, “Developing Plugins” covers how to write plugins for the framework and how to “share it with the world” – naming conventions, documentation style and other advice are included. There is also a new “Quick Reference” appendix which just begs to be reproduced in “Cheat-sheet” format for pinning up on your wall. Chapters already present in the earlier book are more detailed and read better.

The subject matter is expertly covered and unless you were aware of the changes in jQuery 1.3, compared to the older version that the original was focused it would be difficult to tell which portions of the book are new – the revision and updates to the original are seamless.

Quite rightly, Swedberg and Chaffer do not explain all differences between jQuery 1.3 and its predecessors – they rightly assume that if you’re reading “Learning JQuery 1.3″ then you don’t need to be informed of exactly how jQuery 1.3 differs from the version they previous covered. The book flows better because of this and remains very easy to understand because of this approach.

There is no hint of the selector engine in 1.3 being any different than what was already covered. The language used for explaining the different concepts to the reader is more precise, especially so in the Events chapter and this makes understanding the concepts being covered much more easy – for this reason alone buying the revised edition is well worth the money.

The book doesn’t focus on new additions that were freshly added to jQuery 1.3 but also ones that had been added to jQuery since the first edition was published; JSONP, which was introduced in jQuery 1.2 is covered in the chapter on AJAX, as is the more low-level $.ajax() method; it also mentions which features have been removed from jQuery since the first edition was published – XPath being one such example. The listing of development tools has also been reworked, as has the Online Resources section. These listings mention resources that are current and up-to-date.

I remember mentioning in my review of the first book (trying hard not to use the word ‘original’ again!) that until a later edition of it was released that you wouldn’t be able to find a better book on the subject. I stand by that assertion – the only book that covers jQuery better than the first edition of “Learning jQuery” is the second edition of the same.

Here’s my review of it:

The book was published prior to Facebook’s facelift but this doesn’t really impact on the usefulness of the book.
An overview of FBML, FQL, FBJS (a restricted subset of JavaScript and enforced for security reasons) are given along with information on how to use the test consoles, publish to news feeds, some multimedia aspects of what can be done in Facebook applications and more.

Happily the book focuses on using PHP5 for developing Facebook Applications – while there are classes available for developing FB apps with PHP4 there really is no point in doing so; especially now that official support for PHP4 was withdrawn last month.
MySQL appears to be the database system of choice for the examples and Linux/Unix oriented solutions for scheduling tasks to occur regularly are given – some Windows screenshots feature in chapter one with regard to setting up the client libraries for local development but other than that everything else is unix-centric.

I found “Facebook Application Development” more useful than facebook’s own documentation with regard to the main aspects of developing a Facebook application – it is written well and easier to follow than the online documentation and while it is true to say that the Facebook Platform is evolving I am of the opinion that Heyder and Bain’s work will still be applicable for a long time.

As hinted in the title, this near 500 page tome is split into three parts: objects, patterns and [best] practice.
The section on objects covers the basics and then the advanced features of object oriented facilities in PHP and tools such as namespaces, autoloading and the reflection classes along with design basics, class scope, encapsulation, polymorphism and some UML.
The patterns section is obviously inspired by “The Gang of Four” (Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides) and covers what design patterns are, enterprise patterns, database patterns and also the basic patterns such as the factory, fascade, decorator and composite patterns along with a few more. This section is far from comprehensive, but is a good start. (If Patterns do interest you, and they should, have a look at patternsforphp.com)
The last section, focuses on PEAR (including writing your own packages and setting up your own PEAR channel), phpDocumentor, unit testing with phpUnit, version control with CVS (which struck me as a bit odd – I had expected subversion to be covered either instead of or along with CVS) and setting up automated builds with phing.

While being an easy read, this is a well written, serious book and is aimed squarely at enterprise-level developers and software engineers who make their living through the development and architecture of solutions developed in PHP.
Any PHP developer wishing to improve his skills should get a copy.

UML is a standardized visual specification language for object modeling and is short for “Unified Modeling Language” that includes a graphical notation used to create an abstract model of a system, referred to as a UML model. There are many software tools available which can be used for code generation and reverse engineering, such as the new PEAR package PHP_UML which generates a UML representation of existing PHP source code.

This book assumes no prior knowledge of UML and this works very well. It is by no means comprehensive but that it’s what the authors set out to write – this book is focused on being a practical tutorial for learning the essentials of modelling business systems, IT systems and systems integration – no more, no less. It does this admirably and I’ll recommend this book as a reference and introduction for developers performing system analysis and design activities.

This book on phpMyAdmin is written by Marc Delisle, one of the core developers of the application which I think just about any software developer utilising MySQL has dabbled with at the least. I can honestly say that anyone that experimented with phpMyAdmin before reading this book will use it much more thoroughly and more productively afterwards.

This is a well written, easily read, book that is fully comprehensive regarding how to use phpMyAdmin for both casually inserting and maintaining data in a mysql database; checking queries before utilising them in your code; data transformations; and actual database and user administration, such as changing the structure of your databases, collations, creating system documentation, assigning privileges and more.

I scarcely believe this book could be much more detailed, especially as it often has more than two screen shots per page – it is no wonder that I now know much more of what phpMyAdmin is capable of!

The troubleshooting chapter at the back seems invaluable and the chapter covering MySQL 5 additions seems a useful refresher for those of us that may need to be reminded of new functionality present only in that more recent version of MySQL, and after reading this book I fully expect that I shall be using phpmyadmin more and not using either the MySQL Query Browser or Oracle’s SQL Developer as much.

The blurb on the back of the book says that it is for every serious phpMyAdmin user who would like to use this outstanding application to its full power – after reading it I am very much inclined to agree and would recommend it to anyone that uses phpMyAdmin on a daily basis.

If I hadn’t read in the Author’s Profile at the start of the book that Hasin is from Bangladesh, and that English is in all likelihood not his first/native language, I would have realised that he does not have a fluent grasp of the English language anyway and this detracts from being able to focus on what he is trying to communicate.

Putting the aspects of Hayder’s grasp of the English language aside, the book is rather good as an introduction to the various technologies that it covers. If you’re already up to speed with OOP then you mightn’t want to bother with the first few chapters; but after that the book covers phpunit testing, design patterns (Hayder uses the Patterns chapter to introduce MVC and later devotes an entire chapter to it), SPL and PDO.

I got a stunning feeling of deja vu when reading the main OOP chapter: it seemed very reminiscent of the online php manual and user contributed notes at php.net – a resource which Hayder makes the occasional reference to.

The book’s section on phpunit testing is rather good as an introduction to that concept; though it does conclude with ten pages of text from the PHPUnit Pocket Guide by Sebastian Bergmann. I have to question the rationale behind this: PPG is available freely online and I think mentioning the website for that version of the book would have been a better thing to do.

I think I will definitely be picking this book up rather often for reference and that it is worth the money (that I admittedly didn’t have to pay).
But what would I do to make the book even better than it already is?

1. I was expecting some coverage of UML for representing classes and interactions between them – not a lot but just enough to be useful.
2. Avoid mentioning topics that are outside the scope of the book – it makes the content appear weak and less comprehensive than it is. I’d simply have a “recommended reading” section or appendix at the end of the book.
3. This may seem petty but it’s actually quite important, especially as regards the environment – don’t place braces in the example code on seperate lines. It doesn’t matter as much when on screen but when printed out that’s a lot of wasted paper/trees.

Similar in size to the PEAR Installer Manifesto, this book weighs in at 240 pages, is aimed at developers new to CodeIgniter, and is split into 15 chapters:

1. Introduction to CodeIgniter
2. Two Minute’s Work: Setting up a CodeIgniter Site
3. Navigating your site
4. Using CI to Simplify Databases
5. Simplifying HTML Pages and Forms
6. Simplifying Sessions and Security
7. CodeIgniter and Objects
8. Using CI to Test Code
9. Using CI to Communicate
10. How CI Helps to Provide Dynamic Information
11. Using CI to Handle Files and Images
12. Production Versions, Updates, and Big Decisions
13. Instant CRUD – or putting it all together
14. The Verdict On CI
15. Resources and Extensions

Chapter one is a bare-bones introduction to what CodeIgniter is and why it was initially developed.
Chapter two details how to set up an initial site with CodeIgniter.
Chapter three introduces the reader to the concept of the MVC pattern, what it is about and how CodeIgniter implements it.
Chapter four details the ActiveRecord class for interacting with databases.
Chapter five shows the reader how to specify a View, how to nest them for better reuse and demonstrates CodeIgniter’s Validation class.
Chapter six is about session management and securing applications.
Chapter seven, if the reader requires a refresher, explains Object Oriented Programming and through some examples shows that CodeIgniter does not take advantage of PHP5′s enhancements in that regard. It also looks at the object model in CodeIgniter.
Chapter eight details how to perform unit tests, benchmarking, profiling and how to use mock database objects for test purposes.
Chapter nine is about various machine-to-machine communications: FTP, mail and using xml-rpc for providing webservices.
Chapter ten focuses on internationalization, caching and string manipulation.
Chapter eleven is about file uploads, downloads, compression and image manipulation.
Chapter twelve discusses various topics relevant to migrating your code from your development servers to production.
Chapter thirteen details CRUD operations in CodeIgniter.
Chapter fourteen takes an objective look at what the book has covered as regards CodeIgniter’s abilities and what the author chose to not cover – one admitted omission is a lack of focus on AJAX.
Chapter fifteen, the last one, provides a list of resources and extensions that the dear reader will want to investigate. These include, but are not limited to, graphing and AJAX classes, methods of authentication and CRUD libraries.

The book is written well and the inevitable – yet thankfully small – number of spelling and grammar mistakes in the books don’t detract from the book as much as in the SOA one. I got the impression while reading chapter eleven that the author is not particularly knowledgeable about file permissions on linux/unix and specifies the most permissive options for those platforms which is a bit worrying.
I was amused to find the book “PHP Programming with PEAR” gets a mention in the “Resources and Extensions” chapter, more so because CodeIgniter seems to be a framework that has a chronic case of “Not-Invented-Here” syndrome and attacks the PEAR framework on the main page of it’s website and userguide.

All in all, I found the book to be a straight-forward, educational read and that it works very well alongside the CodeIgniter online documentation.
Well worth the read if you are new to CodeIgniter.
Addendum: Kae asked if reading this book might make me inclined to use CodeIgniter; while I found it very interesting I was also shocked that there is no inclination of embracing and utilising PHP5 enhancements and the chronic NIH present in the framework makes me feel very reluctant to use CodeIgniter. There is a spin-off or fork of CodeIgniter called Kohana that takes advantage of PHP5. It may well be worth investigating.