Go check out the release notes.

Related posts:

1. jQuery 1.4 Released
2. jQuery 1.3.1 Go For Launch
3. jQuery 1.4 Alpha 1 Released

View the release notes here: http://jquery14.com/day-01/jquery-14

Related posts:

1. jQuery 1.4.2 Released
2. jQuery 1.4 Alpha 1 Released
3. jQuery 1.4a2 (Alpha 2) Released

1.4 is slated for official launch on January 14th - how cute :)

Related posts:

1. jQuery 1.4 Alpha 1 Released
2. jQuery 1.3 Beta Testing
3. jQuery 1.4.2 Released

Most of the changes seem to revolve around heavy optimization of some core functionality. Installing this alpha and testing in live applications will help get this release out!

Related posts:

1. jQuery 1.4a2 (Alpha 2) Released
2. jQuery 1.4.2 Released
3. jQuery 1.4 Released

The Pragmatic Programmer: From Journeyman to Master

Write better, cleaner, more maintainable code. Learn how to manage your projects and focus on shipping your product. With insight that covers the gamut of software development from low level to management
this one is a must have for anyone involved in this industry.

The Passionate Programmer: Creating a Remarkable Career in Software Development

Highly recommended! Read my full review.

Code Complete: A Practical Handbook of Software Construction

Another classic "software construction" book. Sharpen your saw with timeless information that can be applied to any project in any language. Less bugs, more productivity, more programmer happiness.

Coders at Work

This one is different. Written as a set of interview transcripts with 15 legendary industry giants, this book is a fantastic insight into how some of the great minds think. It's inspiring to hear it from the source, must have!

Programming Clojure

A developer should learn at least one new language a year. This year that language should be Clojure. Clojure is a dynamic, general purpose, language targeting the Java virtual machine and designed for multi-threaded use. It's growing popularity, ability to leverage the Java standard library, and its multi-threaded nature make this a must have.

The Mythical Man-Month: Essays on Software Engineering

Another classic. Primarily discusses project management from the perspective of Fred Brooks and his experiences at IBM. Brooks' Law states that "adding manpower to a late software project makes it later".

Don't Make Me Think: A Common Sense Approach to Web Usability

Web developers should always keep in mind the user of the product their creating. Usability becomes increasingly important as applications move to the web. The design and usability of your app can make or break its success. This classic is a must read.

Design Patterns: Elements of Reusable Object-Oriented Software

This classic known most commonly as the "gang of four" book is the definitive reference on design patterns. Covering all of the most common cases and time and time again serving as an invaluable source of information.

Related posts:

1. Be Language Agnostic – Solve the Problem!
2. Deployment Using Capistrano / Webistrano via Rails / Phusion Passenger
3. Django 1.0 Template Development: Sample Chapter “Serving Multiple Templates”

"Long polling" is the name used to describe a technique which:

• An AJAX request is made (utilizing a javascript framework such as jQuery)
• The server waits for the data requested to be available, loops, and sleeps (your server-side PHP script)
• This loop repeats after data is returned to the client and processed (usually in your AJAX request's onComplete callback function)

This essentially simulates a continuous real-time stream from the client to the server. It can be more efficient than a regular polling technique because of the reduction in HTTP requests. You're not asking over and over and over again for new data - you ask once and wait for an answer. In most cases this reduces the latency in which data becomes available to your application.

There are a variety of use cases in which this technique can be handy. At the top of the list are real-time web-based chat applications. Each client executes a long polling loop for chat and user events (sign on/sign off/new message). Meebo is perhaps the greatest example of this.

It's important to note some of the server side technical limitations of long polling. Because connections remain open for considerably longer time than a typical HTTP request/response cycle you want your web server to be able to handle a large number of simultaneous connections. Apache isn't the best candidate for this type of situation. nginx and lighttpd are two lightweight web servers built from the ground up to handle a high volume of simultaneous connections. Both support the FastCGI interface and as such can be configured to support PHP. Again, Meebo uses lighttpd.

For similar reasons - it's also a good idea to choose a different sub-domain to handle long polling traffic. Because of client side browser limitations you don't want long polling connections interfering with regular HTTP traffic delivering page and media resources for your application.

Implementation

jQuery makes implementation a breeze.

var lpOnComplete = function(response) {
	alert(response);
	// do more processing
	lpStart();
};

var lpStart = function() {
	$.post('/path/to/script', {}, lpOnComplete, 'json');
};

$(document).ready(lpStart);

Straightforward. When the document is ready the loop begins. Each iteration the returned data is processed and the loop is restarted.

On the server side - just like we discussed earlier:

$time = time();
while((time() - $time) < 30) {
	// query memcache, database, etc. for new data
	$data = $datasource->getLatest();

	// if we have new data return it
	if(!empty($data)) {
		echo json_encode($data);
		break;
	}

	usleep(25000);
}

Actually, a couple points of interest here. We don't actually loop infinitely server side. You may have noticed the logic for the while loop - if we've executed for more than 30 seconds we discontinue the loop and return nothing. This nearly eliminates the possibility of substantial memory leaks. Also, if we didn't put a cap on execution time we would need to print a "space" character and flush output buffers every iteration of the loop to keep PHP abreast to the status of this process/connection. Without output being sent PHP cannot determine if the connection was lost via connection_status() or connection_aborted(). As a result this could lead to a situation where there are an increasing number of "ghost" processes eating up server resources. Not good!

That pretty much sums it up! Not that difficult, right?

As always, questions/comments are welcome, hope this helps!

Related posts:

1. Real-time “AJAX” JavaScript Progress Bar
2. PHP Dynamic JavaScript SCRIPT Insertion for Embedding
3. PHP fast, large (megabyte), data transfer between sessions

function roundTo(number, to) {
	return Math.round(number * to) / to;
}

alert(roundTo(1532, 100)); // 1500
alert(roundTo(26, 10)); // 30

If you want to get fancy, you could also modify the Number prototype for a more "integrated" solution.

Number.prototype.roundTo = function(to) {
	return Math.round(this * to) / to;
}

Related posts:

1. JavaScript Event Handler
2. Real-time “AJAX” JavaScript Progress Bar
3. PHP jQuery AJAX Javascript Long Polling

I achieved this in my framework through, what I call, output format filters. Let's say you have an action "cloud" in a controller "markets". The URL to access this resource in its full glory would be:

http://www.domainname.com/markets/cloud

Pretty standard stuff. Let's say we want to offer an embeddable version of this resource. I can append an "output format filter" on this resource:

http://www.domainname.com/markets/cloud/embed

Alright, again, pretty standard stuff. How on earth does this relate to dynamic javascript SCRIPT insertion?

On the remote partner site, I ask them to place the following HTML fragment in the desired location they want the resource to appear:

<script language="javascript" type="text/javscript" src="http://www.domainname.com/markets/cloud/embed"></script>

One line of HTML.

How does this work under the hood? It simply takes the view's content and prepares it as a valid javascript document.write. It also specifies certain HTML headers, notably:

Content-Type: application/x-javascript

function prepJS($js)
{
	// prepare the output as valid javascript
	$js = str_replace("\\", "\\\\", $js);
	$js = preg_replace("/[\r\n]+/", '\n', $js);
	$js = str_replace('"', '\"', $js);
	$js = preg_replace("/<script/i", '<scr"+"ipt', $js);
	$js = preg_replace("/<\/script/i", '</scr"+"ipt', $js);

	return $js;
}

document.write("<?php echo prepJS($viewContent); ?>");

It should be fairly obvious what the function does. It escapes double quotes, adds slashes, and replaces newlines and carriage returns with their inline equivalent. Additionally and VERY important, it splits SCRIPT tag elements (if your view had inline SCRIPT's) into SCR"+"IPT so that the browser treats these as pure strings and doesn't cause JavaScript parsing errors.

What if the resource you are embedding depends upon the availability of certain JavaScript libraries or external source files? The first response usually is, myself included, to simply document.write more SCRIPT tags!

document.write("
<?php prepJS('<script type="text/javascript" language="javascript" src="http://www.domainname.com/path/to/jquery.js"></script>'); ?>
");
document.write("
<?php prepJS('<script type="text/javascript" language="javascript" src="http://www.domainname.com/path/to/morejs.js"></script>'); ?>
");
document.write("<?php echo prepJS($viewContent); ?>");

The problem is of course that in IE, there's no telling what order those SCRIPT tags will get executed. Furthermore, if your resource depends on them, they need to be executed before you document.write the content.

My solution to this problem was two-fold. For other reasons not worth going into here, it's generally a good idea to concatenate all your JavaScript source files into one larger file, minify (if desired), cache, and serve the result. Taking advantage of this we can reduce the above to a single additional SCRIPT insertion. Tack this snippet onto the end of that file:

if(typeof(embedReady) != 'undefined') {
	embedReady();
}

And we come up with this:

document.write("
<?php prepJS('<script type="text/javascript" language="javascript" src="http://www.domainname.com/path/to/cached_combined_js.js"></script>'); ?>
");
var embedReady = function() {
    document.write("<?php echo prepJS($viewContent); ?>");
}

Now we're only concerned with a single SCRIPT load. We've safely placed our document.write of content inside a function that's called at the end of our dependency SCRIPT. In an elegant, browser agnostic fashion our resource will have it's dependencies loaded before it executes.

Yay?

Related posts:

1. PHP jQuery AJAX Javascript Long Polling
2. Real-time “AJAX” JavaScript Progress Bar
3. JavaScript roundTo Nearest Thousandth, Hundredth, Tenth, *

I waited for the 1.3.1 release of jQuery to make sure all major bugs had been resolved (brand new selector engine). This weekend I decided to go for the upgrade. Flawless. Even the plugins all worked as expected.

Fantastic job.

Related posts:

1. jQuery 1.3 Beta Testing
2. jQuery 1.4.2 Released
3. jQuery 1.4 Alpha 1 Released

Major changes include:

• Selector Engine - The selector code has undergone a complete rewrite - it’s likely that some edge cases still exist here.
• DOM Manipulation (append/prepend/before/after) - This code has also undergone a large rewrite along with some of the logic for executing inline script elements.
• .offset() - Another method that has been completely rewritten.
• Event Namespaces - The logic for handling namespaced events has been completely rewritten.
• Event Triggering - When triggering an event the event now bubbles up the DOM - this is likely to cause some problems.

Go lend a hand!

Related posts:

1. Converting from Prototype to jQuery
2. jQuery 1.3.1 Go For Launch
3. jQuery 1.4.2 Released