A Practical Guide to Linux

This book is written for the “next” generation of Linux users—programmers, web designers and technically oriented people who are looking for an alternative to Microsoft's operating system and products—rather than the “hacker” generation (who brought Linux to this point).

Author: Mark Sobell

Publisher: Addison Wesley Longman

E-mail: info@awl.com

URL: http://www.awl.com/

Price: $38 US

ISBN: 0-201-89549-8

Reviewer: Todd Sundsted

Mark Sobell's A Practical Guide to Linux
is one of a growing number of books on the Linux operating system.
It combines about equal parts topical guide and command reference.
It is written for the “next” generation of Linux
users—programmers, web designers and technically oriented people
who are looking for an alternative to Microsoft's operating system
and products—rather than the “hacker” generation (who brought
Linux to this point).

The Linux universe is expanding at an ever increasing rate.
Consequently, books of this type are faced with the challenge of
being simultaneously comprehensive, relevant and up to date. To
this book we must add a fourth challenge—as the title suggests,
the material in the book must be practical. Of the three (or four),
being comprehensive is perhaps the easiest to achieve.

Let's look briefly at what Mark Sobell offers us. Part I is
organized into chapters, each covering a separate topic.

After a brief introduction to Linux and its features in
chapter one, Mark immediately gets down to the business of using
Linux in chapter two. In it, he teaches the reader how to log in,
edit files, access the on-line manual pages and use the command
line. It is pretty basic stuff that is necessary for the complete
beginner.

In chapter three, Mark teaches the reader how to use the most
common command-line utilities—tools like
cp,
mv and
grep. Chapter three ends with a
useful section on locating other users, communicating with them,
and sending electronic mail.

Chapter four introduces the Linux file system. It describes
the tree-like organization of the Linux file system, introduces
files and directories, and describes how to work with them.

Chapter five introduces the command-line shell and related
topics including input and output redirection, pipes and the file
name wild card characters “?” and “*”. The material in this
chapter is not specific to any of the common command-line shells,
but instead introduces the features common to all of them.

Most users expect computers to have a graphical user
interface (GUI). Therefore, the sixth chapter introduces the X
Window System—the most common windowing system available to Linux
users. Chapter six contains an introduction to the X Window System
and its user interface components—buttons, sliders, and kin—and
the mouse. It also describes briefly two of the most popular window
managers available for X—MWM (Motif Window Manager) and FVWM
(Feeble Virtual Window Manager) and provides information on
customizing each.

In the seventh chapter, Mark introduces two very important
topics—networking and the Internet. He describes the different
network types and the various network utilities typically found on
a machine running Linux. He also explains how to access both Usenet
newsgroups and the World Wide Web.

Chapters eight and nine introduce the ubiquitous vi text
editor and the Emacs text editor, respectively. While not the
WYSIWYG writing tools many new users of Linux expect, they are
inarguably an essential part of the repertoire of programmers,
system administrators, web developers and others. The chapter on
the vi editor is quite complete. The chapter on Emacs contains just
enough material to get you going, but nowhere near enough to make
you a master of this complex but powerful tool. No manual entry for
p Chapter eleven introduces the topic of shell programming (or
writing shell scripts).

In chapter fourteen, Mark introduces the tools of the
programmer's trade—the C compiler,
make and the source code
management utilities. This chapter is easy to read but the material
is not really necessary. Readers with any programming experience at
all will find it far too basic, and beginners won't find enough
information to make them into even fledgling programmers.

The final chapter of part one, chapter fifteen, introduces
system administration. In this chapter the reader is taught how to
boot the Linux system, backup files, install software, and rebuild
the kernel.

Part II is a command reference that is quite well done. Each
entry in the reference describes the syntax of a command,
summarizes its operation, describes its arguments and options,
provides a few noteworthy comments and illustrates several examples
of its use. While there is nothing here that couldn't be obtained
from a careful reading of the man pages for each command, the
format is easier to read and the examples are far more useful.
Occasionally an entry omits some of the less used features of a
command. In those cases you'll have to refer to the man pages for
the command or to other documentation.

Four appendices round out the book—one on regular
expressions, one on accessing the copious Linux documentation
available on-line (appropriately titled “Help!”), one on software
emulators and one on POSIX and POSIX compliance.

My overall impression of Mark Sobell's book was positive. The
chapters on the various command line shells easily took top honors
for best of the book. Like it or not, the command line is an
integral part of using Linux, and familiarity with one of the
available shells is necessary to fully utilize its power. Users new
to the Linux world will undoubtedly be daunted by the flexibility
offered by the even the simplest shells—especially if their
previous experience was limited solely to the DOS shell. A good
introduction, however, goes a long way toward making the process of
learning painless, and once learned, the user will find the
flexibility and power exciting.

The chapter on vi was very solid. I only use vi when I don't
feel like waiting for Emacs to start—that turns out to be quite
often when I'm performing system administration tasks.
Consequently, I use vi a lot more than I ever thought I would. I
have a feeling that vi is here to stay and that learning to use it
effectively is best done early.

The chapter on networking was a mixed bag. The information on
networks and networking was interesting, as was the overview of NFS
and NIS. The coverage of common commands such as
rlogin,
ftp and
ping was also very useful. On the
other hand, I don't think anyone uses
archie or
gopher anymore. (It did dredge up
nearly lost memories of a much smaller Internet, however.) In fact,
I'd bet many people haven't even heard of them. The material on
browsing the World Wide Web, while accurate, is already beginning
to go out of date. The material in the book is based around what
looks like Netscape 3.x and Netscape 4.0 is already out, with a
completely new user interface. Omitted is any mention of Java or
Javascript.

I liked the command reference in part II of the book. While
not a replacement for the on-line manual pages, it was fun to flip
through off-line. The on-line manual pages are great when you know
what you're looking for, but they're not much fun to browse. Part
II, on the other hand, made good reading while waiting for a
compile to finish or a page to load into my browser.

The least useful chapter, in my opinion, was chapter
fourteen—Programming Tools. The material presented seems too basic
for an experienced programmer, yet too superficial for a beginner.
But then, as I think more about it, one group does come to
mind—those programmers who are proficient in C or C++ but who have
gained all of that experience while working in an Integrated
Development Environment (IDE) on another operating system.
Compiling and building an application from a command-line
environment would be a big change. Chapter fourteen would help them
get started.

I found the sections on customizing FVWM and MWM, in chapter
six, to be too brief. I'm also concerned that, given the existence
of two mutually incompatible (from a configuration file perspective
anyway) but common versions of FVWM (1.x, 2.x and 95), the section
on FVWM configuration might cause more harm than good for
beginners. Perhaps Mark could have mentioned configuration,
explained what pieces of each window manager can be configured,
pointed the reader in the direction of the manual page and moved
on.

I also found the inclusion of material on the various
emulators to be of little use. While I consider both Wine and
Executor to be two of the most impressive products I have ever
seen, given their current (sometimes extreme) limitations they are
unlikely to be useful to any more than a small minority of Linux
users. WABI and iBCS may have a slightly broader appeal, at least
to those who need to run legacy applications, but neither emulator
will replace the need for good native Linux implementations of
solid application suites.

I would have liked a chapter on Perl. Like the command-line
shells, Perl is a tool many users—especially those administering
their own systems—will find useful. Indeed, whether one writes
system administration programs, backup tools or CGI scripts, Perl
seems to be the language of choice for a large number of
experienced Linux users.

So, how did A Practical Guide to Linux
do against the four challenges I mentioned earlier? It is
definitely comprehensive (but that's the easy part). It's also
relevant—most of the tools and utilities covered within its pages
are here to stay. Aside from the material on the Internet (which
admittedly is moving at a lightning pace), it is up-to-date. And,
except for the chapter on programming, it is very practical.

The fact is, I'd buy it. It's every bit as good as any of the
other Linux books available and better than many.

Todd Sundsted
is a programmer, writer, and
die-hard Linux enthusiast. He writes the “How-To Java” column for
JavaWorld (http://www.javaworld.com/) and provides training and
consulting through Etcee (http://www.etcee.com/). He can be reached
via e-mail at tesundst@emss.com.

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.