defaults write com.apple.finder AppleShowAllFiles TRUE
killall Finder


At least for me, that’s a much more usable solution than permanently showing all hidden files, which is what you get by executing the more commonly documented solution:

See also:
[1] http://www.macworld.com/article/142884/2009/09/106seehidden.html
[2] http://www.mactricksandtips.com/2008/04/show-hidden-files.html

First, you need to download the Mercurial package for your system. If you use a mac with macports you can just use type sudo port install mercurial. You could also use the very nice mac .dmg packages from berkwood. On Ubuntu, you should be able to sudo apt-get install mercurial. On windows, you’ll probably want to download and install TortoiseHG. BitBucket makes it complicated to find the download link so just click this one instead. You’ll want the file in the top of the list. Right now, that is TortoiseHg-0.7.5-hg-1.2.1.exe.

So, you should now have a working mercurial command line executable. To try it out, open your shell of choice and type hg.You should get something like this:

loki:dtest erik$ hg
Mercurial Distributed SCM

basic commands:

 add        add the specified files on the next commit
 annotate   show changeset information per file line
 clone      make a copy of an existing repository
 commit     commit the specified files or all outstanding changes
 diff       diff repository (or selected files)
 export     dump the header and diffs for one or more changesets
 init       create a new repository in the given directory
 log        show revision history of entire repository or files
 merge      merge working directory with another revision
 parents    show the parents of the working dir or revision
 pull       pull changes from the specified source
 push       push changes to the specified destination
 remove     remove the specified files on the next commit
 serve      export the repository via HTTP
 status     show changed files in the working directory
 update     update working directory

use "hg help" for the full list of commands or "hg -v" for details

Now comes the fun part. Simply navigate to the directory you want to put under revision control and run

hg init

. This will create the .hg directory which stores your local repository.

Your next step should be to create a .hgignore file. This file will tell mercurial which file types to ignore. It can use two syntaxes, standard shell globs and also regular expressions. This should give you enough flexibility to eliminate all those pesky auto-generated files, movies, etc from your project directory. Here’s what I’ve been using for drupal projects lately, it should give you a good idea of what sort of patterns you might use.

syntax: glob
*.pyc
*~
hostmeta.ini
Thumbs.db
.DS_Store
*.exe
*.flv
*.mov
*.zip
*.avi
*.wmv
*.dv
*.psd
*.LCK

syntax: regexp
.*\#.*\#$
^files.*
^web/files.*
.*CVS.*

Now that we’ve got an .hgignore file, let’s check it into revision control. Simply execute

hg add .hgignore

and then

hg commit -m 'added .hgignore file'

. The add tells mercurial to flag the file revision control. The commit command will actually push the contents of the file into the revision control repository.

Now, let’s put your files under revision control. At this point, since you have a .hgignore file that eliminates all the files you don’t want controlled, you can run the

hg status

command. It will show you all the status of all the files in the revision controlled tree. File which are checked in and already up to date or ignored will not show up on the listing. For a newly created Django project with a single app in it, you might see something like this:

loki:dtest erik$ hg status
? __init__.py
? manage.py
? myapp/__init__.py
? myapp/models.py
? myapp/tests.py
? myapp/views.py
? settings.py
? urls.py
loki:dtest eri

Now, if all the with ? in front of them are ones you want to add to revision control, simply execute

hg addremove

. This will recurse the tree and add all the missing files, and mark any files that have disappeared from your local tree as deleted in the repository. Then, you just run

hg commit -m 'added first set of files'

in order check everything in.

If you had files with ? that you don’t want under revision control, you will need to add expressions to your .hgignore file to ignore them and re-run status. You can also just use add manually on your files, but in my opinion the addremove feature is such a nice addition and hg status is such a powerful feature you will be much better off taking the time to maintain an ignore file.

So, you’ve now got a copy of your code in revision control. A simple hg status should return blank, indicating that your working copy is in sync with the repository. So let’s check out that safety net.

Let’s make a random change to our urls.py.

echo "# this comment is really lame" >> urls.py

And now run hg status one more time. You should see something like this:

loki:dtest erik$ hg status
M urls.py

The M prefix indicates that the file has been modified. Now, let’s see what exactly was modified. Run hg diff. You should get a result like this:

loki:dtest erik$ hg diff
diff -r 7844b323276e urls.py
--- a/urls.py   Tue May 12 02:56:05 2009 -0400
+++ b/urls.py   Tue May 12 02:58:47 2009 -0400
@@ -15,3 +15,4 @@
     # Uncomment the next line to enable the admin:
     # (r'^admin/', include(admin.site.urls)),
 )
+# this comment is really lame

As you can see, we have a nicely unified diff indicating that we added a single line. If you installed a GUI package, you can probably use the GUI to bring up a much more nicely formatted GUI change viewer.

So, now we know what we changed. That’s pretty useful, but how do we get rid of that change? Again, really easy, simply use the

hg revert

command. If you don’t want to revert all your changes, you can run

hg revert urls.py

for instance, which will only revert changes to urls.py.

If you revert a file and then run hg status, you’ll note that the file is no longer marked as modified and there is a new ? urls.py.orig file which mercurial has nicely decided to keep in case you change your mind. I guess .orig would be a good suffix to add to your .hgnore file!

Obviously we’ve just barely begun to scratch the surface of mercurial and DVCS’s in general, but there’s plenty of time for more learning. Even if you just use it for diffs and revert, you’re getting great value from your DVCS and are ready to add in more functionality as you need it. Good luck!

Revision control or isn’t a new idea. RCS and it’s descendant, CVS, date back to the early 80’s, and they in turn were based on even older systems. That said, many programmers still aren’t using it. Eric Sink blames it on lack of training. Ben Collins-Sussman thinks it’s because 80% of programmers aren’t "Alphas". Andrew Smith (the number one hit on Google, I might add) thinks it’s because takes too long to learn and it’s hard to set up a server. I’ll plead the fifth and say I hope I can be a part of the solution instead of the problem!

In any case, up until the last few years, revision control systems were centralized. That is, there was a single central repository of code to which contributors connected, checking out code and checkin in their changes. Subversion is the latest of these centralized systems. It was developed specifically to be CVS without the worst of the bugs, and to that end it is very successful. If you want great tools support, have a reasonable sized team, like non-mind-bending behavior, and you only work across a local network anyway, subversion is a great system.

However, many developers have become frustrated with centralized version control. Nobody wants to be accused of ‘breaking the build’, so naturally the frequency of checkins decreases. To the same end, to avoid newbies breaking the build, project administrators don’t give out commit access lightly. The end result is that developers lose the safety-net aspect revision control. I’ve been witness to developers making a copy of their source code, out of revision control, because they’re so afraid they might check in something bad.

In addition, since core contributors are the only ones with commit access to the revision control system, most contributions must come as patches. These patches can be tricky to create in the best of times, but with scale this problem becomes untenable. Just check out the linux kernel mailing list to get a sense of the problem.

The answer to these problems is called a Distributed Version Control System, or DVCS. There are quite a few of these animals out there. Most recently, it seems as if the open source playing field is being dominated by three: Bazaar, Git, and Mercurial. All of these systems have their plusses and minusses, but they are all open source and work well enough to get the job done.

Distributed version control systems share quite a few things in common. Instead of using a line or tree with named revision numbers to store the change history, distributed revision control systems use directed acyclic graphs. This basically means that you can have multiple valid lines or trees at the same time. Hence, distributed.

What this means to you (the developer) is that you get a local copy of the entire repository available to you at all times. That means you can check in, revert, merge, create branches, etc without a network connection.

It also means that you always have access to that revision control sandbox. It allows you to ‘check in early, check in often’, and still not live in fear of breaking the build or disrupting somebody elses work with your bad code. When your code is good and ready, you can review it’s entire change history, merge in any changes, and submit the entire changeset directly to the central repository or to a core committer as a patch.

Having a local copy of the repository also means that you have a more complete copy of your source code at every developer location  with a DVCS than you would with a traditional VCS.

I’ll get into the nitty-gritty of how to actually start using DVCS (and how’s it’s arguably faster and easer than svn) in another post, but for now, just get out there and use something. Not using source control is like skydiving without a parachute.

References:

• James Golick has a friendly introduction to DVCS logic.
• Eric Sink has some solid posts about Source Control and DVCS and DAGs

Image by nic221 via Flickr

Going beyond what came free in the box typically means hiring somebody calling themselves a Programmer, Developer, Software Engineer or even Software Architect. If they worked someplace interesting or for themselves, they might prefer terms like Hacker, Geek or Programming Rock Star. Unfortunately, none of this stuff really means anything! Having worked with and around these guys for a few years I can say with great confidence that their ability to program is in no way related to these accolades. Unfortunately, involvement with large companies or ostensibly successful high-profile projects doesn’t necessarily mean anything either. It’s not that hard to hitch your wagon to a train.

So what are you looking for?

1. Engaged with Technology. I’ve never met a good programmer who didn’t get excited about almost any technical project. It could be simple like “hey did you see the new Google fizzbuzz application” or complicated like “hey, did you hear they added support for asyncronous transaction replication to the latest version of MySQL”? Either way, a good programmer will engage. Bear in mind, the first response is likely to be “That’s BS, MySQL sucks, use MS SQL Server”, but they’ll engage. If they sit there like a dead fish and don’t even ask you what you are talking about, be afraid. Caveat: You need to be able to be sufficiently technical to engage in a discussion with a programmer. If you can’t, chances are you aren’t equipped to manage one either, so why try to hire one?
2. Problem Solving. To a degree beyond most professions, programming is about problem solving. See my previous post on Levels of Work, but frankly, you can’t afford to have many Stratum I programmers on your staff unless you’re running an internship program. You want the guys that can engage problems head on, and come out with solutions. Good programmers love to hear about what your problems in an interview, and would love to offer ideas as to how to solve them. Give them the chance.
3. Language Agnostic. Great programmers are familiar with more than one language. Actually, more like more than ten. It should be obvious, then, that looking for somebody with 10 years of C++ experience is a sure-fire way to eliminate great candidates. Bear in mind, if your goal is to create the next revision of the C++ standard, you really do need somebody who is deeply involved in the C++ community and has been for 10 years. Most of us, however, are much better off using the right tool for the job, and frankly, sometimes that means using a new programming language. Anybody who hasn’t even dabbled in another environment for 10 years probably won’t adapt well to the future. Computer languages aren’t that complicated, and even better, learning another language adds a ton of great perspective to every program you write. The obvious extension to this rule is that they should also be familiar with more than one development framework. Every Rails programer should have at least checked out what Django has to offer by perusing their website. J2EE programmers should at least know that they aren’t just WebLogic or WebSphere programmers, but that they are also Glassfish or JBoss programmers.
4. Understands Development Process. If you haven’t seen The Joel Test by now, you’re missing out. Ditto for any programmer that isn’t familiar with Specifications, Revision Control, Defect Tracking and Automated Build Systems. Good programmers whine about how they never get complete enough specs, or say they gave up on specs in favor of agile methods. Good programmers will happily bore you to tears with the reasons you should use distributed version control instead of that lame old CVS clone you’re using. If they say something dumb like “I don’t use revision control, I make backups to floppy discs”, run away. Quickly.

5. 

   Image via Wikipedia

   Continuous Learning. Would you want a brain surgeon who last updated his technique in 1985? Maybe you would, but you definitely don’t want a programmer with skills that old. Technology is the fastest moving set of skills in the workplace today, and among technology, software is arguably the fastest moving of all. Programmers are the mechanics of software, and they need to be up to date. Good programmers are always looking for an excuse to try something new. Suggest a possible Rails app to a guy who’s been doing J2EE and, all things being equal, the correct response is “I’m familiar with it, but never had the chance to use it for a Project”. Now, bear in mind she may be afraid to sidetrack her career by becoming the Junior Rails Programmer (TM), but you wouldn’t be so silly as to try to pull that stunt anyway, right?

In short, hiring a programmer is hiring somebody to think. They have to be able to think out of the box of convention while still staying in the box of what can actually be done using the technology available. They have to continually update their skills, and enjoy doing it. I’ve barely scratched the surface of what makes a great programmer, but here’s some other opinions to consider as well:

• The Ferengi Programmer and it’s followup
• Learning, or Learning How to Learn
• Hitting the High Notes

Let’s look at the word itself first. Virtualization implies taking something “real” and “virtualizing” it, or making it “virtual”. Typically, this is exactly what is going on with virtualization technologies, the differences lie in what exactly is being virtualized.

Storage Virtualization

At the very bottom of the technology stack lies storage virtualization. Unfortunately, the storage industry is probably the most arcane of all IT sectors, and the inability to agree on what truly comprises storage virtualization technology is a great case in point.

From a layman’s perspective storage virtualization should simply mean that your OS images don’t have to worry about where their storage comes from, it’s just there. Virtualization should allow it to be resized, move to new physical hardware, and isolated from hardware failure, all without effecting the running operating system and storage. In practice, vendors will call almost anything storage virtualization, so make sure you put on your skeptics hat when you hear them claiming to support it.

Coupled with server-side operating system virtualization, true storage virtualization delivers a one-two knockout punch to old fashioned IT. Expect to see this technology stabilize quickly as the industry gets excited about cloud compuing.

Operating System Hardware Virtualization

Lately there’s been lots of news over OS virtualization. VMWare, Xen, Parralels, Sun xVM, and Microsoft Hyper-V are all this sort of technology. Newer Intel and AMD processors even have native instructions to make this sort of virtualization more efficient. In short, OS virtualization allows you to run several complete virtual systems on a single virtual machine host.

Operating system virtualization is revolutionary when it comes to maintaining datacenters. Most server applications are not cpu, memory, or even I/O bound. Rather, they are IT staff bound, meaning that every application gets to run on it’s own server because IT doesn’t dare install it any other way.

OS Virtualization seperates the OS image from the hardware support, allowing you to provision a host operating system as specified by a specific application, while migrating it from machine to machine as needs dictate.

There is a ton of R&D going into OS virtualization, both on the client and server side. Modern hypervisors allow you to migrate a running virtual machine from one physical host to another, allow for automatic failover and load balancing, and integrate with backup software. At this point, if you are provisioning new server systems without using virtualization, you ought to be asking yourself why.

On the client side, OS virtualization is pretty cool for tech people, but in my book still isn’t where it needs to be. There is no reason for most computer users to run their OS on native hardware, yet that hasn’t happened. Until it does, you’ll be stuck dealing with rebuilding your system every year or so to clear out the cruft or to handle a system migration. Technologies like VMWare ACE are trying to tackle this proble, but the technology has a long way to go before it catches up with server virtulization with respect hardware isolation.

Operating System Partitioning

Another very interesting technology in the operating sytem world is system partitioning. OpenSolaris Zones, FreeBSD Jails, IBM LPARS and Linux vServers are all variants of this technology. In short, the runtime environment of the operating system is partitioned off from the host system while continuing to share a kernel.

Since kernels tend to be pretty reliable, this allows you to have some of the principle benefits of hardware virtualization (application isolation) without many of the costs (performance and memory overhead).

Unfortunately, this type of technology hasn’t really made any headway in the Microsoft stack, so it’s not used very heavily. Nonetheless, it’s something to keep your eyes on as the world moves towards cloud computing etc.

Runtime Virtualization

Moving farther up the application stack is runtime virtualization. Microsoft .NET and Java are the 800lb gorilla’s in thie space. Runtime virtualization brings much of the application isolation benefits of OS-level virtualization schemes without incurring the much of the complexity of maintaining multiple operating system images.

The downside is obviously that software has to be explicitly targetted at a virtualization friendly runtime. However, you should understand the development and deployment benefits of targetting such an environment before choosing a development platform for a new project. They are by no means insignificant, and a lot of very smart people are working very hard at moving this technology forward.

Projects using Runtime Virtualization that I find particularly interesting are JRuby and Jython for Java and IronRuby/IronPython for .NET. These projects bring the development benefits of modern scripting languages to the deployment benefits of runtime virtualization. Look for a lot more good stuff from these guys.

1. Everything is negotiable. The corollary of this is “you will not get what you do not ask for”. Bear in mind you may not get it even by asking, but you won’t know if you don’t ask.
2. Keep your options open. Make sure you keep as broad a scope on the negotiation as possible. It is in the vendor’s best interest to lock you into thinking you need some aspect of his solution, which he can then use to lever you into considering competitive products that are out of your league. Instead, when you’re negotiating for a new internet pipe, negotiate from the stance that you could downgrade to a cable-modem and co-locate your services.
3. Focus on your business needs. Often-times you may think you need one thing, but you actually need another. While you need to know the specifics of what you’re buying, if you continually bring the negotiation back to the business problems you are trying to solve, you may find your vendors are able to offer you a better product from a different part of the house. This is another form of keeping your options open, but it’s very important, because it keeps the onus on the vendor to meet your needs rather than just quote you a bill of goods.
4. Put time on your side. Simply put, start negotiations early and make sure your deadlines aren’t hard ones. Like Martin says, align your purchasing cycles with your vendors quarterly sales targets. The more time you can afford to take, the more time you have for the vendor to get desperate to close the deal and scare up some better pricing. Don’t overdo it though, your long term relationship will suffer if you are always taking vendors for a ride and never buying.
5. Understand what you are buying. Unfortunately, at least at the scale I am usually buying, I know more about the technical details of the product class and even the specific products being discussed than the vendor reps. I’ve found if I don’t know more, I’m likely to get taken for a ride with things I don’t need. This plays heavily into the next point as well. You simply can’t afford to buy stuff that won’t meet your needs fully, and nobody but you can really ensure that.
6. Demand a demo. When you’re spending big bucks, this usually isn’t too hard. But you can still get demo’s if you’re buying less, and frankly, especially with the economy as it is lately, if the vendor won’t take you seriously enough to get you in front of the kit they want to sell you, you don’t want to do business. There’s really no reason to purchase something you aren’t 110% confident is going to meet your needs, so prove it to yourself before signing anything.

In conclusion, if there’s a single rule I’ve found, it’s that there is no shortcut. A perfect RFP is still just the first step towards getting a good solution for a great price. You’ll still have to learn all there is to know about the product, build a relationship with a vendor, and make sure you’re buying the right thing. Don’t be seduced by the siren’s call of a “write the check solution”, the only problem it will solve is your vendor’s cash-flow.

In short, Jacques found that human’s ability to handle task complexity increases in step-wise manner, each level of which he called a Level of Work. Each level of work can be defined in terms of its maximum Time Span of Discretion (or time span), and also by the problem solving methodology required to be able to operate effectively at that level. In addition, since the levels of work are discrete, the crux of requisite organization theory is that each level must be “stacked” appropriately within the organization for the organization to function effectively. Jacques uses the term “Cognitive Capability” to describe the level of work a given person is capable of.

Hard at Work!

Regardless, organizational theory aside, the concept of work levels brings much to bear to technical work as well. In a technical environment, Jacques theory provides a way to determine the best person for a given technical task. In addition, understanding a person’s cognitive capability makes it possible to ensure that you assign them tasks in chunks they are capable of handling.

Stratum I – Engineers

In a traditional environment, Stratum I is tasked with “getting the work done”. Their time-span is limited to less than 3 months, and they solve problems by trial and error. To put this into perspective, I don’t think I’ve ever seen a programming team that didn’t have at least one fabled Stratum I member. In technical terms, a person capable of Stratum I level of work could handle filling in some function definitions that were already defined, or installing a bunch of operating systems based on a procedure they were given.

The things a Stratum I worker can’t do is where they become fabled. This is the guy that was tasked with putting together a new OS image but forgot to check whether or not automatic updates were enabled. Or the gal tasked with creating a program to extract information from some production logs, but who didn’t bother to check if the parsing libraries they used was compatible with the production environment.

Bear in mind that this doesn’t make them incompetent. They may know more than most people about  OS images or log parsing, but their limited time span makes it hard for them to see a bigger picture. They are focused on the immediate task, and nothing else.

Stratum II – Senior Engineers

In a traditional environment, Stratum II workers are called Supervisors and charged with “making sure the work gets done”. Their time span upper bound is 1 year, and they are capable of problem solving by information gathering. In technical terms, these folk are probably considered “Senior Engineers”. They are capable of working at a higher level, such as “design and implement a system to integrate product A and B”. However, it’s important to note their limitations.

A time span of 1 year is still not very long. It is long enough to implement a significant chunk of code, but probably not long enough to design a chunk of code that will underpin an entire system for many years. In addition, while they are capable of problem solving by gathering information from multiple sources, they are still not really capable of serial processing. This means they will still have trouble seeing the results of their actions on a larger scope.

Bringing us back to the previous example, assigning the OS image creation task to a Stratum II worker would probably result in properly functioning automatic updates, but would likely fail to anticipate the need to roll out the next service pack or hardware generation. Note that this may well be ok, we don’t always have a crystal ball for the future!

Stratum III – Architects

In a traditional environment, Stratum III workers are called Managers and charged with “creating systems”. They have a maximum time span of 2 years and can problem solve using serial processing. In technical terms, these folk are probably your system architects, principal engineers, and perhaps VP of engineering types.

A 2 year time-span combined with serial processing capability is a powerful combination. These are the guys that join your team and start creating systems to speed things up. If you don’t have revision control, defect tracking, or change management, they won’t rest until they’re in place because they can see the long term benefits of these systems. They are also likely to ask lots of big-picture questions and wonder where your specifications and test procedures are.

Unfortunately, the ability to see the big picture isn’t always a benefit. Task a Stratum III worker with a simple task like “refactor this class” and there is a good chance it will take him 3 times as long as necessary to finish as he creates the perfect system to solve your trivial problem and whole host of other associated problems. On the other hand, these kind of system builders are the reason we have automated refactoring tools!

Stratum IV – Integrators

Traditionally, Stratum IV workers are called integrators. They are often general managers, or C-Level execs with cross functional responsibilities such as operations, financial, and technical officers. They have a maximum time span of 5 years and can handle problem solving using parallel reasoning. In technical terms, you’d better hope your CTO can operate at this level. Many very senior engineers operate at this level and above as well. The defining trait of Stratum IV ability is following multiple lines of serial reasoning concurrently.

For instance, the choice of a development platform in a reasonably large company requires at least Stratum IV work level capability. There will be potentially dozens of ramifications of such a choice, from your ability to hire in talent, to the efficiency of development, to the ease of deployment, to the production environment security and finally to the usability of the final product. Each of these lines of reasoning will unfold for years, and the ability to “zoom out” in perspective enough to focus on what is important while ignoring the mass of irrelevant details is of paramount importance.

There are lots of other technical tasks that fall under Stratum IV and higher time span. Language design, API decisions and Enterprise Systems Architecture come to mind immediately. What others can you think of?

Conclusion

In conclusion, it’s important to recognize the work level capability of the folks on your team, and the complexity of the tasks you assign. It’s possible to break down a given task to any level necessary, and if the level of detail provided matches the capability of the worker you will get much better results. As I said above, I highly recommend learning more about Jacques Capability Model to anyone involved in project management or working with teams.

Unfortunately, I’ve only been able to scratch the surface with this post. I’ve included a few links to other blogs that feature Jacques capability model, in addition to some amazon links to Jacques original books (which are not for the faint-hearted).

Other Resources

• Michelle Malay-Carter’s mission minded management blog has some great material about requisitive organization and work levels. Check out her latest post about work levels, and this post talking about the dangers of over-hiring I mentioned under Stratum III.
• Tom Foster’s management skills blog is another great resource for information about work levels and job strata. He’s also a management consultant and teacher. I’ve taken his online course and recommend it highly. Check out this post (or this more recent one) for one entry to his large catalog of material. Tom takes an interesting story-telling approach, but stick with it.  Following the stories will pay off.
• Jacques himself on Executive Leadership: A Practical Guide to Managing Complexity (Developmental Management)

Image by Getty Images via Daylife

Before we get into the details, let’s cover a few ground rules.

1. You have data you care about on your personal computer. If you don’t care about it, don’t back it up, problem solved.
2. Since your data is worth something, you’re willing to pay something to keep it. This is important, because the old saying is true, there’s no such thing as a free lunch.
3. You know where your data is. Unfortunately, sometimes this is easier said than done, but if we start with simple stuff like photos and build out from there you can probably figure it out pretty easily.

Ok so now that’s out of the way, how are we going to solve this problem?

It’s pretty simple, really.

1. Create a data store. Ideally you would do this on a second hard drive. Internal or external, it’s your choice, but usb external ones are cheap and easy so my first recommendation would be that. See the amazon links for a couple options. If you’ve got a monster system drive or are just feeling cheap, at least do yourself the favor of making a C:\Data folder or something like it so you conclusively where the important stuff is.
2. Consolidate your data. I know it’s counterintuitive, but if you don’t actively choose what to back up and what not to, your backups will quickly get out of control as you accumulate all the flotsam and jetsam flying around on the interwebs onto your hard drive. This step is as simple as making a few folders in data store, such as Documents, Pictures, and Music, and filling them up with the stuff you care about. If you have several computers, I’d suggest moving all the important data to a central computer and enabling file sharing between them in order to keep things simple.
3. Make some copies!

Making the copies is the fun part.

The simplest solution is to simply use another external USB drive and use old fashioned “copy” to drag the contents of your nice simple data folder to it. As you get more data, you may want something more advanced. There are lots of great free tools to handle keeping multiple copies of directory in sync with other, such as synctoy,  rsync, and unison. You could also any of thousands of different pieces of backup software. I’d save that for later, however, as right now the goal is simplicity, and it’s just about impossible to beat lots of raw copies.

Now that you’ve got at least two copies in your house, you need something off-site. Again, there’s lots of options for this, but unfortunately most aren’t free. Personally, I’ve been using Mozy with good results, but I’ve also heard good things about Carbonite, and frankly, if you’re up for it you could also use rsync or unison with a remote host or a friends computer. The key here is to get a verifiable copy up and out of your physical location and updated regularly, and the internet is the easiest way to do that by far. Typically, these services will run about $5 per month for unlimited personal data, so piece of mind comes pretty cheap.

Finally, the most important part. Restoring. No backup is worth anything if you can’t restore from it. The good news is, since you’re just keeping spare copies on a USB drive, testing restore is easy: Take the drive to a friends computer, plug it in, and browse your files! Open a few up and make sure the they work. Then don’t forget to bring your drive back home!

The online backup service might be a little trickier to verify restores from, but with Mozy you simply go to their web control panel and browse your backup files. A few clicks will download them to your PC where you can verify whether or not the backup worked.

Related articles by Zemanta

• Clickfree Backup Moves Off Pricey Disks to Pricey Cable (usnews.com)
• Symantec takes on Mozy with cloud backup (theregister.co.uk)
• Is Your Hard Disk Making Strange Clicking Sounds? (labnol.org)
• Backblaze Brings Its Dead Simple Online Backup To The Mac (techcrunch.com)
• SanDisk Launches the World’s First Backup USB Flash Drives (designmind.frogdesign.com)
• Clickfree Backs Up Your Files Easily, So You’re Not Toast [Personal Technology] (ptech.allthingsd.com)
• Online backup is the Trojan Horse of the cloud (johngannonblog.com)

Even two years ago, in order to start a business you’d need to think seriously about getting some basic infrastructure in place just so you can look the part. Those days are all but gone now. Let’s take a look at the sorts of IT services you might need to support a new business.

Internet Domain

Having your own domain isn’t strictly necessary, but really, why not? There are literally dozens of registrars out there who will sell you a domain name. Heck, my company can sell you one if you really want. Register.com is fairly reputable and has been in business for a long time, although I don’t use them personally.

Email

Now that you’ve got a domain name, you need an email service that will support it. For this exercise, I’m going to suggest Google Apps. It’s free in it’s most basic incarnation and gets you a bunch of value added services beyond email. Bear in mind that there are lots of other ways to tackle email, including many low cost and even free options from other companies.

Fax

Personally, I hate faxes but they are nonetheless a fact of life. In fact, legal documents cannot be emailed, so you may find yourself doing business with companies that require you to be able to send and receive faxes. Luckily, this is a really easy problem to solve. There are two good options here, efax and faxaway. Efax is much more polished, and much more expensive. Faxaway is less polished but darn near free at $2/month for your unlimited faxes to your incoming number including voicemail service. You also will pay a few pennies per outbound fax.

Telephone

The explosion of VoIP telephony means there are dozens of options for telecommunication now. Since you probably signed up for faxaway, if you like you can use their voicemail service for inbound calls. For outbound, there are lots of options, but the 800lb gorilla of them all is Skype. They’ve been around for a long time and allow you to download and use their client for free. Since we’re talking about setting up a business here, you will likely want to sign up for a monthly subscription to skype and purchase an inbound telephone number. These services are nonetheless very cheap, around $10 per month. Beyond the quick setup and low cost, pc-based VoIP has the advantage of portability. Set up your laptop in Panera, the local business incubator, or a friends garage, and you’re up and running.

Document Management

It’s not a matter of if, but simply when, in the course of a business that you will need to draft some documents. The great news is that since you already signed up for Google Apps for email, you get Google Docs included with it. Google Docs provides word processing, spreadsheet, and presentation functions which are (in theory) Microsoft Word compatible. They’re certainly not as robust as some of their competitors, but they sure do work.

While you’re at it, however, you could also check out Zoho Office or download OpenOffice to your local PC.

Invoicing

Chances are that if you’re doing work, you’re going to need to ask people to pay you. Luckily, there’s lots of ways to do that. There are several on-line accounting packages worth taking a look at, including Freshbooks and Zoho Invoices.

Customer Relationship Management

CRM is the acronym for your old fashioned customer list. Luckily, again, there’s lots of options out there including Zoho CRM, HighRise, and SalesForce.com. Or, if you prefer to keep things simple, you can just use the Google Contacts application that came with your Google Apps setup.

Web Presence

Now that you’ve got the basics of your business covered, you’ll need to promote yourself. A good place to start is with a solid promotional web-page explaining your business and products. The good news is that Google Apps gives you headstart on this front as well, with the Google Sites feature of Google Apps. Obviously, you can also choose to host your website with a plethora of other hosts or services as well.

Beyond these basic services, there are dozens of other services available on-line. Just make sure to keep in mind what you’re getting for your money (or free). You might find my previous articles on VoIP technology and SAAS cloud services to be helpful with that.

Last, but certainly not least, remember to have fun!