Tales of Coding

Select Advanced Ajax chapters released under Creative Commons

2009-11-15T12:50:00.000-08:00

So with many thanks to my agent David Fugate and Debra Williams-Cauley at Prentice Hall, I have posted four chapters of Advanced Ajax to archive.org under the Creative Commons Attribution-Noncommercial-Share Alike license!

I picked these chapters to set free for two main reasons: 1) I think they can prove the most helpful to the largest number of web developers, and; 2) they could also use the most attention in getting updated to include developments since I first wrote them years ago.

In releasing these under a license that permits remixing/adapting, I also hope to adapt these chapters to use other technologies. One note that I have seen echoed across reviews: this book has a heavy PHP leaning. As such, I've made plans with a GWT enthusiast to start work immediately on a GWT version of Chapter 3: Client-side Application Architecture, which should also give people more of an idea of how I think these adaptations can work.

Random note: I recently received a few copies of my book translated into both Hungarian and Polish. While I want to hang onto one of each for the novelty of it, anyone in the Austin area who reads one of those languages please feel free to get in touch and I'll gladly give one to you in exchange for feedback on how well the translation works.

WebKit CSS Animation behavior weirdness

2009-02-26T19:08:00.000-08:00

Okay, not weirdness. I guess more like (up until now) undocumented behavior. Due to a workaround that I needed to implement in order to properly clear out CSS properties when starting a new transition in my hacked-out S5 presentation, I filed Bug 23528: CSS transitions on opacity fail when used with visibility in certain circumstances.

When performing a transition, I had expected that a function like the following (simplified for demonstration) would work:

/**
 * 1. take the element,
 * 2. make it visible,
 * 3. yet transparent,
 * 4. then set the transition,
 * 5. and then have it fade from opacity of 0 to 1 over one second.
 */
function fadeIn() {
    // <span id="one" style="visibility: hidden;">testing</span>
    var theOne = document.getElementById("one");
    theOne.style.visibility = "visible";
    theOne.style.opacity = 0;
    theOne.style.WebkitTransition = "all 1s ease-in-out";
    theOne.style.opacity = 1;
}

Instead of fading in over one second, the span instantly appears, as if the last three lines of the function didn't even exist. This happens because CSS changes don't take effect when you assign new values. They queue up, taking effect once the JavaScript thread of execution ends. This makes sense for static changes, so that if you have a whole load of changes to apply to the DOM where many of the changes end up canceling out by the time the thread ends, the browser has no reason to apply each one of them to the DOM just in order to remove the change in the end. It also makes sense in a pure performance sense, since this keeps the JavaScript execution moving along at a nice, steady pace, rather than having to wait for the DOM to apply the change before moving on to the next step in the process.

Unfortunately for the code example above, it means that since the DOM node starts out completely opaque, the last three lines of the fadeIn function do effectively fall off and the span simply becomes visible. In order to get around this, the last couple of lines have to run on a different JavaScript "thread" so that it splits up the batched DOM changes into two parts and the node properly fades in:

function fadeIn() {
    // <span id="one" style="visibility: hidden;">testing</span>
    var theOne = document.getElementById("one");
    theOne.style.visibility = "visible";
    theOne.style.opacity = 0;
    setTimeout(function() {
        theOne.style.WebkitTransition = "all 1s ease-in-out";
        theOne.style.opacity = 1;
    }, 0);
}

Proposal in for IPC 2009

2009-02-20T14:19:00.000-08:00

I should hear back within a couple of weeks as to whether I'll need to start learning some basic German before heading to Berlin at the end of May. I just made the deadline for the International PHP Conference' call for papers, basically to give the "Digging Through the Guts of Enterprise PHP" talk, albeit reworked based on how it went at the Zend/PHP Conference last September.

Macworld

2009-01-04T20:36:00.000-08:00

Anyone heading to Macworld this week, should feel free to swing by booth 3418 in the North Hall and say hello! I attend in order to demo and talk about IBM Rational Build Forge to and with anyone interested. It may seem like an odd thing to demo at Macworld, but I have prepared things especially for showing off in MacOS 10.5, which I use on both my own personal machine and my work machine.

Enterprise Guts slides up, with CSS animations

2008-11-29T20:59:00.000-08:00

I just realized that I didn't post the final version of my slides from my talk at ZendCon, but now I have: Digging Through the Guts of Enterprise PHP. However, they will only work in Safari, since I hacked CSS transitions into S5. Different builds of WebKit (and different releases of Safari) will have varying degrees of support for everything used in there (sliding, fading, and flipping). For the talk itself, I ended up having to go back a couple of weeks in the WebKit builds, since they broke a few things... Part of the fun of using experimental technology in a nightly build, though.

As a bonus, this means that the slides (mostly) work in the iPhone/iPod Touch version of Safari:

Due to how S5 triggers moving to the next slide, you just need to bring up the control bar at the bottom so you can tap on the arrows to move forward. In the last bit there, the animation of two simultaneous transforms, flipping the slides around, caused what we software engineers refer to as a "rendering freak out" followed by mobile Safari freezing up. All in due time!

OLPC G1G1

2008-11-17T09:23:00.000-08:00

Having taken part in the first round of OLPC's G1G1, I can definitely say that these things make fantastic ultra-portable machines. Since they run Redhat-based Linux (which you can of course replace with Debian if you prefer, or just replace the UI), you can easily install everything from FreeDoom to Apache HTTPD Server. In short order, I installed subversion, Apache HTTPD Server, PHP5, and MySQL (Vim and SSH come preinstalled). Since they designed these things for kids to carry to school through everything from rain storms to sand storms, they'll out-rugged anything else even remotely like it.

Or, you can give it to someone you know who can get use out of the myriad of Activities it includes for kids to learn everything from reading and writing to programming to music.

Either way, Go give one.

Opera may have just found what it needed

2008-10-09T23:12:00.000-07:00

Today, the Opera Desktop Team and Jon Hicks both announced Jon's joining Opera as Senior Designer! This comes as very exciting news to someone who has had to continually add "...and Opera." to many browser discussions here in the States, even among fellow developers.

Jon's biggest challenge (and advantage) will, in my opinion, come in the form of making Opera approachable and continually usable to new users, without hiding its power from them. I definitely wish the both of them the best of luck, and eagerly wait to see what happens next.

Power Failure + Road Trip = Fail

2008-10-02T22:13:00.001-07:00

Well, that sucked. Back on a normal hosting service...backup power supplies work much better when outages only last a matter of seconds.

S5 with CSS Slide Transitions in WebKit

2008-09-02T07:23:00.000-07:00

So, in an effort to have the ability to post my slides for my Zend/PHP Conference talk online without having to rely on Flash or typically awkward HTML exports from other formats, I've decided to go with S5, as mentioned previously. I've also decided to add a little of WebKit's recent additions of CSS transforms and animation support for transitions.

Since CSS CSS animation only occurs when attributes change, it just means that the current and next slides need to have the changes applied at different times, or at the same time, depending. To make managing these things easier, I started with a base object:

function Transition() { }
Transition.prototype = {
 "duration" : 1,
 "cslide" : null,
 "nslide" : null,
 "transition" : function(toggle) {
  this.cslide.style.WebkitTransition =
   this.nslide.style.WebkitTransition =
    (toggle
     ? 'all ' + this.duration + 's ease-in-out'
     : 'all 0s none');
 },
 "prepare" : function() { },
 "perform" : function() { },
 "cleanup" : function() { },
 "run" : function(cid, nid) {
  this.cslide = document.getElementById(cid);
  this.nslide = document.getElementById(nid);
  this.cslide.style.visibility = this.nslide.style.visibility = 'visible';
  this.transition(false);
  this.prepare();
  var dis = this;
  setTimeout(function() {
   dis.transition(true);
   setTimeout(function() { dis.perform.apply(dis); }, 0);
  }, 0);
  setTimeout(function() {
   dis.transition(false);
   dis.cslide.style.visibility = 'hidden';
   dis.cleanup.apply(dis);
  }, dis.duration * 1000);
 }
}

The code managing the switch of the slides now calls RunTransition(transitions[snum], cid, nid);, where transitions just holds an array of constructor references corresponding to the slide numbers (snum):

var transitions = [
 null,
 Fade,
 Wipe,
 Rotate,
 Rotate,
 Fade
]

function RunTransition(className, cid, nid) {
 var trans = new className();
 trans.run.call(trans, cid, nid);
}

Each transition just extends Transition and overrides the applicable methods in order to change the slide CSS properties at the correct time, like this Fade transition:

function Fade() { }
Fade.prototype = new Transition;
Fade.prototype.prepare = function() {
 this.cslide.style.opacity = '1';
 this.nslide.style.opacity = '0';
}
Fade.prototype.perform = function() {
 this.cslide.style.opacity = '0';
 this.nslide.style.opacity = '1';
}

I've uploaded a very quick demo of the transitions in action, which will work in whichever builds of WebKit support CSS transforms and animation. It worked a bit smoother in WebKit builds a few weeks ago than those current (bugs galore at the moment), but nightly builds always tend introduce unpredictable behavior.

Update (1/25): Between fixes in the WebKit trunk since this post, and fixes in my code (with many thanks to smfr in comments and on the bug itself), all of the transitions work in the current Webkit nightly! From my final note, just in case anyone else has issues with transforms when used with transformations:

"If you set the WebkitTransform using just matrix() in the first step, then set the WebkitTransition, then set the WebkitTransform using both matrix and scale, it (reasonably) will not apply the transformation. When I set both both functions for the start and end styles, it works beautifully."

Google launching open source browser based on WebKit?

2008-09-01T11:59:00.000-07:00

No idea whether this theory holds any water, but given the recent speculation hitting...everywhere, I checked http://code.google.com/p/chrome/ and found a login screen (quickly followed by a permission denied error), rather than a Not Found error for a project that doesn't exist.

Wondering what this will bring to WebKit that Safari doesn't (aside from Gears and even-more-targeted advertising), but I guess we'll see soon enough.

Edited to add: the more I read about this, the more it looks like they ported a bunch of features from Opera (tabs above window chrome, long-running scripts' threads not killing your browser, Speed Dial-like default page, etc.) to a WebKit-based browser with what sounds like XUL for the window chrome itself. I guess tomorrow we'll find out for sure, but it seems a bit odd that an open source project would outright deny access to the public before launch, and distribute the info under the most closed-minded CC license available (feel free to share it, just don't touch it, don't charge for it, and you'd better tell people who made it). I suppose after the recent Android SDK excitement, this still makes a decent step forward, but still. I guess so long as it takes market share away from IE, I shouldn't complain too much.

Target to pay out $6M and have quarterly/annual accessibility tests

2008-08-27T17:50:00.000-07:00

Found via Glenda the Good, this marks a huge milestone in moving from infrequently enforced laws regarding government sites to making sites and web applications of private entities accessible to the general public.

"As part of the settlement, Target will establish a $6 million fund from which members of the California settlement class can make claims. In addition, the National Federation of the Blind will certify the Target Web site through its Nonvisual Accessibility Web Certification program once agreed upon improvements are completed in early 2009. Target and NFB have agreed to a three-year relationship during which NFB will perform accessibility testing of the Target Web site. For more information about the terms of the settlement, please visit www.nfbtargetlawsuit.com."

The $6,000,000 fund doled out to those who file claims will draw attention to this, but to me the (comparatively) rapid compliance and ongoing tests make this worthwhile. Target won't just throw money at the issue, but will make its site accessible to those using assistive technologies, and maintain that for at least three years following!

Zend DevZone book review

2008-08-26T20:14:00.000-07:00

Cal Evans of Zend just posted a shining review of Advanced Ajax!

It’s not often that I review a book that is a year old for several reasons. The main reason is that technology changes so fast. In this day and age a book 12 months old usually contains out dated information. As with any good rule, there are exemptions, this book is one of them.
Having said that let me lay out a warning, “Advanced Ajax” means what it says, it is an advanced book. If you are a web designer who has just completed “Learn JavaScript in One Week” then you do not want to buy this book. Go play with the other crayons and come back when you’ve got a few years experience under your belt. This book is for those developers that already know what a pain it is to develop using JavaScript and love it anyhow. If you’ve already busted one flat-screen by banging your head on it because “the code should work!” then you are ready for this book.

Read the rest of the review.

Books to give away during my ZendCon08 talk!

2008-08-10T01:08:00.000-07:00

In order to bribe more people to attend my talk at ZendCon08, my publisher has sent me three copies of my book to give away! I haven't quite figured out how to dole them out yet, or even have any idea how many people will attend the talk and want a copy, but I'll figure something out.

I think for the talk, I'll use a modified S5 theme I have in-progress using Safari's new CSS transforms and animation support for transitions. I'll post some examples of that as I make it ready for the talk, since I can't really post the content of my talk until I get the go-ahead from those who give it at IBM. The talk centers around looking at source code from work, and I'd rather not upset IBM's Higher Powers by exposing even part of the product without explicit permission...

W3C recently posts updated docs on relationship between usability and accessibility

2008-07-07T18:40:00.000-07:00

The W3C posted an update to the Relationship between Mobile Web Best Practices (MWBP) and Web Content Accessibility Guidelines (WCAG), something which I (for some reason) don't remember seeing go by in January when they posted the initial draft.

Work like this means a great deal to web developers who promote accessibility, as most people regard accessibility as little more than a drain or a checkbox on a compliance to-do list. The MWBP and WCAG relationship guidelines look at the similarities in issues and solutions found in each working group, providing a comprehensive list of direct connections between accessibility and usability. Until seeing this work, I have had little reference material to offer those who questioned my (and others') relentless insisting that they should use accessible markup and scripting in order to make their web applications both accessible and more usable in one fell swoop. All efforts had previously resulted in spontaneous lectures at the nearest machine where I could demonstrate examples, and (more recently) Chapter 1: Usability and Chapter 2: Accessibility in Advanced Ajax: Architectures and Best Practices.

The current MWBP and WCAG relationship guidelines have the following in-progress sections available, which will all prove exceedingly useful to web developers and designers, especially for those learning about one side of this after implementing the other:

These sections cover specific examples of matching mobile web usability issues with accessibility issues, ranging from color contrast requirements (...unfavorable ambient light and the ability of devices to display contrasting color at all, while users may have color blindness and color perception deficits...) to the fact that large amounts of dry text becomes equally unreadable for those with attention deficit related disabilities to those with postage stamp-sized screen. Anyone who had clicked impatiently through an EULA displayed in a one-inch textarea knows the latter of these two quick examples all too well.

For a quick introduction to the correlation between web accessibility mobile web usability, the WAI has posted Web Content Accessibility and Mobile Web: Making a Web Site Accessible Both for People with Disabilities and for Mobile Devices as part of their Implementation Plan for Web Accessibility.

Proposal accepted for ZendCon08

2008-06-12T12:12:00.000-07:00

My proposal "Digging Through the Guts of Enterprise PHP: A Case Study," which looks at PHP usage, techniques, and features as used at my day job at IBM, got accepted for the Zend/PHP Conference and EXPO 2008!

An exploration of the features of PHP used in the Ajax-driven user interface of IBM Rational Build Forge, with a focus on inheritance, interfaces, and Iterators. This talk will demonstrate how we built its user interface on a solid foundation of PHP.

I submitted it shortly after the call for papers opened up and this year, I got in. I've never spoken at a conference before, but it'll at least make for an interesting (and hopefully even successful) experience.

I couldn't resist one named "Tendrils"

2008-06-02T17:50:00.000-07:00

While setting up the most recent addition to the house (my wife's new hi-res 17" MacBook Pro), I had a little time during Windows' installation into its VMWare image, so I took a look through some more of the visualizations. I saw this one, and ported it to JavaScript, adding a few lines to animate it:

I recommend sticking to a low number of tendrils (especially in Opera, which gets choppy rather quickly), or the non-animated version.

Based on Tendrils, Created by Tom De Smedt (which Tom based on the "Tendrils" algorithm by ART+COM).

Fun with visualizations

2008-05-31T17:12:00.000-07:00

Looking through MacResearch, I saw NodeBox, "...a Mac OS X application that lets you create 2D visuals (static, animated or interactive) using Python programming code and export them as a PDF or a QuickTime movie." A bit of a hobbyist math geek, I checked it out a bit and realized that a lot of the Python source code used with NodeBox looks rather similar to JavaScript interacting with the canvas HTML5 element.

So I took a few and wrote a quick library to behave similarly to NodeBox, albeit for JavaScript to run in a browser. I just looked at the parametric equation examples for something easy to start off with, and wrote a few examples. The first, extremely simple example more or less just draws a circle within certain bounds:

function CircleEquation(dt, steps, r) {
 Frozen.Chart.Equation.call(this, steps, dt);
 this.r = r;
}
CircleEquation.prototype = new Frozen.Chart.Equation;
CircleEquation.prototype.next = function() {
 this.x = Math.cos(this.t) * this.r;
 this.y = Math.sin(this.t) * this.r;
 return Frozen.Chart.Equation.prototype.next.apply(this);
};

function circleTest1() {
 chart.clear();
 chart.map.lineWidth = 0.5;
 chart.renderEquation(new CircleEquation(4.5, 75, 95));
}

This results in the following visualization:

You can see it in action, along with a couple of slightly more interesting examples. NodeBox can do a lot more than simple charting, this part of its functionality just inspired a fun exercise in web+math geekery.

Opera Dragonfly (alpha) Released

2008-05-06T09:37:00.001-07:00

Over a year ago, I wrote about the Opera Developer Console. This morning (for me, at any rate), Opera posted Dragonfly, which (two years in the making) offers a completely fresh look at browser-based debugging.

It offers most of the familiar tools for DOM inspection (along with a nice DOM editing capability), error logging (with the same granularity as before wrapped in a more polished UI), a JavaScript debugger that rivals WebKit's Drosera, a JavaScript thread logger, and a lot more that I haven't explored yet.

Time will tell whether Dragonfly can get enough developers to use Opera and keep them there, and how much the developers behind the new developer tools listen to the community in the coming iterations, but so far this looks extremely promising.

Edit: Chris Mills from Opera gave me some additional info:

Part of the reason I haven't found the XMLHttpRequest logger/debugger apparently stems from it not getting exposed yet, though it will appear in an upcoming iteration, along with HTTP header inspection (not just for XMLHttpRequests, of course) and a new "single window mode" which sounds like it will make things much more usable! When using Safari's inspector, I almost always find myself attaching it to the window, and I always had the urge to do the same with Opera's developer console.

Chris also mentioned something which makes me very happy to hear: even though the Developer Tools (loaded via the Tools → Advanced → Developer Tools) download from Opera's server, it only does so the first time, and for each following update of the tools. This ensures that it not only saves Opera's servers when usage takes off, but it also ensures that developers can work offline, and the slow loading of the tools will only happen initially, loading from the local drive after installation.

Written in XML/CSS/JavaScript, Dragonfly will run in all browsers including Opera's Core-2.1 rendering engine (except Opera Mini for some reason), and even supports debugging on mobile devices by way of a proxy setup between the device and the desktop Dragonfly installation! This will prove invaluable for developers of web applications supporting devices, as they will have the ability to use their normal desktop tools to debug on the mobile browser without having to use emulation.

You can find more information in an Introduction to Opera Dragonfly and on the Opera Dragonfly product page (which has a very good start of fleshed-out documentation already, feedback and bugtracking, and of course a blog).

Edited to fix the Introduction to Opera Dragonfly link...

Heading to Google I/O at the end of the month

2008-05-05T19:26:00.000-07:00

As an added benefit of living in the Bay Area again, I get much easier access to many of the conferences and events that go on around Ajax/RIAs/etc. May 28-29, I'll take BART into the city in order to attend Google I/O, which looks extremely interesting. Somehow, in the short two days, I need to find my way to the sessions on design patterns, performance, HTML5, open source, and chase down some of the speakers and fellow developers to pick their brains for a bit. Fun!

History meme

2008-04-15T10:13:00.000-07:00

Indirectly tagged by Arve Bersvendsen's entry.

wollstonecraft:~ shawn$ history | awk '{a[$2]++ } END{for(i in a){print a[i] " " i}}'|sort -rn|head
85 screen
52 ssh
50 ls
44 vi
39 cd
36 svn
25 ping
20 telnet
16 cp
14 mv

I guess I reattach my screen session a lot. The telnet calls probably stem from checking the server once I got it up and running again, since the router had some issues letting everyone through for a while.

Part 2 of the Advanced Ajax review went up!

2008-04-05T16:32:00.000-07:00

In the midst of things, the second half of the review from Agile Ajax went up! It seems that despite the rather heavy use of PHP for the server-side example code, Brian (apparently more into ASP, JSP, and Ruby) still liked it, which makes me very happy.

Back in February, I reviewed the first half of Shawn M. Lauriat's "Advanced Ajax: Architecture and Best Practices" (Prentice Hall, 2008, 360p). The first four chapters of Lauriat's book, which focused almost exclusively on client-side technologies, impressed me considerably. But it's taken me several weeks to get through the remainder of the book, and there's one reason why: PHP.

The server-side portion of "Advanced Ajax" uses PHP code to illustrate its many and varied lessons about Ajax architecture. It's not that I have anything against the popular web-development framework and scripting language. It's just that, after spending my career in the ASP Classic and JSP trenches and slowly ramping up on Rails in the last year, I'm not the ideal target audience for these code samples. Adding "PHP" to the title of the book might have limited its potential audience, but it also would have been more accurate.

That said, there's a lot of value here for adherents of any server-side framework. Lauriat discusses each topic from a general perspective before diving into the code. The technical approach to a given problem would obviously differ by framework, but the high-level approach wouldn't. If you don't mind skimming past the content that doesn't apply to you, Lauriat's advice about developing stable, scalable, accessible and secure Ajax applications transcends framework allegiance.

Read the rest of the review.

Sidenote: On the Ajaxian post for the review (part 2), Joeri left a comment that really hit on what I tried for in writing the book, almost quoting what I told Prentice Hall when describing the type book I intended to write:

I’ve read this since the last review.
It does a pretty good job documenting the best practices when building ajax apps. This is a book to read when you want to move beyond knowing the basics of javascript and xmlhttp to building a real web app using ajax methods.

Thank you, Joeri! I feel glad knowing that people out there have read the book and gotten out of it something resembling what I had hoped they would.

No place like 67.102.65.250

2008-04-05T16:23:00.000-07:00

I haven't posted in a while, partly to figure out the details of, and then execute a move from Austin, TX to Oakland, CA. It made for a hell of a trip, but a successful one nonetheless. I still have my job with IBM, now working remotely and officially from my home office. From my desk chair, I can see the loading docks of the bay in the distance, and have already timed the trip from my favorite peanut sauce source to the house at a mere 15 minutes (with light traffic)!

The site(s) and email(s) went down during the move partly because of DNS issues that resulted in utter failure to move to the temporary hosting service, and partly because so much came up that needed handling in the last couple of weeks that I just had too many higher priority things to do. Speaking of which...back to unpacking!

Advanced Ajax (Kindle Edition)

2008-02-16T11:42:00.000-08:00

For those interested: Advanced Ajax (Kindle Edition) apparently went up on Amazon. I haven't met anyone yet who has a Kindle, but I imagine someone out there does! Hopefully lots of Ajax developers...

Vienna + PHP (source code) + iUI

2008-02-12T17:20:00.000-08:00

Source posted! BSD License. From the README:

You'll need to do a few things to get this working:

1. Move the extracted vienna directory to /Library/WebServer/Documents
2. Download iUI (http://code.google.com/p/iui/) and put the main iui directory into the extracted vienna/ directory
3a. Setup a cron job to copy ~/Library/Application Support/Vienna/messages.db to the extracted vienna/ directory
3b. For the adventurous: mv ~/Library/Application Support/Vienna/messages.db to the extracted vienna/ directory and sym-link it back to ~/Library/Application Support/Vienna/
4. Make sure to enable web sharing
5. Go to (your computer's name).local/vienna

Book review up on Agile Ajax

2008-02-12T16:05:00.000-08:00

Book review: Advanced Ajax by Lauriat (Part 1 of 2) went up earlier today (also linked to from Ajaxian), and so far Brian Dillard (RIA Evangelist @ pathfinder and project lead for Really Simple History) seems to like it:

Because Ajax moves so much application logic from the server to the client, it forces many developers to master a wider range of web technologies than ever before. To work effectively on Ajax projects, front-end developers have to concern themselves with database performance, business logic and other server-side concerns. Back-end and middleware developers, meanwhile, have to make friends with XHTML, CSS, JavaScript and a wide range of browsers. Sure, it's possible to develop Ajax apps in a siloed team environment. But it's not the easiest way, and it rarely provides the strongest results.

Shawn M. Lauriat's "Advanced Ajax: Architecture and Best Practices" (Prentice Hall, 2008, 360p) bridges the gap between developers with exclusive client- or server-side skills. By exploring tools, technologies and best practices for every layer of the Ajax programming model, this solid new programming manual promises to plug the holes in any developer's resume. Lauriat's tops-to-tails approach offers something for almost any developer, but it also guarantees most readers will find some sections remedial. As this two-part review will demonstrate, that's not necessarily a liability.

Read the full review