An increasing number of laptops these days boast SSDs, but capacities are rising quite slowly. For some people, 128GB as your main drive might be enough, but if you want more, is it worth shelling out the huge fees charged by manufacturers to upgrade to a higher capacity SSD, or can you make do with alternative storage?

To find out, we ran our standard file transfer tests – first between a RAM disk and the SSD of a brand new laptop, then between a RAM disk and a variety of external storage devices. The results are in the table at the bottom of this post.

The SSD

The tidiest upgrade is to a larger internal SSD, and there’s no doubt this is also best for performance. With a single 1.5GB file, the SSD in our test MacBook Air delivered read and write speeds of 187MB/sec and 156MB/sec. More importantly (you’ll see why later), with 1.5GB of tiny files its read and write speeds were a healthy 87MB/sec and 75MB/sec.

The big problem is the hefty price of a bigger SSD, with Apple charging £250 to step up from 128GB to 256GB in its 13in MacBook Air, and Sony charging £410 for the same upgrade in the VAIO Z. That’s a lot of money.

The external hard disk

The first alternative is an external hard disk, and it’s a cost-efficient way of adding storage, particularly for files you won’t always need to hand. The winner of this month’s USB 3 hard disk Labs (issue 204, in shops now!) costs only £51 inc VAT for a 500GB drive.

In our tests with a single 1.5GB file, it achieved identical read and write speeds of 82MB/sec. With 1.5GB of tiny files this figure fell, but only to 60MB/sec read and 51MB/sec write; not as fast as an SSD, but significantly cheaper.

Of course, not all laptops have USB 3 ports – the MacBook Air being one such example. In our last USB 2 hard disk Labs, the winner achieved 32MB/sec read and 28MB/sec write speeds with a single 1.5GB file, and 26MB/sec and 12MB/sec with 1.5GB of tiny files.

The SD card

Adding external storage is cheap and fast, but if you prefer the convenience of having something you don’t have to carry around, you could make use of the SD card slot. Now, SD cards aren’t built for the kind of constant writing that you do on your main hard disk. They have a limited number of guaranteed write cycles before the card risks failing, so they’re best considered for storing files you don’t update often – a media collection, for example.

There are also several speed categories of SD cards. Look for a class rating on the packaging: this refers to its minimum non-fragmented sequential write speed. So, Class 2 will do at least 2MB/sec, and Class 10 at least 10MB/sec. To confuse matters, some manufacturers use “x” ratings that have minimum rates even higher than Class 10.

Sure enough, in the large file test a Class 10 card saw read and write speeds of 30MB/sec and 23MB/sec. For Class 6 this was 18MB/sec and 15MB/sec, while Class 4 saw 16MB/sec and 6MB/sec. You wouldn’t want to write 64GB of data regularly, but for a one-off the speeds are fine.

With small files those cards had healthy read speeds too, from 44MB/sec on Class 10 down to 20MB/sec with Class 4. But the big problem with using an SD card in this way is writing multiple small files: transferring 1.5GB of files to a Class 10 card pummelled the speed down to below 1MB/sec, and that fell even further with lower classes. If you’re going to regularly write a lot of small files, these cards are a terrible choice.

The value question

For data that will be written once and largely stay unchanged, however, does an SD card offer a value alternative to an SSD upgrade? At the kind of large capacities where it’s feasible, we found several 32GB Class 10 cards on sale for less than £40 inc VAT, and 64GB Class 10 cards at around £100. That’s for basic cards; those rated faster and with a higher number of guaranteed write cycles can cost up to several hundred pounds, so you can pick and choose to suit your needs.

You’ll need an SDXC slot for 64GB cards, and some slots don’t accept the card fully inside – on the MacBook Air it protrudes by 8mm, ripe for the snapping. But if your laptop meets the requirements, and if you’re after only a quick boost in capacity for non-critical files, the sheer convenience of being able to leave an SD card in there at all times makes it a great way to save money. And at lower capacities we really are talking pocket money.

(Click to enlarge)

There are so many devices and routers now using the unlicensed space between 2,400MHz and 2,475MHz that finding a quiet, undisturbed channel for your network to reside on is nigh on impossible. That’s why we recommend anyone upgrading their wireless router chooses a dual-band model — one that gives you the option of connecting in the less congested 5GHz frequency band.

This can be a difficult concept to grasp without visual aids, so let me show you exactly what we mean when we talk about RF congestion.

Using our recently-acquired Wi-Spy spectrum analyser (kindly supplied by Metageek for use in a forthcoming wireless router Labs), combined with the firm’s Chanalyzer 4 radio frequency (RF) analysis software, we recorded the above graph.

It shows all the RF activity in the vicinity of the PC Pro office, and can detect not only nearby wireless networks – of which there are an alarming number — but also other devices using the 2.4GHz band.

Look closely and you’ll see that, on channel 8, there’s a non-Wi-Fi source of interference, represented as three bright stripes in the bottom “waterfall” window: I’ve not tracked down the culprit yet. To the right, the broad red/green stripe flanked by two narrower vertical green  lines shows you the devastation a cheap wireless video sender can wreak.

While this might seem a rather extreme example, I’m sure that many living in densely populated urban centres will be surrounded by a similar level of congestion and interference. Just imagine how many baby monitors, cordless phones and wireless routers there are in a modern, central London block of flats, and you’ll get the idea.

It’s frequency band bedlam out there, and the effect is slower, more unreliable wireless networks. Now take a look at the 5GHz band at the same location:

The difference is quite staggering — an oasis of calm by comparison, with only PC Pro’s own dual-band wireless router interrupting the tranquil RF landscape.

If that doesn’t get you hankering after a dual-band router, then nothing will.

Intel’s Light Peak technology has made a surprise early appearance in Apple’s MacBook Pros, under the new name Thunderbolt. But those leaving the Apple store with a shiny new laptop will find it’s not as simple as plugging in and getting started. We run through the facts.

Q: What is Thunderbolt?

Thunderbolt is an advanced input/output technology capable of carrying data, video and power over a single copper cable. It can transfer two simultaneous PCI Express channels of data at 10Gbits/sec each – twice the speed of USB 3 – and a DisplayPort channel, as well as up to 10W of power to connected peripherals. The two 10Gbits/sec channels mean you can daisy-chain up to six data devices, or five devices plus one display, from a single Thunderbolt port.

Q: Light Peak was optical, but Thunderbolt uses copper?

Intel’s cost-saving tests using copper came out better than expected, simple as that. The first Thunderbolt cables will be copper-based, but Apple told us for cables longer than 3m optical is still an option in the future.

Q: How fast is Thunderbolt in the real world?

Apple demonstrated to us an external Promise Pegasus RAID device running four simultaneous uncompressed HD video streams on a MacBook Pro 15in across a Thunderbolt connection. This was daisy-chained to a 27in Cinema Display. The process peaked at 600MB/sec (4.8Gbits/sec), an effortlessly attained real-world speed that almost tops USB 3’s theoretical maximum throughput.

Q: What laptops can use Thunderbolt?

It’s making its debut in the new MacBook Pro 13in, 15in and 17in models, as part of a collaboration between Intel and Apple. Thunderbolt is integrated into the existing Mini-DisplayPort connector design, but is signified by the new lightning bolt symbol. There are no other laptops currently announced with Thunderbolt support, although Intel says there is nothing in the Apple deal to prevent other manufacturers incorporating the technology.

Q: What can I plug into it?

Right now, nothing that can take advantage of that bandwidth. Any monitor that currently uses the Mini-DisplayPort connector (including HDMI, DVI and VGA via existing adapters) will plug straight in and work as normal, and adapters are in the works for connecting to existing USB and FireWire products. But there are currently no other native Thunderbolt products on the market.

Q: When will third-party peripherals be released?

Eight companies have already announced plans to produce Thunderbolt products, including Promise Technology, LaCie and Western Digital. None has put an exact date on release yet, but we’ve seen a prototype of the Promise Pegasus RAID in action and have been told to expect products by summer, with an outside chance of some arriving in late spring.

It isn’t just about Kelkoo and Google Products any more either. These days there’s a huge choice of specialist sites, catering for everything from supermarket shopping to selling your mobile phone. Here’s our pick of the best.

1. MySupermarket.com

This is not your run of the mill price comparison site. Instead of comparing prices of individual products, it allows you to compare the cost of your whole shop. First, choose from one of the four supported supermarkets – ASDA, Tesco, Sainsbury’s or Waitrose – then fill up your cart with groceries as normal.

The site displays the cost of your shop in tabs at the top of the screen as you go; you can switch to the cheapest at the end and even book your delivery slot.

The truly impressive thing about this website, however, is its Swap & Save feature, which suggests better value alternatives to items you’ve already selected. It has an uncanny knack of rooting out the best bargains, and has the potential to slash even more off your weekly bill.

2. Omio

Trawling around the individual mobile networks’ websites trying to find a good deal on a phone is so tortuous the CIA ought to use it on terrorist suspects as an alternative to waterboarding. If you want to avoid the pain, we suggest Omio – a fantastic comparison website for skinflints with no patience.

It compares prices across a huge number of brokers and networks, and offers every filter and sorting option you can think of. Want a free phone on a 24-month contract with internet but below £15 per month? How about the best free gift or cashback offer? Omio’s sliders and simple-to-use front end make it easy to ferret out the best value deal. Give it a whirl: even £5 cut from your monthly mobile bill would save £120 over the course of a 24-month contract.

3. SellMyMobile

You can maximise your money saving in the New Year not only by using a price comparison site for your new smartphone, but also selling your old handset to the highest bidder. One way of doing this is to hawk it on eBay, but if you don’t want to take the risk of the phone being damaged in transit, or having your buyer fail to cough up, this is the website to try.

SellMyMobile compares the prices mobile phone recycling websites offer for your model of phone and helps you find the best one. Prices offered for an 8GB Apple iPhone 3GS ranges from £150 to £186, so it definitely pays to use the site.

4. Scccope

This one isn’t a specialist comparison engine, but it does offer one unique feature that no other site we use does. As well as straight product prices from all the big name vendors, Sccope also offers price analysis tools.

Displayed as a line graph alongside your traditional results, you can see maximum, minimum and average prices across all retailers over the past three months. The filtering options across the various categories could be better, but for the tactical bargain hunter it’s an indispensible aid: a flat graph for months, then a momentary dip in the minimum price might indicate a not-to-be-repeated deal, for instance, while an unstable, fluctuating graph could help you decide whether to wait for a currently high price to drop again.

5. Cable.co.uk

Visit Virgin Media or Sky’s websites and it’s easy to be confused into signing up for a deal you don’t want, and paying more than you planned to. You can cut through the confusing bundles and options, however, by using Cable.co.uk.

Pop your postcode into the search box and it quickly allows you to compare sports, movies, and HD packages available in your area, as well as broadband and phone packages across multiple suppliers. Through the website we discovered a deal for Sky Sports 1 and Eurosport, plus 65 other channels, for £17.75 a month for the first six months, then £21 per month for the remaining 12 months of the contract. It’s a brilliant way to save on what for many people (especially sports fans) is one of their highest monthly outgoings.

6. TOP10.com

Of all the broadband comparison websites we’ve seen (and there’s a bundle out there, believe us), TOP10.com is the best. Although very simple, it has a wide-ranging list of suppliers on its books: type your postcode into the box on the home page and you’ll be provided with not only a list of deals, sortable by speed, cost, or the size of the download cap, but also a page of information showing you how far you are from your nearest exchange, and the sorts of speeds others near you are getting from their broadband suppliers. Don’t take its results as gospel – some quality providers such as Zen Internet don’t make the TOP10.com cut – but it is very useful as a general guide.

7. Tunechecker

If you’re not among the legion of illegal music downloaders, there’s no need to pay top whack for your downloaded music. Tunechecker compares prices for MP3 downloads (and CDs – remember them?) across a total of 11 different services. It isn’t the most attractive website, but in a matter of seconds it will find you the cheapest single or album and allow you to search by artist, single, album title and more. With potential savings of up to a fiver an album these aren’t savings to be sniffed at.

8. uSwitch.com

With energy prices rising every year there’s every reason to switch supplier, but with each of the big companies offering an array of prices and deals that would baffle even money-saving expert Martin Lewis, it can be hard to see the wood for the potential eco-friendly energy source.

Use uSwitch.com’s comparison engine to keep on top of prices, however, and you could be saving yourself over £100 per year. Not only that, but it’s a good source of news on price rises and movements in the energy markets, so you can make sure you’re not switching to a supplier that’s about to put its prices up by 10%. uSwitch also has comparison tools for everything from mortgages, credit cards and loans to insurance and broadband. A well-laid out, very easy to use comparison site.

9. eBookPrice.info /

We love the Amazon Kindle for the sheer convenience and the (generally) low cost of books in the Kindle store. But some prefer the more open approach, the touchscreen and better build quality of Sony’s eBook readers. Trouble is, the prices of non-Kindle ebooks can vary wildly from website to website, making it a slow process to find a good price on a particular title.

eBookPrice.info may be a bit sparse on the design front, and it certainly isn’t exhaustive in its list of suppliers, but as it’s the only comparison site we’ve come across to make an even halfway decent stab at comparing eBook prices, it’s worth bookmarking.

10. Google Products

No price comparison round-up would be complete without mentioning the king of comparison engines, Google Products. It’s great: we use price comparison sites every day at PC Pro to find the best prices for laptops, netbooks, peripherals, PCs, gadgets and phones, and the one we come back to every time is Google’s.

In short, there is no general price comparison search engine that can match Google’s reach and breadth of product search, and it manages to pack in a wealth of features too, from overviews and specifications lists for individual products to reviews and ratings for the retailers themselves. We wouldn’t be without it, and nor should you. A class act.

One of the most popular features on websites today is a marker pinpointing a location on Google Maps. It’s incredibly easy to add such a map to a website and I’m going to show you how.

I said it was easy, and with the recent release of version 3 of the Google Maps JavaScript API, it’s become even easier. With the previous version of this API, you had to register your map to receive an API key, but that’s now no longer necessary.

Naturally Google provide a comprehensive guide to the Maps API, but I will run through the basics here.

Setting up the Map

First of all you need to include the map API in your web page. This is done by adding the following line in the <head> element of your code:

<script
type="text/javascript"
src="http://maps.google.com/maps/api/js?sensor=false">
</script>

You may notice the sensor parameter, which is set to false. This is a required parameter and should be set to “true” if the application used to determine the user’s location has a sensor device (e.g. a GPS locator). That’s not the case here, so we set it to false as shown.

Naturally, we need to define a map to display, but before we do that we need three things: somewhere on the web page to actually place the map, a default position to use as the map’s centre, and then some options to define the type of map that we require.

Setting up somewhere on the web page to place the map is a simple case of defining a div with a unique id, and some inline styling. So we have:

<div id="map" style="width:600px;
height:600px; margin-top:10px;"></div>

And that’s all we need.

To define a default position we need a latitude and longitude. There are plenty of websites out there that will convert addresses or places into coordinates for you, and I will centre this particular example on the PC Pro offices at latitude 51.515252 and longitude -0.189852. From these values a Google map position is defined by using the following:

var latlngPos = new google.maps.LatLng(51.515252, -0.189852);

We then set up the map options as follows:

var myOptions = {
   zoom: 10,
   center: latlngPos,
   mapTypeId: google.maps.MapTypeId.ROADMAP
};

Where zoom (naturally) indicates the zoom level of the map (you may want to play about with these to get the value that you want), center is set to the latitude/longitude position that we defined, and mapTypeId is set to the type of map that we wish to display initially. The map types are defined by the Google Maps API and are:

• MapTypeId.ROADMAP displays the default road map view
• MapTypeId.SATELLITE displays Google Earth satellite images
• MapTypeId.HYBRID displays a mixture of normal and satellite views
• MapTypeId.TERRAIN displays a physical map based on terrain information

Note: this simply defines the initial map type to display, the user can change it via a dropdown list that appears on the map itself. You can read more about the different map types over at Google should you want to know more.

With these things done, we can now initialise our map as follows:

var map = new google.maps.Map(document.getElementById("map"), myOptions);

This will now cause the map to appear on your web page, contained within the map div (the map itself stays within the boundaries of the div’s dimensions).

Marking the Location

With the map set up, we can now go about defining the marker on the map that we want displayed. Once again we need to define a position for the Google map using latitude and longitude. I’m using the same values as above, as I want to place a marker on the PC Pro offices (it’ll help the staff when they stumble back from their Christmas party).

var markerPos = new google.maps.LatLng(51.515252, -0.189852);

Adding a marker to this location is as simple as:

var marker = new google.maps.Marker({
   position: markerPos,
   map: map,
   title: "PC Pro Offices"
});

(where map is the id of the map div)

As usual I have a simple example so that you can see it in action. (Note: this example also uses some jQuery)

Going further

The Google Map API is very powerful and you can go much further than I have shown here, such as adding pop-up information windows on the map marker.

You can even use the API to convert addresses into latitude/longitude positions and display them on the map. I have included a more advanced example should you want to take a look at it. It’s pretty straightforward and I’ve commented the code in order to make it clearer.

Throughout your web browsing careers I’m sure you’ve come across the notion of cookies, pieces of text stored by the browser to be retrieved and used at a later date. These vary from simply remembering your name to welcome you personally next time you visit, to more complicated storage of authentication and shopping-cart contents.

Cookies generally work well but can be fiddly to implement, as they are set to be deleted by default once the browser is closed. If a website owner needs the data to be stored for a longer period, a cookie can be given an expiry date. Again this isn’t as clean as it could be: how far into the future do you set the date, for example? And what happens when a user flushes out their cookies?

HTML5 attempts to clean this up with the introduction of web storage.

Web Storage

Web storage comes in two different types, sessionStorage and localStorage. As might be deduced from the names, sessionStorage is for storing data that’s required for a particular session only, and localStorage is for data that’s to remain indefinitely.

Web storage correctly separates session data from long term data

This does away with the need for expiry dates, and instantly makes it clearer which data is for when and for how long. It also makes it incredibly easy to implement.

The API

As both types are so similiar, they share the same API, which contains the following items and functions:

// The number of items being stored
long length;

// To retrieve the item 'key' from storage
getItem(key);

// To set the item 'key' in storage with 'value'
setItem(key, value);

// To remove the item from storage
removeItem(key);

// To clear the entire storage
clear();

It’s all quite simple and straightforward to use.

Saying Hello

Let’s say you wanted to store a user’s name to welcome them back later. Assuming the existence of a simple HTML5 page consisting of one input field called name and a link that calls the function saveName() it would be defined as follows:

function saveName() {
   var name = document.getElementById('name').value;
   localStorage.setItem('username', name);
}

Each time this page loads, call a new function sayHello() which is defined as:

function sayHello() {
   var userName = localStorage.getItem('username');
   if (userName != null) alert("Hello " + userName + " and welcome back!");
}

This will check for the existence of a username in localStorage, and if it’s there, will welcome the user.

Note that localStorage is used here rather than sessionStorage as we want the name to be displayed next time the user visits the page again, during which time they may have closed the browser, which would clear anything in sessionStorage.

You can see this working for yourself in this very simple “say hello” example. Enter a name, click ’save’, and reload the page.

If you enter a different name in the input field and click ’save’, the existing value will be overwritten. We could also remove the item by calling localStorage.removeItem('name'); which would remove that item only. The entire localStorage could be cleared by calling localStorage.clear();

Session storage

sessionStorage works in the exact same way, except that the data will be automatically cleared once the brower is closed.

You can also store multiple data items in web storage attached to the one key, but you will need to use a JavaScript object and something such as JSON which helps to “stringify” the stored data, thus facilitating its storage.

Browser Support

If you’re used to reading about Internet Explorer’s current inability to support any HTML5 feature, you’re in for a surprise here. Web storage is actually supported by IE8 as well as all the major browsers:

• Firefox 3.5+
• Safari 4.0+
• Chrome 4.0+
• Opera 10.5+
• Internet Explorer 8.0+
• iPhone 2.0+
• Android 2.0+

So basically, you can start using it now!

If you or your company has a Twitter account, chances are you’d like to promote it and display your latest tweets from your website. Since many websites – both personal and increasingly business – are built on blogging software such as WordPress, this is usually achieved via a plugin, of which there are many out there.

But what if you simply want to add your live Twitter feed to a “normal” web page? Twitter itself provides a number of HTML widgets, but in this article I’ll show you how easy it is to achieve with a little bit of JavaScript, CSS, and jQuery.

In case you haven’t come across it before:

What is jQuery?

jQuery is a fast and concise JavaScript Library that simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development. It’s very powerful and makes life a whole lot easier when writing JavaScript. To include jQuery in your webpage, simply add the following within the <head> tags:

<script type="text/javascript" src="http://jqueryjs.google
code.com/files/jquery-1.3.2.min.js"></script>

This uses the version that is hosted on Google Code, which saves you having to download the file.

Twitter API

Twitter itself provides a complicated API to allow access to all sorts of things. A lot of this complication arises around authentication, and necessarily so, but thankfully to simply retrieve a stream of tweets, authentication isn’t required (as long as the user in question hasn’t hidden their tweets).

First of all the API provides many different ways to obtain a user’s statuses. I won’t go into any of them other than the one that I favour, and this is the one that I’ll talk about here: user_timeline.

user_timeline

This returns a number of the most recent statuses posted by the user. It can return the data in different formats: XML, JSON, RSS and Atom. I favour  JSON, a lightweight data-interchange format, so this is the one that I will talk about.

You can use a number of parameters, and a full list of what they can do can be found on the Twitter API description for user_timeline. For now, I will only use a few relevant ones.

Give me the Tweets!

To retrieve the data for a particular Twitter account (I will use pcpro in this example here) you call the following:

$.getJSON("http://twitter.com/statuses/user_timeline.json?
screen_name=pc_pro&count=10&callback=?",
function(tweetdata) {
// do some stuff here
});

This will return the last 10 tweets from the pc_pro account in JSON format in the tweetdata variable. By default, retweeted tweets are not included in this feed, but to include them, add the &include_rts=1 parameter above, and they will be returned.

Of course we now have to make sense of this data, parse it and actually do something with it.

On our HTML page, define a <ul> and give it the id tweet-list. This is where we will hold our tweets. The above code is then extended to do the following:

$.getJSON("http://twitter.com/statuses/user_timeline.json?screen_name=pc_pro&count=1O&callback=?", function(tweetdata) {
var tl = $("#tweet-list");
$.each(tweetdata, function(i,tweet) {
tl.append("<li>“" + tweet.text + "”– " + tweet.created_at + "</li>");
});
});

Some explanations: var tl = $("#tweet-list"); grabs a reference to the <ul> element that we created above. We need this as we will add each tweet to it.

$.each(tweetdata, function(i,tweet) {... is the start of a jQuery loop, in this case iterating through each item in tweetdata and storing it temporarily in tweet. The following line then adds the tweet within an <li> item. The actual text of the tweet is contained within the text data member, and here we put double quotes around it, and the time it was created is contained within the created_at data member.

This will now display the last 10 tweets in list format on the relevant HTML page.

However, if there are links contained in the tweet, they won’t be clickable, and the created date is a bit long and not like the Twitter standard timelines such as “about a minute ago” or “two hours ago”. We can fix this with the following two functions urlToLink(); which we call on tweet.text:

function urlToLink(text) {
var exp = /(\b(https?|ftp|file):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/ig;
return text.replace(exp,"<a href='$1'>$1</a>");
}

and relTime(); which we call on tweet.created_at:

function relTime(time_value) {
time_value = time_value.replace(/(\+[0-9]{4}\s)/ig,"");
var parsed_date = Date.parse(time_value);
var relative_to = (arguments.length > 1) ? arguments[1] : new Date();
var timeago = parseInt((relative_to.getTime() - parsed_date) / 1000);
if (timeago < 60) return 'less than a minute ago';
else if(timeago < 120) return 'about a minute ago';
else if(timeago < (45*60)) return (parseInt(timeago / 60)).toString() + ' minutes ago';
else if(timeago < (90*60)) return 'about an hour ago';
else if(timeago < (24*60*60)) return 'about ' + (parseInt(timeago / 3600)).toString() + ' hours ago';
else if(timeago < (48*60*60)) return '1 day ago';
else return (parseInt(timeago / 86400)).toString() + ' days ago';
}

So we need to change the above line to the following:

tl.append("<li>“" + urlToLink(tweet.text) + "”– " + relTime(tweet.created_at) + "</li>");

This will be called when the HTML page is loaded (or you can load it some other time, it’s up to you of course) and this is done using jQuery by inserting the code within:

$(document).ready(function() {
// code here
});

which basically calls the code when the entire DOM has been loaded.

End Result

I have put together an example using all the code above, so you can see all this together and working for yourself. Plus you can view the code to see how it’s done. It’s all commented too, probably overly so, in case you get stuck.

You can of course also style the list and its contents with CSS, but I’ll leave that as an exercise for the reader.

*Update*

One of the comments below asked about retrieving the latest statuses from a specific account’s list. I’ve created a quick example that retrieves and displays the latest updates from PC Pro’s ’staff’ Twitter list. You can of course view the source code.

The main difference is the URL in included in the &.getJSON() call which should be:

http://api.twitter.com/1/account-name/lists/list-name/statuses.json?callback=?

where account-name is the name of the account, in this case pc_pro, and list-name is the name of the list, in this case staff.

As with the video element, in the past the only method of embedding audio files into a web page was to use Flash or another third-party plugin. There simply was no other way. With the introduction of the audio element, this has changed.

Browsers and file types

There are currently three different audio file types that are supported, and (of course) the different browsers each support different formats. The table below illustrates this:

Code

So how do we actually go about adding an audio file to a web page? Well it’s quite simple really, especially if you’ve already used the video element.

Instead of using the <video> element we naturally use its brother, the <audio> element. Like the <video> element, we can use the src attribute to directly specify the audio file to play, but, as shown above, it’s more practical to use the <source> element to indicate a number of possible sources in order to cover all most browsers.

The <audio> element

The audio element takes the following attributes:

So you can easily add a WAV audio file to your website by using the following markup:

<audio src="audioFile.wav" autoplay controls></audio>

Of course, as mentioned above, this can limit your browser compatibility and it’s better to provide different audio sources using the <source> element.

The <source> element

The source element can take the following attributes:

Stacking the audio sources

Combining the <audio> and <source> elments together couldn’t be simpler, as the code below shows:

<audio controls autobuffer>
<source src="audioFile.ogg">
<source src="audioFile.mp3">
<source src="audioFile.wav">
Sorry, your browser does not support the audio element
</audio>

The code above should play the specified audio file in all of the browsers mentioned above (except for the current incarnations of Internet Explorer and Android – which will display the message indicating as much. This could be replaced with a Flash fallback of course).

Feel free to test this code for yourself.

Conclusion

So there it is in its simplest form, adding an audio file to a web page. Of course it depends on the browser the page is being viewed in, and, as usual, we’re still waiting for Internet Explorer to catch up (A beta version of IE9 is due out next month).  Nevertheless, it’s still worth using today. Just don’t set your files to autoplay!

And I wrote what I considered to be an innocent line: “…for landscape shots, place your camera on a tripod, use a remote shutter release to minimise the risk of camera shake, and apply a small aperture (f/16 is ideal) to get as much of the frame in focus as possible.”

This prompted subscriber Simon Barnes to write to PC Pro’s editor, Tim Danton, to say: “he makes a canard, suggesting f/16 is good for depth of field in landscapes, when in fact, even at full frame this is already straying into diffraction, which will be worse with smaller sensors. He’s not the only one saying this of course, it’s regularly trotted out.”

Quite apart from teaching me a new word, Simon was raising an interesting point, which I’ll attempt to tackle here. I should add that the pratical effect of diffraction in photography is to limit the resolving power of the camera as a whole – in other words once diffraction sets in, your images will in theory be softer, with less detail.The “sweet spot” for lenses is normally f/8 – f/11, so shooting f/16 might not get you the absolutely sharpest possible image you could possibly, possibly get.

What it will get you is very good depth of field – i.e. if you’ve focussed properly on one point in the frame it’s likely the rest of the landscape will be focussed as well. If I had the choice between a 100% focussed image that was slightly soft or an image where focus fell off towards the back of the scene I’d take the 100% focussed image and either live with the softness or sharpen it out afterwards.

Most of my favourite landscape images (such as the one above) are taken between f/8 and f/16 and I’ve got no problems with the sharpness of the images taken at f/16. Every lens is different, obviously, so a thousand pound wide-angle lens will perform much better at f/16 than the lens that comes with a 1000D.

Tim passed my comments on, to which Simon responded: “But again there is no mention of the sensor size which is critical in this! Also diffraction cannot be mitigated by better lens design as it’s a property of the light and aperture, not the glass.” Hands up: he’s absolutely right (for more details, visit Cambridge in Colour, which has an excellent discussion of this very subject).

But: the odds of a landscape being ruined by diffraction or sensor size are tiny compared to the odds of it being ruined by misjudging composition/focus/exposure/using a non-professional lens. In other words, it isn’t, personally, something I’d worry about. The lens attached to a camera has a much bigger impact on image quality than the camera it’s attached to (caveats apply as always… in most cases… with some exceptions… etc).

Then again, photography is a personal thing and if Simon has found a way of working that produces sharp, beautiful images that he’s proud of then I’d absolutely urge him to ignore me totally and carry on.

For people looking for a general guideline I’d still say f/16 is a good starting point. (If you have the inclination, look on that Cambridge in Colour page for the section headed “Notes on real-world use in photography” and read the first two paragraphs – that’s what I’m getting at.)

f/16 is a pretty general rule. As with most aspects of photography the rules change depending on what you’re using, what you’re shooting and what kind of light you have available. And it’s true that if you’re shooting with a compact then different rules apply once again.

In particular, when the “what you’re using” is a compact rather than a Digital SLR, diffraction becomes a much bigger issue. As the Cambridge in Colour article points out, the sensor size in a compact is so tiny that diffraction is an issue at quite large f-stops, which means far more pictures will be affected.

It makes sense to me, though, that with the image quality/lens quality on offer from compacts being so much lower than that of DSLR, that diffraction will never be noticed before the other flaws in an image. I confess, though, that’s a bit of an assumption, so I’d be fascinated to know if people have encountered diffraction issues with their compacts – or indeed their DSLRs at f/16.

In my last blog entry I briefly mentioned CSS3 when talking about the confusion surrounding HTML5. In this post, I’m going to talk about one of the new features of CSS3 and one which will possibly be noticed most by the non-web developer.

Allow me to introduce @font-face.

What does @font-face do?

It allows a web developer to embed a font within a web page and display it to the user. So instead of the bog standard fonts that are normally found on websites, you can now see much fancier and prettier fonts.

A brief history

The @font-face CSS rule was first introduced in the CSS 2.0 specification and then removed in CSS 2.1, before being reintroduced in CSS 3.0. The fact that it existed in CSS 2.0 is important, because it means that even legacy browsers such as Internet Explorer 6 (the bane of many a web developer’s life) support it.

the @font-face rule was first introduced in the CSS 2.0 specification

Issues

As is usual with such things, there are some issues with regards to implementing @font-face. First of all, as is customary in the world of web development, different browsers support different formats. Why these guys can’t seem to agree on the same format for anything is a mystery to me. So this means that a font defined with @font-face needs to be made available in different formats to be usable by each of the major browsers.

Secondly, not all fonts can be used legally in this manner. As @font-face downloads the required font from the server (where the site is hosted) to the user’s personal machine, the font licence needs to allow this free distribution of fonts. Thankfully there are many font developers out there who are now beginning to release their fonts with the required licence.

Using @font-face

So how can you use @font-face to embed an attractive typeface in your website? The answer is very easily.

First of all you need to pick a font, and ensure that it has the required licence. The best place to go for a comprehensive list of such fonts is Font Squirrel. (Incidentally, the site also has a @font-face Kit Generator which allows you to upload fonts, and I highly recommend using it.)

For this demo I have chosen Hattori Hanzo from Font Squirrel and downloaded the font kit. The kit is a ZIP file that will contain a number of files, most of which are the fonts themselves in different formats, which are:

• EOT – the font format used by Microsoft and supported from IE 4+
• TTF – the outline font standard originally developed by Apple and supported by Firefox 3.5+, Opera 10+, Safari 3.1+ and Chrome 4.0.249.4+
• SVG – SVG uses XML to describe 2D graphics and here, font characters, for the iPad and iPhone
• WOFF – is a repackaged version of a TrueType or OpenType font in a compressed form and is supported by Firefox 3.6+, IE9 and Chrome 5+

As shown above, different browsers support different font formats, and the @font-face CSS rule will reflect this. Included with the @font-face kit will be a CSS file which will contain this rule. Let’s take a look at the one that comes with the Hattori Hanzo font. It contains two font rule declarations, one for HattoriHanzoLight and another for HattoriHanzoLightItalic. Both declarations are the same and simply reference different files, so I will only go through the first:

@font-face {
font-family: 'HattoriHanzoLight';
src: url('Hattori_Hanzo-webfont.eot');
src: local('?'), url('Hattori_Hanzo-webfont.woff')
format('woff'), url('Hattori_Hanzo-webfont.ttf')
format('truetype'),
url('Hattori_Hanzo-webfont.svg#webfontwDgCZ3F8')
format('svg');
font-weight: normal;
font-style: normal;
}

The first part of the @font-face declaration indicates the font-family, in this case HattoriHanzoLight. This will be the name that is used throughout the CSS file to indicate that this @font-face declaration is to be used.

Next is the EOT declaration. This needs to be the first src declaration otherwise Internet Explorer won’t find it and will break. As you can see, it simply points at the font file to use.

The third declaration local('?') tells the browser to check the local system for the font first. If the user has already installed it, then that one will be used. Otherwise the declarations that follow it will be downloaded in whatever format the browser understands.

All you need to do to apply this font to any normal CSS declaraion is to assign the appropriate name to the font-family attribute. For example:

p {
font-family: 'HattoriHanzoLight';
font-size: 16px;
font-weight: normal;
}

That’s it really. Quite simple. I have created a demo page for @font-face and Hattori Hanzo Light for you to see the font in action.

Conclusion

For many, @font-face won’t seem like a big deal. And the fact that the different font formats are rendered differently on the various browsers, with varying degrees of success, may dampen the effect that embedding fonts within a webpage may have. I, on the other hand, believe it to be a big step forward in allowing web developers and designers to produce better looking sites and interfaces that will benefit the end user.