Usually here at MakeTechEasier, we focus on specific topics for our tutorials. This time we’re taking a different approach, and providing a high-level overview of series of steps designed to hone the skills of a Linux beginner, and turn them into the kind of geek who compiles a new kernel for fun.

Step 1 – Install an “Easy” Linux in Real Partitions

There’s a good chance that if you’re reading this, you’ve likely already installed a Linux such as Ubuntu or Fedora. These “desktop” Linux systems are specifically designed to be as simple as possible to install. It’s important to do an actual partition-based install (as opposed to a “virtual” partition as done by Wubi) because this will ensure you understand the way the partitions are named and the importance of a swap partition.

Step 2 – Learn the Filesystem

This is particularly important if you’re transitioning from Windows. Linux does not store programs the same way Windows does. On Windows, a program’s files are normally stored in (drumroll please) Program Files, and that usually includes just about everything the program needs. Linux, however, takes an approach that may seem a bit more complicated but has some advantages.

A Linux package will normally place its executable files in a location like /usr/bin, its configuration files in /etc, and perhaps its log files in /var. Why the split? In short, because that allows a user or administrator to work with groups of related files. For example, if you wanted to reinstall your OS but a lot of your apps have custom configurations, you can just back up your /etc directory and all your configs are saved. You could put /var in its own partition so that log files have a hard limit on the space they can take up.

For detailed info on the Linux filesystem hierarchy, check out this great guide from the folks at The Linux Documentation Project.

Step 3 – Explore /proc

We’ve mentioned before how useful it can be to understand /proc, the special filesystem created by Linux to hold dynamic system information. Understanding proc is essential toward understanding Linux, because it gives you live feedback on the state of your hardware and software.

Step 4 – Compile a Kernel

This is where a lot of people step back, feeling as if they’re not ready. The honest truth is that compiling a custom kernel is not as complicated as it may sound. Most of the time, the process consists of a few shell commands and a few minutes of reading over checkboxes. Often, customizing a kernel build is literally as simple as browsing a long list of options and picking the ones that sound good. Many options come with a recommended setting to help guide choices you might not be familiar with.

Ubuntu provides an excellent guide on this topic here.

Step 5 – Install Gentoo

There are a few source-based distributions out there, and Gentoo is probably the best known among them. Where your average Linux like Ubuntu and Fedora will fetch packages, Gentoo fetches only the source code, and compile that code into the actual program. There are a few advantages (and disadvantages) to this approach, namely speed and flexibility.

Gentoo users set certain flags for the system that specify, among other things, the CPU type of the machine. When a user requests a package, say for example Firefox, Gentoo’s package manager will search the Firefox source code pack and download the code. It will check the user’s flags to get information, and then build the package that’s specifically optimized for that CPU.

The Gentoo install process is not easy. It’s done through the command line and almost everything is done manually, so Gentoo provides excellent install documentation to help get you through.

Step 6 – Learn a Scripting Language

While C is usually the language of choice for Linux system internals, many of the applications are tied together using higher level programming and scripting languages like Python and bash. Learning one or both of these can be IMMENSELY useful for managing and automating your system.

For example, just yesterday I spoke with a friend who was tasked with gathering the specs from hundreds of hard drives on a company network. Many people would let out a little sigh, grab a clipboard, and start opening machines. This friend, being a Linux geek, instead whipped up a 3-line bash script which scanned the hard drive data for the whole network and printed the results in seconds.

If you’re looking for a place to start learning, MTE has a Basic Introduction to Python 3.

Step 7 – Install Linux From Scratch

You may have noticed in the section above when I mentioned that a Gentoo install involves doing nearly everything manually. Take out the word “nearly”, and you’re beginning to envision a LFS install. LFS is not a distribution exactly. In fact, it’s not a distribution at all. It’s a series of instructions, a way to build every… single… piece… of your Linux install directly from source code tarballs. There is no package manager, no installer, no helpful utilities. You just follow the steps to put each and every piece in place to make a bootable system.

The first time I did LFS, it took me a solid week to get it bootable. With some practice and a fast machine, you may be able to trim that down to a few hours. LFS is not for those lacking in serenity and patience, but if you’re willing to put in the time and effort, it’s one of the most rewarding experiences you can have on a PC.

Image credit: DebianAdmin.com

Getting checkinstall

Ubuntu users can install by clicking here or using your normal package manager. Others can download the tarball from the checkinstall website.

How it Works

Essentially, checkinstall replaces the make install portion of a normal source code installation. If you’re unfamiliar with installing from source code in Linux, check out this guide to get the basics. The rest of this guide will assume basic familiarity of the normal config/make/install process.

Once you’ve run configure (if necessary) and make, you’d normally run make install to complete the process. Now you’d run checkinstall instead, and it would take over the rest. It will record all the files that would be used by make install and build the proper type of package for your system, so that the existing package manager (apt, yum, etc) can handle upgrades and removals.

Running Checkinstall

For this example, we’ll be using checkinstall to install Python from a source tarball. To follow along, you can download the same tarball here. Once extracted to your target location, open that location in your terminal. Run the normal two steps to start the build

./configure && make

And here is where checkinstall comes in. Instead of make install we’re using

# like "make install", you'll need root
sudo checkinstall
#See later section for command line options

If this is the first time checkinstall has been run in this directory, it’ll start by asking if you want to create a directory to hold some documentation that may be needed for packaging later. Accept the default of Yes and continue.

Next you’ll be asked for a description. This is what will be seen in places like the Summary field when showing package info.

Finally, you’ll get the last screen confirming all of your package’s details. One important aspect of this screen is that you can set dependencies for your package. For more details on that, see this Debian guide.

Make note of the location of the package generated by checkinstall. It has been installed, but the package file could come in handy to reinstall later, bring to another computer, or share online.

Options for Checkinstall

Not everything can be covered by defaults, so of course checkinstall comes with a full set of options. Some of the more useful include:

--type=(slackware, rpm, or debian)   #By default, it will use the current host distro type
--install=(yes or no)                #If no, it will just build the package without intstalling
-y                                   #Assume defaults for all questions
--umask=(mask)                       #Set mask for file permissions
--deldoc=(yes or no)                 #Delete doc-pak when finished
--deldesc=(yes or no)                #Delete description-pak when finished
--delspec=(yes or no)                #Delete spec file when finished

Full details are of course available with the –help option or man page.

Sometimes, however, the package doesn’t exist in your distribution’s repositories. Often, in cases like that, your only option is to download a tarball (usually .tar.gz, .tar.bz, or .tgz) which contains the source code for the program that you have to compile yourself. While it may be a little intimidating at first, compiling from source is normally a quick and easy process. Today, we’ll learn how.

First off, I should note that not all tarballs are the same. This guide will be assuming that the program you’re trying to install is a normal GNU-style source code collection. Most require all the steps noted below, but many skip one step or another. For the purposes of the tutorial I’ll be compiling the source code package of Python 3.0.1 from the Python homepage.

Step 1: Extract the tarball

For those new to Linux, tarball is a term commonly used to refer to a file which contains other files. It’s a lot like a ZIP or RAR file in Windows, except that the tar program, on its own, does not compress the files. Tar works with a compression program like gzip to actually compress the files, which is why you commonly see two extensions (.tar and .gz). This is sometimes abbreviated to just .tgz.

Fortunately, we don’t need to run two separate programs to extract the files, we just tell tar to run the files through gzip to decompress. You can use a graphical utility to extract those files by simply double clicking the tarball from your file manager, or you can do it from the command line with:

tar -zxvf mytarball.tar.gz

The options we gave tar are as follows:

• -z to tell tar to run this file through gzip to decompress (use -j for bzip files)
• -x to extract the files
• -v for “verbose”, so we can see a list of the files it’s extracting
• -f to tell tar that we’re working with a file

For easier unzipping, see the Tips section at the bottom of this page

Configure

Once the files are extracted, open a command terminal and go to the directory where the files have been unzipped. Before we can compile, we need to run the configure script. The job of the configure script is to check your system for all the software necessary to compile the program from source code into a usable binary program. It looks for things like gcc version and other tools needed to build the software. So once you’re in the directory with all the files that were unpacked from the tarball, type in

./configure

If all goes well it’ll go through a check of various parts of your system, then drop you back to the command line like below:

The most common cause of errors in this step is a missing dependency. Look closely at any errors you may get to determine what package is missing.

Make

This is the real meat of the process – where we compile the source code into a runnable program. This is normally the easiest step, only requiring a single command. If the configure step completed without errors, simply type in

make

On a large program, this step might take a few minutes. Once done, you’ll be dropped back to the shell prompt as shown here.

Technically, your program is now ready to use. Under most circumstances, however, you’ll want to run one more step so that she program can be fully installed into the correct locations for it to be run from anywhere.

Make install

All this really does is copy the now-compiled program into the system directories like /usr/bin so that it can be run from any directory without having to specify a path to the files. Since it’s copying to a directory outside your home, you’ll probably need root privileges. If the make step completed without errors, simply run

sudo make install

to copy the files. At this point, you’re all done! Your new program can be used like any other.

Tips

Chances are, you’ll be compiling from source more than once in your life. In fact, for those who like to use the latest and greatest software, this can be very common. To make it a little easier, open your .bashrc file from your home directory, and add the following aliases to the end:

alias ungz="tar -zxvf"
alias unbz="tar -jxvf"
alias cmi="./configure && make && sudo make install"