The only assumptions I’m making is that a fresh, recent version of Ubuntu is installed on some relatively recent hardware and you have an ISO of the OS installation. Ideally, you’re using an Intel Core 2 Duo or better. I installed it with a normal Desktop Edition, but this guide is targeted at command-line management. You’re welcome to install Server Edition in which you’re getting a command-line only version of Ubuntu to reduce system requirements and operate with utmost efficiency.

Install VirtualBox

1. Add VirtualBox repositories to apt’s sources (this assumes they’re not already there)

   printf "\n# VirtualBox\ndeb http://download.virtualbox.org/virtualbox/debian karmic non-free\n" | sudo tee -a /etc/apt/sources.list

2. Install the public key

   wget -q -O - http://download.virtualbox.org/virtualbox/debian/sun_vbox.asc |  sudo apt-key add -

3. Update repo contents and upgrade

   sudo apt-get update && sudo apt-get upgrade

4. Install main VirtualBox package

   sudo apt-get install virtualbox-3.1

That’s all there is to getting VirtualBox installed. Unfortunately, it’s not too useful without any virtual machines or operating systems, so that will be our next step.

Create a Virtual Machine

1. Create a Virtual Machine named “LAMP1″ and keep it registered

   VBoxManage createvm --name "LAMP1" --register

2. Configure the new VM. The setting should be somewhat obvious, so feel free to tweak as necessary. Memory = 256MB, ACPI, hardware virtualization, and VRDP enabled. Set the VRDP port to 3391. Make NIC1 be of type bridged and bind that bridge to eth0. If you’re using wireless, you might need to change this to wlan0 or something similar.

   VBoxManage modifyvm "LAMP1" \
   --memory 256 \
   --acpi on \
   --hwvirtex on \
   --vrdp on \
   --vrdpport 3391 \
   --nic1 bridged \
   --bridgeadapter1 eth0

3. Create a new hard drive file of size 10GB and remember it.

   VBoxManage createhd --filename LAMP1.vdi --size 10000 --remember

4. Add a SATA storage controller to the VM for the hard disk to attach to.

   VBoxManage storagectl "LAMP1" --name "SATAController" --add sata

5. Now, bind the VDI file to the SATA controller. This is like plugging the hard drive into a SATA port.

   VBoxManage storageattach "LAMP1" --storagectl "SATAController" --port 0 --device 0 --type hdd --medium "LAMP1.vdi"

6. Also add an IDE controller for things like ISO mounting

   VBoxManage storagectl "LAMP1" --name "IDEController" --add ide

7. Attach OS installation media to the IDE controller.

   VBoxManage storageattach "LAMP1" --storagectl "IDEController" --port 0 --device 0 --type dvddrive --medium ~/ubuntu-9.10-server-i386.iso

That’s it, you’re done! Well, mostly. Depending on your exact circumstances, you may have to tweak a few things.

Verify and Start

1. Verify everything looks good

   VBoxManage showvminfo "LAMP1"

2. Start the Virtual Machine.

   VBoxHeadless --startvm "LAMP1"

The major component to managing virtual machines on the command-line is simply knowing the correct commands and parameters to configure everything. I plan to write an addendum which addresses some advanced features such as USB, remote management, and automated startup/shutdown.

Update: The addendum for extra features is up.

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It is also possible that the RSA host key has just been changed.
The fingerprint for the RSA key sent by the remote host is
8b:ff:a1:b5:32:06:4d:fd:2e:2f:67:80:9e:ba:8d:ff.
Please contact your system administrator.
Add correct host key in /home/taylorg/.ssh/known_hosts to get rid of this message.
Offending key in /home/taylorg/.ssh/known_hosts:2
RSA host key for 192.168.1.100 has changed and you have requested strict checking.
Host key verification failed.

All the message says is that the fingerprint for the host that was previously stored no longer matches the target. If you know this is okay and want to clear out the error, the process is very simple – just remove the stored fingerprint.

You have a couple of options how to do this depending on your situation:
The first, preferable method would be to use ssh-keygen with the following syntax:

ssh-keygen -R hostname

Assuming all goes well, you should receive a message similar to this:

/home/taylorg/.ssh/known_hosts updated.

Alternatively, if ssh-keygen is not available for some reason, you can manually update the known_hosts file:

1. Open up the known hosts file:

   nano ~/.ssh/known_hosts

2. Delete the line containing the hostname of the server you’re trying to connect to (Ctrl+K). The name should be the left-most item on each line, or use Ctrl+W to search.
3. Ctrl+O to save the file, then Ctrl+X to exit nano.

Try to ssh again (ssh username@hostname) and you should receive a message akin to the following:

The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
RSA key fingerprint is 8b:ff:a1:b5:32:06:4d:fd:2e:2f:67:80:9e:ba:8d:ff.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.1.100' (RSA) to the list of known hosts.

As the last message indicates, the ssh client will store the current fingerprint back into known_hosts, bypassing the warning for future connections.

Basically, if you run passwd and receive the error,”passwd: Authentication token manipulation error”, the culprit is likely Likewise Open. Unfortunately, even having this installed — but not configured — will prevent you from using passwd to update a local users’s password. Fortunately, the fix is very easy if you don’t actually use Likewise Open – just remove it from your system with this command:

sudo apt-get remove likewise-open

Confirm the prompts and after apt-get is done, you should be able to use passwd like normal. Thanks to Bug 302026 for guiding me to the solution. The bad news is that if you need to change the password of a local account and need Likewise Open installed, you might be out of luck.

The List

Deluge

Deluge is a bittorrent client similar to the now-official µTorrent in Windows. While this particular program is not alone in this space, I find the interface of Transmission far too simple for my preference. Fortunately, we have choice! Deluge supports popular features such as encryption and web interface. Extensibility is built-in with support for plugins, including an eMule-style IP block list.

Deluge Screenshot

FileZilla

I discovered this application years ago when it was Windows-only. Since then, the author has completely rewritten it from the ground up using wxWidgets and a variety of other open source tools. FileZilla is an absolutely amazing FTP client that also supports FTPS and FTP along with a bevy of helpful features such as bookmarks, filename filters and proxy support. This utility is one that I install everywhere.

FileZilla Screenshot

Firefox

Probably the most well-known open source application, Firefox’s usage share has steadily climbed since pre-1.0 days. It is the second most popular browser after only Internet Explorer and has widely spread on other OS‘s where IE is not a choice. The plugin and theme architecture mean that the browser can serve many needs – such as website debugging and even IRC – that once required multiple utilities.

Firefox Screenshot

hellanzb

Continuing the network theme, we have probably my most favorite application, hellanzb. This is a usenet binary downloading program at its finest. Give it an NZB and it takes care of the rest, including download, parchive check, and extraction. If you use Usenet for downloads, go get this right now. It is officially supported on any Unix-like OS, including OS X. An automated installer and Cygwin guide are available for Windows users. Be forewarned, hellanzb is a command-line tool, which works great in it’s own right. Fortunately, it provides an XML RPC interface allowing GUI applications to be easily built on top of it. Below is a screenshot of one of those tools: Remote HellaNZB GUI. If you’re looking for a UI that is cross-platform as well, tools built on platforms like Adobe AIR will fit-the-bill.

Remote HellaNZB GUI Screenshot

Pidgin

Originally known as Gaim, Pidgin is probably the most-used multi-service IM application across all operating systems. Even though OS X users love Adium, it’s the libpurple engine underneath Pidgin that drives it all. This is another program that supports theme and plugins, increasing its usefulness. I would suggest you try it out, but if you’re reading this, there’s a good chance you already have.

Pidgin Screenshot

KeePassX

KeePassX started as a port of KeePass for Windows known as KeePass/L. When the application finally became cross-platform, KeePass/L was changed to its KeePassX. Although it can only read and save KeePass 1.x-style databases, this utility is becoming indispensable in a world of dozens of passwords. The database is stored in your choice of encryption (AES or Twofish) with one or both of password and key file. In addition to simply storing login information, KeePassX can also generate passwords based on your own filters and help automate the filling-in of login forms.

KeePassX Screenshot

TrueCrypt

TrueCrypt is another piece of desktop encryption software. It allows users to create self-contained encrypted volumes or entire encrypted partitions. This utility also supports multiple encryption algorithms and forms of authentication. In addition to the end-user tools like a Quick-start guide, the author has posted a very detailed explanation of the internal mechanisms. Geeks rejoice!

TrueCrypt Screenshot

VirtualBox

My love for VirtualBox is no secret. What I truly love about VirtualBox is that the underlying virtual disk images are OS-agnostic, I can easily move a VDI from Linux to Windows to Mac, and the guest operating system doesn’t care. Furthermore, with the added ability to read VHD and VMDK formats, this has become my virtualization software of choice.

Virtualbox Screenshot

Handbrake

Handbrake is an absolutely amazing video transcoding application. Give it just about any file format and convert it to many destination formats on-the-fly. Recently downloaded a FLV off YouTube and want to keep a local copy on your iPhone? Just a few clicks and Handbrake can help with that. Supports a queue for batch operation and works efficiently.

Handbrake Screenshot

VLC

The great thing about VLC is that it can play just about as many formats as Handbrake can convert. All the A/V support is built-in, so there’s no need to worry about gathering the necessary codecs. It can often stand on its own, but also works great as a supplemental video player.

VLC Screenshot

Note: This article is the third in a multipart series introducing the Linux swap. Part 1 is intended to familiarize the reader with the concept of swapping, why it exists, and what it’s used for. Part 2 highlighted basic analysis and management techniques for handling swap space. Part 3 appears below and discusses the current state of swap usage and present opinions about its implementation today.

Questions

Several questions are repeatedly posed in regards to swap:

• How much swap space do I need?
• What is the right settings for swappiness?
• With so much memory, do I even need swap?

I want to address each of these questions and hopefully provide a larger understanding of swap in the context of everyday use.

How much swap space do I need?

This is probably the most-asked question in regards to swap, and the answer isn’t entirely clear-cut, however, there are a couple of rules to be guided by.

In a strictly technical sense, the amount of swap you’ll need should be the total amount of virtual memory you’ll need minus system memory. In other words,

Total Virtual Memory - Memory = Swap

Traditionally, the recommendation was twice the amount of RAM. However, this was many years ago when 128MB (or less) might have been standard, resulting in a 256MB swap partition, totaling as much as 384MB of virtual memory. This pales in comparison to today, when 2GB is a standard amount on desktops. It is unlikely that a server with 16GB of RAM will ever need an additional 32GB of swap.

Desktop

Remember that virtual memory is a mapping of all available memory to a system, no matter the device type. Therefore, if you anticipate that you will never utilize more than 4GB of virtual memory and have 2GB of physical memory, 2GB might be a good amount for you. But better than 2GB of swap would be an additional 2GB of memory, allowing your heaviest usage to wholly fit inside RAM.

On my desktop at home (which currently runs Gnome + Compiz on Ubuntu 8.10 Intrepid Ibex), I started with 2GB of RAM and a 2GB swap partition. I’ve since upgraded the memory to 4GB and – as expected – seen swap usage drop to virtually none. The only situation in which my swap fills up, is when a process runs amok and grabs every last piece of memory available. Although I practically never reach into that extra memory, I was thankful it was there instead of having OOM Killer wreak havoc or forcing my system to a screeching halt.

Because the old “two times” model is bunk, some are recommending a new allocation guideline that goes something like this:

Laptop

Assuming similar usage patterns, you can follow the guidelines as a desktop, with one major exception. Because of the ability to hibernate – if you plan to use this functionality – allocate at least as much swap as you have of system memory. This is especially important during partitioning, because Linux cannot hibernate to a swap file.

Server

Generally speaking, servers tend to be loaded with memory for speed and efficiency, reducing the tendency to page to disk. Because they are often designed with a particular function and load in mind, swap may be of little need. In fact, if the server is adversely swapping, it is likely indicative of a more serious problem requiring more memory or application changes.

A consequence of this would be a small amount of swap (half, quarter, or less of system memory). When provisioning the server, you might instead decide that the workload and applications have been set in a very specific way (i.e. a VM server) and would prefer no swap at all. I wouldn’t recommend this, but it’s certainly possible from a technical and practical standpoint.

There are, of course, exceptions to these rules. If you anticipate gigantic workloads where you cannot reasonably fit the entire contents into memory (i.e. very large datasets on heavy-traffic, multi-user database systems), you may have no other choice than to allocate lots of swap space.

Red Hat’s own recommendations for RHEL5 are as follows:

What is the right settings for swappiness?

This is an entirely subjective setting, but there are a few strong opinions on what they feel is best. Because there is no way to anticipate the workload of an OS on installation, default swapiness setting falls somewhere in the middle. For example, on Ubuntu, the default value is 60.

Very high

One 2.6 kernel maintainer insists that a very aggressive setting is preferred (i.e. 100). His logic is that wasting a lot of memory on large, bloated applications is not an ideal use of that memory space; instead, force those pages out to disk, freeing up memory for useful items. The counter to this argument is that this produces the undesired behavior of delayed interactivity between the user and system when switching back to that application, because the operating system is busy reading the pages off disk back into memory. A further concern of this behavior is that cache is being given greater importance than applications – a useful scenario in servers and development workstations, but less so for general desktop use.

Very Low

For the average end-user, system responsiveness likely trumps cache performance, so there is a tendency for users that tweak swappiness towards the bottom. Though many have tried setting swappiness to 0, they found it unworkable; instead, many report a better experience with a setting of 10. A group of members have even proposed that this value be tuned lower by default in Ubuntu. Telling the kernel to swap as little as possible also has the effect of “as late as possible”. If memory cannot entirely cover the requirements of the next process, the kernel has no choice but to swap immediately, making loading the process slower. This speaks to the argument for a high setting if your system is typically memory-constrained.

With so much memory, do I even need swap?

Even if you decide that you have copious amounts of memory for the intended tasks, the inexpensiveness of disk space makes not having at least a small swap space (256MB) ludicrous. Additionally, the kernel can do strange things when there is no swap available, throwing out-of-memory errors and killing processes, making this decision a no-brainier. Disk is cheap, so allocate some space for swap, even if as a swap file rather than partition.

Final Thoughts

As with most things in life, the answer to how to configure swap is, “It depends”. Your specific situation largely dictates how much space and how quickly the kernel should page items out to disk. Much like a financial budget, you make a best estimation at first and then changes as the situation requires. Aside from a few specific instances, you can grow or shrink swap area as your needs change.

With the additional knowledge on what swap is used for and how to gauge its importance to your workload, you can start making a better-informed decision on how much you need and how to configure it. Take a look back at Part 2 and use those tools to measure how your system is responding to the hardware constraints and system settings. Even with all this in mind, there is a single overriding rule to swap space: more memory is better.

Exploring Swap

If you’re new to Linux and choose a guided installation where the partitioning was automatically configured for you, you may not even be aware of how much swap space you’ve allocated and where exactly it lives. Fortunately, there are a couple different ways that allows us to explore, analyze and manage this information.

swapon/swapoff

swapon -s

swapon is part of a pair of commands (its complement being swapoff) intended to wholly toggle the state of swap. Specifically, man states, “enable/disable devices and files for paging and swapping”. The -s parameter simply displays current usage. The output should look similar to this:

Filename                                Type            Size    Used    Priority
/dev/sda3                               partition       2000084 5452    -1

This result tells us a few things:

• Filename: /dev/sda3
  • This is the actual device that swap lives on
• Type: partition
  • This filename is actually a partition, rather than a file. Swap can live in either type of device
• Size: 2000084
  • The size in KB of the device/file. In this case, 2GB
• Used: 5452
  • The amount of space currently in use in KB. Just over 5MB currently
• Priority: -1
  • This is an arbitrary number (typically from 0 through 10) that allows the user to configure the order in which Linux should utilize swap space (highest to lowest). Most users will only have a single swap file, but it is certainly possible to have multiple and spread them among several different files/partitions.

More information on priority: A scenario that might exist in which you would need this, is if you decide to add another swap, but have it within a file rather than partition new space for it. You can set the partition to a priority of 5 and the new swap file to Priority of 1. Because the highest value is always preferred, this will ensure that the swap partition is used before the swap file. Another case is spreading the swap over multiple separate drives. If the priority is set the same for both swap devices, the kernel will utilize them in a manner similar to a striped array (round-robin). When it comes time to write to disk, this can help increase performance a bit.

free

Another utility, free, doesn’t give us anymore information than swapon -s, but it allows us to see swap usage in the context of overall system memory.

free -mot

The -m parameter simply displays the values in MB rather than KB. -t gives us a grand total at the bottom. The -o option hides some information we’ll get to shortly. The output might look something like this:

             total       used       free     shared    buffers     cached
Mem:          3959       3934         24          0        158       1957
Swap:         1953          5       1947
Total:        5912       3940       1972

There are 3 lines in the output: Memory, Swap, and the aggregate Total. This gives a better overall picture as to what memory is allocated where. Most of the lines are self-explanatory, but it’s important to note that the very low value of free memory is somewhat misleading. In this example, there is usable free memory of 2140MB.

Without getting too far into the details, think of this as saving a seat next to you in the movie theater. Maybe a friend was joining you for a movie, but in an emergency they had to leave during the previews. Most people assume this seat is reserved, until the theater begins to reach capacity, in which case the seat might really be needed. This extra seat is analogous to cached memory. It was in use at one time, and is still being saved in case your friend comes back, but could be used by another person. Modern OS’s handle memory the same way: They mark the space as used, but available.

To get a simpler picture of how much space we have, we need to add the buffers and cached columns back into the free column, because after all, the seat is technically empty. We can accomplish this automatically by removing the -o and -t parameter from our example (free -m):

             total       used       free     shared    buffers     cached
Mem:          3959       3934         24          0        158       1957
-/+ buffers/cache:       1818       2140
Swap:         1953          5       1947

Now, compare these values to the swap space. Although there is plenty of memory free, some swap is being utilized – a piddly 5MB of 1953MB – nothing to worry about. The final line, total sums things up, indicating we have 5912MB of usable space between all memory and swap, of which 3940 is in use, leaving 1972MB.

The -/+ buffers/cache sub-item simply summarizes how much used or free memory we actually have, and it becomes clear that there is plenty of available room for new applications. So why is swap being used up at all? Without exploring the gritty details, I can offer a much simpler solution: adjust how quickly swap is utilized.

Controlling swap

Because swap is intended as a supplement to memory, the process by which items are swapped in and out is automatic, giving the user little choice what goes into it. However, since kernel 2.6 a small tweak was added to configure how quickly the system swaps items – swappiness.

Swappiness is an arbitrary number from 0 to 100 that indicates how fast you want the system to page items out to disk, freeing up precious RAM. The higher the number, the sooner pages will be written out to swap. You can alter swappiness either temporarily or permanently, as outlined below. Before you go about that, check the value currently set:

sysctl vm.swappiness

Temporary

A simple terminal command is all that is required to change swappiness for the current session. If you want to keep things in memory longer than the current value provides, try lowering swappiness. For example, setting a value of 40:

sudo sysctl vm.swappiness=40

The nice thing about this, is that you can change the setting without rebooting and find a nice threshold that suits your needs. After restarting, the settings will be returned to the default value, so once you find a preferred value, you may decide to change swappiness permanently.

Permanent

This is only slightly harder, but not by much. It actually involved adding or editing a parameter in a single file.

sudo nano /etc/sysctl.conf

Then press Ctrl+W to search for “vm.swappiness”. If nano finds it, great! Just change the value from the current to your desired. If the value is not found, scroll to the bottom of sysctl.conf and add it. In either case, it should look like this:

vm.swappiness=40

On succeeding boots, this value will be the default. We can re-read the config file, verifying any changes:

sudo sysctl -p

Turn-offs and Turn-ons

There’s one last thing we can actually do to control swap: completely disable and enable it. This brings us back to the first section on swapon and swapoff. There are several reasons why one might want to completely turn swap off. One of those reasons is to flush whatever is in swap back to memory. As long as you actually have enough system memory for the contents of swap, you’re not going to break anything, but it might by worthwhile to ask yourself what the system might have swapped the pages out in the first place. Maybe there’s a runaway process leaking memory. Assuming everything is acting appropriately, in the long run, it is probably better to adjust swappiness as detailed above.

If you’ve decided that you want to move pages out of swap and back into memory, all you need is a couple commands, which we can combine into a single line:

sudo swapoff -a && sudo swapon -a

The -a option on both of these command stands for “auto”. To be a more specific, it tells them to operate on all swap devices located in /etc/fstab that aren’t explicitly marked at “noauto”. Don’t worry about the details for now, just know it works.

After running this command, my memory looked like this:

             total       used       free     shared    buffers     cached
Mem:          3959       3935         23          0        159       1956
-/+ buffers/cache:       1819       2139
Swap:         1953          0       1953

Notice that Swap now reports 0MB used, with a small decrease in the amount of cached and free memory. If there’s a lot of data in swap, it may take a bit of time for this to finish. Don’t panic, but instead, open another terminal and observe your memory usage:

free -ms 1

Again, -m reports usage in MB. -s 1 activates a continuous polling delay of 1 second. In other words, free -m will continue to run every 1 second until you tell it to stop with Ctrl+C. If you use this while swapoff is at work, you should see all the memory numbers adjust magically.

Last Resort

If course, if all else fails, a simple reboot will clear out not only your swap, but also anything in memory.

Wrap-up

Fortunately, Linux allows us to tweak many settings and the GNU/Linux toolset gives us a great way to handle these changes. Hopefully, this article has shed some light on how to manage that mysterious swap partition and will provide a jump point to learning more about the specific commands involved.

Part 3 will be less technical, instead focusing on a discussion about modern swap usage and how that impacts the end-user today.

What is swap?

The first question in an introductory article about swap should probably be, “What is swap?”. But, before that question can be answered, we need to ensure a concrete understanding of a more fundamental concept in computers: memory. If you feel that you could use a brush-up on the different types of memory and their function within a modern computer, check out Memory 101: A Primer.

On the most basic level, swap acts as storage space auxiliary to system memory. Fortunately for developers, modern systems need not know or care about swap. This is achieved by abstracting away the physical details through the use of “virtual memory”, which acts as a sort of mapping system. Of course, memory isn’t the only capacity in which this idea is utilized – quite the opposite. Just about every part of a contemporary general computing system abstracts physical details through various device drivers. Taking it a step further, programming languages themselves disconnect the details of the underlying system from the actual operations in the program. These techniques hide the complexities of where data is stored, and instead allows developers to focus on actually interacting with the device, rather than knowing the nuts-and-bolts of the system. Other common uses include video output and file systems. For example, although a program might be stored at /usr/bin/gcc, the system largely doesn’t care which type of device, drive, platter, or cluster the file exists in, because the details have been dissociated from the functionality.

A discussion should also be had about the term “swapping”. In modern operating systems, swapping and paging have similar meaning and are nearly interchangeable. In the Windows world, the term paging is used almost exclusively, whereas swapping is a preferred term within Unix-like systems. The difference originally was in the amount of data that was changed from memory to disk or vice versa. In more primitive OS‘s, swapping originally referred to an entire process being brought in and out of memory. As technology advanced, the need to work on an entire process eventually faded; current systems instead switch out only portions of memory known as a page (a smaller fixed-length set of data). Because the older, traditional method of swapping is not longer utilized, the terms are mostly synonymous and will be for the purpose of these articles.

Using Swap

Although swap acts as an extension of system memory, there are several purposes swap space can serve within that descriptor.

Extra “memory”

In the classic scenario, swap space could be considered a last-resort for data before an application – or the entire system – crashes. How does it work? Let’s pretend you have 1000MB of RAM, of which 800 is used. You now load a program that consumes 300MB of memory. In this simplistic scenario there is more data than memory available; therefore, approximately 100MB will be moved into swap. Is this inherently bad? It isn’t ideal, but typical far better than having the system grind to an uncontrollable halt and forcing a shutdown.

Optimizing memory usage

The operating system may anticipate that data will be repeatedly accessed, in which case it can be very beneficial to keep this information in memory. This is known as cache. If stale program data is sitting in memory, taking up valuable space that can be used for cached data, the kernel may decide to place the infrequently-accessed memory in swap. Probably a common example of this is the cache – or temporary internet files – in a web browser. Especially if you’re browsing around a particular website, there may be some common elements such as the logo that will be displayed continuously. There is no need to fetch the data from the server again, because the file has been placed in a local cache.

This could also be placed into an analogy comparing it to looking up information in a library. You can travel to the library, locate the book, then locate the actual page containing the information (and yes, the analogy holds true for the term “page” discussed above). Do you simply read the passage, close the book, and commute back home, hoping you never need it again? Or is it more efficient to make a copy of that passage and take it with you, just-in-case? Much like you might copy the page and keep it with you for referencing again, so too does a modern system copy a page of data into RAM and keep it there until no longer needed.

Suspend-to-disk (a.k.a. Hibernation)

This is a more esoteric use of swap space, but a convenience of modern OS‘s (Linux >= 2.6) – and particularly laptops – the ability to Sleep and Hibernate. Hibernating actually stores the entire contents of memory on non-volatile storage (usually a hard drive), then turns off. Because memory cannot be maintained without power and cached objects can be removed from memory, this makes swap space a prime candidate for the storage location.

Putting it all together

After familiarizing yourself with swap space and its common uses, you might be thinking that the drawbacks sometime outweigh the benefits, and you might be correct. In the desktop age, the much easier fix to using swap as an extension of memory is to simply increase system memory. In the past, this has been an expensive endeavor, but currently, lots of memory can be had for relatively little money. The solution is obvious, easy, and relatively cheap: buy more memory! If you’re at a memory limit due to hardware, software, or financial reasons, fret not, there are some solutions.

The next part of the swap space series, I’ll go into depth on how to analyze and manage your swap, tweaking it for performance and understanding how your system is shuffling data around. Additionally, it will provide examples for how to add more swap space.

What is it? It’s a bidirectionally synchronized folder in The Cloud. It synchronizes and shares files between your computers in addition to provided access through the web interface. I have 3 different computers I use on a regular basis, so keeping important files synchronized is a boon to productivity.

Let’s say you need a few files at work. Copy them into your Dropbox folder at home and and be on your way. By the time you arrive to the office, the files have already replicated to all registered computers, and they’re ready to use.

Dropbox Nautilus Overlay Icons

On the desktop

How does it work? A tiny program runs in the background that monitors a special Dropbox folder. Any changes to that folder are copied up the server and then down to all your other computers.

Dropbox Tray Icons

In addition, overlay icons are displayed on files and folders to indicate the sync status. I can’t say enough about how well this integrates into the graphical shell, providing a nuanced view into the inner workings.

Dropbox Explorer Overlay Icons

The simplicity of the whole system is what makes this software so powerful. Though most details are obscured, there’s still a few nerdy details that can be had with a little research:

Dropbox claims that files are transferred over SSL in addition to storing them encrypted on Amazon S3 servers. It supports change tracking, so you can revert to a previous revision if necessary. Also, the company claims to transfer only file deltas (changes), which helps conserve bandwidth and speed transfers.

Dropbox Tray Right-click Menu

On the web

In addition to the client goodies, Dropbox has a wonderful web front-end that provides a superset of desktop features.

There’s several management options that can only be accessed from the web: account type, contact information, and computer management. Because these are items not often changed, I don’t mind that they’ve been left out of the client application; it helps reinforce the simple mantra.

Dropbox Web Interface: Manage Computers

You can also add files via the website directly. This speaks to the universal usefulness, even while accessing files on a foreign computer.

Another interesting feature is the availability of an Event Feed in the form of RSS. If you’re somehow sharing an account, this feature would work well to notify each other of changes. Even included is a direct download link to that file. My only suggestion, would be to also provide a link to that particular revision, instead of only the most recent copy.

Dropbox RSS Feed

Dropbox also directly supports various shared-use scenarios. It’s got built-in photo gallery support, collaboration features, and the ability to supply a public link to any file.

Conclusion

I certainly don’t use Dropbox for everything: Most documents I keep in Google Docs and large amounts of data still lives on my NAS. Also, I’m not willing to synchronize a whole movie just to transfer between computers – traditional networks and sneakernets still have their place. Even still, I’d be crazy to not take advantage of the ridiculous simplicity that this service offers.

With Dropbox, I truly fell in love with a brand-new product. If you’d like to experience Dropbox for yourself, get an extra 250MB free by using my referral link.

As long as the above requirement is met, you may share the folder you want to access. I say “may” only because if your host OS is Windows, you can access the hidden drive shares directly. If this is the case, skip the next section and head right for the next paragraph. If you’re new to sharing a folder, here are the steps to accomplish it.

Windows

1. Right-click the folder name and choose, “Share…”
   

   Vista Share Menu

2. Verify the user with access is correct. It should be your current account and have Owner privileges
3. Click Share
   

   Vista File Sharing

Ubuntu

1. Browse to a folder using Nautilus (your default file manager when using Gnome)
2. Right-click and choose “Sharing Options”
   

   Ubuntu Sharing Options Menu

3. If this is your first time enabling sharing, you will be prompted to install the service. Authenticate and let the package manager download and configure Samba. I was prompted to reboot my computer, however, I did not reboot and was still able to continue configuring the shared folder
   

   Install Samba service

   

   Ubuntu Nautilus Permissions

Mac

1. Sorry, I don’t have a Mac. If anyone wants to buy me one, or just generate some revenue through ad clicks, I would appreciate it!

You should then be able to access the share by browsing “\\localhost\sharename”. If you opted to skip creating a share, and want to use the built-in hidden shares, specify “C$” as the share name. Authenticate if necessary and you should be browsing your shared folder locally.

1. Once that is complete, switch over to your VM installation (Windows 7 or otherwise)
2. Bring up Computer (Start Orb→Computer)
3. Click the “map network drive” button
   

   Windows 7 Map Network Drive

4. The “Map Network Drive” dialog box will open and you should configure several items:
   1. Drive: Specify your preferred drive letter. I chose “S:”, but any available letter will work fine.
   2. Folder: This should be defined as “\\HostComputer\ShareName”. Alternatively, you can specify the IP address instead of hostname. Because you are now on the guest OS, this should not be “localhost” as above.
   3. Connect using different credentials: I like to check this, just to ensure I can specify the correct login and password instead of using my current user.
   4. Press the Finish button
      

      Windows 7 Map Drive Options

A new window should open with your new share. You can also minimize this window – exposing the underlying Computer window. A new drive letter under Network Location should be available.

That’s it, you’re done. Windows shares don’t always behave as easily as they should, so if you encounter an error, don’t give up. Keep trying and post the error in the comments.

1. Switch to tty1 (Ctrl-Alt-F1)
2. Start X on a second display – this should kick you right into the new X session. Note that displays are 0-base indexed. Your normal session runs on :0. If you need more, use :2, :3, etc. and they should increase along with tty8, tty9.

   startx -- :1

3. To return to your original X session, switch to tty7 (Ctrl-Alt-F7)
4. To return to your new X session, switch to tty8 (Ctrl-Alt-F8)
5. To end your new X session, simply logout as normal, and switch back to tty7 (Ctrl-Alt-F7)

You may also want to consider playing with xnest to embed one X session within another. I haven’t personally tried xnest, but I found a recommendation and thought it might be worthwhile to someone out there.

Hope that helps!