Web developers have been concerned about the vendor prefix crisis since February 2012. To summarize the issue, this is what should happen in an ideal world:

1. Vendors implement experimental CSS3 properties using their own prefix, e.g. -webkit-transform, -moz-transform, -ms-transform, -o-transform.
2. Developers can use the technologies today without breaking cross-browser compatibility. Properties can be listed with their prefixed and unprefixed names to ensure they work everywhere.
3. Once a property becomes a W3C recommendation, all browser vendors can provide a stable unprefixed property, e.g. transform.
4. Optionally, developers can remove the prefixed properties from their stylesheets. However, it’s not strictly necessary if the unprefixed property is defined last and CSS cascade rules apply.

This is what occurs in the real world:

1. Vendors implement experimental CSS3 properties using their own prefix. In some cases, vendors promote them as an HTML5 “standard” even if they’re device-specific or never submitted to the W3C.
2. Some developers use the proprietary property from a single vendor, e.g. only -webkit-transform. This might be owing to ignorance, laziness or because they’re testing a limited number of devices.
3. Once a property becomes a W3C recommendation, all browser vendors can provide a stable unprefixed property, e.g. transform…
4. but developers neglect to change their stylesheets. The site looks good in some browsers but worse in others even when they support the standard W3C specification.
5. The vendors become concerned and add support for other prefixes into their browser, i.e. Opera implements the -webkit prefix for some properties. The prefix process is broken and, while it’s too early to predict the outcome, the majority of developers consider it to be a bad move.

We have discussed the issues at length on SitePoint; there are no easy solutions. However, two interesting proposals have been raised by W3C members during the past week.

Option 1: Unprefixed Properties are Supported From Day One

The first proposal comes from Florian Rivoal, Opera’s W3C representative:

When a browser vendor implements a new CSS feature, it should support it, from day 1, both prefixed and unprefixed, the two being aliased. If a style sheet contains both prefixed and unprefixed, the last one wins, according to the cascade.

Authors should write their style sheets using the unprefixed property, and only add a prefixed version of the property (below the unprefixed one) if they discover a bug or inconsistency that they need to work around in a particular browser.

If a large amount of content accumulates using the a particular vendor prefix to work around an issue with the early implementation in that browser, the vendor could decide to freeze the behavior of the prefixed property while continuing to improve the unprefixed one.

For example, you could use the following transform code in your CSS:

transform: rotate(30deg);

The property would be ignored by all browsers which had not implemented transforms. If there were a difference between two or more implementations, e.g. webkit browsers rotated anti-clockwise by default, you could override the property accordingly, e.g.

transform: rotate(30deg);
-webkit-transform: rotate(-30deg);

It’s a simple solution and easy to implement. Most existing stylesheets would continue to work and prefixed properties would rarely be necessary. In most cases, you would never need to update your CSS again.

However, what would happen if webkit changed rotation to the W3C-approved clockwise direction? Developers would need to fix their stylesheets by removing or rearranging the -webkit-transform: rotate(-30deg); property. Unfortunately, not everyone uses the same version of the webkit engine at the same time. You could encounter a situation where your site works in Chrome but not in Safari for several months.

Option 2: A New Vendor-Draft Modifier

The second proposal comes from François Remy:

Let’s introduce the “!vendor-draft” value modifier. I propose we use unprefixed properties from start, but with a token explaining which version of the property we built our CSS for:
border-radius: 3px !webkit-draft;

Any browser which is not webkit but implemented border-radius in a way that is compatible with the “webkit draft” can support the declaration. This is different from vendor prefixes: other browsers don’t impersonate webkit, they just acknowledge they support one specific property the way the webkit draft defines it. Browsers which are not compatible with that draft will just ignore the declaration. Browsers that change their implementation of a property are encouraged to iterate their “!vendor-draft” flag (using a version number, if appropriate).

This solves the issue by changing the property value rather than its name (in a similar way to the !important modifier). Again, the following transform code could be used:

transform: rotate(30deg);

But a default anti-clockwise rotation could be fixed in any browser adhering to a webkit specification:

transform: rotate(30deg);
transform: rotate(-30deg) !webkit-draft;

If a browser subsequently supported the W3C specification, the second property would be ignored.

It would also be possible to implement draft versioning, e.g.

transform: rotate(30deg);
transform: rotate(-30degrees) !webkit-draft;
transform: rotate(-30deg) !webkit-draft-2;

It’s a flexible solution which finally addresses the issue of properties evolving over time.

Unfortunately, it’s more difficult to implement and could take months to appear in browsers even if all vendors agreed today. It may be technically better, but it’s a fundamentally different approach which could break existing stylesheets. In the short term, vendors would probably support both prefixes and value modifiers — and that would lead to confusion.

I like both solutions. From a coding perspective, vendor-draft modifiers seems the most logical option but I doubt it can be considered until vendors “complete” CSS3 and begin work on CSS4.

Supporting unprefixed properties is more practical but will certainly cause versioning issues which couldn’t be fixed in CSS alone. But perhaps that’s the price you pay for using experimental technology?

Do you have a preference for either of these options? Or is it too late to prevent a vendor prefix catastrophe?

Networking is often regarded to be complicated and very difficult to manage but as it forms an essential role in the day-to-day use of your computer the purpose of this article is to expose a few ‘tips and tricks’ that will serve to improve your computers connectivity and overall performance by showing you how easy it is to take control of Ubuntu 12.04, LTS Precise Pangolin.

So let’s get started …

What is my local IP address

It may be a easy question to begin with, but in a world of complexity it is often the simple questions that get overlooked.

Using the graphical tools:

Right click on the ‘networking icon’ in the top panel of the Ubuntu desktop and choose ‘Connection Information’ as shown below:

The resulting dialogue box will then provide feedback on your current settings.

Using the command line interface:

On the other hand, for those individuals who are beginning to enjoy the power of Terminal or for those of you who use a server (via the Console or Putty or similar).

If you have a wireless based connection, run:

iwconfig

If you have a ‘wired’ connection, run

ifconfig

The results for ‘ifconfig’ will look something like this:

eth0      Link encap:Ethernet  HWaddr 00:1d:92:65:09:e1
          inet addr:192.168.1.100  Bcast:192.168.1.255  Mask:255.255.255.0
          inet6 addr: fe80::21d:92ff:fe65:9e1/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:510 errors:0 dropped:0 overruns:0 frame:0
          TX packets:315 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:80353 (80.3 KB)  TX bytes:38731 (38.7 KB)
          Interrupt:42 Base address:0xa000
lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:108 errors:0 dropped:0 overruns:0 frame:0
          TX packets:108 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:8176 (8.1 KB)  TX bytes:8176 (8.1 KB)

And because the command line provides us with additional opportunities, if you would like to quickly identify all the available ethernet devices on your computer, you can run

ifconfig -a | grep eth

The result will look something like this:

eth0      Link encap:Ethernet  HWaddr 00:1d:92:65:09:e1

Well done, but just before we finish-up I would like to take this opportunity to show you another useful command that can help identify all the network interfaces available to your system. Known as the ‘lshw’ command, this tool will not only detail your ethernet devices but it will also provide a plethora of information on your hardware’s ‘other’ capabilities.

To use this tool, simply run the following command and wait a few seconds whilst Ubuntu quieries your devices:

sudo lshw -class network

And the result will look something like this:

  *-network
       description: Ethernet interface
       product: RTL8111/8168B PCI Express Gigabit Ethernet controller
       vendor: Realtek Semiconductor Co., Ltd.
       physical id: 0
       bus info: pci@0000:02:00.0
       logical name: eth0
       version: 01
       serial: 00:1d:92:65:09:e1
       size: 100Mbit/s
       capacity: 1Gbit/s
       width: 64 bits
       clock: 33MHz
       capabilities: pm vpd msi pciexpress bus_master cap_list rom ethernet physical tp mii 10bt 10bt-fd 100bt 100bt-fd 1000bt 1000bt-fd autonegotiation
       configuration: autonegotiation=on broadcast=yes driver=r8169 driverversion=2.3LK-NAPI duplex=full firmware=N/A ip=192.168.1.160 latency=0 link=yes multicast=yes port=MII speed=100Mbit/s
       resources: irq:43 ioport:d800(size=256) memory:feaff000-feafffff memory:feac0000-feadffff

Sometimes you’ve just ‘gotta’ love the details, but now we know something about our computer we can begin to take control :-)

How do I create a static IP address with the Network Manager

The following instruction shows you how to create a fixed (or static) IP address with the Network Manager.

This approach is best suited to all desktop users who may require the need to keep the functionality of the Network Manager or for those that use netbooks, laptops and and other wireless connections that may require a DHCP based option in the future. Don’t worry, it is all very simple:

Click the network menu on the top panel (the ‘up/down’ arrows icon) and select ‘Edit Connections’.

Alternatively you can choose System Settings > Network > Choose your ‘Network Connection’ from the left hand panel and select ‘Options’.

Now choose the relevant connection and click edit.

For example, if you are using a ‘wired connection’, choose the ‘wired’ tab to find your connection.

In the resulting dialogue box you should:

• Select the ‘IPv4 Settings’ tab and change the ‘Method’ to ‘Manual’.
• Click Add and complete each field with your IP address, network mask and default gateway.Always press the ‘Enter/Return’ when you’ve finished typing each address otherwise the dialogue will fail to accept your new settings and the ‘save’ button will remain inactive/greyed-out.
• Include the IP addresses of the DNS servers. Multiple addresses should be separated by commas.
• Click Save and close the remaining dialogue boxes.

And there you go …

If all is well you should be able to view web sites and/or view your local network but in some situations and depending on your network topology a reboot may be necessary.

To confirm your new settings, simply check your connection settings as shown previously (see above)

But what if I need DHCP again?
If you ever need to return to a dynamically assigned IP address simply re-run the previous steps. Find your current connection, select the ‘IPv4 Settings’ tab and change the ‘Method’ to ‘Automatic (DHCP)’. To finalise this reversal click save and reboot (depending on the network conditions and how the DHCP server is configured).

Disable the Network Manager and ‘hard-code’ a static IP address

This solution explains how to create a fixed (or static) IP address without using the Network Manager.

The Network Manager is a very nice feature, but only suitable for individuals who require dynamically assigned connections or those who require wireless connectivity. Yes, it is true to say that these are both very popular in homes and offices throught the world but for those of us who use and prefer the benefit of a ‘wired connection’ using the Network Manager does come at the cost of performance. So this solution uses the traditional approach to ‘hard-coding’ your network connection and it is most suitable to those individuals who demand maximum performance or absolute stability.

By using this approach you should note that we will not be removing the Network Manager, merely disabling it with the intention to capitalise on the performance gains by by-passing or side-stepping this device. These performance gains will not only be noticed in terms of network speed but also in terms of the computer in general.

Again, don’t worry, the process to disable the Network Manager is very simple but it will require us to run various ‘commands’ in Terminal in order to complete some steps.

So let’s begin by making a backup of our original file.

In Terminal type:

sudo cp /etc/NetworkManager/NetworkManager.conf /etc/NetworkManager/NetworkManager.conf.bak

This will serve to back-up our original file to ‘/etc/NetworkManager/NetworkManager.conf.bak’. Hopefully you will not need it, but if you ever need to restore the original file simply open Terminal and reverse the command like so: ‘sudo cp /etc/NetworkManager/NetworkManager.conf.bak /etc/NetworkManager/NetworkManager.conf’ and reboot.

And with the confidence that we are fully backed-up we shall now proceed to disable the Network Manager.

In Terminal, type:

sudo gedit /etc/NetworkManager/NetworkManager.conf

This will open the ‘NetworkManager.conf’ file in our text editor.

Now change:

managed=false

to

managed=true

So it looks like this:

When done, save the file and close it.

You can re-enable the network manager at any time by simply reversing the steps shown above or by restoring your back-up file. Remember to reboot in order to apply these changes.

Now we have successfully disabled the Network Manager we can proceed to create our Static IP address by making some direct changes to the ‘interface’ file; but with safety in mind let’s begin by making a backup of our original file.

In Terminal and type:

sudo cp /etc/network/interfaces /etc/network/interfaces.bak

This will back-up our original file to /etc/network/interfaces.bak. Again, it is not expected that we will need it but if you ever need to restore it open Terminal and reverse the command like so: sudo cp /etc/network/interfaces.bak /etc/network/interfaces

Now lets add our static IP address.

In Terminal type:

sudo gedit /etc/network/interfaces

Authenticate yourself in the usual way and then replace the file contents as shown below, where xxx represents values relevant to your needs:

auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
	address 	xxx.xxx.xxx.xxx
	netmask 	xxx.xxx.xxx.xxx
	network 	xxx.xxx.xxx.xxx
	broadcast 	xxx.xxx.xxx.xxx
	gateway 	xxx.xxx.xxx.xxx

And to help you out, here is an example with an explanation of the values concerned:

auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
	address 	192.168.1.100 	(this is my computers IP address)
	netmask 	255.255.255.0 	(this is my subnet mask)
	network 	192.168.1.0	(this is my network base address)
	broadcast 	192.168.1.255	(this is my broadcast address)
	gateway 	192.168.1.254	(this is my gateway/router's ip address)

When complete, simply save and close the file and reboot your computer to complete these steps.

We are re-booting our computer at this point in order to ‘dis-engage’ the Network Manager, and once complete you can always re-configure your IP address at any time by making the necessary changes to the ‘interfaces’ file (shown above) and using the following command to restart your networking service: ‘sudo /etc/init.d/networking restart’.

After you restart your computer you will discover (visually) that nothing has changed but as a consequence you should be experiencing a ‘more’ responsive computer and network connection.

Should you ever want to re-enable the Network Manager. Simply reverse the steps we have taken above and/or restore you back-up files and reboot and as we created them with the ‘cp’ or copy command – unless you delete them, your original backup files will always remain for future reference.

Create Virtual Network Adapters (add more than 1 IP address to a single ethernet card)

In some situations this can be very useful and as an extension to our previous solution of ‘disabling the network manager and hard-coding a static IP address’ I will now show you how to assign more than one IP address to the same ethernet card:

In Terminal type:

sudo gedit /etc/network/interfaces

Authenticate yourself and then replace the file contents like so, where xxx represents values relevant to your needs:

auto lo
iface lo inet loopback
auto eth0
iface eth0 static
	address 	xxx.xxx.xxx.xxx
	netmask 	xxx.xxx.xxx.xxx
	network 	xxx.xxx.xxx.xxx
	broadcast 	xxx.xxx.xxx.xxx
	gateway 	xxx.xxx.xxx.xxx
auto eth0:0
iface eth0:0 static
	address 	xxx.xxx.xxx.xxx
	netmask 	xxx.xxx.xxx.xxx
	gateway 	xxx.xxx.xxx.xxx

And to make this as simple as possible, here is an example:

auto lo
iface lo inet loopback
auto eth0
iface eth0 static
	address 	192.168.1.100
	netmask 	255.255.255.0
	network 	192.168.1.0
	broadcast 	192.168.1.255
	gateway 	192.168.1.254
auto eth0:0
iface eth0:0 static
	address 	192.168.1.101
	netmask 	255.255.255.0
	gateway 	192.168.1.254

By doing this I will be adding two IP addresses to my a single ethernet card. It will not only have the IP address of 192.168.1.100 but it will also have the alternative address of 192.168.1.101 (as a virtual instance).

The trick is to follow the virtual naming scheme (i.e. eth0:0, eth0:1, eth0:2 etc …) and to ensure that every instance maintains a unique IP address. In this way you can create as many ‘instances’ of an IP address as required.

To illustrate this point, let’s add a third IP address to our example:

auto lo
iface lo inet loopback
auto eth0
iface eth0 static
	address 	192.168.1.100
	netmask 	255.255.255.0
	network 	192.168.1.0
	broadcast 	192.168.1.255
	gateway 	192.168.1.254
auto eth0:0
iface eth0:0 static
	address 	192.168.1.101
	netmask 	255.255.255.0
	gateway 	192.168.1.254
iface eth0:1 static
	address 	192.168.1.102
	netmask 	255.255.255.0
	gateway 	192.168.1.254

When complete, remember to reboot your computer to apply the changes or open Terminal and type:

sudo /etc/init.d/networking restart

You can then run ‘ifconfig’ to view your new settings.

Have fun ..!

Change your computer’s hostname

You may like your current computer name, or you may want to change it.

In this short recipe I will show you how to view and change your computer name with relative ease …

In Terminal type:

sudo gedit /etc/hostname

The file will probably look something like this:

ubuntu-computername

To change the name of your computer, simply delete the existing content and replace as required.

Remember, the actual name can be anything your want as long as you remember some basic principles:

• Desktops generally use a singular name (as shown above) whereas all servers or ‘desktops acting as servers’ should be in the format of computername.computerdomain.suffix.
• On a local network computers should refrain from using the standard or typical internet based suffix or TLD unless your local DNS can account for such similarities.
• Use ‘internet friendly’ names and do not use a computer name that already exists on your network.
• Do not use spaces or non-internet friendly characters.

Once complete, simply choose ‘save’, ‘close’ the file and reboot your computer to see the changes.

Your new computer name will be in the top-left hand side of the login screen but if you missed this or need to confirm your current or new hostname at any time.

Open Terminal and type:

sudo hostname

And the result should reflect the changes you made …

Managing the Hosts file

The hosts file file consists of a list of IP addresses and corresponding hostnames. Most users may never need to touch this area of their computer but there maybe an occasion when you need to edit the hosts file on your machine. This can because of any number of reasons (i.e. reversing the effect of malicious activity) or it can be because your are trying to make your life that little ‘quicker’ buy ‘hard-coding’ the address of an internal or external web site. Similarly, if your network contains computers whose IP addresses that are not listed in an existing DNS record, then it is recommended that you add them to the hosts file. So with this in mind I will now show you how to manage you hosts file.

Before you begin, you can make a back-up of this file by simply typing the following command in to Terminal:

sudo cp /etc/hosts /etc/hosts.bak

Now, to proceed and customise your hosts file simply return to the command line and type:

sudo gedit /etc/hosts

A typical desktop file will look like this (simply substitue the example values with those relevant to your computer):

127.0.0.1			localhost
127.0.1.1			ubuntu-computername
# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

However, having said that and just for the record, for the ‘server’ or ‘desktop server’ version of the same file should look more like this:

127.0.0.1       localhost.localdomain   localhost
192.168.1.100 	ubuntu-computername.ubuntu-domainname.lan  ubuntu-computername
# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

You will notice that my examples include the IPv6 instruction and this is entirely at your discretion as it depends on whether your network supports it.

For example, you may ignore these values (not include them or comment them out by placing a ‘hash’ character at the beginning of the line) like so if your computer does not use IPv6.

# The following lines are desirable for IPv6 capable hosts
#::1     ip6-localhost ip6-loopback
#fe00::0 ip6-localnet
#ff00::0 ip6-mcastprefix
#ff02::1 ip6-allnodes
#ff02::2 ip6-allrouters

Of course, disabling IPv6 is optional and can sometimes improve performance but if you are in doubt, simply ignore them (but as they sometimes say in ‘old blighty’ – ‘don’t fix what ain’t broke’).

So getting back on track …

In your hosts file you may want to include a list or pre-identified servers and workstations in order to speed-up name resolution like so:

192.168.1.200		servername1 www servername1.localdomain.lan
192.168.1.200		servername2 mail servername2.localdomain.lan

In my example I have included an alias in addition to the actual names – i.e. servername1 is also known as www and servername2 is also known as mail. You do not need to do this as my other examples will show.

Windows (and Mac) users should notice that this process very similar to customisng the ‘hosts’ file on any Windows/Mac based operating system and the resulting file could look like this:

127.0.0.1			localhost
127.0.1.1			ubuntu-computername
# PUT YOU COMMENT AFTER A HASH (#) FOR REFERENCE - NOT REQUIRED BUT USEFUL
192.168.1.200		www.website1.com
192.168.1.201		www.website2.com
# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Consequently, my computer will now use the IP address for www.website1.com instead of searching a DNS record thereby ensuring that my ability to view the website in question would be quicker than before.

Taking this one step further … and by giving it a little twist.

For those of you who wish to excercise some ‘parental power’ you could easily use this as a way to block direct access to some ‘unwanted web sites’ by sending someone who expects to go to www.website1.com to www.website2.com, like so:

#192.168.1.200	www.website1.com
192.168.1.201		www.website1.com
192.168.1.201		www.website2.com
192.168.1.202		www.website3.com
192.168.1.123		www.website4.com
192.168.1.167		www.website5.com

Notice I have commented out the real address of website1 with a hash (#) and that both website1 and website 2 now have the same IP address … (the IP address being the actual address of website2)

It isn’t a perfect of solution by any means but it is food for thought and can serve as a starting point for future development ;-)

How to re-configure DNS resolution

The purpose of this section is to show you how to configure the appropriate nameserver to use when resolving IP address to hostnames and vice versa. It is not intended to explain how to configure the system as a name server as this is something I will be covering in a future article. You should only affect this file if you are not using the Network Manager and want to use a static IP address.

The resolv.conf file is the resolver configuration file and it is used to configure workstation or server access to the Internet Domain Name System (DNS). This file defines which nameservers to use and in what order they are tried. You should therefore put the most reliable server first. It is convention that up to three name servers are supported. However, if no nameserver option is given, the resolver will attempt to connect to the name server on the local host.

Resolv.conf still does this, but with the release of the Precise Pangolin a few things have changed, and regardless as to whether you are running a desktop or a server your system is probably running the resolveconf program:

‘Resolveconf’ is a small program that resides in ‘/etc/resolvconf’ that dynamically modifies the nameserver information on boot. It is a useful tool, but for our purposes it can be disruptive, so we are going to work around it by simply adding a new entry to our ‘/etc/network/interfaces’ file:

In Terminal type:

sudo gedit /etc/network/interfaces

Now add the following nameserver line to your file, changing XXX to something more applicable to your needs:

dns-nameservers xxx.xxx.xxx.xxx xxx.xxx.xxx.xxx

Similar to the example shown above here is the new file using Google’s public nameservers:

auto lo
iface lo inet loopback
auto eth0
iface eth0 static
	address 	192.168.1.100
	netmask 	255.255.255.0
	network 	192.168.1.0
	broadcast 	192.168.1.255
	gateway 	192.168.1.254
        dns-nameservers 8.8.8.8 8.8.4.4

When complete, click ‘save’, then ‘close’ the file and reboot to apply the changes.

On reboot, you can see that the new nameserver information has now been applied to our ‘resolve.conf’ file by opening Terminal and typing:

cat /etc/resolv.conf

Which may look something like this:

# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
#     DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 8.8.8.8
nameserver 8.8.4.4
nameserver 127.0.0.1

So having made your changes, to query the DNS capabilities of your system, simply return to the command line and type:

nslookup www.sitepoint.com

or alternatively try

dig www.sitepoint.com

And that’s it for now … but most of all, have fun :-)

So until next time …

I hope that you continue to enjoy using Ubuntu 12.04 LTS Precise Pangolin.

In my recent article, we discussed 7 Reasons to Consider SVGs Instead of Canvas. SVGs are ideal if you require a scalable diagram such as a chart or logo which can be altered or animated using JavaScript DOM methods.

So … what are SVGs and how do we use them? This is the first part in a series articles about the vector image format.

What Are SVGs?

SVGs are vector graphics. Rather than defining the color of each pixel like you would in a bitmap (JPEG, PNG, GIF, BMP etc.), vector graphics define lines and shapes, e.g. draw a black line from co-ordinate 0,0 to 100,100. This has a number of advantages: vectors are easy to modify, generally require smaller files and are scalable to any dimension without losing quality — which makes them ideal for responsive web design. Bitmaps remain the best choice for photographs or very complex images (note that SVGs can include embedded bitmaps).

SVG is a royalty-free web standard maintained by the W3C SVG Working Group. Version 1.0 of the technology was originally proposed in 1999. Version 1.1 is the most recent standard with version 2.0 expected in 2013.

There are a couple of other flavors: SVG Tiny and SVG Mobile. These are simplified profiles or subsets of the full SVG specification which target devices with reduced computational and display capabilities. These standards largely relate to how rendering engines parse the image; an SVG 1.1 file can be rendered on a device which supports SVG Tiny but some effects such as gradients and opacities would not be applied.

How are SVGs Defined?

SVGs are declared using eXtensible Markup Language (XML). It uses tags like HTML — the following code draws a white circle with a black border:

<circle cx="100" cy="100" r="50" stroke-width="4" stroke="#000" fill="#fff" />

Be aware that XML is stricter than HTML. You cannot, for example, omit a closing tag since this will make the file invalid and the SVG will not be rendered.

The W3C SVG1.1 specification defines 14 main features:

1. Basic shapes: straight lines, polygons, circles, ellipses, and rectangles with or without rounded corners.
2. Paths: outlined or filled paths containing curved or straight lines.
3. Text: on straight or curved paths in any direction.
4. Painting: fills and outlines using solid colors, gradients, patterns, transparency, and markers (line terminators such as arrow heads).
5. Color: fill and stroke properties defined using standard 3 or 6-digit hex or rgb values.
6. Gradients and patterns: CSS3-like gradient declarations or bitmap backgrounds.
7. Clipping, masking and compositing: using elements to outline regions which can be painted.
8. Filters: effects applied to all elements within a container, e.g. blurring, lighting, color adjustments, etc.
9. Linking: hyperlinks to other documents.
10. Interactivity: attaching event handlers using JavaScript.
11. DOM Scripting: accessing and manipulating SVG elements using the Document Object Model.
12. Animation: built-in animations using Synchronized Multimedia Integration Language (SMIL).
13. Fonts: text glyphs defined in an SVG file which can be used as a standard font.
14. Metadata: titles, descriptions, subjects, creators and other properties about the SVG image.

Cascading Stylesheets in SVGs

SVGs also support embedded or external CSS rules. Like HTML, the selectors can target tag types or IDs and classes assigned to specific elements. CSS properties and values generally follow element attributes. For example, this CSS renders every circle in the SVG with the same white fill and black border color:

circle
{
	stroke: #000;
	fill: #fff;
}

SVG Creation Tools

Creating SVGs in a text editor is possible but it’s a slow process, error-prone and not much fun. Fortunately, there are several open source and commercial tools which allow designers and non-programmers to easily create SVG images:

• Inkscape
• OpenOffice or LibreOffice Draw
• svg-edit

Therefore, a design team could create a great-looking chart which a programmer can modify by applying real data to specific elements.

However, note that some graphics packages may not create the most optimal code or apply their own XML extensions.

SVG Browser Support

Although the technology has been available for more than a decade, SVG use within browsers was held back by Internet Explorer which first provided support in IE9. Today, most desktop and mobile browsers can handle SVGs and it is a recognized HTML5 standard.

Browser implementations vary, but SVGs can either be:

• viewed as a separate file directly in a web browser.
• embedded as an XML section within an HTML page.
• defined as an external page resource within img, object or the old embed tags (or as an iframe, although that’s effectively viewing the SVG file)
• set as background image in CSS.

There are a number of plug-in and shim options if you require SVG support in Internet Explorer 8.0 and below. Several fallback to Vector Markup Language (VML); a technology used in Microsoft products which influenced the SVG standard:

• Raphaël — JavaScript/VML
• AmpleSDK — JavaScript/VML
• svgweb — JavaScript/Flash
• Batik — Java toolkit

SVG Performance in Browsers

SVG XML must be parsed to render images on-screen and represented in memory as a Document Object Model. As with HTML pages, performance will be affected if you attempt to move or manipulate SVGs containing a large number of elements. In extreme cases, the redraw will be noticeable.

For this reason, it’s often preferable to use the HTML5 canvas tag for fast action games with hundreds of animated items. However, you may be able to adopt SVGs for some aspects, e.g. a player’s spaceship could be a simple SVG which can be moved, rotated, scaled and warped over a canvas-generated background.

SVGs and Accessibility

Owing to their XML data structure, SVGs provide better accessibility than bitmap images. At a basic level, meta data, short text and long text alternatives can be applied to any SVG image.

That said, screen reader support is poor. SVGs were not considered a viable browser technology until the release of IE9 so vendors did not consider them a priority. The situation will undoubtedly improve.

In the short term, you could consider transforming SVG XML into a text-based alternative using XSLT.

SVGs and Search Engine Optimization

Unlike bitmaps, XML is inherently machine-readable so static SVG files can be read, parsed and indexed by search engine bots. Google has been indexing SVG content since August 2010 and results can be found in the standard and image search systems.

Replacing a few PNGs with SVGs is unlikely to improve your rankings. However, if you’re displaying data as images without textual fall-backs, switching to SVGs could offer an SEO boost.

In my next SVG article we’ll create our first images without the use of a graphics package!

We’ve all been there. Your wonderful website has been running successfully for months then — BAM — it disappears. Or, more often, certain features stop functioning. Despite your protests that nothing has changed, your client isn’t happy. Prepare yourself for a few frustrating hours of problem probing.

Step 1: Identify the Issue

This might sound obvious, but I’ve known many developers open their IDE and start hacking at random code. It’s more important to determine the issue than the cause at this stage. Is the site unavailable? Is a particular page or function failing? Is it limited to specific browsers?

Step 2: Test Resource Availability

Nine times out of ten, the problem will be caused by a connectivity issue at your end or the client’s. If you can’t access any other pages, it’s not surprising that your website has disappeared. That said, it’s not always obvious; certain IP ranges, countries or sections of the internet can become temporarily blocked.

Test your site from a variety of locations — a public proxy server will help identify whether it’s a local or global problem. If possible, examine the status of other sites running from the same server or web host.

One less obvious problem is disk space. If you’re running a busy site, server logs can rapidly use the available space even when your application’s storage requirements are low.

Remember that you might be using resources on other servers. This includes CDN-hosted files, database servers, or remotely-hosted APIs such as those for Google Maps, YouTube, Twitter, advertising services etc.

You should also check your server loads. A major traffic spike or Denial of Service attack will cause access problems.

Finally, is your domain registration valid and is the DNS server responding as it should?

Step 3: Identify What Changed

Once you’ve rejected connectivity, traffic, DNS and disk space, it’s time to determine what changed. 999 times out of 1,000 the problem will have been caused by an update.

You may not have touched the files but are you sure others haven’t? Check with everyone who has access but don’t necessarily believe them. Here’s a typical conversation you’ll encounter…

Client: My sites not working. What are you going to do about it?
You: I’ll fix it. Have you made any changes recently?
Client: No. It was like that when I got here.
…five hour’s frantic investigation…
You: You changed X, didn’t you?
Client: X? Oh yes, I changed X. I did that when I was fiddling with Y and Z.

Your application may not be directly to blame. Has your web host updated the OS, language runtime, database software or file permissions? While vendors attempt to ensure PHP, Ruby, Python, MySQL, PostgreSQL, etc. remain backward compatible, features will almost certainly change or break between editions.

Step 4: Reject the Edge Cases

Although rare, you should look for signs of cracking. Software such as WordPress, Joomla and OScommerce are obvious targets, however, changes are often subtle because the cracker wants to retain access. For example, you might discover that a file explorer add-on has been installed or phishing pages have appeared deep within the file structure.

Finally, you should never rule out hardware problems. Corrupt memory chips or disk sectors could be responsible for any number of bizarre issues. If possible, evaluate your application on a similar set-up or install a separate test version on the same server.

Step 5: Fix Your App

Once you have eliminated the impossible, whatever remains, however improbable, must be the truth. Perhaps your code isn’t as perfect as you thought…

Do you have any tips for diagnosing website or application problems? What was the most difficult issue you encountered?

We all know Kevin Yank is a pretty smart guy.

Now’s your chance to see if you’re as smart as Kev, by taking the PHP & MySQL Quiz (which accompanies his new book “PHP & MySQl: Novice to Ninja“)

Jump in now, and take on the elephant in the room :)

In February 2012, we reported the minutes of W3C meeting where Mozilla, Opera and Microsoft discussed implementing -webkit prefixes in non-webkit browsers. The reason: some developers use only webkit prefixes — their sites look good in some browsers, but broken in others even when they offer the same level of CSS3 support. The issue is especially prevalent on mobile browsers and many developers fail to look beyond their high-end Apple or Android devices.

Opera has now announced support for 14 CSS3 webkit properties in their Mobile Emulator. The implementation will eventually reach all editions of their desktop and mobile browsers. If you’re thinking “Opera has a tiny market share”, think again: it’s the world’s most-used mobile browser.

Perhaps I’m being overly dramatic, but Charlton Heston’s famous line comes to mind: “They finally, really did it. You manics. You blew it up!”

Opera -webkit Aliasing

Opera analyzed stylesheets from 10,000 popular websites to determine which CSS values/properties would receive -webkit aliases:

If the browser encounters a property such as -webkit-border-radius, it will apply that effect. If you’ve defined -webkit-border-radius, -o-border-radius and border-radius, normal CSS cascading rules apply and the last defined rule or most appropriate selector will be applied, e.g.

#myelement
{
	-o-border-radius: 3px;
	border-radius: 6px;
	-webkit-border-radius: 9px;
}

All properties are considered to have equal priority so Opera applies a border radius of 9px.

With regard to differences in behavior, Opera state:

As far as we can tell, the behavior the properties that we have aliased is identical in WebKit and Opera, or at least close enough that the differences will not matter in practice. If it turns out that there are differences big enough to cause breakage, we will consider our options, one of which is to align the behavior of our -webkit- prefixed variant to what WebKit actually does.

Opera make a reasonable case to justify their decision. While they understand the complaints, their primary goal is to create a browser which works well for users — who outnumber developers by many thousands to one.

The Backlash

Most developers understand the problem but disagree with the solution. It’s crude and has the potential to break the web. Taking the decision to it’s logical extreme, all vendors would support every prefix but any implementation differences would render the CSS property useless.

The solution rewards bad development practices. While Opera advises you use all vendor prefixes, they will exacerbate the problem:

• Less conscientious developers will see this as justification for only targeting webkit browsers.
• If your site uses differing -webkit and -o values, it will now be affected by CSS cascade rules. Is it easier to analyze and retest your code or simply remove the Opera properties?
• It will become easier to accidentally omit the -o prefix since sites will work as expected.

Several problems have already been reported. For example, Modernizr evaluates prefixes in turn until it finds one the browser supports. Therefore:

Modernizr.prefixed("transition");

now returns WebkitTransition in Opera. Transitions are new to Opera and the browser doesn’t support every webkit CSS and JavaScript property. If you want to adjust or disable effects in Opera, you can’t rely on Modernizr-like detection code. You may even need to implement nasty browser sniffing.

However, my biggest issue is this: where are all these problem sites? Has user experience suffered from the lack of rounded corner, gradient, shadow, transition and transform effects? Are those sites genuinely broken or has Opera taken a (marketing) opportunity to make their browser look better?

Since Opera has analyzed 10,000 websites they can contact the owners directly. At the very least, they could publish a “hall of shame” which provides examples and highlights the technical issues. Many developers would happily contact companies on Opera’s behalf. Some would be prepared to fix sites for free since it could lead to future contracts.

There are no easy solutions to the vendor prefix crisis. I understand Opera’s reasons but, regardless of how this is implemented, it’s inevitable that something will end up broken.

Some good news: Microsoft has announced they will not support webkit prefixes in Internet Explorer (although there’s nothing to prevent them reversing that decision). Mozilla is yet to reveal their intentions — they will be watching Opera’s situation closely.

A console is a software artifact for reading line-oriented textual input from the keyboard and writing line-oriented textual output to the screen. Consoles are often used to implement operating systemcommand-line interfaces, but are also handy in text-based adventure games and other contexts.

Although text-oriented consoles are not as popular as they once were because of the proliferation of graphical user interfaces, they can be useful to power users who are not intimidated by this style of interface. Also, consoles can open up a new class of web application such as the embedded browser shell.

This article begins a two-part series that presents a JavaScript-based console library for use with web applications that may benefit from this style of user interface. Part 1 introduces you to the library’s simple API along with a browser shell application that serves as a useful demonstration of this API. Part 2 shows you how the library is implemented so that you can modify it to meet additional requirements.

Explore the Console Library

The console library consists of a global object named Console with several properties. This arrangement minimizes pollution of the global namespace. Furthermore, it reflects my desire to avoid supporting multiple consoles, as I find it easier to implement a singleton console.
Console provides the following features:

• easy initialization based on number of desired rows and columns (the <canvas> tag requires only an id attribute)

• canvas placed in tab order and gains keyboard focus immediately for browsers such as Firefox

• clear console capability

• green on black text with monospace font

• visible cursor that marks the current input position

• text echoing capability

• vertically scrollable when text flows past the lower-right character position

• simplified editing in terms of the backspace key

• automatically call a function when no input is available

• supports FireFox, Internet Explorer, Chrome, Opera, and Safari

Although Console encapsulates multiple accessible properties, I consider only four of them to be members of the “public” API. The other properties should not be accessed; they exist to support the following four properties and could change in a subsequent version of the library:

• init(canvasName, numCols, numRows) initializes the console. The string passed to canvasName must match the value of an existing <canvas> element’s id attribute. The integer passed tonumCols identifies the desired number of columns (e.g., 80), and the integer passed to numRows identifies the desired number of rows (e.g., 25). The console is cleared and the cursor position is set (0, 0). The resulting console displays green text on a black background. This function does not return a value.

• clear() clears the console and sets the cursor position to (0, 0). This function does not return a value.

• getLine(callback) returns a line of input and echoes this input to the console. It first checks if a line has been entered by noting whether a newline character (indicated by the user having pressed the key labeled Enter or Return) is present in the input. If so, the line is returned without the newline character. If a newline is not present, or if there is no input, this function returns null. When a function is passed to callback, that function is called when nothing has been entered.

• echo(msg) echoes the string passed to msg to the console starting at the cursor position, which is updated. The console scrolls vertically when the message flows past the lower-right corner. This function recognizes \b (backspace) and \n (newline) special characters. Also, it does not return a value.

The getLine(callback) function does not block the current thread while waiting for the user to press Enter/Return. Instead, it returns immediately. It does so because JavaScript code runs on a single thread. (HTML5′s web workers are an exception, and are beyond the scope of this article.) Blocking this thread for longer than what the browser considers acceptable causes the browser to display a dialog box that reports an unresponsive script.

The console library is easy to use. After defining a <canvas> element, and after initializing and echoing any preliminary text to the console, repeatedly execute a function via JavaScript’ssetInterval() function. Each execution should invoke getLine(callback) (with an optional callback function) and then take appropriate action based on getLine()‘s return value. Listing 1 presents the HTML for a simple demonstration of this library.

<html>
   <head>
      <title>
         Console Demo
      </title>
      <meta http-equiv="X-UA-Compatible" content="IE=Edge"/>
      <script src="../Console/Console.js">
      </script>
   </head>
   <body style="text-align: center">
      <p>
      <h2>
        Console Demo
      </h2>
      <canvas id="mycanvas">
      HTML5 canvas element not supported by this browser.
      </canvas>
      <p>
      You might have to press the Tab key or click the canvas to give it keyboard focus.
      </p>
      <script>
         Console.init("mycanvas", 64, 16);
         Console.echo(">");
         function tick()
         {
            var line = Console.getLine();
            if (line != null)
            {
               if (line != "")
                  Console.echo(line+"\n");
               Console.echo(">");
            }
         }
         setInterval("tick()", 50); // Invoke tick() every 50 milliseconds.
      </script>
   </body>
</html>

Listing 1: Echoing entered text on the console

Listing 1 describes ConsoleDemo.html. This listing is fairly straightfoward, except perhaps for the <meta> element. This element enforces a compatibility mode – use latest standards rendering mode — so that the console will work under Internet Explorer 9 (and probably higher versions of this browser). Otherwise, Explorer outputs an error message about the Canvas API’s getContext() function not being defined.

Listing 1 continues with a <script> element that includes the contents of a JavaScript source file named Console.js. This file defines the console library and is located in a Console directory that’s accessed relative to ConsoleDemo.html. The code file that’s attached to this article contains ConsoleDemo.html and Console.js in appropriate directories relative to each other, so you should be able to run ConsoleDemo without problems.

The body of this HTML file specifies a <canvas> element whose id attribute is assigned mycanvas. No other attribute is required because the console library takes care of them. The body also contains a <script> element that presents the console demonstration code.

The code first initializes the canvas to a 64-column-by-16-row drawing area — I chose these values because they were the dimensions of the text screen on my old TRS-80 Model III microcomputer. The code then echoes a > character to the console as the initial input line’s prompt.

At this point, a function named tick() is defined for repeated execution. This function will be executed every 50 milliseconds courtesy of the setInterval("tick()", 50) function call. Each invocation attempts to retrieve and echo back to the console a line of input.

tick() first invokes getLine() without passing a callback function because none is needed in this example. If this function returns null because nothing has been entered or the user is typing some input (and has not yet pressed Enter/Return), nothing further happens. Otherwise, if the returned line is not equal to the empty string (only Enter/Return was pressed), the entered text followed by a newline is echoed to the console. At this point, a > prompt is echoed to inform the user that another line of input is expected.

Figure 1 shows you the resulting console in the context of Firefox.

Figure 1: You don’t have to press Tab to start using the console on Firefox.

Encounter a Browser Shell

A shell provides an operating system’s user interface, and its primary purpose is to run programs. Modern operating systems feature graphical shells, but many also feature traditional command-line-oriented shells (e.g, Unix’s Korn and Bourne shells). A similar shell can be embedded within a web page via the console library, and this browser shell can be used to execute browser-oriented commands.I’ve created a browser shell application as a useful demonstration of the console library. Figure 2 reveals this application’s console in the context of the Internet Explorer 9 browser.

Figure 2: The browser shell currently supports four commands.

Figure 2 reveals an interesting anomaly: geolocation information is not immediately displayed. Instead, latitude and longitude data is often presented multiple lines later in the browser. You will learn the reason while exploring Listing 2.

<html>
   <head>
      <title>
         Browser Shell
      </title>
      <meta http-equiv="X-UA-Compatible" content="IE=Edge"/>
      <script src="../Console/Console.js">
      </script>
   </head>
   <body style="text-align: center">
      <p>
      <h2>
        Browser Shell
      </h2>
      <canvas id="mycanvas">
      HTML5 canvas element not supported by this browser.
      </canvas>
      <p>
      You might have to press the Tab key or click the canvas to give it keyboard focus.
      </p>
      <script>
         Console.init("mycanvas", 64, 22);
         Console.echo("Browser Shell 1.0\n\n");
         Console.echo("Type 'help' (without the quotes) to obtain help\n\n");
         Console.echo(">");
         var geo = "";
         function callback()
         {
            if (geo == "")
               return;
            Console.echo(geo+"\n");
            Console.echo(">");
            geo = "";
         }
         function tick()
         {
            var line = Console.getLine(callback);
            if (line != null)
            {
               line = line.trim();
               if (line == "browser")
                  Console.echo(navigator.userAgent+"\n\n"); else if (line == "cls") Console.clear(); else if (line == "geo") { Console.echo("querying location info...may take a few moments\n\n"); function report_error(error) { geo = error.message; if (geo == "") // geo is "" on Safari geo = "unknown error"; } function report_geolocation_query(position) { geo = "Lat: "+position.coords.latitude+", Lon: "+position.coords.latitude; } navigator.geolocation.getCurrentPosition(report_geolocation_query, report_error); } else if (line == "help") { Console.echo("Available commands...\n"); Console.echo("browser -- display current browser info\n"); Console.echo("cls -- clear screen\n"); Console.echo("geo -- obtain geolocation information\n"); Console.echo("help -- display this help text\n\n"); } else if (line != "") Console.echo("bad command\n"); Console.echo(">"); } } setInterval("tick()", 50); // Invoke tick() every 50 milliseconds. </script> </body> </html>

Listing 2: Interpreting and executing commands

Listing 2 presents BrowserShell.html. This listing has a similar layout to Listing 1 and should be fairly easy to follow. After initializing and echoing preliminary text to the console, the tick()function is repeatedly executed to get the next line of input, trim whitespace from both ends, check for one of four possible commands, and execute the command. If an invalid command is entered, bad command is echoed to the console. Regardless, the user is then prompted to enter the next command.

The geo command is the most complex to implement. It obtains geolocation information about the user via the Geolocation API, which is asynchronous to avoid blocking the JavaScript thread.navigator.geolocation.getCurrentPosition(report_geolocation_query, report_error) queries the user to grant permission to obtain geolocation information, proceeds to get that information when the user accepts, and then invokes one of two callback functions:

• report_geolocation_query(position) is invoked (upon success) with a Position argument that stores the geolocation data via its coords member, of Document Object Model typeCoordinates. This DOM interface includes latitude and longitude fields of DOM type double.

• report_error(error) is invoked (upon failure) with a PositionError argument that stores the reason for failure via its message member, of DOM type DOMString, and its code member, of DOM type unsigned short.

Each of these callbacks extracts information from its passed argument and builds a string that it assigns to the geo variable. During testing on Safari, I discovered that this browser wouldn’t let me obtain geolocation information. Furthermore, it assigned the empty string to message. To address this situation, I coded report_error(error) to assign "unknown error" to message. (I could have output a message based on error.code whose value was 2 — the position is unavailable. I leave making this change with you as an exercise.)

Listing 2 declares a callback() function that it passes as an argument to getLine(callback). This function is invoked each time getLine(callback) detects that there is no input. After verifying that something has been assigned to geo, callback() echoes this variable’s value followed by a > prompt to the console, and then assigns the empty string to this variable (to avoid having geo‘s value repeatedly output).

Why don’t I echo geo‘s value within report_geolocation_query(position) and report_error(error) (and then I wouldn’t need geo but could use a local variable) instead of going to the trouble of passing a callback function to getLine(callback)? If I did so, that navigation data could be output in the midst of entering a command, resulting in a mess. For example, while entering help I might end up with the following intermixed output:

>helLat: 49.88, Lon: 49.88
>p

Conclusion

Console is a useful tool for embedding a simple console into web pages. The previous browser shell application gives you an idea of what’s possible. You might want to extend this application with additional commands, such as a dir command for obtaining a directory listing of web storage. However, you first need to understand how this library works, and that is the subject of Part 2.

It’s been one month since we last looked at the browser market. Since then, Firefox 12 and Chrome 18 were released and Microsoft has embarked on an aggressive television, movie and online marketing campaign for IE9. Has any of this affected usage patterns in the worldwide StatCounter statistics?…

The table shows market share estimates for desktop browsers. The ‘change’ column shows the absolute increase or decrease in market share. The ‘relative’ column indicates the proportional change, i.e. another 12.7% of IE6 users abandoned the browser last month. There are several caveats so I recommend you read How Browser Market Share is Calculated.

Chrome’s monthly growth has fallen below 1% for the first time since October 2011. Other vendors dream about a market share increase of 0.37% but it’s unusually low for Chrome. I’m not convinced adoption rates have begun to plateau and it could be a statistical blip. That said, the advantages Chrome holds over the competition are more marginal than they’ve ever been.

This month’s biggest winner is IE9 and it’s risen 3.6% since the start of March. Three factors have contributed to it’s success:

1. Automated browser updates.
2. Microsoft’s glossy marketing campaign.
3. Businesses migrating to Windows Vista/7.

However, Microsoft cannot be complacent. IE8 is falling faster than IE9′s gains and total IE usage dropped by 0.74%. Chrome is still poised to overtake during the summer of 2012.

Safari had another good month and the browser is slowly creeping toward double-digit usage figures. The iPad accounts for 2.12% of the 7.14% total which means it now has more users than IE6.

Firefox and Opera’s market share barely changed. Perhaps this isn’t surprising; there are few major differences between the top five browsers and we could be entering a period of stability with little significant movement in browser market.

Mobile Browser Usage

April’s mobile usage increased to 9.58% of all web activity. This is partly owing to better weather in the northern hemisphere — although the UK had its wettest April for 100 years.

The primary mobile browsing applications are:

1. Opera Mini/Mobile — 21.52% (down 1.34%)
2. Android — 21.31% (up 0.15%)
3. iPhone — 20.04% (down 0.06%)
4. Nokia browser — 11.42% (down 0.44%)
5. UC Browser — 7.77% (up 1.42%)

There’s little change within the top five although UC Browser has helped itself to another slice of Blackberry.

While it’s great to see healthy competition in the mobile market, it remains frustratingly difficult to test web sites and applications on a range of popular devices. Do you bother?

In a previous article I showed you how easy it was to install Ubuntu 12.04 LTS and by now you should be making yourself familiar with the idea of how your desktop works, where your files are stored and some of the basic concepts that make Ubuntu 12.04 LTS Precise Pangolin a truly great operating system.

On the whole it would be true to say that Ubuntu also comes pre-installed with an excellent range of software and for the purpose of installing software Ubuntu maintains its very own Software Centre. Giving you instant access to thousands of free and open-source applications, games, and magazines does make things nice ‘n’ easy but with so much to choose from and for those of us who want to ‘hit the floor running’ it can be a little overwhelming (if not time consuming). So the question remains, where do I start?

To get the most out of your computer it is simply a question of what software you can run, what music you can listen to, what videos you can watch and what games you can play. You want to own your desktop and make it do fantastic things, you want familiarity but you also want something different. Choice can be a dilemna but it is purpose of this article is take up the running with a check-list of post install ‘tips and tricks’ that will deliver a fully functional desktop in no time at all. I  am not only going to show you short-cut the Software Centre process but I will also show you how to install a whole host of screensavers, remove the guest account, and install the classic Gnome interface – leaving you with plenty of time on your hands to discover the hidden gems of the Ubuntu Software Centre at your leisure.

So let’s get started …

Additional software sources.

Before we begin we must make sure that our software sources list is up-to-date.

You can achive this by simply opening the Ubuntu Software Center icon (found in the Launcher or by searching for the ‘Ubuntu Software Center’ in the search bar of the ‘dash’) and then:

• Place your mouse over the top bar (near your username), choose Edit > Software Sources
• From the resulting window choose ‘Other Software’.
• Tick the checkboxes next to ‘Canonical Partners’ and ‘Canonical Partners (Source Code)’. This repository includes access to software such as Skype and Adobe Reader.
• Choose the ‘update tab’ to configure your update schedule. A weekly or daily schedule is advised.
• Click ‘close’ when done thereby allowing the operating system to update itself with the new settings.

Please note,
For the purpose of this article I will not be addressing the use of any Personal Package Archive (PPA). Otherwise known as PPAs, these archives are used to help test pre-release or specialty software.

Using Terminal.

A brief introduction to software installation can be found here, but for the purpose of this article we will be using the Terminal.

By single definition the Terminal is similar to the command line in Microsoft Windows but it differs in the fact that it can perform any operation on the system. It is a very powerful application, but after a little practice you will discover that it is a very easy tool to use.

You can find Terminal by using one of the following methods:

• Dash > Search for Terminal
• Dash > More Apps > Accessories > Terminal
• But my favourite is to simply use Ctrl + Alt + T as a keyboard shortcut.

A helpful guide on this subject can be found here and here but once Terminal is open you will see somthing similar to the following:

username@ubuntu:~$

Let’s digress and just for a quick experiment try the a command. Type in the following (exactly as you see it) or use copy/paste and press the ‘return/enter’ key when done:

date

By doing this you have just requested the system to tell you the time and date. Obviously the exact time and date will be different on your system but you should now see something like this:

Sat Apr 28 15:35:35 BST 2012

And throughout this article that’s as complicated as we will get :-)

Naturally, I would encourage you to read the background information at your leisure but it isn’t necessary as all we are going to do is run the following types of command in order to perform an installation request:

sudo apt-get install <package_name>

or to install multiple packages we will use:

sudo apt-get install <package_name_1> <package_name_2> <package_name_3>

In reverse or if you ever make a mistake and you need to remove a package, simply use the following command format (replacing <package_name> with the name of the software you wish to remove):

sudo apt-get remove <package_name>

The most important thing to remember is. It may be a little awkward and strange at first (and I have merely introduced you to the subject), but by doing it this way, you will not only get a true feel for the Linux operating system but you will discover that Terminal is the fastest and most efficient way of getting the job done.

Updating your system

So without further hesitation, let’s jump straight in and use the Terminal to update our system. The commands are a little bit different to what we just discussed but I am sure they will be self-explanatory :-)

Open Terminal and type:

sudo apt-get update && apt-get upgrade

You will be asked to authenticate yourself – so simply enter your password and hit the ‘return/enter’ key.
Terminal will now perform a check on your system to see if any updates are available to you.

If none are available then no further action is required but if updates are available, Terminal will respond by asking you to confirm the update by using either a simply Y (Yes) or N (No) to complete the task.

A large update may take a while to complete but that’s it, to update your system it really is that simple and you can repeat these steps whenever you need to.

Building your desktop

Now we will turn our attention to building the desktop.

So let’s begin by installing a collection of useful utilities by returning to Terminal and typing:

sudo apt-get install flashplugin-installer gsfonts-x11 unace rar unrar p7zip-rar p7zip zip unzip sharutils uudeview mpack lha arj cabextract file-roller acroread geany geany-plugins filezilla calibre gparted

Some of the package names will be familiar to you whilst some others may not, but we have just asked the system to install a collection of tools that includes the Adobe Flash Plugin and the associated fonts, (acroread) Adobe Acrobat Reader, a series of zip/compression utitlities, (gparted) a disk partitioning tool, (calibre) an e-book catalogue and viewer, (filezilla) for FTP, and (geany) a compact text editor that shares some features of a larger IDE.

In the same way we can now consider installing a collection of tools to finish off Libre Office with a global menu bar, provide PDF functionality and incorporate the Mozilla plugins whilst including a Viso-like diagram creator called DIA.

sudo apt-get install dia libreoffice-pdfimport mozilla-libreoffice

While we are here, let’s install the basic tool kit that will enable you to compile from source (you may not want to do anything like this now, but by installing these utilities you will be giving yourself options for the future):

sudo apt-get install build-essential checkinstall cdbs devscripts dh-make fakeroot libxml-parser-perl check avahi-daemon

And to finish up, for those who like options and want to install Google Chromium, in Terminal type:

sudo apt-get install chromium-browser chromium-browser-l10n

Now wasn’t that quicker and easier than searching for and installing each item individually :-)

Building for sound, vision and design

For those who want the very best in audio-visual play back and recording in Terminal type:

sudo apt-get install smplayer libxine1-ffmpeg gxine mencoder mpeg2dec vorbis-tools id3v2 mpg321 mpg123 libflac++6 ffmpeg totem-mozilla icedax tagtool easytag id3tool lame nautilus-script-audio-convert libmad0 libjpeg-progs flac faac faad sox ffmpeg2theora libmpeg2-4 uudeview flac libmpeg3-1 mpeg3-utils mpegdemux liba52-0.7.4-dev libquicktime2 gstreamer0.10-ffmpeg gstreamer0.10-fluendo-mp3 gstreamer0.10-gnonlin gstreamer0.10-sdl gstreamer0.10-plugins-bad-multiverse gstreamer0.10-plugins-bad gstreamer0.10-plugins-ugly totem-plugins-extra gstreamer-dbus-media-service gstreamer-tools ubuntu-restricted-extras ttf-mscorefonts-installer regionset

This collection of important utilities should provide you with enough media codecs and players to keep you happy for quite a while :-)

For those who want to use their desktop for photography and/or graphic design, in Terminal type:

sudo apt-get install scribus gimp gimp-data gimp-plugin-registry gimp-data-extras inkscape pinta libraw-bin ufraw ufraw-batch and gimp-ufraw rawtherapee

This will install Scribus, Gimp, Pinta and Inkscape with a collection RAW file viewers/editors/plugins for SLR Digital Photography.

How do I remove the guest account

The Ubuntu ‘Guest’ account is installed by default and for those of us who want to keep the login screen nice and tidy, to remove it all we need to do is this:

In Terminal type:

sudo gedit /etc/lightdm/lightdm.conf

This will open the ‘lightdm’ configuration file in your text editor.
At the bottom of this file, underneath the existing copy add the following line:

allow-guest=false

Now save the file, close it and reboot.
The Guest account should no-longer be visible!

Restoring the screensaver

Ubuntu 12.04 LTS Precise Pangolin does not feature any screensavers in the standard installation and if you are like me (and miss them) this can fixed like so.

Run the following command to remove the existing gnome-screensaver package:

In Terminal type:

sudo apt-get purge gnome-screensaver

Next, run the following command to install the ‘xscreensaver’ packages:

In Terminal type:

sudo apt-get install xscreensaver xscreensaver-gl-extra xscreensaver-data-extra

Next, run the following command to create the ‘xscreensaver autostart file’.

In Terminal type:

sudo gedit /etc/xdg/autostart/screensaver.desktop

This will open a newly created file in your text editor. Simply copy and paste the following lines into that file and click ‘save’:

[Desktop Entry]
Name=Screensaver
Type=Applicaton
Exec=xscreensaver -nosplash

Close the file, reboot, search for screensavers in the ‘dash’ and configure as required and you will have as many screensavers as you will ever need …

Fall-back to the Gnome desktop environment

Some people like Unity, some people do not; (who am I to judge) but if you ever find yourself wishing to see the face of Gnome back on Ubuntu simply open Terminal and enter the following commands, one line at a time (press the ‘enter/return’ key at the end of each line):

sudo apt-get install gnome-session-fallback
sudo apt-get install indicator-applet-appmenu
sudo apt-get install gnome-tweak-tool

Each command may take a few minutes to complete but when done, simply ‘reboot’ your computer and at the login prompt, use the small ‘cog’ icon to change the user interface style.

You will have the choice of Unity, Gnome Classic or Gnome 3.

On the other hand, if you do not want to do this right now and just in case you are curious, Gnome Classic looks like this:

Whereas Gnome 3 looks like this:

And what about security they ask …

Last but not least we want to make our desktop environment safe and secure and to do this we need an anti-virus solution.

In Terminal type:

sudo apt-get install clamav clamtk

This will install ClamAV, an open source (GPL) antivirus engine designed for detecting Trojans, viruses, malware and other malicious threats.

When the installation is complete simply search for ClamTK in the ‘dash’, it is very easy to use, the software also runs on Windows and all updates are made free of charge. See http://www.clamav.net/ for further details.

And finally, to finalise our ‘desktop starting point’ we now want to install a firewall.

Thank fully, Ubuntu have made this an easy choice that simply requires you to install the ‘Uncomplicated Firewall’. Otherwise known as UFW, it is designed to be very simple and is packaged with an intuitive user interface. According to the developers,

“The reason ufw was developed is that we wanted to create a server-level firewall utility that was a little bit more for ‘human beings’”

They may call it simple (and it is), but don’t underestimate its power.

In Terminal type:

sudo apt-get install gufw

When the installation is complete you will be able to find it in the ‘dash’ under UFW but for now this is where I will leave you as I shall come back to the UFW and the art of firewall configuration at a later date.

If you followed this article you should (by now) have a desktop swimming with ‘apps’ and more than enough to get you started. And I think it’s time to let you play …

I hope you enjoy using Ubuntu 12.04 LTS Precise Pangolin.

The web development community is one of the most trend-focused groups of professionals that you’ll find anywhere. As part of their quest to define a new way of displaying content and introducing users to a site’s best posts, this community of designers and programmers has invented the so-called “featured post slider” or “tabled posts box.” This box is responsible for displaying between two and (typically) five posts which are the site’s best and most recent works. This is a great idea when catering to new site visitors as they’ll be interested to see just why a website thinks that its content warrants saving, printing, bookmarking, or sharing. When combined with vivid and descriptive post images, this post slider box becomes a great way to draw users’ attention inward toward the website in much the same way that newspapers and magazines use large images and titles to captivate their readers’ attention.

Indeed, a tabbed post box is designed to be the primary element displayed on a site’s index page and it’s intended to be placed “above the fold,” meaning that it will be displayed before the end of a browser’s length on a typical laptop or desktop computer. It can optionally use JavaScript to rotate through posts, with slick animations that further increase readers’ attention and curiosity. No matter which technique is used to develop this box full of featured posts, it’s sure to grab attention and introduce new and existing readers to your site’s best authors, its premier articles and entries, and its stunning use of imagery. Here’s how it’s done using WordPress, XHTML, CSS, and optionally jQuery code.

Step 1: Define a Block Element to House the Post Slider Feature

Essentially, every image and story contained within the post slider will be styled using just one div tag. Therefore, it’s important to define this tag at the outset so that it can be used and called within all the styles and functions that are about to be defined both in WordPress and in the theme’s files themselves. So, this is the time to decide exactly where the post slider feature will be placed on your website’s index page. When you’ve decided that, simply place the following code into your theme’s existing “index.php” template and move on to the second step:

<div id="slider-post-box">
  /* THIS IS A PLACEHOLDER FOR FEATURE SLIDER CODE */
</div>

That’s simple enough, and it’s all we’ll need to do to the “index.php” template for now. If you like reducing your desktop clutter, you can close this template as we proceed with developing the function itself.

Step 2: Taking Advantage of Built-in (Hidden) WordPress Features

This post slider box is going to use images to draw users’ attention to the featured stories that are highlighted on the index page, and it’s going to do that using a secret WordPress feature that most users simply don’t know exists. This is known as the “featured post image” feature, and it was once known as the WordPress “post thumbnail” feature. At one time in WordPress’ history, this feature was included and turned on by default; now, however it must be enabled on a theme-by-theme basis by the designer who wishes to take advantage of it. This is done by modifying the theme’s “functions.php” file.

Navigate to your theme’s home folder at /public_html/wp-content/themes/your-current-theme/ and select the “functions.php” file to edit it. If there are already a number of custom functions defined, simply scroll to the end of those functions and then paste in the code below. This code will cause WordPress to initialize the featured image both in the Dashboard itself and throughout the templates that comprise the current theme. That code is as follows:

add_theme_support('post-thumbnails', array('post' ));
add_image_size('click-image', 60, 30, true);
add_image_size('post-slider-box-image', 600, 300, true);

The first line of code in this setup simply adds support to the existing theme (and to the Dashboard itself) for the featured post image. The second line of code creates a thumbnail that is just ten percent of the size of the full-size featured post image. This can be used in the “tabs” that navigate between featured posts, or it can be left out, but it’s always a good idea to generate a thumbnail. Finally, the third line of code creates a full-sized featured post image that will be used for the main display within the post slider box. All of the image sizes are customizable, so feel free to make this work for whatever type of layout your website currently has in place.

Step 3: Initializing a Second WordPress Loop

Unfortunately, the WordPress Loop can only be initialized once per template. That’s not to say that the same content cannot be pulled in multiple times, however, in order to place entries on a page multiple times using a standard Loop-like setup, a database query will be initialized to pull variables and information from the standard WordPress entries table within the database. This is done on the “index.php” file, so be sure to open that file and place this code within the div tags created in the earlier part of this tutorial. The opened, secondary Loop looks like this:

<?php $featuredPosts = new WP_Query();
$featuredPosts->query("showposts=3");
while ($featuredPosts->have_posts()) : $featuredPosts->the_post(); ? >

This secondary WordPress Loop is pretty straightforward, and it’s used to display only the three latest entries produced by site authors. If a certain category is desired for this post slider box, it can be specified using the cat=5 construction, where “5” is the numerical ID of the preferred category. If no changes are required, it’s time to add more to this Loop. Next, we will produce the actual “slides” or “tabs” that will display to users:

  <div id="slider-">
    <a href="<?php the_permalink() ?>"><?php the_post_thumbnail('post-slider-box-image'); ?></a>
  </div>

This displays only the featured post “thumbnail” image, as it is called by the WordPress variable, if one is featured in the “Add New Entry” area of the WordPress Dashboard. If an image is not defined within the Dashboard, a post will not be considered “featured” and it will not be presented in the slider. With this being defined, it’s time to close the loop. That’s done with this piece of PHP:

<?php endwhile; ?>

Step 4: Adding Tabs for Maximum Usability

At this point, all that will happen with the above code is that one image will be displayed and nothing else will be. The image will link to the post which it’s associated with, but users have no way of seeing the other feature posts or navigating between them. This is a significant usability problem, but it’s easily solved by adding so-called tabs, or side-by-side links, to the other featured posts (up to three, unless the number was increased by the designer in the above WordPress Loop).

Because we’ve established how to use multiple WordPress Loops throughout the site, it will come as no surprise to most designers that we are going to take this opportunity to use a tertiary Loop that will call the other posts into a list. This list will then be styled using CSS so that the post links appear side-by-side, rather than in a traditional vertical listing. It all comes together like so:

<ol id="slider-links">
  <?php $nav_id=1;
  while ($featuredPosts->have_posts()) : $featuredPosts->the_post(); ?>
    <li><a href="#slide-< ?php echo $nav_id; ? >">< ? the_title(); $nav_id++;? ></a></li>
  <?php endwhile; ?>
</ol>

As any experienced WordPress Developer can see, an ordered list is first established and then each of the featured slider posts are placed into li tags. Only the title of the post is displayed, and this helps to save on space versus including a thumbnail-sized post image as well as the title. For websites that prefer a thumbnail, a simple variable (modeled after the full-size image in the earlier part of this process) can be included within the tertiary WordPress Loop.

Step 5: You’re Done! Unless …

This brings us to the end of the tutorial for creating a simple WordPress post slider box. Each full-sized image is paired with a small tab that links to the other featured posts. It’s a great way to draw users’ attention to one post, and encourage that they click on the other tabs to enjoy more top-notch content as well. But what happens if a site wants to expose all three of the featured posts equally? This is not as impossible as it might sound, especially because WordPress contains the necessary language to do so built into its core.

If you’re ready to tackle JavaScript, by way of the jQuery library of animations and functions, then it’s time to turn this slider box into one that actually, literally “slides” images back and forth and features all posts to users in an equal fashion.

You can start this process by including all three of the default jQuery libraries built into WordPress in the “header.php” file. All three libraries are included using a PHP variable:

<?php wp_enqueue_script('jquery-ui-core'); ?>
<?php wp_enqueue_script('jquery'); ?>
<?php wp_enqueue_script('jquery-ui-tabs'); ?>

Don’t forget any of these libraries, as functions from all three are an important way to make sure that the tabbed layout is fully functional and fully animated. When each of these three lines has been pasted into the theme’s “header.php” file, it’s time to move on to the next step.

Step 6: Remember that “Div” Tag from Step 1?

Before closing the “header.php” file, another simple line must be inserted using a JavaScript script tag. This determines the functionality of the box and to which CSS “ID” element it will be applied. The code that will be used looks like this, and it can go anywhere between the <head> and tags in your header file:

<script type="javascript">
  jQuery(document).ready(function($){
    $("#slider-post-box").tabs({
      fx: { opacity: "toggle" }
    }).tabs("slide", 1000);
  });
</script>

Images will now “slide” into each other every one second. That’s a bit fast, but it’ll hammer the point home pretty well during a test run. The “1000″ number can be increased and this will slow down the actual sliding / rotating action between featured post images in the post slider box. The animation style can also be changed to any of the methods that the jQuery Core UI library supports, and users will enjoy playing around with animations until they find the perfect way to draw attention to their featured entries.

Be sure to customize the “ID” element indicated in this script by the hashtag. If this is incorrect, the animation and automatic cycling through featured post images will not occur at all. That simple mistake often leaves many users frustrated and feeling as if they can’t conquer jQuery, but simple attention to detail can avoid this occurrence altogether.

Step 7: Bug Test and Make it Public

It’s well-known for being temperamental, so any design element using jQuery should be rigorously tested by website designers and administrators before it’s permitted to go public. Be sure to double-check that the new post slider box looks uniform in all major browsers, and do a little mobile testing to ensure that it doesn’t cause mobile phones to glitch (this can often happen to Android users when dealing with JavaScript on non-mobile sites).

If everything works perfectly, then the process is finished and the post slider box is ready too wow and woo new users.

Ubuntu 12.04 has arrived and this is the guide to get you up and running in no time at all.

Representing the latest release in an excellent pedigree there is no doubt that Ubuntu 12.04 LTS looks great and does the job exceedingly well. Naturally, things may feel different, particularly in view of the new features found, but on the whole we are going to discover that Ubuntu remains steadfast, reliable, easy to use, highly customisable and secure.

So let’s begin …

Requirements:

Assuming that your host computer meets the specific requirements you will need to download an iso image of Ubuntu 12.04.

You can obtain this from the Ubuntu Website where you can elect to choose either, the 32-bit or 64-bit version; but given the range of multimedia plug-ins associated with today’s desktop environment the 32-bit version is advised.

When the download is complete:

• Burn the image to a blank CD with your favourite CD/DVD burning software.
• Insert the media and boot from that drive.

You should be aware that during the installation an active internet connection is required and for those wishing to install this operating system on a mobile device (i.e. Laptop or Netbook), it is advised that a mains power supply is used or made available throughout this process.

Installation

In this first part of this article we will take a quick trip through the typical installation process.
From the boot screen, select your language and choose “Install Ubuntu”

On the next screen you will be shown the requirements of the installer.
Ensure that the following checkboxes are ‘selected’.

• Download updates while installing.
• Install this third-party software.

In many respects, I would say that checking these boxes should be considered as a requirement as this action will ultimately make the entire process a little easier.

In the next screen we will simply confirm that we want to erase the contents of our hard drive and install Ubuntu.

Note:
These guidelines are for a typical installation.
If you are attempting to ‘dual-boot’ then your screen may look different at this stage.

To proceed, choose “Erase disk and install Ubuntu” and click “continue”.

As the installation method chosen will remove all the data from our hard drive the resulting screen will act as a confirmation of our previous instruction.

Note:
If you have made a mistake and wish to salvage any existing data (or attempt a completely different type of installation)
then this is the time to quit and to start again.

Confirm the correct hard disk has been chosen and if you are happy to proceed, click ‘install now’.

Ubuntu will now begin the installation process and the installer will ask a few simple questions.
Don’t worry, there is no time limit.

The first screen will ask us to confirm our time zone/location.

By using your mouse simply choose your closest geographical location.
When done, click ‘continue’ to proceed.

The next screen will ask us to confirm our keyboard layout.

Again, this is relatively straight forward and a test field is provided in order that we can validate our selection.
As before, when done, click ‘continue’ to proceed.

The final screen will ask us to create a user identity.

Start with your name or preferred alias and complete the subsequent fields.

In general all usernames/passwords/computer names should be no longer than 16 characters long and they should not contain spaces or non-standardised characters.
Remember to keep your password safe at all times.

When done, click ‘continue’ to proceed.

The basic steps are now complete and from this point onwards (and until prompted) you can click through the feature dialogue on the main installation screen by using the left and right arrows on the main display area.

Please be patient.
Depending on the speed of your internet connection the installation process may take some time and when complete you will be required to reboot.

As indicated below click ‘restart now’ to in order to complete the process.

Your computer will now reboot and ask you to remove the installation media from your optical drive.
(You will be asked to confirm this by pressing the ‘return/enter key’).

After a successful reboot you will be welcomed by the Ubuntu 12.04 login screen:
Login with the password created during the installation process to uncover your crisp and shiny new desktop.

Well done, you have now successfully installed Ubuntu 12.04 LTS Precise Pangolin.
And this is where the fun begins …

What happens after first boot

Just like a typical Windows desktop, Ubuntu will automatically check for updates and depending on the options available to you, you may be asked to:

• Confirm the use of any optional drivers for your video card (You can also find this in System Settings > Hardware > Additional Drivers.)
• Install operating system updates.

With regard to system updates, when prompted simply click the ‘yes’ button to update.

Note:
If you are not prompted to update the system you can always start the ‘Update Manager’ by opening the ‘Dash’ and typing ‘Update Manager’ into the search bar. When found, click the icon to open the tool. Choose ‘check’ and then ‘install updates’ if any are available.

And that’s it …

In the next installment we will take up the running with a check-list of post install ‘tips and tricks’ that will deliver a fully functional desktop computer suitable for most home and office environments, but before we ‘jump in’ I am sure you may want to spend some time discovering your new system. There are lots to discover and may I suggest starting with Ubuntu One, Terminal, Rhythmbox, Shotwell Photo Manager, Gwibber, Libre Office, and Transmission to name but a few.

Until next time, have fun …

Brian Raymor’s recent SitePoint article, WebSockets: Stable and Ready for Developers provides a fabulous overview of the technology. In essence, WebSockets permit asynchronous bi-directional communication between the client and server. A connection is held open so lightweight messages can be sent from either device at any time. It’s an ideal solution for real-time chat and games and is likely to be more efficient than Ajax polling.

That said, there are a couple of drawbacks:

• WebSocket technology is relatively new and, at the time of writing, it’s only fully supported by Firefox and Chrome.
• Even if your browser supports WebSockets, there’s no guarantee it’ll be natively supported by your server platform.

Stable and ready? Perhaps not yet.

Fortunately, there’s another option if you’re desperate to exploit WebSocket technology today. Pusher is a new service which ployfills over the gaps in WebSocket implementation:

• Pusher is a proxy service that sits between your clients and server.
• On the client, Pusher provides a range of WebSocket libraries for JavaScript, iOS, Android, Flash, .NET, Silverlight, Ruby and Arduino.
• If you’re using a browser which doesn’t offer native support, the JavaScript library automatically imports a Flash-based shim which implements WebSocket technology on IE6 to 9, Chrome 1 to 4, Firefox 1 to 3, Safari 1 to 4, Opera and Android.
• On the server, Pusher provides a range of WebSocket libraries for PHP (generic and framework options), Ruby, ASP.NET (C# and VB.NET), Python, Node.js, Java, Groovy/Grails, Clojure, Coldfusion and Perl.
• If you’d prefer not use the WebSocket API for triggering server events, you can adopt Pusher’s REST API.

The whole process is reassuringly simple. Once you’ve registered for a Pusher account, you’ll receive an API key. Your HTML5 page includes the JavaScript library, establishes a connection and subscribes to a named channel:

<script src="http://js.pusher.com/1.11/pusher.min.js"></script>
<script>
var pusher = new Pusher("YOUR-PUSHER-API-KEY");
var channel = pusher.subscribe("my-channel");

You can then define callbacks that bind to events coming in via the Pusher socket:

channel.bind("my-event", function(data) {
	alert("An event was triggered with message: " + data.message);
});

To send a message from PHP:

require('Pusher.php');
$pusher = new Pusher($key, $secret, $app_id);
$pusher->trigger( 'my-channel', 'my-event', array('message' => 'hello world') );

The Pusher website provides full documentation, a selection of tutorials for PHP and Ruby and a showcase with case studies which might inspire your next world-beating real-time app.

I like the concept behind Pusher. It’s a great solution if you want to try WebSockets today while supporting the majority of browsers and native OS platforms. There are free plans for experimental prototypes as well as paid accounts for heavier usage.

For more information, refer to Pusher.com.

The Web is growing not only in size, but also in importance. The modern web as we know it has little to do with its early days of static pages; today, it’s anything but static. Some pages even earn the title of web applications–think Google Docs, for instance–apps that are accessed via a browser, and that start presenting serious competition to more traditional distribution models.

Development these apps is not simple. They’re inherently distributed between the client – a browser – and the server. Both are typically developed with different technologies and effort needs to be put into communication between them.

We often end up with a complex technology stack. A programming language for the server side, often with a framework on top of it, a programming language for the client side (usually JavaScript) with some libraries (jQuery, Dojo, Prototype, …), and a Database and its query language. All different technologies, with different concepts and models. Add configuration and tending to communication between them and you’ll get a picture of a fairly complex puzzle. Making all elements fit together is not an easy feat.

The goal of the new web programming platform, Opa, is to simplify this picture and to replace this complex technology stack with a single programming language. Let’s take a look at some simple Opa programs to see how it tries to make web developer’s life easier.

Hello, Opa!

Perhaps the simplest Opa program is the following:

Server.start(Server.http,
  { title: "Hello web",
    page: function() { <h1>Hello web</h1> }
  }
)

Let’s try to understand what happens here. First, Server.start is a function that starts a web server. It takes two arguments, the first one is a server configuration, including port, encryption parameters etc. – here we are just using default http settings. The second argument is the description of how the server should handle incoming requests. There are many variants possible for this second argument, here we are using a simple single-page-service variant which accepts a record with two fields: title and page.

Title is just a string with the title of this single page. Page is a function with no arguments that returns the HTML content of the page. Notice how we used an anonymous function for this field and that the last expression in a function is its return value. Also note how Opa “understands” HTML and accepts it via usual syntax.

Opa is built on modern standards so it supports HTML5, as witnessed by existing community projects using: WebGL, Canvas and SVG vector graphics. It also offers connectivity with existing services, including extensive libraries for: Facebook, Twitter, Dropbox and GitHub.

Compilation

How do we run the app? In Opa, it’s a two-step process. First, we must compile this program: (assuming we saved it in file named hello.opa)
opa hello.opa, and then we can run it with: ./hello.exe

With the growing popularity of interpreted languages one may wonder why Opa requires compilation. Apart from the usual argument that compilation allows for optimizations and better overall performance, there are at least two advantages of this approach.

The Opa compiler gathers and packs all application resources (including images and such) into one final executable (hello.exe in our case). That means that deploying it on a server requires just copying this single file and running it there. No external dependencies. No forgotten files.

Type checking

Next, Opa is a strongly, statically typed language and the compilation phase has many checks, including type-checking. That means that the compiler is able to detect a large class of programming mistakes and point them out to you, even before you run your program. This is very important and is in fact one of the crucial differences between Opa and some other web technologies, such as Node.js.

To better understand that let’s take a look at our simple program. What if we made a typo in one of the function or field names? What if we forgot one argument? What if page returned a string, not an HTML fragment? In all those situations the compiler would point out the mistake with a clear indication of the problem.

But the checks go much further than that. There are many variants possible for the second argument of the Server.start function. Opa’s type checker is strong enough to infer which variants are permissible and accept only those. I said infer, because in most situations you are not required to annotate your programs with types (as in, say, Java) and instead the compiler will perform type inference for you. Especially in bigger projects: this is a life saver.

Simple Demo

It’s hard to judge a language by how one writes “Hello world”, so let’s look at a slightly more complex, though still basic, Opa program.

database mydb { int /counter = 0; }
function action(_) {
    /mydb/counter < - /mydb/counter + 1;
    #msg = <>Hello, user number {/mydb/counter}!;
}
function page() {
    <h1 onclick={action}>Hello, world</h1>
    <div id="msg">Click the header</div>;
}
Server.start(Server.http, { ~page, title: "Hello, world" });

What does this program do? It presents a page with a “Hello, world” header, and a message saying “Click the header”. Upon clicking the header the message is replaced with “Hello, user number x”, where the x is replaced with the number of times the header was clicked since the inception of the service, i.e: it won’t be reset upon, for instance, restarting the web server.

Database

Let’s take a closer look at this program. To count the clicks it uses a database and so it starts with a declaration of a database called mydb, containing a single value of type int at path /counter. Database paths in Opa are locations for DB values and, conceptually, are somewhat similar to filesystem paths. That’s a very modest database but there are essentially no limitations on the number and complexity of paths.

As you can see in the action function, Opa tightly integrates database programming in the core language, providing convenient syntax for database reads and updates; and also querying, although that’s beyond the scope of this article. With a simple annotation one can choose the database engine that will power the application, with MongoDB being the prime choice in Opa right now.

Interactivity

Onto the page function. Interestingly, the static HTML contains an event handler, which points to a function in our program.

<h1 onclick={action}>Hello, world</h1>

where the said function does some database manipulation and DOM manipulation using special syntax:

#msg = <>Hello, user number {/mydb/counter}!;

There are two things at play here. Firstly, #id = content means: replace the content of the DOM element with id with content. Secondly the HTML fragment contains an insert, which is an easy and safe (more about that later) way to inject values into strings/HTML fragments. For instance Java’s:

System.out.println(x + " + " + y + " = " + (x+y));

would in Opa become:

println("{x} + {y} = {x+y}");

Unified client/server coding

In the snippet from the action function, the insert happens to be a read operation in the database. The interesting thing about this function is that obviously all database manipulations will have to be executed on the server, while all DOM manipulations will need to happen on the client. Not only does the Opa compiler figure out what should happen where, but it also automatically generates Javascript for the client and transparently takes care of all client-server communication.

Of course the developer can have better control over what’s happening and decide himself what should go where by means of simple function annotations. But the nice part is that moving function from client-to-server (or vice-versa) boils down to replacing the client keyword with server and the rest is handled by the compiler.

Another thing worth noting is how easy it is how easy it is to program event handlers and achieve interactivity in Opa. In fact, the language offers powerful constructions for real-time web, however that goes beyond the scope of this short article.

Security

One of the main challenges of web applications, and one to which Opa pays particular attention, is security. With constant client-server communication and the interactive nature of web apps its very challenging to make sure that sensitive information does not leak, and that users cannot do harmful things. Opa takes a twofold approach to this problem.

Apart from the client/server function annotations it provides two additional ones for the server functions: exposed and protected, which differentiate between server entry points that can be optimized for performance and those that should not be accessible, event to a compromised client.

The second security measure comes from the aforementioned type-safety of Opa. On one hand it means that (just like for some other high-level languages) buffer overflows or null pointer exceptions just cannot happen in Opa. On the other hand it offers protection against most popular security threats such as XSS attacks and code injections. This protection is possible because thanks to typing Opa knows what is an URL, what is HTML and what is a database-query (as opposed to dynamically/weakly typed languages where all of the above would just be strings) and therefore can properly sanitize all inserts.

In this short article I only had a chance to scratch the surface of what Opa has to offer, but I hope that was enough to get you interested in the language. I hope to continue with more news and tutorials about Opa in the near future. For now, if you want to know more, I suggest you visit Opa’s website, where you candownloadit, read themanual,theblog (with numerous tutorials) and a bunch of otherarticlesaboutOpa. And if you want to know more you can meet the helpful Opa community on theforum.

Kevin Yank’s done it again! He’s just completed a new 2012 edition of his best-selling book (Build Your Own Database Driven Web Site, 4th Edition) which is now titled - PHP & MySQL: Novice to Ninja. And, today you can:

• Take a sneak peek inside the book (with an excerpt from the Chapter 3 -Introducing PHP)
• Order the book, and SAVE up to 50%

Introducing PHP

PHP is a server-side language. This concept may be a little difficult to grasp, especially if you’ve only ever designed websites using client-side languages like HTML, CSS, and JavaScript.

A server-side language is similar to JavaScript in that it allows you to embed little

programs (scripts) into the HTML code of a web page. When executed, these programs give you greater control over what appears in the browser window than HTML alone can provide. The key difference between JavaScript and PHP is the stage of loading the web page at which these embedded programs are executed.

Client-side languages like JavaScript are read and executed by the web browser after downloading the web page (embedded programs and all) from the web server. In contrast, server-side languages like PHP are run by the web server, before sending the web page to the browser. Whereas client-side languages give you control over how a page behaves once it’s displayed by the browser, server-side languages let you generate customized pages on the fly before they’re even sent to the browser.

Once the web server has executed the PHP code embedded in a web page, the result takes the place of the PHP code in the page. All the browser sees is standard HTML code when it receives the page, hence the name “server-side language.” Let’s look back at the today.php example presented in Chapter 1:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>Today&rsquo;s date (according to this web server) is
<?php 
echo date('l, F jS Y.'); 
?> 
</p>
</body>
</html>

Most of this is plain HTML except the line between <?php and ?> is PHP code. <?php marks the start of an embedded PHP script and ?> marks its end. The web server is asked to interpret everything between these two delimiters and convert it to regular HTML code before it sends the web page to the requesting browser. The browser is presented with the following:

Notice that all signs of the PHP code have disappeared. In its place the output of the script has appeared, and it looks just like standard HTML. This example demonstrates several advantages of server-side scripting:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>Today&rsquo;s date (according to this web server) is
Sunday, April 1st 2012. </p>
</body>
</html>

Notice that all signs of the PHP code have disappeared. In its place the output of the script has appeared, and it looks just like standard HTML. This example demonstrates several advantages of server-side scripting:

No browser compatibility issues

PHP scripts are interpreted by the web server alone, so there’s no need to worry about whether the language features you’re using are supported by the visitor’s browser.

Access to server-side resources

In the above example, we placed the date according to the web server into the web page. If we had inserted the date using JavaScript, we’d only be able to display the date according to the computer on which the web browser was running. Granted, there are more impressive examples of the exploitation of server-side resources, such as inserting content pulled out of a MySQL database (hint, hint …).

Reduced load on the client

JavaScript can delay the display of a web page significantly (especially on mobile devices!), as the browser must run the script before it can display the web page. With server-side code this burden is passed to the web server, which you can make as beefy as your application requires (and your wallet can afford).

Basic Syntax and Statements

PHP syntax will be very familiar to anyone with an understanding of JavaScript, C, C++, C#, Objective-C, Java, Perl, or any other C-derived language. But if these languages are unfamiliar to you, or if you’re new to programming in general, there’s no need to worry about it.

A PHP script consists of a series of commands, or statements. Each statement is an instruction that must be followed by the web server before it can proceed to the next instruction. PHP statements, like those in the aforementioned languages, are always terminated by a semicolon (;).

This is a typical PHP statement:

echo 'This is a <strong>test</strong>!';

This is an echo statement, which is used to generate content (usually HTML code) to send to the browser. An echo statement simply takes the text it’s given and inserts it into the page’s HTML code at the position of the PHP script where it was contained.

In this case, we’ve supplied a string of text to be output: ‘This is a <strong>test</strong>!’. Notice that the string of text contains HTML tags (<strong> and </strong>), which is perfectly acceptable. So, if we take this statement and put it into a complete web page, here’s the resulting code:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p><?php echo 'This is a <strong>test</strong>!'; ?></p>
</body>
</html>

If you place this file on your web server and then request it using a web browser, your browser will receive this HTML code:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Today&rsquo;s Date</title>
</head>
<body>
<p>This is a <strong>test</strong>!</p>
</body>
</html>

The today.php example we looked at earlier contained a slightly more complex echo statement:

echo date('l, F jS Y.');

Instead of giving echo a simple string of text to output, this statement invokes a built-in function called date and passes it a string of text: ‘l, F jS Y.’. You can think of built-in functions as tasks that PHP knows how to do without you needing to spell out the details. PHP has many built-in functions that let you do everything, from sending email to working with information stored in various types of databases.

When you invoke a function in PHP—that is, ask it to do its job—you’re said to be calling that function. Most functions return a value when they’re called; PHP then behaves as if you’d actually just typed that returned value instead in your code. In this case, our echo statement contains a call to the date function, which returns the current date as a string of text (the format of which is specified by the text string in the function call). The echo statement therefore outputs the value returned by the function call.

You may wonder why we need to surround the string of text with both parentheses ((…)) and single quotes (‘…’). As in SQL, quotes are used in PHP to mark the beginning and end of strings of text, so it makes sense for them to be there. The parentheses serve two purposes. First, they indicate that date is a function that you want to call. Second, they mark the beginning and end of a list of arguments that you wish to provide, in order to tell the function what you want it to do.

In the case of the date function, you need to provide a string of text that describes the format in which you want the date to appear. Later on, we’ll look at functions that take more than one argument, and we’ll separate those arguments with commas. We’ll also consider functions that take no arguments at all. These functions will still need the parentheses, even though there will be nothing to type between them.

—

Fantastic, thanks Kevin for sharing that!

The good news is there’s loads more practical and hands-on examples just like this in the 500+ pages of the book. Which covers:

• Tutorials: Easy-to-follow tutorials with downloadable code examples
• Installation: Instructions for PHP & MySQL on Windows, Mac OS X, and Linux
• PHP coding: Learning the correct PHP syntax
• Database design: Mastering SQL database design
• Object Oriented Programming (OOP): Crash course in OOP principles.
• Building a CMS: Step-by-step guide to creating a CMS.
• Shopping Carts: Developing an e-commerce cart from scratch.
• Latest technologies: Updated for Windows 7, Mac OS X Lion, and the latest versions of PHP, MySQL, phpMyAdmin, XAMPP, MAMP, and HTML5.

Order your copy now:

• PRINT Book + Digital EPACK Bundle – for $34  (SAVE 50%)
• Digital EPACK (pdf, epub, mobi) – for $17  (SAVE 42%)

That’s it. Enjoy, and as always, we’d love to hear all your thoughts and comments.