The most critical part of a page’s load time is the time before rendering starts. During this time, users may be tempted to bail, or try a different search result. For this reason, it is critical to optimize the <head> of your HTML to maximum performance, as nothing will be visible until it finishes loading the objects inside.
For example, say your ad provider wants you to include their script in a separate file so they can make updates whenever they choose. So much for combining it into your site’s global JS to reduce the request, eh?
mod_concat makes combining shared libraries easy by providing a way to dynamically concatenate many files into one.
See mod_concat in Action
You can check out the Pagetest results here, and check out the time to start render (green bar):
We can see that the time spent downloading is typically the green time, or the time to first byte. This happens on every object, simply for existing! A way to make this not happen, is to combine those files into one, larger file. Page weight (bytes) stay the same, but Requests are reduced significantly.
Let’s take a look at our Pagetest results of a second example with mod_concat enabled.
Notice our the number of Requests went from 14 to 5, and we saved 1.5 seconds! We probably could have made an even faster example by moving to just 2 requests (one for CSS and one for JS), but the speed win here is clear.
How mod_concat Works
mod_concat is a module for Apache built by Ian Holsman, my manager at AOL and a contributor to Apache. Ian gives credit in the mod_concat documentation to David Davis, who did it while working at Vox, and perlbal.
The idea is straightforward, and you can pretty much figure out how it works by viewing the source code of our second example:
You can see in the highlighted code above that a single request is referencing multiple files, and the server is returning the concatenated version. The URL takes the following format:
Let’s break it down.
The first bit should be straight forward, it’s the host name.
Next comes the optional path to the files. This is important, because you can’t concatenate files above this directory if you include it. However, it allows you to optimize a bit so you don’t need to keep referencing the same path for files below this directory.
The ?? then triggers the magic for the files that come next. It’s a special signal to Apache that it’s time to combine files!
If the file is in the current directory, you can simply include it next, followed by a comma “,”.
If you need to go a bit further in the directory hierarchy, you can do that too.
You can include as many files as you wish as long as they fall within the same server directory path defined early on in your optional/path/.
Performance and Caching Considerations
mod_concat uses the Last-Modified date of the most recently modified file when it generates the concatenated version. It should honor any max-age or expires Cache Control headers you set for the path in your server or htaccess configuration.
If you have a far future expires or max-age header, to bust the cache you will need to rename one of the files or directory names in the string, and then the user will download the entire concatenated version again.
Because mod_concat is an Apache module, performance is near instantaneous. Performance is improved further still if the server happens to be an origin point for a CDN, as it gets cached on the edge like an ordinary text file for as long as you tell it to, rarely hitting your servers.
Same Idea, Different Platforms
Rakaz’s PHP Combine Solution
Niels Leenheer of rakaz.nl has a nice solution for PHP. Niels writes:
Niels takes advantage of Apache’s Rewrite rules as such to make the combine PHP script transparent to the template designer:
This is nice because it keeps the PHP script and HTML template separate from each other, just like mod_concat.
Ed Elliot’s PHP Combine Solution
- He masks the actual file names being combined, and/li>
- A new version number is automatically generated to automatically bust the cache
For folks who don’t mind digging into PHP, the above benefits may be worth the effort. I especially like the cache-busting, as it allows me to put a far future expires header without worrying if my users will get the update or not.
This might be useful for folks, but I’m the obfuscator type and promote that for production build processes. I’d love to see a safe obfuscator like YUICompressor written in C so we could turn it into a module for Apache.
Lighthttpd and mod_magnet
For users of Lighthttpd, mod_magnet can be used to do the concatenation. It appears similar in nature to Rakaz’s solution, though I will leave it to you to dig in further as it seems to be fairly involved. This blog post by Christian Winther should help get you started.
ASP.Net Combiner Control
Cozi has developed an ASP.net control to combine multiple JS and CSS into a single file, and includes a cool versioning feature much like Ed Elliot’s script. It’s very easy to use; you simply wrap the script with the control tag in the template:
It then outputs the following code at runtime:
The only problem I see with their approach is that since the output file has query parameters, Safari and Opera won’t honor cache control headers as it assumes it is a dynamic file. This is why simply adding ?ver=123 to bust the cache is not a good idea for those browsers.
Java JSP Taglib – pack:tag
Daniel Galán y Martins developed a combine solution for Java called packtag. It follows in the spirit of PHPSpeedy and provides additional optimizations such as minification, GZIP, and caching.
It’s not obvious from the documentation what the output of the combined script looks like, but in a flow graphic it seems to include a version number, which would be cool.
The code to do the combination goes right in the JSP template, and looks like this:
<pack:script> <src>/js/validation.js</src> <src>/js/tracking.js</src> <src>/js/edges.js</src> </pack:script>
CSS can be combined too. The syntax appears to be quite flexible:
<pack:style> <src>/main.css</src> <src>../logout/logout.css</src> <src>/css/**</src> <src>http://www.example.com/css/browserfixes.css</src> <src>/WEB-INF/css/hidden.css</src> </pack:style>
As you can see this idea has been implemented in many languages, some with additional innovations worth considering, so if you can’t leverage mod_concat, at least use something similar as the benefits are well worth it.
mod_concat is a performant, cross-language, high-scale way to build concatenation into your build process while maintaining files separately. While it lacks automatic versioning (Ian, can we do this?), it provides a clean way to dynamically merge JS and CSS together without touching a bit of server-side code, and it works across server-side languages.
One feature I’d like to see added is a debug mode. For example, if the code throws an error it may not be apparent based on line number what file is having issues. Perhaps the filename could be included in comments at the start.
Remember, improving the time to start rendering the page is critical and you should focus on this first. With tools like mod_concat and the others mentioned here, there should be little excuse to implement this into your routine. Little pain, a lot to gain.