It’s always nice to be able to undo things. In real life, particularly, but that usually isn’t an option.

With computers, though, it is! Most software (particularly word processors and office-type stuff), nowadays, features an undo button; allowing you to revert things to the way they were before. But what if you don’t realize you’ve totally messed things up until a week later? After you’ve closed all applicable applications or permanently deleted files?

That’s when it’s time to click that system-wide undo button — and run Back In Time.

Back In Time is an automatic backup system, that, once properly configured, will take snapshots of those directories you want protected at regular intervals. Whether you’re working on a complex project and want to keep track of your revisions, or just had your hard drive fail beyond any hope of recovery and want to recover your data (provided you had Back In Time configured to save backups to an external medium), or even are feeling nostalgic and want to see what your home directory looked like way back when — Back In Time is a nice thing to have installed.

There are three different downloads available on the Back In Time homepage, to choose from. For most people, downloading the source will be the best option. If you run Ubuntu, or some other dpkg-using distro, you might prefer the .deb package, for easy installation. And if you run Ubuntuand speak French, there’s a package specifically made for your unique needs.

But even if you get the source code, don’t think you’ll have to compile anything! Back In Time is written in the Python language, so all that’s needed to install it is to run sudo ./install.sh. This will copy the necessary files to all the necessary places, and then you’re ready to run! You can find Back In Time under the Administration section of your application menu, or alternately can run the command backintime from a shell.

And I ought to mention here that this latest version of Back In Time adds complete multi-language support. To install it for non-English use, you can run the commands ./translate.sh and sudo ./install_locale.sh fr. Once there’s more languages available, you’ll be able to replace that ‘fr’ with the abbreviation for the language of your choice. However, there’s nothing to stop you from translating it yourself, either! All you have to do is edit and rename the fr.po file found in the /po directory to reflect the language you’re translating Back In Time into.

When you first run Back In Time, you’ll be shown the Settings window. Here you can configure Back In TIme to do what you want it to. You can choose what directories to back up, what filename patterns to exclude in that backup (for example, if you don’t want to back up hidden files and folders), and where you want to snapshots to be stored. If you’re trying to protect your data against hardware failure, then I highly recommend choosing a flash drive or secondary hard disk for keeping your backups on. This way, if your primary medium dies, you’ll still have a copy of everything important on your backup drive. If you just want to keep track of revisions to your work, though, it doesn’t really matter where you put the backups, so long as they aren’t within any of the directories you’re actually backing up (which could possibly create both a paradox and an infinite loop, filling up your storage space and inverting the universe all at once). In fact, Back In Time will specifically prevent you from doing anything so foolhardy, so you’ll be able to rest easy at night.

Also on the settings screen, you can choose the interval at which automatic backups are taken, ranging all the way from never to once a month. But even if you choose to back things up once an hour, you don’t have to worry about needlessly wasting storage space — Back In Time is smart enough to not take snapshots when there haven’t been any changes made since the last backup. And for even greater hard drive conservation, you can tell Back In Time to automatically deletebackups it’s taken, once they exceed a certain age, or once the free space on your drive shrinks beyond a certain amount.

Then, once you’ve got all that taken care of, you can do . . . nothing! Yes, that’s right — you can close Back In Time and worry about data loss no more, in the assurance that every revision made to your filesystem is preserved. Back In Time uses cron to make sure it’s run, silently and in the background, as often as you told it to be. Unlike so many regularly recurring programs on thatother operating system, Back In Time takes up no resources whatsoever when it’s not in the actual act of backing up your data, since it’s not even running; and even when it is doing that, it only uses leftover processor power to do so, so that it doesn’t slow your machine down!

If you want to, though, you can take an active part in the life of your backup system. If you’re a real Scrooge when it comes to your storage space, you might want to tell Back In Time to never automatically back up your data at all, and just press the Backup Now button in the upper left corner of the window, yourself, whenever you think it’s needed.

Besides the toolbar at the top of the window, the main Back In Time interface is divided into three panels. On the left you’ll find a timeline, showing the date of each backup on your system. In the middle portion of the window is a list of the places you’ll most often want to access — the root of your filesystem, your home directory, and each of the places you told Back In Time to back up on occasion. The rightmost space shows the contents of the directory currently selected in the middle panel, at the time in history selected in the leftmost. You can browse through this area just the way you do in your file management program, and even double-click on the files listed to view them in their associated programs, as they were at the time of your backup.

And then, in the upper right corner of the window, you’ll see the Undelete button — the button that allows you to undo all user errors, hard drive failures, and other modifications that have taken place since the currently selected backup, and change things back to the way they were.

And with that, your backup system is complete.

An important part of pretty much everyone’s Linux system is a graphical windowing manager, with or without an attendant desktop environment — and, just like with every other aspect of open source computing, there’s many different options to choose from. Nearly everyone knows about Gnome and KDE, and statistics show that about 75% of Linux folks use one or the other. But there are many many other worthy environments available, some of which are downright awesome.

Like, for instance, Awesome.

Awesome is a very small and fast tabbed windowing manager. Rather than having windows which only take advantage of a portion of the screen, cover each other up, and must be moved around, Awesome divides up the screen between the various windows (or, as they’re called in Awesome, clients) you have open, making the most economical use of the space available. No mouse is required, because everything can be controlled using the keyboard, and every aspect of it is very configurable. It’s geared toward the geekier types of folks, though, so not everything is exactly intuitive — but I’ll explain a lot of it in this review.

Awesome requires a rather considerable number of dependencies, which are listed in the readme file found in the main Awesome directory. Some of these are rather large and complicated, and the newest version of many of them is required, which can make installation difficult. However, there’s a wiki on the Awesome website, which, while out of date in spots, can prove very useful at times. Particularly this page. If your distro is listed (or a similar one: I use Linux Mint, but followed the Awesome-3-Ubuntu-git tutorial), you can make use of the instructions provided; else you can muddle through on your own.

When you start Awesome (as explained in both the readme and the various distro-specific instructions), you’ll see that it’s up and running almost instantly. No long load-times here, unlike in (ahem) certain very popular desktop environments! A window will open welcoming you to Awesome, and explaining that you can open a new terminal by right-clicking on an empty screen, and that more info can be found in the Awesome manpage. You may also get a message informing you that Awesome can’t set a background image in and of itself, and needs a helper application to do so. A terminal emulator called eterm is recommended for this; install it.

And now is a good time to become acquainted with Awesome’s user interface. The main part of the screen is where the clients go. As previously explained, you can right-click to open a terminal, and run stuff from in it, or, if you want, you can press Win-F1 to open a command line at the top of the screen. By default, the most recent program opened takes up the entire left-hand part of the screen, and the others are arranged on the right. Most ways of interacting with Awesome involve using the Windows key (which the man page and config files call Mod4) on your keyboard: to rearrange clients you can Win-leftclick on them and drag them from one space to another, and Win-rightclick and dragging on margins between clients will resize them. Or, if you don’t have or don’t feel like using your mouse, you can swap clients with the keyboard combinations Win-Shift-J and K, and resize them with Win-H and Win-L.

At the top of the screen is the statusbar. On the leftmost part of it you’ll find a list of numbers, the first of which has a small square next to it (to let you know it has windows assigned), and is highlighted in blue-grey. Click on a different one of them, and you’ll get a fresh screen containing nothing but your background image, ready to have more windows opened. But these are not workspaces, such as you’ll find in most other windowing managers; these are tags. Clients do not belong to them, they belong to the clients. A single window can have multiple tags assigned to it (by means of Win-rightclick, defaultly), and you can view more than one tag at a time (right-click on one to add it to your view). This allows greater control over which windows you want to have visible on your screen than pretty much any other window manager around.

Then, to the right of those, comes the tasklist. This is the part of the bar where the names of every client using the currently visible tag are listed, lined up in an easily-accessible row. Normally you won’t really need this much, but if you’re using a non-tiling layout (more on that later) or are reassigning a client’s tags, it can come in handy.

And next, continuing rightwardly, is the clock, which displays the time in seconds since the Unix epoch. This further demonstrates the fact that Awesome was written with “power users” in mind — people to whom such a numbering system evidently makes sense. However, it’s perfectly fine for normal folk to use too, and remember: everything about Awesome, pretty much, can be changed; including the clock.

Finally, on the far right of the statusbar, is the layout box. Clicking on it changes the layout — the way in which Awesome arranges the various clients on the screen. There are a number of different layouts available, from sensible, orderly schemes to zigzags and spirals. One layout allows the selected window to fill the whole screen, which can be useful depending on what sort of programs you’re running. And another sets all the clients to be ‘floating’.

Which is something that we ought to go into more deeply. Normally, all your clients are in tile mode. They line up evenly with each other, are assigned their position according to the layout you’re using, and can only be dragged from one slot in the layout to another. Floating clients, however, behave just like the windows in stacking WMs. They cover each other up, and can be moved freely (by holding down Win and dragging on them with the left mouse button). Message boxes are always set to be floating, and the configuration file can force specific programs to always float as well. As explained above, one layout has all clients in floating mode, and you can toggle the floating/tiled status of the selected client by pressing Win-Ctrl-Space, no matter what the layout.

But by now, perhaps, you’re anxious to get down to configuring, and change stuff. Now here’s the bad news: Awesome uses the Lua scripting language for configuration. And the good news: Awesome uses the Lua scripting language for configuration. Because it all depends on your viewpoint! Lua is very powerful, and is part of what makes Awesome so configurable. But it’s a complete programming language, so it won’t be as easy to work with as are those environments that allow you to change settings with sliders and radio buttons. So if you’re really into this Awesome thing, you might want to learn Lua. It’s pretty easy to understand, as far as programming languages go, and there’s some good tutorials available. Or, you can just read the provided configuration file, try to figure out how things work, and do it by trial and error. You can restart Awesome at any time, without disrupting any open programs, by pressing Win-Ctrl-R, allowing you to nearly-instantly see the effects of your changes.

The default configuration file is found in the directory /etc/xdg/awesome, and is called rc.lua. To play around with it, copy this file to ~/.config/awesome, and make changes. Some things can be done that don’t really require any Lua expertise. If you don’t like the default clock, you can make it display the time in a more conventional format by commenting out line 443 (by typing “–” at the beginning of the line) and uncommenting line 445. And something I recommend is adding titlebars to your clients. To do this, change the “false in line 61 of rc.lua to “true.” Now, by clicking and dragging on a floating client’s titlebar you can move it around without having to use the Win key, and you can close open programs by clicking on the familiar X in the upper right corner, rather than having to type the combination Win-Shift-C.

Once you’re more familiar with Lua and Awesome’s rc.lua file, you’ll be able to change keyboard combinations, the position of the statusbar, what appears on it, what the components of it do, and other fun things like that. And Awesome also can use theme files, allowing you to change the entire color scheme with a single line in your rc.lua!

While not for everyone, Awesome provides a fast, unobtrusive, and highly configurable interface for your graphical computing needs. And, above all, further enriches that great feature of the open-source world: multiplicity of choices.

And that’s pretty awesome.

Those of you who read this site regularly, or pay attention to the dates at the end of each post, may have noticed that it’s been a while since I last posted anything here. This is, of course, due to many factors (I’ve been alternately very busy and very lazy, these past couple months); but one major one is the problems I’ve had with my computer. A while ago I upgraded my distribution to the latest version, only to receive a GRUB Error 21 upon rebooting. After hours of reading documentation, searching online, asking for help on IRC (Thanks, cathbard, MichMash, and EchoLynx!), and a couple reinstallations, I finally realized that all my problems were caused by a simple mistake in my GRUB menu.lst file, which was easily fixed.

But not before I had, somehow, corrupted my NTFS partition.

Now I suppose this could have been an opportunity to leave Microsoft once and for all, and overwrite the bad partition with an XFS one or something; but I had a lot of rather important files on board, and didn’t want to lose them. If I hadn’t lost them for good, already. I figured there had to be a way to recover a broken partition, so I searched online on a tech support forum, and found a program called TestDisk recommended. I looked up the program’s homepage, and found that not only is there a version of it for Linux, but it’s also open source!

TestDisk is a program for the express purpose of recovering deleted, unbootable, or damaged hard drive partitions. It’s a text-based program, so as to keep it small and cross-platform, but it’s got a very easy-to-use interface which’ll set GUI junkies at ease.

Linux binary downloads are available as an RPM, as well as in tarball form for those of us who don’t use a Red Hat-derivative distro. Upon downloading the tar.bz2 of TestDisk, I was pleasantly suprised to find that there was nothing further I had to do, besides executing it. Because it’s a binary, you don’t have to run a Makefile or anything, and because it’s compiled statically, it doesn’t depend on any external libraries. Just navigate to testdisk-6.10/linux from where you extracted TestDisk, and run sudo ./testdisk_static in a shell. (By the way, you may have noticed a binary entitled photorec_static in the same directory that the TestDisk binary was in. This is TestDisk’s companion program, PhotoRec, that ships with it. PhotoRec is for recovering lost or deleted files from your hard drive, and is also a very useful application — but we haven’t space enough to talk about it much, here, so you’ll have to go to its homepage to learn more.)

Depending on whether you use a terminal window for text-based stuff (as opposed to using one of Linux’s built-in virtual consoles) and what its default size is, you may or may not receive the message: TestDisk need 25 lines to work. Please enlarge the terminal. If you do, follow the instructions; and you’ll come to the introduction screen. Here you’ll see a brief explanation of what TestDisk is and does, and be asked whether you want to create a log file. Whether you do or not is up to you (though doing so is recommended) — to tell TestDisk of your decision, use the up and down arrows to choose your option of choice, and press Enter.

Now you’ll come to a list of all the hard drives on your computer. Choose the one that contains your deleted/unbootable/damaged partition, again by using the arrow keys, and press Enter again while the word Proceed is highlighted (if you feel like quitting at this point, you can use the rightwardly-pointing arrow key to select Quit). Then you’ll have to inform TestDisk as to what type of partition table your drive has. Chances are you have a PC, in which case you can go with Intel;though if it’s not, select the appropriate menu entry. TestDisk will try to detect what type of table you’ve got, so unless you know that what’s automatically selected is wrong, you can usually just go with the default.

And then you’ll happen upon the main menu itself. There’s a lot of different choices that can be made, but commonly you’ll just be able to press Analyze, and continue. You’ll be shown a list of the partitions on the drive in question. Look at these carefully. If there’s anything odd about the list (error messages, the same partition being shown twice, etc.), you’ll be able to tell which partition is causing problems, if you didn’t know already. Then, select Quick Search, say whether or not it ought to look for partitions created under Windows Vista, and TestDisk’s real capabilities will spring into action. The listed partitions will be repaired and then relisted, with healthy partitions highlighted in green. If everything is as it should be, you’ll see the message Structure: OKin the lower left of the screen. Next to each partition is a letter designating what type of partition it is — primary bootable, primary, logical, extended, or deleted. If you have reason to believe that one of the partitions ought to be of a different type, you can use the arrow keys to change it: up and down to choose between partitions, and left and right to swap types. Depending on the type of partition (some sorts, such as XFS, are not yet fully supported), you can also press ‘P’ to view a list of the files and folders contained within it; to make sure the partition is operational, or even to copy files to somewhere else (done by pressing ‘C’).

Then you can press Enter to continue, where you’ll be shown your partition list again. If there’s still something missing, you can do a Deeper Search. This can take a long time, but is much more thorough than the quick way of doing it. But, if all your partitions are available, you can selectWrite to write a new partition table to your drive and fix it for good!

If you happen to be so lucky, you can exit TestDisk, restart your computer, and access your partition that once was lost, but now is found (which may very well warrant a rousing rendition of Amazing Grace). But maybe your problems weren’t solved so easily. In that case, you can rely on TestDisk’s excellent documentation, available on their website. Every function of the program is explained in detail, and there’s lots of example case studies, which may also help. But as good as the documentation is, don’t expect it to be perfect. I wasn’t able to find out, at first, what to do about the message Warning: Incorrect number of heads / cylinder. But — the docs are also available in French and German, and by use of Google Translate, I was able to find the answer and ultimately solve my problem.

So, if you’re in a similar predicament, I highly recommend TestDisk. It fixed my partition, and brought the episode to a happy conclusion —

Until my graphics driver tried to kill me.

. . . But that’s another story!

Nowadays, being able to type well is a vital skill for just about everybody. If you use the internet, you need to be able to type (to a certain extent, at least) to do nearly anything — post on forums, participate in IRC chats, even just enter search terms for Google. Consequently, since you’re reading this website, you probably have acquired some typing skills already. But if you’re among those who wish to improve their current typing speed, or learn a different keyboard layout (like me), then Klavaro will prove quite useful.

Klavaro is a typing tutor program, based on the premise that having all kinds of bells and whistles and meters and on-screen keyboards make learning to type more difficult: and, therefore, is very simple, streamlined, and easy to use. Another great benefit is that it includes support for an enormous number of keyboard layouts, and you can easily add your own as well; so no matter where in the world you live, you can make use of Klavaro.

Installation is very easy, since both Debian and Red Hat (and, for that matter, Microsoft Windows) installation packages are provided. Even compiling from source is near-foolproof, since the only dependency is the GTK+ libraries.

Klavaro is also a multi-language application, so don’t be put off when you run it and find the default language is Portuguese. You’re supposed to be able to select your language from the drop-down list next to the word Idioma, and then click the button with the reload icon and the wordAtualizar! to translate the program. For some reason this didn’t work for me; the list was blank, and no matter which of the blank entries I clicked on, it changed the language to Czech. However, this is easily remedied — merely edit the prefences.ini file found under .klavaro in your home folder, changing the language value to the abbreviation for the language of your choice (possible values can be found by looking at the names of the text files found in /usr/local/share/klavaro or /usr/share/klavaro). To make English the default language, change the appropriate line tolanguage=C.

And now you’re ready to begin! First you’ll have to define which keyboard layout you’re using. The current selection is shown in the textbox at the top of the screen. To change it, click the button marked Define (if you’ve managed to change the language to English), and a configuration window will appear. Pick from the list of Original Layouts (I’m using dvorak_us), or, if you’ve got a really unusual keyboard that’s not shown in the list, click on the keys of the virtual keyboard shown at the right, and manually define the keys to match your hardware. Of course, if you want for some reason to learn a layout different from what’s printed on your keyboard, that’s quite possible, too. Klavaro doesn’t have any built-in layout transposer (selecting what keyboard layout to use merely changes what the lessons will be like), but you can change your keyboard’s layout using KDE or GNOME’s included keyboard software, or by using setxkbmap.

Once your keyboard is set, it’s time to type. You’ll notice five buttons in a column toward the bottom of the window. The top one of these, labeled Introduction, gives you a bit of information on how to correctly position your hands on the keyboard for touch-typing. Just to the right of it you’ll notice a checkbox. If this is checked, you’ll be taken back to this main menu the next time you start Klavaro. If not, however, Klavaro will automatically take you to whichever type of lesson has its radio-button on.

The four lower buttons take you to the actual lessons. There are four types of training involved, which, respectively, heighten your knowledge of the key layout, your adaptability, velocity, and fluidness while typing.

The first button will take you to the basic course, which consists of 2-4 minute lessons in which you merely repeat the same couple keys in various combinations, until you are thoroughly bored. Dull as this may seem, it is a good way to memorize the positions of the various letters, fairly quickly. Once a lesson is completed, you’ll be given the time it took you to type out the lesson, and your accuracy rate. If you’ve got over 95% of the letters correct, you’ll then go on to the next lesson, or else be instructed to do the lesson again.

Of course, if you don’t enjoy that idea, you can always skip to whichever lesson you like, using the spinbox in the upper left of the window. Klavaro will remember what lesson you were on last, the next time you start it up, but if for some reason you wish to begin again at the beginning, you can click the Reset! button, found next to the spinbox at the top of the screen. Next to that is aProgress button, which will show you a graph of your accuracy or velocity for the current lesson, and how much progress you’ve made each time you’ve typed it. Then comes the Keyboard button, which will show you the virtual keyboard, and tell you which finger to use for each key, when you click it. If you select the Keep Hands checkbox, a small window showing a pair of hands will remain visible while you continue the lesson, and highlight the finger required to press the next key, as you type. Then, still moving along the toolbar in a leftward direction, comes a button for displaying the lesson type’s introductory message, a button to take you back to the main menu, and beneath them, a checkbox for determining whether to beep the internal speaker whenever you make a mistake, and a small button which brings up a dialog to change the display font, to add some variety to your typing lessons.

Once you’re relatively familiar with where to put each finger to type all the letters, it’s time to work on your adaptability by typing random letters. Klavaro arranges these into wordlike formations that are actually pronounceable, most of the time, so that while you’ll be going through the motions of typing an email or an article, you won’t be distracted by what the words mean, and instead focus on further memorizing the letter placement. Probably.

Next in line are lessons to test your typing velocity. These are quite similar to those for adaptability, only here you’ll be typing real words. The words will be arranged rather like sentences, with punctuation, but since the words are picked randomly from the included dictionary, there’s still no actual meaning to what you’re typing; though you will, now, be typing the actual letter patterns of your language. And if you get tired of the selection of words Klavaro gives you, you can have the test instead choose words from any text file stored on your computer, or from the clipboard, by clicking the Other button in the upper-left corner.

And then, finally, come the fluidness tests. Here you actually type complete paragraphs, on the subjects of Esperanto, world hunger, and the importance of letter writing — while focusing on typing smoothly. You can adjust the number of paragraphs in a lesson; and once you’ve exhausted the possibilities of the above subjects, you can give Klavaro your own bodies of text, the same way you do in the velocity lessons. The fluidness tests take the form of a sort of contest, since Klavaro keeps track of the top ten typing scores (a combination of velocity, accuracy, and fluidness) on your computer. And, if you’ve got ftp-upload installed, you can send your scores to the Klavaro website (or, for that matter, any other site that feels like comparing people’s typing scores), and then see who the top ten typists are, by clicking the Top 10 button on the toolbar.

And that’s about all there is to it! While Klavaro does not have as polished an interface nor as expertly-designed lessons as other typing tutors, such as the famous Mavis Beacon, it does have one major advantage over many commercial programs — the ability to support just about any language or keyboard layout the people of earth can come up with. And that’s saying a lot!

You’re racing along in your flashy new Ferrari Spider, nearing 200 miles per hour. The road ahead leads up a hill — but what a hill! It’s a perfect 45-degree angle! Unable to stop and ponder this geological oddity, you fly on up it, and over the top, sailing spectacularly through the air. And then immediately afterward comes an enormous loop-the-loop! You race up it, too, lose control at the top, spin off, tumble through the air, and land inexplicably intact — only to crash into a brick wall half a second later. This, my friends, is the world of Ultimate Stunts.

Back in 1990, Distinctive Software released a racing game called Stunts. Besides being just a generally great racing game, it had the special features of stunt equipment, providing for lots of loops and jumps and barrel-rolls, and best of all, a track editor. Today’s review is of Ultimate Stunts — an open-source remake of the old DOS game. In many ways it’s just like the original, but with better graphics, 3D sound, and multiplayer functionality!

Currently the only way to install Ultimate Stunts in Linux is by compiling the source code. This, however, is not particularly difficult. OpenGL, SDL and SDL.image libraries are required, and either OpenAL or FMOD for audio support. Then it’s merely a process of ./configure, make, make install, and finally ustunts.

First comes the main game menu. The menu system isn’t particularly pretty, consisting of simple text buttons against a screenshot background, but it works fine, and that’s what really matters. You’ll also hear some of the ambient game music. Music is stored under Ultimate Stunts’ share directory (/usr/local/share/ultimatestunts/music, for me), so if you don’t like the three tracks included, or would like more variety, you can add your own music to have it played ingame. The currently playing track is automatically looped over and over, but you can press F1 at any time to switch to the next piece of music.

You’ll likely want to set up your character, before racing. To do that, select Players and cars and then 1: (Human) Anonymous. Here at the Player Configuration screen, you can enter your name, what car you wish to use, whether you want an automatic or manual gearbox (you can use ‘;’ and ‘/’ to shift gears up and down) and what color you want your car to be. There are 11 different cars to drive, all with different maximum speeds, rates of acceleration, and things like that. Most of them are ordinary sports/race cars, but there are also few strange vehicles (such as a LEGO car, and a Model T) thrown in for fun. And you can repaint them to absolutely any color you like!

And now it’s time for a race. Select a track from the main menu, click Drive!, and it’s just you and the open road. While the cars are very realistically modeled, there’s nice lens flares, reflective windows and chrome, good textures, and great sound effects, you’ll notice that the shape of the terrain is no different from the 1990 original, with angular hills and sharp-cornered roads. Before long, though, you’ll be able to look past this aberration and enjoy the ride — for there’s certainly a lot to enjoy! Depending on the track you chose, there’s loops to go over, jumps to take, ramps and aerial roadways to drive on and tunnels to drive through, roadblocks to swerve around and always the challenge of trying not to lose control every time you go around a corner.

You can drive just about anywhere you like as well (though there are time penalties for leaving the road), so if you want to take the same jump over and over, you can quite readily do so. The borders of the map seem awfully close to the road sometimes, though, and since going off the edge counts as a crash, you may find it difficult to get to the end of the track in one piece; particularly if you’re of the more reckless sort. In that case, you might want to turn off car crashes, found under Settings -> Simulation in the menus. Then you’ll be able to bump into things as hard as you want, with no consequences besides a satisfying crunch sound.

Eventually, though, you might tire of racing by yourself. Want some competition? Select Players and cars again from the menu, click Add a Player, and you’ve got yourself a computerized opponent! The AI is only good for some maps, though. While it’s great at turning corners and going over jumps, it isn’t smart enough to manage loops or roadblocks, and smashes up every time. But merely change the player type to Human, grab a friend, and you have instant multiplayer action! You can have up to four human players (using the arrow keys, WASD, the numpad, and a joystick) at the screen together, and, as far as I can tell, an unlimited number of AI drivers. The number of human players isn’t exactly limited in the menus — you can add as many as you like — but if there’s more than four players in a race, Ultimate Stunts will crash and quit suddenly, so you’re best off not trying. If you want your keyboard all to yourself, however, you can still have multiplayer races. Click Select the game type from the main menu, and you can start a LAN or internet game, or join one.

And then there’s a whole other dimension of fun involved, too: designing your own maps! To do this, click Select a track -> Edit track in the menu. Wait a couple seconds and the track editor will come up. On the left is a collection of all the tiles used in the map with some editing tools beneath it, to the right is the map editing area itself, and at the top is a toolbar with buttons for basic functions. There is no readily apparent way to start from scratch, but you can load any of the Ultimate Stunts tracks (by clicking on the red folder icon), and edit them to your heart’s content. Or, even cooler in my opinion, you can import tracks for the original Stunts game, save them in Ultimate Stunts format, and drive on them! To do that, select the green folder icon, and browse to wherever on your hard drive you have the old maps stored.

The track editor works on a tile-based system. Pick a tile to place in the left-hand collection, and then use the arrow keys to position where you want it to go in the map. The four buttons in the lower left corner are what you use to do the actual editing. From left to right, they rotate the tile to be placed, add the tile, replace anything that is in the current position with the selected tile, or erase anything in the current postion; respectively. The little arrows beneath these buttons can be clicked, in lieu of the arrow keys on your keyboard, to move the tile-cursor horizontally in all four directions, or vertically.

You may have noticed that your tiles are constrained within the boundaries of the track you began by editing. There is not yet any in-game way to resize the map, but you can change the boundaries in a text editor. If you don’t like the selection of tiles you have in the collection, you can add to or replace them by clicking the rightmost button at the top of the screen. This will take you to another screen, from which you can view the complete list of possible tiles — and there’s a lot of them! All the tiles in the collection are, I believe, loaded when you run the track, whether they are physically present or not, so it is a good idea to click Remove unused tiles in the Collection Editing screen, when you’re done. Then, click the floppy disk icon to save your changes, and choose a filename for your edited map. And now you can race on it!

Ultimate Stunts is lacking a few features, and has a bit of a rough feel to it, but it is still only about three-quarters of the way to version 1. Even at the current stage of development, it’s already a terrificly fun game — definitely worth a download!

If you’re anything like me, you probably find it quite easy to entirely forget things that you’re supposed to do in a day — particularly if your obligations take place in real life, and you’re using the computer. Perhaps you have a dentist’s appointment this afternoon, and just as you’re heading out the door to your doom, you decide to check your email one last time. Now it turns out one of your friends sent you a link to icanhascheezburger.com, and, whether intentionally or by accidental mouse reflexes, you click it. A little later you look at the clock — and realize you’ve just spent two hours looking at pictures of cute cats with hilarious captions, and completely missed your appointment. Considering the nature of the appointment, you might not be too chagrined; but another such incident could be disastrous.

Something must be done about this. You need some way to automatically remind yourself when things need to be done. And KAlarm fills the bill nicely.

KAlarm is a simple program, whose primary purpose is to inform you about various things (namely, whatever you want to be reminded of) at specific times and dates. It can do a few other things besides, but that’s mainly what it’s made to do, and it does it quite well.

Before it can be used, though, it necessarily needs to be installed. The program’s website offers Debian packages and Slackware packages (the latter for older versions only) of KAlarm, as well as the sources, to compile yourself. It depends on the Qt and kdelibs development packages, in addition to bison. KMix and KTTSD are optional assets, providing volume control for audio notifications, and speech synthesis, to have your reminders read aloud.

The first time KAlarm is run, an introductory window will explain to you the purpose of the smiley and frowny faces that appear at the upper right of the whatever window is currently active. Basically, these are feedback buttons — click on one of them to send a message to the developers, telling them what you like or dislike about the program’s features. You can also send such a message by going to Help -> Send a Comment to Developers in the menu, so you may wish to disable the feedback buttons. To do so, click on one of them, press Alt-W, and click Save Setting. Then you can press Cancel, or, better yet, tell the developers what you think of KAlarm.

Though, quite likely, you haven’t seen enough yet to form an opinion. It’s time to take a look at what KAlarm actually does!

KAlarm consists of a small main window, which will show your list of upcoming notifications, if you have any. It also has an icon in the system tray, so you can hide it when not in use, but still keep it running so it can remind of things. KAlarm is a KDE application, and consequently has KDE-style documentation, available in the Help menu. Unfortunately, when compiled from source, at least, the KAlarm Handbook is installed to /usr/share/doc/HTML instead of /usr/share/doc/kde/HTML, where it ought to be. However, this is easily fixed by moving the files in question.

There are three types of notification that KAlarm can give you: Display Alarm, Command Alarm, and Email Alarm. To choose one, and remind yourself of something, click the New button on the toolbar, and select the desired alarm type from the dropdown list.

A Display Alarm is the type you’ll likely use the most. When its time has arrived, it will pop a window up on whichever of your multiple desktops you’re currently using, displaying the message on a vibrantly-colored background. To further get your attention, you can make KAlarm sound a beep at the same time, or, if you want, play an audio file or read your message with a synthesized voice. The color of both the background and the text can be changed, as can the font. And besides entering the text by hand, it is possible to display the contents of a file or the output of a command (or script), instead!

But if you’re into scheduling commands, you may prefer to choose a Command Alarm. If you don’t really care to see a command’s output, or would rather it were save to a file instead of displayed, but still want to run a program of some sort, this is the sort of notification to run. The possibilities of Command Alarms are just about endless. Anything that a bash script can do, it can do. You can use it to run OpenOffice with what you’ve got so far of that report you were supposed to write, to start up your IRC client just in time for that developer’s meeting you’re having tomorrow, or even to download and compile the latest snapshot of your favorite open-source program!

And then there’s Email Alarms. If you want to remind other people, not yourself, of what they need to be doing, then these’ll come in handy. Just type in the message you want to send and the address of the person you’re sending it to, and KAlarm will automatically tell them whatever you think they ought to be told, at the specified time. It has to use either KMail or sendmail to send the message, though, so you need to have either KMail or a sendmail compatible mail transport agent installed for use.

Being on time is quite important, so there’s a number of different options you can change to make certain the alarm goes off when you need it to. Alarms can be set to any date in the future, with or without a specific time of day (without which it’ll notify you as soon as you turn on your computer). Or, if you want, you can set an alarm to go off a certain time from now, rather than a set o’clock. You can set the time-zone of the alarm, as well, if you are, for example, coordinating something with someone who lives in another part of the world. You can also ask to be reminded in advance about something, so that you’re in the proper state of mind when the actual alarm goes off. And, as if all that weren’t enough, you can also set your alarms to recur, as often or as rarely as you like!

If you use multiple computers, you may want to synchronize your notifications between them. This is also possible. Merely click the Show Resources button on the toolbar, click the Add button in the panel that appears, and choose Alarms in Remote File. Then you can choose a folder on another computer in your network from which to download alarm data.

And in addition to all this, KAlarm can import birthdays from your KDE address book, save templates for alarms that you tend to use over and over, undo and redo your actions, and even allow you to schedule alarms from the command line! For those who are schedully-challenged, KAlarm is a great way to help keep you in time with the rest of the world.

Once upon a time, nearly all computers came with a copy of the BASIC language. In fact, Micro-Soft’s first product was a BASIC interpreter for the Altair 8800. The BASIC language was thousands of people’s introduction to programming. It was the perfect tool for the speedy development of simple programs.

But then came the age of the graphical interface, and something new was required. The variant of BASIC that rose to the forefront was Microsoft’s Visual Basic, a language still popular today. It has, however, two major drawbacks: Visual Basic costs money, and it only works with Windows. Three, actually, if you count its great bugginess.

Happily, for freedom-loving Linux users like us, there’s an excellent alternative: Gambas.

Gambas is a complete development environment, consisting of both a BASIC interpreter (with object oriented parts, for GUIs and such) and a graphical code/form editor front-end. Besides writing classic text-based BASIC programs, it can be used to create desktop applications using either Qt or GTK+, use OpenGL and SDL for 3D and 2D graphics, and handle printers, networking, databases, compression, XML, audio, and video.

Because of this impressive list of features, Gambas also has a lot of dependencies. Luckily, they’re (almost) all listed in the readme file, and, if you choose to compile it from the sources, the./configure script will tell you which components will not be compiled, based on which libraries are available. The reason I say ‘almost’ is because the readme does not mention what libraries the component gb.qte (for embedded applications) depends on, so I was unable to build it; but most people won’t be making embedded apps anyway.

An easier way to install Gambas is to get the binaries for your distribution. Many distros include Gambas in their repositories, so you may also be able to install it with your package manager, and install all dependencies automatically.

Then, execute the command gambas2 to begin. A small window will pop up giving you the option of starting a new project, opening an old one, or trying one of the numerous example programs; and also providing a nice list of the most recent projects opened. The examples are excellent, demonstrating almost every area of Gambas’ feature-base, as well as demonstrating how to use the Gambas language. But the finest example of what Gambas can do is the Gambas IDE itself — yes, it was written with Gambas BASIC!

To start writing your own program, you naturally click New Project… This will take you through a user-friendly wizard in which you choose what type of project to create (and therefore which libraries to use), what directory to store it under, and what to call it. Then comes the main Gambas window, and development can begin!

The window is split into three panels, by default. On the left is an overview of your project structure, listing the forms (window layouts, basically), classes and datafiles the project contains. In the center is the main workspace, where pretty much everything goes on. Click on a form in the list on the left to show it in the central panel, ready to be covered in widgets. Open a class, and the center area comes up with a screenful of code. Even icons can be edited in the central workspace, using rudimentary draw and fill tools. And this panel in the middle is tabbed, too, so that you can have multiple things open at once. The rightmost panel only shows when the center area is editing a form, in which case it displays a palette of widgets and a table of properties.

The creation of a graphical Gambas project usually follows the pattern of creating a form, testing it, coding, testing, and repeating. To design a program’s look and feel, widgets are selected from the palette and added to the form, and then their settings and default values are edited, in theProperties table. Double-clicking on a widget will open up the form’s class file, taking you to that specific widget’s subroutine. Then you can type in some code to modify the widget’s behavior (made easy and enjoyable with Gambas’ auto-indentation, keyword highlighting, and code-completion), and, thanks to the interpreted nature of the BASIC language, instantly try it out by clicking the Play button at the top of the screen.

People who’ve used Visual Basic (or even old non-Visual versions, such as QBASIC, GWBASIC, Applesoft BASIC, etc.) will find it easy to start programming with Gambas. There are differences between the two languages, but a great many similarities, as well. For those who’ve only ever used C++ or something, or are non-programmers, it’ll be a bit more difficult. However, Gambas comes with excellent documentation, explaining every keyword and function, and there are some good tutorials available, as well. At least three books (four, if you count WikiBooks) have been written about Gambas, though only one of these is in English, and all three are for a slightly outdated version. But possibly the best way to learn is by reading code and messing around with it, starting with that of the many examples included. There’s also a website, gambasforge.net, which hosts a large quantity of simple open-source programs written with Gambas.

Gambas programs are fully translatable, as well. To enable translations, go to Project -> Properties -> Options and set “Project is translatable” to Yes. Then you can click the translate icon on the toolbar, and start a new translation. The window that pops up lists all translatable strings (such strings being the text on widgets, and strings within your code enclosed by parentheses), to each of which you can provide a translated string in the language you’re translating to.

And then when you’ve completed a project, and want to share it with the world, you can compile and package your program. Gambas includes a compiler, which converts a project into an executable binary, making it runnable from a terminal, clicking on an icon, or any other way any other program can be run. Such executables are not machine code, like C++ compilers put out, but rather bytecode, which must be interpreted. It still runs extremely fast (the Gambas IDE is a testimony to this), but because it’s interpreted, certain components of Gambas must be installed on the user’s computer for the program to run. This could turn into a bit of a pain for those non-you people who use your program, so, quite fortunately, Gambas also comes with a very convenient packaging wizard. This will walk you through the process, as you fill in your project’s description, changelog, and desired menu location, and then you can select from a list of package types. You can create Debian, Fedora, Mandriva, OpenSUSE, Slackware, Ubuntu, and/or Autotools packages, with the click of a button. Then the dependencies will automatically be fulfilled, on the end-user’s machine. It can’t get any easier than that!

The best feature of Gambas, though, is the speed with which you can develop a working program. A very simple, yet fully functional web browser can be written with just 25 lines of code! With an intuitive interface, great documentation, and a robust feature-set, Gambas is the ultimate tool for speedy software development on the Linux platform.

There will undoubtedly come a time in your life when it becomes necessary for you to have a look at a .chm file — a Microsoft Windows compiled HTML help document. It’s happened to me multiple times. Nearly all Windows programs use the chm format for their documentation, and some eBooks are chm, too.

But these are Windows help files. What to do if you exclusively run Linux? . . . Fire up KchmViewer!

KchmViewer is a very handy and easy-to-use application, with a look and feel almost identical to that of Microsoft’s Help program. As the ‘K’ in its name signifies, KchmViewer was designed for the KDE environment, but as long as you have the Qt libraries installed, it will work with any windowing manager.

Only the source files are available from the official website, but KchmViewer is provided in binary form by several distributions. Of course, if you want the latest version, compiling is the way to go, and it’s not that hard, either. This newest version provides support for KDE4, so it is dependant on the libqt4-dev and qt4-dev-tools packages (names may be slightly different for your distro), and on libchm-dev. This is a Qt program, so instead of running a ./configure script to generate your Makefile, you run either qmake (if you don’t use KDE4) or cmake (if you do); followed, of course, by make. Those using KDE4 will need to then run make install, but the rest of us can run it from the kchmviewer-4.0beta3/bin directory, or copy it manually to some handier location.

When KchmViewer is run, it may, for a very brief time, seem to have crashed. None of the buttons can be pressed, the menu is unresponsive, etc. However, just wait a little bit — the program is merely in the process of waking up! After a couple seconds, a file browsing dialog will pop up, and operation can begin. Select the chm file you want to view, and then click Open.

The window is divided into two panes: the left-hand one displays navigation options, and the one on the right shows the current page. The left side has four tabs, respectively containing a tree view of the file’s page hierarchy, an alphabetical index of all the pages in the file (sometimes takes a long time to generate; only use if necessary), a search tool, and a list of bookmarked pages: very similar to the Windows Help program. The panel to the right also supports tabs, allowing you to have multiple pages open simultaneously, and to switch quickly between them — a feature that, I think, Windows’ program does not have. To utilize it, click the small button marked ‘+’ at the upper left of the right panel. This will open a new tab, in which you can open any page you like, by clicking the appropriate link in the Contents.

KchmViewer does not support JavaScript or anything like that, and by default asks you if you want to continue, when a clicked link will take to to another file or a web page, so the program is entirely safe and secure. It does not, as far as I can tell, support background images, either, but that is a shortcoming few will notice.

One nice feature is the persistent nature of the program. KchmViewer remembers the pages and tabs you had open the last time you viewed a document, and restores them when you open that file again. You can also, of course, bookmark any number of pages in a chm file. Then, when you want to come back to a subject months later, you can merely click on the bookmark, and continue from the exact point on the page where you left off.

In addition to all this, KchmViewer allows you to print out pages from your chms, view the HTML source for them, and even extract a help document into its component HTML files. It also has a great emphasis on accessibility, with complete support for non-English languages, and easily resizable text, for people afflicted with poor eyesight or fuzzy CRT screens. No documentation is included, nor is really necessary, this being a fairly intuitive program. If any is eventually written, though, it would be neat if it were in chm format!

While most Linux users won’t often need to access chm files, for those that do, KchmViewer is an excellent choice. It does have a few quirks that take some getting used to, but, overall, this is a very useful program.