The Git work environment.

Working with Git is quite different to using Subversion. The actual contents of the project directory change to reflect the currently active branch: the directory contains a whole repository, not a checked out copy. Don’t get alarmed when files start disappearing only to reappear again when you switch branch.

I also noticed that I interacted with the version control less frequently when editing, delete, and create files. The interaction is saved until you’re ready to commit, making the process feel more seamless. I occasionally used to get into trouble by deleting files via the OS, rather that using the Subversion command.

For the majority of the time, I’ll use the Git commands, as I’m working in a Git repository. The git svn functionality is only needed as a Git interface with Subversion.

Getting ready to work.

I like the master branch to always reflects the current trunk until I choose to update it, so all my commits are made from other working branches.

I start by checking out a branch based on master to use as a base from which to work. I’ve imaginatively called it basework in this example, and as a branch of master it is linked to the same remote branch: trunk.

git branch -a

should display all your branches in the repository.

jkw@mac> git branch -a * basework master svn/trunk jkw@mac>

I work in increments based on stories, that’s another post, so I actually create a story branch from basework, that can be merge back into this parent upon completing the story. This helps cope with changes in the remote codebase.

Creating my working branches.

It’s a good idea to check that basework is up to date with the remote Subversion trunk before branching:

git svn rebase

This will either update the local repository with the remote changes, or tell you that the current branch is already up to date.

I’m now in a position to create my story branch:

git checkout -b inwork

The -b option is used to create a new branch and then switch to it. Without this option the same command is used to move between branches.

This same process was used to create basework.

I have my working repository structure, and I’m currently working on my story branch, see the asterisk.

jkw@mac> git branch -a basework * inwork master svn/trunk jkw@mac>

The local commit.

You can see details of the changes to the local working branch using the git status command:

jkw@mac> git status

On branch inwork

nothing to commit (working directory clean) james@cybermac1> git st

On branch inwork

Changed but not updated:

(use “git add/rm …” to update what will be committed)

(use “git checkout — …” to discard changes in working directory)

#

modified: footer.php

deleted: images/feed-icon-64.png

modified: style.css

#

Untracked files:

(use “git add …” to include in what will be committed)

#

includes/category-1.inc.php

no changes added to commit (use “git add” and/or “git commit -a”) jkw@mac>

To add the new file show in the example to those being tracked:

git add includes/category-1.inc.php

If I wanted to add all of the untracked files, I could use the -A option instead of individually naming them.

Now all the files are staged, the time comes to commit them to the local Git repository:

git commit -a -m "A message to describe the changes."

Leaving the -m option off will cause Git to request comments using whichever editor is defined in your configuration files.

I now the story is complete, and all the changes committed to the inwork branch, it’s time to commit them to Subversion.

The remote commit.

I start the remote commit process by switching to the basework branch:

git checkout basework

Next I check that the remote codebase hasn’t changed, or update the changes:

git svn rebase

I’ll merge inwork into basework:

git merge inwork

I use my text editor to manually fix conflicts that arise. Git tells you where to find them by marking up the code. This is followed by another local commit, at which point the merge is complete.

Now I can try a dry run of the remote commit:

git svn dcommit -n

It’s the -n option that makes this a dry run: nothing has been committed yet. It shows you the local versions to be bulk committed if you choose to go ahead. To actually perform the commit, remove the -n, and re-run the command, it may take a while if you’ve been busy.

Verifying the remote commit.

This is where leaving the master branch untouched pays off. basework has been committed to the remote trunk, whilst master still reflects the pre-commit trunk.

I switch to master, which should contain none of my new work, and update it from the remote trunk:

git svn rebase

It should have changed to match basework, and if so the previous commit worked.

Cleaning up.

I’ve verified the commit: I have master and basework branches that are identical, so inwork is no longer needed, I’ll delete it:

git branch -d inwork

Deleting a child branch of a different parent is a little dangerous, so if you’re not in basework you’ll get a warning. Either switch to basework and try again, or re-running the command with the -D option.

If I’ve finished work on this project, I’d delete the basework branch too, but if I’m going to continue, I’d use it to create another working branch, and I’ve gone full circle.

mkdir myproject cd myproject

The initialisation itself is pretty simple, just remember to point Git at the correct url for your Subversion repository, and watch the communication protocols.

git svn init -s --prefix=svn/ svn+ssh://svn.repository.com/svn/myproject

The -s option tells the repository to expect the typical trunk, branches and tags structure of a Subversion project. You can specify the location of your trunk, branches and tags using the -T, -b, and -t respectively.

Using the --prefix option is handy, ensuring that the remote directories will be prefixed with svn/. This makes it clear which are Subversion and which git branches later.

All that remains is to checkout all of the information relating to your project from the Subversion repository.

git svn fetch

Depending on the size of the project, this could take a while, it’s downloading the entire project history from the remote repository.

I word of warning you about the strangeness that can ensue if the remote repository contains any tags. They will be imported as git branches, and you may find the local master branch pointing to something other that the remote trunk.

These git svn commands, and all the others, are pretty well documented. Now I’ve got a Git repository, in the next post I’ll to describe my normal workflow.

Branching and merging is quick and simple, and as a result I find I do this far more often than when using Subversion alone. I also commit changes more frequently: it’s far quicker than using a remote repository, even when not off-line.

This sort of functionality is vital to successful version control, and I think it promotes better practice, as long as you’re only committing working software. All the local Git commits will later be bulk committed to the remote repository. However they all retain their identity as separate versions, so discipline is important, we wouldn’t want anyone finding broken code.

I could get all this from Git alone, but the combination retains Subversion vendor branching and the deployment advantages of my existing Subversion / Capistrano set up. I’m going to try GitHub, or my own remote Git repository, and exploiting the Capistrano support for Git, but at the moment why reinvent the wheel?

I prefer to work on the command line, and that’s the approach this series will take, but GUIs are available for Git, try typing git gui to check out the one bundled.

I use this approach for anything I need version controlled, including my Curriculum vitae/Resume, but before try this out for yourself you’re going to need to check out a local copy of that remote Subversion repository… I’ll cover that next time.

My experiences got me thinking about what I needed to code confidently. As a minimum, I need to know that everything works before committing code to version control, but security comes with regular testing, and this is no use unless everything is covered.

Based on web development frameworks using the nearly ubiquitous MVC design pattern, the logic and side effects at each application tier must be tested, and I came up with this list.

1. The Database tier schema, whether RDBMS, XML or anything else.
2. Data Access logic is usually implemented in models, but often uses built-in features of the framework, such as ActiveRecord.
3. Business logic is encapsulated in the models, libraries, and sometimes controllers.
4. Presentation logic at the server comprising controllers and their respective views.
5. Presentation and business logic at the client tier implemented by DOM scripting, mostly in JavaScript.
6. The actual data presentation at the client tier based on XHTML and CSS.

I’ve tried to order it from inside the application, working out from the data tier to the client, and it’s quite a list; I’d be interested to hear what I’ve missed.

Since this is a huge topic, I hope to write a series of posts isolating specific areas as I encounter them, and comparing tools and approaches. The first will look at how a few development frameworks in popular languages appear to measure up.

Unfortunately, testing anything other than libraries and models is difficult because there’s no way to access the another important type of object: controllers. CodeIgniter positively encourages using controllers to implement business logic, consequently not being able to test them is a serious anomaly.

Integrating a front-end testing framework, such as Selenium, might be the solution, but does that properly test the controller code? I don’t think it does; the target there is the presentation tier at the browser.

The lack of good code coverage bothers me a lot, but I continue to struggle on with CodeIgniter because I’ve found other PHP frameworks to be just as lacking. Is this a general problem with frameworks? I’m tempted to try Ruby on Rails next to find out.

Information technology (IT), as defined by the Information Technology Association of America (ITAA), is “the study, design, development, implementation, support or management of computer-based information systems, particularly software applications and computer hardware.” IT deals with the use of electronic computers and computer software to convert, store, protect, process, transmit, and securely retrieve information.

This covers an ever increasing amount of ground: smartphones, MP3 players, games consoles, software for any platform, ATMs, and even the checkout at the supermarket are examples of the breadth of IT.

In my experience, IT means PCs, and mainly Windows, to most people. When these go wrong, it’s a work department called “IT” they expect to help… or not: hence the association.

The strange thing is that they don’t associate it with the mobile phone in their pocket, or any of the devices that have become ubiquitous at home. How long is it going to be before everything uses “electronic computers and computer software to convert, store, protect, process, transmit, and securely retrieve information”?

For example, the ubiquitous Microsoft Office offers great productivity features; such as macros, pivot tables and database connectivity. However once trained few office workers will ever use them. They can’t conceive of the situations in which these tools can be helpful: these problems are too hard.

By comparison a flint flake, or a modern steel knife, is readily understood: it’s sharp so you can cut things with it. What’s more, simple experimentation will show just about anyone how.

That’s the key: complex tools are designed for complex problems. So what if I’m only expecting the user to, well… use the tool, not solve the problem? Someone else will have to make the software, or the stone tool. There are two approaches to using technology to decouple humanity from the problem.

Simple interface.

Technology can be encapsulated to present the user with a simple interface.

In this case the user has little or no idea how the problem is solved, but is better aware of what can be done and how to instruct the device to do it. The field of Human-Computer Interaction (HCI) is focused on pursuing this approach.

The underlying technology may be capable of far more than the relatively simple interface is capable of communicating. Again, the human user is the limiting factor, but at least the design case problem has been solved by someone else.

Substitute the user.

The technology could be freed of dependence on human intervention.

Most examples of automation seek to do this, relying on relatively capable human minds to provide the programming framework.

This can be combined with weak artificial intelligence, so that the machine is capable of making minor decisions to overcome difficulties: for example the chess playing computer or robots capable of avoiding obstacles.

Dividing humanity.

Use of these approaches has been accelerating since the advent of industrialisation. Technological problem solving is really applied by an ever shrinking proportion of the humanity. The remainder are present as sentient regulators to check the machine does as the manual says it should.

Does this mean that the average skill level of the human race is actually falling, or just being placed into fewer hands and heads?

Positive experiences.

The most frequently touted benefit frameworks have to offer is minimising the time taken to code and deploy a software solution. Given my interest in Agility, this is an attraction, reducing the time to market.

Another solid development practice is code reuse in the form of software components, and frameworks have a place amongst them. This approach offers the reliability and security inherent in widely used and tested code. Remember to choose popular software though, or this benefit disappears.

On the downside.

Applications developed using frameworks have to carry significant excess baggage in the form of unused features. This raises two main issues: your codebase will be unnecessarily large, and underused blocks of code are a breeding ground for hidden exploits and errors.

Frameworks are designed to function in a specific way, some with more flexibility than others. This much you’d expect, after all it’s the essence of a framework, but what if it doesn’t provide everything you need? For example, I’ve spent hours trying to integrate SimpleTest, a unit testing suite, to produce satisfactory results with CodeIgniter. My unit tests run well for my own libraries, but I’m still unhappy with the test coverage imposed by CodeIgniter’s MVC implementation.

Finally, they say practice makes perfect, but does reliance on any framework reduce developer skill? This isn’t a problem if everything is pre-packaged in your chosen tool, but what if a client wants something that isn’t included?

Too good to ignore.

That said, I’ve found all of these software very useful and there are far too many advantages to ignore them. But I often find myself fighting these same tools, frustrated at they’re eagerness to help me do something in a way I don’t want it done. I guess the key is to understand which is the right tool for the current job: the ultimate skill for a developer.

There’s a good TextMate bundle to support Git, but to be honest I’ve mostly used the command-line.

Weaknesses.

Vendor branching is possible, but awkward. I frequently use vendor drops of WordPress, SimpleTest and a number of other libraries. There may be a good way of doing this, but I haven’t found it online… yet.

I miss the svn:externals functionality, especially in applications that use a lot of plugins: WordPress in particular. Subversion allows me to define particular tagged versions of these to be pulled from their repositories during deployment without needing to bother controlling them myself.

Strengths.

Branch merging when trying out new ideas is a dream. I created a new branch, refactored huge sections of the codebase, and merged it all back together flawlessly. With Subversion this would have been a lot slower and more problematic. Git’s simply great for those investigatory spikes.

The verdict for Git.

I’ve yet to seriously try Git to interface with my remote Subversion repositories, using the ‘git svn’ series of commands. Having local copies of these, whilst still being able to use remote Subversion would be very useful. I’ve found using remote Subversion repositories easy, but trying to push a Git repository to Subversion is not so easy. I’m also going to try deploying from a Git repository using Capistrano in the near future.

It strikes me that Git is best at programmer related activities and weakest in those of interest to administrators deploying applications. I shall certainly continue to use it, but alongside Subversion.

Changing the Architecture.

I’m not a keen on the idea of dumping all my code in the web server root directory, so I tested the framework flexibility by rearranged the application structure a little.

    -rw-r--r--   1 Capfile
    drwxr-xr-x  14 application
    drwxr-xr-x   3 config
    drwxr-xr-x  13 system
    drwxr-xr-x   5 public

Once these locations were updated in the application configuration files it all worked perfectly. The reasons for doing this sort of thing have been documented elsewhere, and I agreed with them from this security standpoint, however this structure also fits better with Capistrano deployment.

A positive first impression.

The Views deal with the presentation logic, and I like the fact that embedding PHP within the HTML is the default, instead of a complex templating system. It’s not the cleanest approach, but I prefer to have full control over my HTML.

As for the Controllers, the implementation is quite intuitive and you can build a friendly set of URLs with a little help from mod_rewrite and the URI class.

The form validation is a great feature that I found easy to implement within the Controllers and Views. I’ve centralised my validation rules in the global configuration file suggested in the documentation, but haven’t got the automatic rule group feature to work yet.

The Model class is used to represent a single database table. I’m used to mapping tables with a Class in this way, but normally each instance would represent a row of data. CodeIgniter Models implement the Singleton design pattern, only one instance per class, from which the Database class methods can be called.

The Database class provides the data access layer and a good set of robust methods which return an array of stdClass instances representing the resulting data rows. These arrays are then forwarded to the View, where the instance variables can be directly accessed. This is quick and easy, but not very OOP.

Implementation reservations.

I believe that the Model should be capable of running as a stand-alone application, once equipped with any interface, even the command-line. It’s this level of autonomy that results from the MVC design pattern: substitute a different Controller and View and it’ll still work the same way on a different platform.

Controllers reacting to events, whilst Views shouldn’t have direct, mutable access to instance variables. The Model should encapsulate both the data and the business logic, not something that can be effectively achieved with Singletons alone. Indeed CodeIgniter blurs this distinction by making Models optional and allowing data manipulation directly in the Controllers.

I’ve implemented my preferred approach by providing my own classes to replace the stdClass. They don’t extend the CodeIgniter Model class, but are instantiated within those that do, encapsulating data and business logic; including Object–relational data mapping and CRUD functionality.

It works well, but I’m concerned that by introducing a more rigourous approach I’m losing some of the advantages of the framework. May be I would be better to take CodeIgniter at face value, as a flexible, if a little dirty, rapid development environment that works.

The Agile approach is more adaptable with respect to three key project variables; only the last of which, in my experience, is considered flexible in the waterfall world of engineering.

• Scope.
• Time.
• Resources.

Scope contraction.

Scope flexibility is something of a taboo subject. Scope is something that is added to in both a controlled manner — providing additional revenue — or uncontrolled creep. But the point of any project is delivering something that achieves the customers business goals. This is not necessarily the product that they, or the development team, initially envisaged.

One uncomfortably overspent project lead to the realisation that I could have achieved the business objective well under budget by actually drastically reducing the scope. It wouldn’t have delivered exactly what the customer expected, but it would easily have achieved their goal.

Which is more important, expectation or results? If you have a customer representative on the team it’s much easier to explain your rationale, and the chances are they’ll like the idea of results with less work as much as you do.

Timescales.

If you have a customer that doesn’t mind when you deliver, you’re a rare and lucky project manager, though you’ll never actually finish anything; deadlines do provide focus. So set plenty of deadlines, that’s what iterations and releases are about.

Try to answer the most pressing question as quickly as possible. Leave refinements and those ever present scope changes to the next iteration, it’s probably only a few days away.

This rapid cycle provides useful results, whilst allowing the flexibility to quickly change direction without that wasteful churn: just tidy this up a bit then I’ll be with you.

And the resources?

I’m afraid the project manager has to earn their money too. Line management will always have the urge to reassign any of your key people they feel aren’t being fully employed. It’s important to emphasise that the productivity of any team depends on preventing this happening.

Agile teams don’t strictly segregate workload on the basis of job descriptions, that’s why you need versatile individuals. Unfortunately, these are exactly the type of individuals that those managers will want to steal away. Removing the demarcation of tasks will help ensure everyone is kept busy and that work is conducted using the minimum number of people.

Better than the Waterfall.

I’ve found actual project goals shift too frequently for effective use of the Waterfall approach to project management. Using iterations within this framework always felt unnatural; how do you decide how may there will be and when will you actually deliver something?

An Agile approach perversely leaves me feeling more in control by worrying less about control. There are a huge array of Agile software development techniques, many of which can be adapted to other engineering disciplines.

For Software Engineering, I would recommend reading The Art of Agile Development. The Agile Alliance promote the use of Agile techniques, so take a look at the Manifesto for Agile Software Development upon which it’s all based.

This came to my attention a few years ago when my Mother decided to learn how to use a computer. Once she retired she needed to keep up with the technology she’d avoided for years. I actually think it was a great idea; retirement often increases the perception that the world is leaving you behind. She’d never used a typewriter: why are those letters in such a strange place? The mouse was a huge challenge to hand–eye co–ordination.

She enrolled on CLAiT Level 1, and she’s made great progress, but I doubt she’d claim to be comfortable enough to be able to try something completely new without a lot of support. She can surf the Web, check and send basic email and do a little word processing, but that’s about it. It’s more than enough for her needs, but a business is going to need a little more.

The point is that there are a lot of younger people still in the workforce that are in much the same position to my Mother. They are often encouraged to undertake ECDL training as shown on the BCS website:

The European Computer Driving Licence® (ECDL) is the internationally recognized qualification which enables people to demonstrate their competence in computer skills. The record breaking ECDL is the fastest growing IT user qualification in over 125 countries. ECDL is designed specifically for those who wish to gain a benchmark qualification in computing to enable them to develop their IT skills and enhance their career prospects.

The problem I have is that I’ve encountered people with these qualifications, and others, purporting to be ‘Microsoft Excel Expert Users’, and they haven’t even figured out that a spreadsheet IS a big calculator! This can’t be entirely due to the course content, so why are these people allowed to pass this qualification: it has to be in the assessment and a reluctance to fail anyone.

So as an employer facing a knowledge based economy — according to the UK government — where success is based on the skills of your employees, how do you decide which candidates are fit for purpose? My experience is that you can’t rely on these benchmarking qualifications.

The problem is trying to decide which of these mutable resources are likely to be accessed in a concurrent fashion, provide locks to enforce mutual exclusivity; ensuring no other processes is working from an intermediate, invalid state; and all without becoming deadlocked. Traditional debugging and even test—driven approaches aren’t much help, because the errors are dependent on the order in which the processes are scheduled to be executed; not very repeatable, and certainly not controllable.

So the course left me itching to have a go, but aware that concurrent object oriented development needs to be done in the right language, oh, and very carefully. A little reading around the topic lead me to the idea of immutable state development.

Now in OOP terms an immutable state is not very helpful, nothing much ever happens. We rely on the software state being stored in the attributes of all those objects, and actions being driven by the exchange of messages between them. But in the functional programming paradigm an immutable state is implicit, since the state is stored in the way functions execute each other, and themselves, no data is actually stored in variables. This means that processes can be executed in any order without any danger of seeing an invalid state: no need for any locking and a much simpler programming job!

I’ve only just started investigating these ideas, but with the thrust of computing performance in the direction of multiple processors, either on a single machine or via the ‘cloud’, it seems that concurrent, parallel programming may be very important in the future. A couple of languages I want to check out are Erlang and Clojure. Finally, I found the Ruby on Rails Podcast interview with Jim Weirich an interesting perspective on the programming.

Here’s the near future dream; they can get a lot wilder.

I’m working on my latest project on the train, in a tunnel, whilst I travel to a meeting with a client. I reach a critical part where I need to see the big picture, so I find transfer the output to an LCD display in a coffee bar at the station.

It’s not going smoothly, and I decide I could use some help, so I call a few colleagues and arrange a conference in 15 minutes time. Once we’re all virtually present, it’s early remember, I’d show them the problem by sharing my display output via the network. Each using our own devices we work together, version controlled and still conferencing, until we crack the problem.

I thank everyone and leave for the Client’s office. Once there I transfer the presentation of the key project details to a large TV in the conference room and send a hardcopy to the printer in the office.

Oh… and all seamlessly without wires. Of course, this is a picture of the utopia of perfect interoperability and security, but what are the chances?

Interoperability.

The device layer interface is a key feature, with transparent support a wide selection of drivers and protocols, I don’t want to have to get involved. As many devices aren’t wireless enabled at the moment, have poor device driver support, or use proprietary communication protocols, this is a real challenge.

Getting input.

Input is probably still the good old keyboard and pointing device, of which there are several approaches for those who don’t mind carrying extra kit.

• Fabric keyboards that can be folded away, like the Just Mobile RoKy².
• Projected light keyboards like the I-Tech Virtual Laser Keyboard are compact and lightweight.
• The pointing is easier, a wide range of Bluetooth mice and other devices already exist.

And for those that do?

• Traditional mobile phone keyboard. I hate this, I’m too old to be any good and have an aversion to developing arthritis in my thumbs.
• Touch screen keyboards, the Apple iPhone is the best implementation I’ve come across.
• Stylus on touch screen for handwriting recognition as used by Palm.
• Or just being able to use any input device I find lying around, wireless of course.

There are other options like voice recognition, cameras, and detecting eye movements which could find wider use in the future. I’d like a direct mental link, so I can just think what I want to do, but I’d probably end up with a nasty brain wiping piece of malware!

Displaying output.

Displaying output raises important issues surrounding the usability of the actual user interface, after all, I’m proposing to go from working on a typical PDA size display to a 40 inch TV! I want to make the best use of the visible area on any given device, whilst avoiding 4 inch high characters.

The experience of designing for different web browsers, screen resolutions, and colour maps could be leveraged for this new platform. CSS can be targeted at different media types and such an approach could be adopted throughout the new system.

Staying mobile.

Power management is vital for extended mobile operation and I’d like to be able to work normally for several days at least.

This may be achieved by longer battery life or a totally different energy storage or generation technology. Fuel cells, solar panels or even nuclear power could be used; though even I’d be a bit concerned about carrying around a nuclear reactor. What if the fuel cell ran on a range of organic feed stocks, just like I do? I could recharge my computer at the same time as myself in any restaurant.

Wireless recharging could be an option, maybe inductive charging such as WildCharge pad. I’d prefer my device to selectively recharge at any opportunity, and from any source, so that I don’t have to be in any particular place or make any conscious decision. The device could decide to top-up from a nearby power cable, the sun as I walk around, or even using the heat of a warm day. Again, I don’t want to know it’s happening or how.

How long?

Much of the software architecture and implementation technologies already exist to make my dream device a reality, the real work is in perfecting the hardware at a cost that makes loss or damage acceptable; it’s portable remember. At the current rate of development I suspect I won’t have to wait too long for the device itself. But the legacy issues for hardware interoperability?

Ultimately it’s my guess that computing and the Internet will become indivisible; not sticking my neck out too much since for many of us it already is. If some of the wilder concepts of ubiquitous computing come to pass I won’t need a single device anyway, I’ll just pick up computing resources whenever I need them from the environment surrounding me.

1. Log in as a privileged user.
2. Create the domain deployment directory.
3. Export the application code from Subversion.
4. Update the file ownership and privileges.

For WordPress I also had to export code for each theme or plug—in to the required locations. So I decided to improve the situation. I’ve changed the way my WordPress sites are handled in Subversion; haven’t moved to Git yet like the rest of the world, and I am using Capistrano to manage the deployment.

Capistrano is a Ruby based remote task manager, the most commonly used tasks being for web application deployment. Obviously the original target was Ruby on Rails, but many people use it for PHP. It uses Secure Shell (SSH) as the preferred method for logging into remote servers; all communication is then encrypted.

What follows isn’t a full set of instructions on deploying PHP with Capistrano, HostingRails.com provide a useful piece and you should look at the Capistrano manual, these are my thoughts. May be something more detailed might come later… but no promises.

Managing the source code.

The Subversion repository for each blog project uses a vendor branch of the WordPress source code and svn:externals properties to import the required themes and plug—ins from their respective repositories.

WordPress updates are integrated into the vendor branch and then into any of my projects without disturbing any custom code changes. For merging changes I can strongly recommend using the svn_load_dirs.pl script, it allows you to maintain file history and makes the whole process easier.

And now deploy.

I currently have my main Subversion and Web servers on the same machine, leaving me with the option to use the local file:// protocol to retrieve the application files. I wanted to make my deployment script more universal so that I could use it for the production and development platforms.

The obvious choice was the svn+ssh:// protocol I normally use, but in addition to SSH, I use public key authorisation with passphrases for all of my servers. A frequent problem was that Capistrano didn’t like asking for passphrases for remote machines.

Since the repository and deployment machines are one in the same, I can use SSH forwarding to provide a recursive tunnel by defining the following in the deploy.rb script.

set :user, "me" 
ssh_options[:forward_agent] = true

The variable user tells Capistrano which user has SSH access and the forward_agent option allows the same SSH credentials for the tunnel to the Subversion server. Now , if your svn user is different from the ssh user you’ll need to add another couple of things:

set :svn_user, username
set :repository, "--username #{svn_user} svn+ssh://hostname/repository/#{application}/trunk"

These variables enabled me to use the default deployment tasks for my application, there’s no need to override them, just use the before_ and after_ hooks to define additional functionality.

The result.

I have two WordPress blogs deployed on my server using Capistrano and Subversion for remote control, including custom themes and third—party plugins. I’ve already redeployed to incorporate changes and everything has worked perfectly.

Next… Drupal?

So it looks like it’s going to be one of those coupled with a secure online backup service and DVD-R backups of RAW image files, very big and expensive to upload, in the fireproof safe.

Still waiting on the Mac support from online backup providers though.

I run a small network at home with all of these data on a single drive sitting inside a Synology DS-101g+ NAS. There’s an old 80GB external USB hard drive attached to it, onto which the NAS content is incrementally backed up at night.

The Synology NAS has been great since is replaced a Linux server when the cooling fans failed. However, that incident coupled with a laptop drive crash has got me wondering whether my current approach is good enough. After all, can I afford to lose the data I’ve created between the daily backup and what if the house burned down? On top of this, the last time my server lost a fan I couldn’t access my files and why are these things always a non-standard, hard to get sizes?

So I’m wondering whether to take the following steps:

<ul>
    <li>Set up a Synology DS-106, the 101g+ has been replaced, as my primary file server.</li>
    <li>Configure the new <abbr title="Network Attached Storage">NAS</abbr> to backup to the old one each night, providing redundancy.</li>
    <li>Make regular copies of all the files on DVD-R, storing them in a fireproof safe or a remote self storage locker.</li>
    <li>Consider secure online storage for critical files only as it&#8217;s not cheap, but could be configured to back them up whenever they change.</li>
</ul>

The problems are that a failure between backups could lose me a days work and finding an online backup service for a networked Mac is not as easy as it should be. With reference to the former, if I was producing a lot of commercial data I’d install a good RAID system. As for the latter, they’re all promising to have Windows and Mac support soon, honest.

I don’t bother backing up the individual machines, a Mac mini and a Windows laptop, because I enjoy spending a whole day rebuilding them if something goes wrong. A cloned copy of these drives might be a worthwhile exercise, even if it isn’t kept totally up to date.

All this is telling me to spend some money, but will I get away with it??