Applixware for Linux seems to be the great
hope for the Linux community, it's billed as
the application that will beat Microsoft
Office and remove the major obstacle to
Linux on the desktop.
The Bottom Line If you have a modern
machine and need to exchange documents
with MS Office users or need an integrated
office suite then this is worth getting.
Applixware is certainly a fully featured
product, it includes:
A word processor (used to write this
. A graphics program.
. An HTML editor.
. An application to write Business presentations.
. Mail program (MUA).
. A development language (not in the base product).
The suite is supplied on a CD-ROM with a three-inch manual that covers the WP, Spreadsheet, and Business Presentation programs. Additional documentation is installed on the hard disk drive and is viewed using the Applixware on-line help system.
Hardware: You really need 36 Mbyte of
RAM and a 486DX running at 66MHz or
above; if you only have 16 Mbyte, there is a
lot of swapping when starting applications
and modules, although performance when
actually using the applications is fine, even
on slower machines. The Linux version is
released by RedHat and was supplied with
the GPL version of RedHat Linux which I
Applixware is a heavyweight contender for
the desktop and it feels sufficiently familiar
to this MS Office user that I was able to
perform basic functions without much, if
any, reading of manuals. However, this is
not a complete MS Office clone and some
reading is recommended.
The application can be extended with a
built-in scripting language, ELF, which can
call custom C routines installed in shared
libraries. Using such a mechanism, it would
be possible to integrate PGP into the Mail
application, but I would prefer something a
Desktop applications have today become so
bloated that is would be very tedious to list
all the suite's features. However, the main
word processing and spreadsheet features,
(according to the Applixware
A WYSIWYG (What you see is
what you get) display.
. Live links between Spreadsheets, Data, Graphics, and other wordprocessing documents.
. Multiple font sizes and styles, including many foreign language, mathematical, and other special characters.
. Spell checking in sixteen languages, including a system dictionary, a personal dictionary, and a thesaurus.
. Book production tools that allow you to combine separate documents into one book, including automatic footnote generation, automatic indexing, and table of contents generation.
. Metric operation.
. Hypertext links.
. Table creation and editing.
. Local calculation and equation inserts.
. The ability to create customised letters or mailing lists using merge fields.
. Importing of documents created using other software packages into Applixware and exporting documents to other file formats.
. Analyse and manipulate spreadsheet data using built-in functions and formulae.
. Create what if?' scenarios that let you explore possibilities, test hypotheses, and develop forecasts.
. Integrate your spreadsheet with a wordprocessing document, live links between data, words, graphics, and other spreadsheet documents.
. Run remote functions written in the C programming language.
. Maintain up to four different windows of one spreadsheet.
. Arrange information in a database format and extract the data matching your criteria.
. Generate 2- and 3-dimensional charts.
It was not possible to test all of these features because of lack of time. I did experience some problems importing MS Word 97 documents and older MS documents with some more obscure formatting (such as landscape tables). Importing of RTF format documents may be a better compromise.
The installation gives very few choices
about how the package is installed. All
applications are copied onto your hard disk
and the US dictionary is installed as well.
The only options are which additional
national dictionaries are required and
whether you wish to install the
documentation set (about 260Mb is required
for a typical installation). As an option the
software can be installed in CD mode,
where most files are left on the CD and are
run from there. Apart from the performance
hit and the fact that the CD drive is occupied
this works well. There was no dicussion of
loading the software onto a central server
for client use in any of the documentaion or
sales literature that I noticed.
When running on a slow, or very heavily loaded, system Applixware seems a little sensitive to timing issues and will crash if a job, e.g. printing, takes too long. Printing is
done using Postscript or PCL5 and I
managed to get some output on my dot-
matrix printer using Apsfilter and
I would have liked to see the Getting
Started section in the printed manual as
well as the on-line help and for it to discuss
only the applications I had purchased, rather
than what appeared to be the whole
Applixware product set.
(Reviewed by Phil Docking)
This book is a revision of the previous
Learning Perl book, with modifications for
Win 32 systems, but with most chapters
largely unreconstructed. If you already have
one of the previous editions, the major
advantages of reading this book are the
changes of the Process management and
System Information sections into a Win32
context, and the addition of a section on
OLE automation towards the end of the
book. CGI programming is also covered
with more regard to Microsoft's IIS
(Internet Information Server) and its own
methods of interfacing.
My main criticisms of this book are firstly
that the content appears to be written for
11-15 year-olds, but with a grammar and
vocabulary more suited to an advanced C
programmer. For a complete beginner, it
would be frustrating trying to decrypt the
computing terminology. For someone who
knows other languages it would be an
infuriatingly slow introduction to Perl.
Secondly, I'm not so sure that the book wouldn't have benefited from a more complete re-working for a Win32 edition, rather than just the minimal modifications applied where necessary. This is shown particularly in the Win32 Process management section, where Perl Object access is shown long before it's explained. My third criticism is that the book is not extensive enough (indeed, none of the previous editions have been either).
If this is a book on learning Perl, surely it
should include as much as possible about
Perl functions and abilities, rather than
constantly referring us to the Programming
Perl book otherwise the book should be
titled Learning (a little bit of) Perl. If
anything, this should be the book that other
Perl books refer to. Or maybe
Programming Perl should be re-written with
more learning sections.
Despite these criticisms, the book does, at least, present a friendly face for those of us who are using Perl on Windows NT systems (the book does explain that Windows 95 Perl behaviour is slightly different). The introduction tells us what Perl is used for, and where to get it, as well as outlining the differences between the standard Perl and the ActiveState distribution. The Stroll through Perl section presents us with a Perl program in the making, starting off with a simple program and adding functionality as
it evolves from a simple login type script
to a multi-user user management system.
Chapters two to five define the basic
variable types available in Perl and shows
how to use them in simple control structures
Chapter six shows the reader how to start
handling I/O from the standard input and
output file streams.
Chapter seven explains basic regular
expression usage, and chapter eight defines
how to use functions in Perl.
Chapter nine looks at more advanced control
structures, such as those used for
terminating loops and in-line and and
or structure usage.
Chapter ten deals with more file handling
and chapter eleven shows the reader how to
use the Perl format structures.
Chapters twelve and thirteen deal with file
and directory access and manipulation.
Chapter fourteen starts to get a bit more
advanced with Process management in Perl,
which is where the real differences between
UNIX and Win32 Perl starts, but this
chapter gives only a very short example of
create a Notepad process, using the as yet
unseen object terminology, as noted above;
so it's very disappointing if you were
expecting more at this stage.
Chapter fifteen reverts to the previous
editions' data transformations chapter
showing examples of finding substrings,
sorting strings and transliteration in strings.
Chapter sixteen deals largely with Win32
versions of getting user and system
information. The chapter begins by
referring the reader to an appendix of Win32
modules, rather than giving any detailed
information, apart from showing how to
retrieve very basic information. Later a brief
introduction to the registry shows the reader
how to open registry keys and read and
write registry values not really a topic for
a learning book, but just another
contradiction amongst many in this book.
Chapter seventeen again reverts to the
previous editions' DBM to Perl interface,
with a couple of paragraphs only on using
Chapter eighteen deals with CGI
programming, and is, again, a repeat of the
previous editions' chapter except for
screen-shots which have curiously
metamorphosed from Netscape to Internet
Explorer browsers which, however, show
effectively the same content. There's not a
lot of difference between UNIX and Win32
Perl in this area, so I guess they just decided
to change the pictures. Finally, there's a
little information on the Win32 Internet
Information Server extensions: PerlIIS and
Chapter nineteen is a new addition to this edition. It shows the reader how to use OLE automation within the Win32 context. However it's rather a short discussion with only two brief example of using Win32 MAPI to send a mail message, and using
DAO to alter a database. The chapter ends
with a short tip on converting Visual Basic
In summary, there are too many
contradictions in the level of the target
audience for this book. Is it a beginner's
book or not? The author or the editor of this
edition seem to have lost sight of this. To be
fair, previous editions were also written with
complex terminology and simple content, so
there's nothing new on that score here. The
second problem with this book occurs as a
result of the revision to includeWin32 Perl.
With all of the references to the appendix
listing of Win32 modules, O'Reilly might as
well have just re-issued the original
Learning Perl with an extended appendix on
Win32 modules and appropriately placed
footnotes telling the reader to read the
appendix. In effect, they have just re-issued
the original edition with additional notes in
Phil Docking looks after the PC systems in the
Department of Computer Science, Birkbeck College.
The book is organised into three
sub-sections: Chapters one to three outline
the basics of the NT systems which are the
topic of the book, with basic pointers to
writing stable code. Chapters four to eight
deal with the associated subsystems of the
NT environment: The I/O manager, the
Virtual Memory Manager, and the Cache
manager, and how file systems drivers
interact with them. Chapters nine to twelve
give a detailed description of how to
actually write the file system driver/filter,
based upon the information presented
There are two drawbacks to this book. The first problem is the actual structure in which information is presented within the book. Admittedly, writing on such a complex topic presents a chicken-and-egg problem do you explain the core components first, or do you explain the structure within which the core components must operate first? This may be a personal opinion, but I feel that it would be better to give the reader a description of what a file system driver does, before describing the specific details of associated components. I would rather see the problem first and then read about the
context, rather than read the details of the
context first, with a constant feeling of I'm
not sure why I'm reading this. For those of
you who have an extremely good memory,
and don't mind reading several chapters
before getting to the point, then you should
read the book from chapter one onwards.
For those others, who like to get to the point
immediately, start with chapters one to
three, and then skip to chapter nine. You
can fill in the details from the previous
chapters when you get to a point where you
don't understand how the driver interfaces
with the rest of the system. (In fact a lot of
information from the first few chapters is
re-iterated in these sections, so you
shouldn't have to turn back too often.)
The second drawback to the book is in how
interface/system calls are presented within
the book. Normally these are presented in a
list structure, detailing the parameters to the
call, return codes, and information on the
particular call. My complaint with this is
that they don't need to be listed along with
the text of any particular chapter, but should
be listed one entry to a page in an appendix,
which makes for easier reference material
Despite the drawbacks, this is an
exceptionally well-written book, with
smidgeons of humour now and again, which
can make all the difference in a book of this
size and complexity.
The preface states that the intended
readership of this book is those who design,
implement, or are just interested in
kernel-mode software on Windows NT, such
as device drivers and file systems drivers.
The author assumes that the reader will have
a knowledge of the fundamentals of
operating systems, and some knowledge of
high level programming languages (since
the examples are all in C).
Chapter one is a good short introduction to
the internal architecture of the NT kernel
and executive. It's concise and to the point,
covering the basics and includes an
important treatment of IRQ levels.
Chapter two is another well-written and
detailed description of what a file system
driver or filter driver is expected to do
within the NT system it shows exactly
where drivers are expected to attach
themselves in the hierarchy of drivers, and
also touches on networked and distributed
file system basics. The chapter starts to
address issues of working in kernel mode,
such as how to allocate and manipulate
memory in kernel mode drivers.
Chapter three deals with exception
conditions which might arise and how to
deal with them. A lengthy description of
structured exception handling within the
context of kernel mode drivers, emphasises
the importance of writing exception-secure
code for stable systems performance. The
following section on event logging gives us
a method of letting the user/administrator
know what's going wrong within your
driver. The final parts of this chapter shows
us how to use synchronisation mechanisms
(spin locks, dispatcher objects, and resource
objects) to ensure the internal consistency of
data across different execution threads.
Chapter four describes the I/O manager,
placing the I/O manager in context with the
rest of the operating system. This chapter
details the common data structures used
within the I/O manager, and the
all-important I/O Request Packet structure
used for all mainstream input/output
requirements. Later in the chapter the NT
boot sequence is described, defining exactly
where particular drivers are loaded and
reminding the developer that some systems
may not be up-and-running when their own
driver is loaded.
Chapter five describes the virtual memory
manager. This is probably one of the more
vital chapters since a good knowledge of the
VMM is required in order to do any driver
development at all. The chapter deals with
process address space, memory
management, page fault handling and
describes the memory management interface
to file system drivers.
Chapters six to eight deal with the Cache
manager detailing the functionality provided
by the cache manager, and the methods by
which file system drivers can interface with
the cache manager. In these chapters more
detail of I/O processing is presented, with an
in-depth discussion of the role of the cache
manager and the developers' driver within
Chapters nine to twelve is where we finally
write the file system driver. This part of
the book starts with designing the file
system, details how the registry is used to
maintain parameters, and how the driver
installs itself into the system. A great deal of
detail is shown together with sample code
fragments, although there's plenty left out
too (in order not to swamp the reader with
information, I assume). After this, each
function that a file system driver can
provide is described and examples are
shown, together with any associated caveats.
Chapter twelve deals with writing a filter
driver, to hook file system calls and pre- or
post-process data from file system calls.
All-in-all, this is a good book, written by
someone who seems to have his finger on
the pulse of NT file systems. He obviously
knows a lot about the NTFS and FASTFAT
file systems, and this shows in places where
he contrasts the two, showing how they
would handle particular operations when
called by the I/O manager. The examples
are useful because they guide you through
the process of writing the file system driver,
including comments on all the possible
pitfalls, and the book comes with a sample
filter driver on a companion floppy disk.
Despite my criticisms about the layout of
the book, this is worth reading if you're
interested in finding out more about what
exactly it is that file systems on NT have to
go through just to provide the service they
Phil Docking tends the NT systems in the Department
of Computer Science, Birkbeck College.
(Reviewed by Alec Clews)
This is the best Linux distribution I have used to date. I have absolutely no problem in recommending it, particularly for desktop and new users. People who are supporting larger numbers of systems should also look at Debian to see which one might suite them, but it's a toss up here as well.
The three big wins with SuSE are:
. A lot of the system administration can be performed via menus.
. Many of the applications seem to be set up with sensible defaults and work right out of the box.
This was the first time that I did not need to delete a new distribution after installing it and start again, it went in first time (or perhaps I'm just getting better). The CD distribution can be booted from a supplied floppy diskette, from DOS using
or, with the correct BIOS, directly from the
The supplied book, 350 pages, has detailed
instructions which I really did not need to
read (there is a quick install section as well).
The installation, as well as allowing the user
to pick individual packages, has several
default profiles which can simplify the chore
of choosing what one needs to copy to the
hard disk. Have a notebook and pencil
handy though to make notes during the
installation process (this is of course good
advice for any system!).
Once the system is installed, system
administration is carried out using
which satisfies over 75% of my
administration needs. The tool works in
character mode and so it is not necessary to
have X running. Even with X installed this
is an advantage on occasions. Postscript
printing worked out of the box to my
dot-matrix printer using
. The PPP configuration for
a dial-up connection still needs some work
but seems to be pretty much there.
Package management is handled using
RPM, so it is pretty easy to use packages
from the RedHat distribution unless they
are using PAM or other places.
I am uncertain what the copyright notice
implies about the SuSE software. I think it
implies that you can copy and distribute the
software for free, but not charge money.
(Reviewed by Alec Clews)
This is the only book that I have found on Oracle system administration and I had hoped to have a handy reference to use in my daily work (I support a large Oracle- based application). This book should address a real need in the market as there are very few books on this subject currently available. However, it suffers from many faults which limit its usefulness and I
suggest that you save your money and make
do with the Oracle manuals.
The book is based on the College course that
the author gives in California. It is a pity
that time was not taken to flesh out the
lecture notes with the information that is
normally given verbally by the instructor,
for instance many of the examples used to
illustrate points are not fully explained. The
book is also full of spelling mistakes, some
of which would have been corrected with a
spell checker and the rest that should have
been corrected by a copy editor. In addition,
topics such as normalisation are poorly and
inaccurately explained. Much of the useful
information is re-hashed form the Oracle
documentation set, there are not even any
extra diagrams to make the explanations
There is some information of value; the
description of the Oracle architecture and
installations is well done, but this book has
many faults most of which should have
been avoided by the publisher. There must
be a significant market would someone
please write a decent book on Oracle
administration for me to carry when I go on
client site? Are you listening O'Reilly?
The book claims to cover all needed
material for both novice and experienced
users. Since it is less than 200 pages this
claim is obviously fallacious.
It would be possible to list other faults in the
book (if Prentice Hall would care to contact
me I would be happy to supply a list) but I
think we have better use for our column
(Reviewed by Mick Farmer)
First off, I must own up to not reading the whole of this book. I skimmed through a number of chapters and really only read carefully those concerned with the mailing list management (MLM) package that I use, Majordomo.
This is the kind of book that O'Reilly does really well. A specific subject area covered in depth by an author who knows that topic backwards. The book is divided into three broad sections. The first two chapters cover the general concepts of e-mail and mailing lists. The next six chapters are for list maintainers, and cover the four MLM packages, Listproc, LISTSERV Lite, Majordomo, and SmartList. The final four chapters are for server administrators, and deal with the installation and configuration
of each MLM package. Finally, there are
four appendices providing reference
material for the four packages.
The first chapter describes the concepts of
e-mail, mail agents, mailing lists, etc. at the
right level with plenty of examples. The
sections on how mailing lists function are
especially lucid. The second chapter covers
all the decisions that have to be made when
you decide to set up a mailing list. There
were certainly a few items included that I
hadn't given much thought to when setting
up some of the lists that I maintain!
As I said at the beginning, I only read
carefully the chapter dealing with
Majordomo list administration. This covers
all of the important topics that a
(Majordomo) list administrator needs to
know. I learnt about some useful features
provided by the latest release of Majordomo
(1.94.4 for this book) and implemented one
of these for my largest list (just over 550
subscriptions) having Majordomo send
an authentication number to an applicant,
which they must send back to Majordomo to
complete the subscription. This prevents
people from subscribing others unwittingly,
but I use it as a counter-measure against
spammers who might try to subscribe to a
list, then send their junk mail, and then
unsubscribe, automatically. Very useful.
The chapter covering server administration
is also very thorough. Majordomo is written
in Perl and I had hacked an earlier version to
uuencode binary files, so this material was
familiar to me. However, the server
administrator doesn't really need to know
Perl in order to administer Majordomo. The
administration of archives and digests is also
dealt with in this chapter.
The Majordomo reference appendix
describes the user commands and list owner
commands, Majordomo's files, and the
configuration file directives.
So, I think that this is a good book covering
all aspects of the MLM package I use. I can
only assume this goes for the other packages
as well. This book would also be useful for
someone thinking about using an MLM
package for the first time, as Chapter 2 also
discusses how to choose an MLM by
looking at the different philosophies and
specific features of the four packages
covered in this book.
(Reviewed by Huw Gulliver)
This book is by the same authors as Learning Perl (the Llama book), aided on this occasion by Erik Olson. So it is not surprising to find that it is based on the Llama book; We have removed some things that are not applicable to Perl programmers on Windows NT systems, and have added coverage of other things that are special to Windows NT.
A quick comparison with Learning Perl
shows they are peas from the same pod.
You get Larry Wall's foreword from the
first edition of Learning Perl and chapters
of the similar name and content with a few
exceptions which we will come onto shortly.
This is not a criticism Learning Perl is
renowned for providing a good introduction
to Perl so there's no reason to change a
Learning Perl on Win32 Systems (the Gecko
book) presents the main features of Perl data
types, control structures, hashes, regular
expression, I/O and functions using a
tutorial style. Numerous code examples are
included and each chapter ends with a set of
exercises for the reader to attempt, the
answers to which are provided in one of the
appendices. It is essentially everything you
will need to know to be able to write your
own useful Perl scripts. In fact, most of the
book is applicable, whether you are
predominantly a UNIX or Win32 user.
The bits that orientates the book to the
Win32 user come in two forms; short
sections within chapters such as explaining
the installation process or when to use
as the path delimiter, and longer
sections in the later chapters which
introduce some of the Win32 specific Perl
modules (a complete chapter in the case of
OLE Automation). This chapter and the
previous one, CGI Programming give a
brief taste of the object-oriented interface
that many Perl modules now provide.
The book is completed by four appendices;
Exercise Answers (already mentioned),
Libraries and Modules (listing the main Perl
libraries and modules in the standard
distribution and the Win32 specific ones),
Networking Clients (which presents via a
couple of examples the object-oriented
interface to socket programming), and
Topics We Didn't Mention (the bits that got
left out to prevent the book growing too big
or are covered in Programming Perl).
If you are about to start learning Perl and
you are mainly looking to run your scripts in
an MS Windows environment then this book
will get you off to a good start in your
programming career. If you already have the
basic Perl skills and are just looking for help
migrating to the MS Windows environment,
it is hard to say whether the book is for you.
Certainly the examples and exercises will
give you that jump start that is often needed
to get going initially, but if you already own
Learning Perl you'll find the books
effectively cover much of the same ground.
Huw Gulliver is a member of the Service
Communications Group at Computing Centre
University of Wales, Cardiff.
(Reviewed by Huw Gulliver)
Have you ever wondered why a piece of your Perl code did not work as expected? Well, you may find the answer in Advanced Perl Programming where Sriran Srinivasan gets out the spanners and lifts Perl's engine cover (or should that be wrenches and
hood), along with learning about
object-oriented Perl programming, how to
extend Perl with C and embed Perl in C.
The first three chapters take a look at data
types and how they can be accessed and
manipulated. The section starts with
references to Perl variables and anonymous
storage, moves onto implementing complex
data structures. It finishes with typeglobs
and symbol tables which explains how you
can have a scalar, an array, a hash and a
filehandle all called
at the same time.
The next three chapters examine different
aspects or features of Perl, subroutine
references, call-back procedures and
closures, and the eval function which the
author considers one of the biggest reasons
for using the language. Also covered is
how to create and use your own modules.
These chapters, together with the first three
chapters provide necessary background for
the next two chapters that introduce Object-
Oriented programming. Nevertheless they
present useful information in their own right
even if the reader has come across them in
other books such as Perl Programming also
published by O'Reilly.
The Object-Oriented Programming and Object Orientation: The Next Few Steps chapters introduce this methodology using Perl. For those familiar with object- orientation (OO) the author has provided a syntax summary in appendix B. For the rest of us we are guided through the new terms and concepts such as object, attributes, classes, methods, used in OO which get used extensively in the rest of the book.
Chapter 9 examines how the Tie function
works with various data types. Plus how to
use the function to give an existing package
an easy front-end and how to monitor an
There are two chapters on persistence,
saving data to files and databases. The first
chapter deals with the issues an application
programmer has to reconcile, and then looks
at some of the Perl modules FreezeThaw,
, SDBM_File, DB_File
and DBI that support persistent storage of
streamed (no boundaries) and
record-oriented (relational databases) data.
The second chapter studies the Adaptor
group of modules that makes use of the
ObjectTemplate library, introduced in
chapter 8, to provide a uniform interface to
Networking with sockets and
Networking: Implementing RCP chapters
introduce and use the object interface to
socket communications. The module is used
a messaging toolkit.
toolkit is then used to build a
remote procedure call module. During the
course of the first of these chapters the
problem of client/server deadlock and I/O
blocking and ways to avoid it are discussed.
The User interfaces with Tk chapter
introduces the Tk toolkit and its Perl
interface, Perl/Tk, for building GUIs with
the most common properties and methods of
Tk widgets described in appendix A. The
next two chapters demonstrate how to build
applications such as the game Tetris and
a UNIX man page viewer Perlman.
Chapter 17 uses the concepts learnt in the
first half of the book to build a
template-driven code generator Jeeves,
named after the butler in P. G. Wodehouse's
novels. The design and implementation
make interesting reading.
In the first of the remaining three chapters
Extending Perl: A First Course we move
away from OO to examine how to extend
Perl by cementing Perl and C code together,
using as an example creating a Mandelbrot
set image from Perl. The second chapter
Embedding Perl: The Easy Way moves in
the other directions, looking at embedding
the Perl interpreter within C/C++
applications. The final chapter Perl
Internals goes inside, exploring some of the
critical data structures and function of the
interpreter not for the faint hearted.
The chapters introducing object-oriented
programming will probably be one of the
main reasons to consider this book for a lot
of people. But, if like me, you are not
familiar with object-orientation, be prepared
to spend sometime looking at some other
references. Given that the author states in
the preface that the reader is only expected
to know a subset of Perl and cites Learning
Perl, which only briefly touches on
object-orientation, to attain this knowledge,
I feel a little more time should have been
spent on introducing object-orientation. Not
everyone who uses Perl is a C++ or Java
programmer and most Perl modules now
appear to provide this type of interface.
Aside from the afore mentioned comment, this book slots in well with the other books in the O'Reilly Perl series. I found the writing style, with the author's odd humorous comment or footnote, makes the book enjoyable to read. Plenty of code fragments are included to help the reader understand the topic under discussion. As usual these are available for download from O'Reilly's FTP site. Also, the plentiful references to other resources and comparisons with other languages (principally Python, C/C++ and Java) at the end of chapters will no doubt help the serious scholar.
Huw Gulliver is a member of the Service
Communications Group at Computing Centre
University of Wales Cardiff.
(Reviewed by Robert Pitchford)
This book would be invaluable for anyone embarking on the C learning curve from the beginning, with or without any previous programming experience in other computer
languages. C is treated from the very
beginning as a foreign language which is
slowly built upon throughout the book until
full fluency is attained. A C programmer
would find it an invaluable text from their
first tentative programming steps through to
Oualline's writing shows him to be
experienced in his chosen topic. Having
been a C programmer myself for many
years, I found myself identifying with many
of his comments and observations which are
not readily found during a purely academic
look at the language. This is best illustrated
by his lengthy discussions concerning
keeping any coding simple. With reference
to programming comments and general
documentation, which may seem an
unnecessary burden the inexperienced
programmer, Oualline stresses how such
things really do matter. Perhaps, in addition
to this, Oualline could have more emphasis
on user liaisons (i.e. the commissioner of
the program). While this is covered to some
extent, the real fickleness of most people
could have been highlighted more.
The book's Preface contains a good
synopsis of what can be found within
individual chapters, this being repeated at
the head of the three sections plus
Appendices, as well as a pointer to FTP sites
where example code may be obtained.
Section 1, Basics, consists of chapters on
What is C, Basics of Program Writing,
and Style. The final chapter of the
section, Programming Process, reviews all
the necessary steps of developing software,
from the specifying, through writing, testing
and debugging to prototyping and
implementation. During this last chapter
there are also useful tips on the writing of
Makefiles, which are useful when compiling
programs, especially those containing
One area of the book which I was a little
unhappy about was Chapter 2, Basics of
Program Writing, which gives a brief
overview of different compiler commands
which may be used with C programs. The
danger here is that it is very difficult to give
an exhaustive list, and some may find an
available option is not listed. Also, there is
an extensive description of Integrated
Development Environments (IDE), which
allow writing, compiling and linking
programs within an integrated package,
under different compilers (e.g. Turbo C).
Again, such an environment may not readily
be available, especially for those
programming under the UNIX operating
The second section, Simple Programming, introduces some of the more advanced features. Chapters including Variable Scope and Functions, C Preprocessor, Bit Operations, and File Input/Output show how the language builds in
complexity. Each chapter has good
examples of working C code, and are
concluded with a number of exercises which
can be attempted, although no model
answers are provided.
As in the first section, the author gives a
good explanation of every aspect discussed.
There is a good clear chapter entitled
Simple Pointers which introduces the
concept of C pointers efficiently and clearly,
showing the pitfalls and how they may be
avoided. This chapter, I felt, was one of the
most important. C Pointers is one area
which does require careful explanation; it is
the one concept which most programmers,
new to C, often find particularly difficult to
Pointer concepts are also followed through
to their advanced stage within the third
section of the book Advanced
Programming Concepts. The section
introduces Modular Programming,
Portability Problems, as well as discussing
the maintenance of ancient C code.
The final chapters of the third section
describe a software project from its initial
design and concept phase, through coding,
debugging and testing. This finishes the
book off well; all previously discussed C
tools are used and incorporated. This book,
therefore, would be invaluable to anyone
learning C, or simply requiring a reference
manual for their daily programming
activities. Almost every aspect of the
language is included and described, making
it well worth the purchase.
Robert Pitchford works at the University of Manchester
and has been involved in a number of C programming
projects over several years in conjunction with the
North West Regional Health Authority.
(Reviewed by Chris Cook)
The ongoing fashion for organisations to get themselves connected, both internally and to the rest of the world, has meant that there must be an awful lot of people out there who suddenly find themselves needing to become proficient at administering a networked computer or two. This book in intended for those readers who are already reasonably experienced UNIX users, and to some extent administrators, who need just to fill in the gaps. It resists the urge to be other things such as a System Administrator's, Postmaster's or Webmaster's guide, though obviously, all of these will probably have to cross this territory to get to where they're going.
The book starts by describing the TCP/IP protocol and how it physically works. From there it goes on to introduce the concept of different services, introducing the fundamental ones such as name to address resolution. The next four chapters cover the basics of preparation: obtaining an IP address, planning your network and subnets, configuring the machines to use the correct
parameters and choosing the appropriate
routing protocols. Serial line protocols are
covered, with understandable preference
being given to PPP over SLIP.
Most of the ancillary services are lumped
into one chapter, with sections on NFS,
LPD, NIS, BOOTP and DHCP. Whilst the
discussion is obviously at a basic level,
there are many useful tips about how best to
employ a service and how to avoid simple
mistakes, such as unnecessary NFS
dependencies, that prevent machines from
booting. As well as describing the
configuration of a service, the book tells you
whether or not you can expect your system
to be running that particular one out of the
box. Whilst not perfect, for instance
different Linux distributions come with
different services enabled, this is a definite
time saver, allowing a fledgling system
administrator to decide whether or not
configuration of a particular service is likely
to be an issue.
By far the largest individual topic, in terms
of pages devoted to it, is Sendmail with a
fifty page chapter describing configuration,
and another fifty pages of appendix devoted
to reference. The relevance of e-mail
configuration is extremely pertinent in this
day and age, where many an administrator is
being instructed from on high, to get our
business onto the Internet. The boss wants
an e-mail address on his business card by
coffee time. Curiously, little or nothing is
mentioned about other mailers such as
Qmail, Exim or PP. Perhaps for the Third
The configuration pages include tips on how
to work with the older, lesser featured
versions that some vendors inexplicably
insist on still distributing with their
operating systems. However, you really
ought to upgrade to a recent version and this
is catered for in the appendix where the
author demonstrates a build from scratch on
first a Solaris 2.5.1 system, then a Slackware
96 Linux system. This is rather useful as the
builds don't actually work out of the box,
requiring minor adjustments before things
work. This is nice as it exposes the novice
to the realities of system administration,
where not everything works as the
documentation says and some thinking is
The last three chapters cover
troubleshooting and security. The basic
tools are covered to find out where a
network service has failed. In addition to
the obvious problems, such as machines
using the wrong IP address, a number of real
examples are given complete with the
processes used to deduce the reason for the
failure. The chapter on security doesn't
merely quote lists of tools, but usefully
starts by highlighting the importance of
planning and policy, and the importance of
not panicking is stressed in the event of a
real security breach.
The book closes with a chapter on Internet
information resources followed by 150
pages of appendices. The bulk of these are
reference pages for
, and the aforementioned Sendmail.
I know a few system administrators with a
start-up ISP who found themselves in at the
deep end and only stayed afloat by owning
a copy of the first edition. In the long run
you'll probably want to supplement this
book with a few others dedicated to
particular aspects but for the time being, it
will save you about a yard of shelf space.
When you are ready to take a more detailed
look at one of the topics you'll find one
recommended amongst the text. It seemed
strange that these weren't gathered together
into a formal bibliography at the back.
Closer examination showed that they were,
in the guise of the O'Reilly catalogue :-).
The text is well put together with very few
errors. The introduction to the structure of
the DNS includes a description of the
top-level domains. Whilst pointing out that
most systems in the U.S. are in the
organisational top-levels (
etc), it fails to mention that many non-U.S.
sites can be found amongst them. The
reference referred to four quotas that
are controlled by the
then went on to describe only three of them,
omitting the files quota. Intensely
frustrating but I'm over it now.
Although the book is inevitably UNIX
oriented, much of what it says applies to NT
and '95. However, good news for NT
administrators, as the author is currently
working on an NT version of this book.
Whilst the book does claim to be as useful to
the home user as to an administrator of a
network, it's more likely to be of interest
rather than of practical value unless the
home user has a growing home network (er,
like myself). It represents extremely good
value for money and ought to be given to
every new UNIX system administrator on
their first day, placed on their chair so that
they can't miss it. It has no CD-ROM.
Chris Cook is the Postmaster and a System
Administrator at Cardiff University. He is currently in
shock after his father-in-law painted the hall, the stairs
and the landing, in what can only be described as
(Reviewed by Raza Rizvi)
It takes a really very good book to stand out from the crowd. This is just such a book. Of course it has the excellent O'Reilly pedigree but even apart from that, this book has the right match of focused information, is well written, and it matched my expectations.
To provide a common understanding through the rest of the text, a good introduction to IP networking is provided. This covers the format of IP addresses and the difference between classful and classless use of addresses. An English language
syntax is given to explain the function of
routing protocols and the pros and cons of
dynamic and static routing are elaborated.
The initial chapter concludes with a
description of the Domain Name System.
Any strategy for managing a network
depends upon the network that you have in
place (or that you are about to design). Scott
covers this in two separate chunks. The first
deals with the physical selection of media
and topology. This is for both Local and
Wide Area Networks, and he relates how the
choice of media, or indeed topology, is
affected by (or can affect) the ultimate
traffic pattern on the network in question.
The following chapter builds on the physical
topology by discussing layers 2 and 3 of the
networking model. Firstly, the respective
roles of switching and routing in any
network are outlined. Since this book
centres around management of networks
using Cisco ROUTERS, it is not a suprise
that the argument swings in favour of the
need to employ routers in your network!
Given that routers are required, one needs to
turn to the assignment of IP address space
(yes, this book is almost exclusively about
IP). This is covered exceedingly well and
explains well the topic of subnets which can
be a source of much confusion. The use of
variable length subnet masks in conjunction
with routing protocols like RIP and IGRP,
which is likely in any transition from
classful to classless networking in an
established company, is not ignored. To his
credit, the author also covers the use of
Proxy ARP to completely avoid the use of
subnets, even though it is relevant only in
certain specific cases.
Chapter 4 provides you with the criteria that
could be used to make your selection of
router vendor and router model. This
appeared complete, and 40 pages long.
Moving onto Chapter 5 he tackles the
(occasionally more difficult) selection of
routing protocol. The argument for and
against dynamic protocols is explained
further and the difference between distance
vector and link state is made very clear. A
useful table summarises the features of RIP,
OSPF, IGRP, and EIGRP.
Now, some half way through the book, you
reach the point where you wish you had a
Cisco router, since all the examples are
IOS-based. Even if you do have a Cisco
router and you have the excellent
documentation CD, this book is still a must
have. It makes clear, in a readable fashion,
the concepts and examples to do a particular
task. With the normal Cisco documentation,
you are fine if you already know what it is
you want to do. The background Cisco
documentation is normally divorced from
the examples so there is a gap that this book
fills very nicely.
Having chosen your routing protocol (and
the book gives examples of all the topics in
RIP, OSPF, and EIGRP), you have to
configure it. The basics of each protocol
together with examples of static definitions
are clearly illustrated. In a world where it is
always wise to trust no one, mechanisms to
suppress the broadcast and receipt of
dynamic updates are clearly defined.
An essential part of managing a network is
how you deal with both the technical and
non-technical issues. Scott has not forgotten
this and provides information on the
approach you should take to deal with
problems and the tools you can use to
determine the cause and boundaries of a
problem. One of the useful suggestions was
the implementation of a consistent time
stamp across all the routers. Thanks to this
I now have just such a consistent view using
NTP (Network Time Protocol).
Having largely dealt with LAN-based
issues, the focus turns to the wider picture.
External routing might require knowledge of
protocols like BGP. This often obscure
subject is concisely explained and I would
recommend reading it to any budding ISPs.
Issues of security and access control are
illustrated towards the end of the book
which finishes with an appendix on interface
specific commands for LAN and WAN
connections (Ethernet, FDDI, PPP, ATM,
Frame Relay etc).
I have no doubts in recommending this book
to anyone who has Cisco routers on their
network, whether it be a single humble 1000
series or a mixed bunch of LAN and WAN
routers. The only thing the book does not
cover is the use of Cisco management
software such as CiscoWorks or NetSYS,
but it is not a great oversight. Even if you
are not a Cisco fan, the book has great
merits as a background text.
Raza Rizvi is technical support manager at REDNET,
a very busy network integration company and medium
sized ISP. He is still recruiting networking and
administration staff at
(Reviewed by Andrew Cormack)
As a fan of Æleen Frisch's Essential System Administration, hereafter known as the Armadillo book, I was looking forward to a similar treatment of Windows NT. The first thing to note about both books is that they are essential and not complete, covering in detail only the parts of the operating systems which will be used by most administrators, most of the time. Anyone needing more information on a particular topic will find suggestions for further reading. Nor, in the case of NT, is the
operating system regarded as complete.
Those on tight budgets may be alarmed to
discover that the NT Resource Kit is needed
to plug gaps in the basic system when
managing more than just a few servers. In
other areas where NT is deficient, such as
backups and batch queues, other commercial
products are recommended. It is all a far cry
from the UNIX world where almost
everything necessary is available in the
The sequence of chapters is traditional,
falling roughly into four sections on users,
files, networks and performance. It is
assumed that the system is already up and
running, so there is no help with installation
or licence management. Most of the
administration tools have graphical
interfaces, so some experience of navigating
around NT will be useful, though there is a
helpful list of the more obscure
combinations of mouse buttons and control
keys. The book makes particularly good use
of illustrations. Written descriptions of
administrative operations are accompanied
by screen shots, making them much easier to
follow. Seeing what a tool looks like gives
a better chance of finding its options in
future. The same applies to the performance
section which has annotated graphs, taken
from the NT Performance Monitor, of
systems in various states of distress. Event
logs can be another way to detect problems,
but include such a variety of information
that they can be confusing. The examples of
audit trails, for both normal and abnormal
occurrences, are a great help. There are
even some useful packet dumps in the
introduction to TCP/IP; unfortunately these
are not produced by a standard NT utility,
but a commercial program.
The book shows its UNIX heritage most
clearly in the first appendix which gives
conversions between common UNIX
commands and control files and their NT
equivalents. There is also the choice of Perl
for writing scripts, though in fact the
appendix on NT's scripting language
contains more detail. The most useful Perl
script, for adding users in bulk, is described,
but without giving any source for it. Unlike
other NT books there are simple and lucid
descriptions of the different classes of user
and group, and even how Access Control
Lists work. Just reading these pages should
justify the cost of the book in saved time
and frustration. A few pages on security
and backup policies are borrowed from the
Armadillo book since they are just as
relevant to NT. The NT-specific security
section starts by explaining that the
operating system was designed for
trustworthy users, so attempts to make it
secure against others are likely to be a
struggle. The scale of the problem is shown
by a two page list of files which need their
default permissions changed to give even a
semblance of security!
Despite its occasional lapses, this is much
the best introduction to Windows NT
administration I have found. The word
painless on the cover is fully justified. As
the Armadillo book has been a desk-side
companion in a familiar place, I expect this
to be a comforting guide to the strange
world of Windows NT.
Andrew Cormack works in Information Systems
Support at the University of Wales, Cardiff.
(Reviewed by Paul Rock)
As a Netware Engineer of some years standing with an NT Workstation on my desk, I thought this would be my kind of book. The author starts by telling us what a fine operating system Netware 3.1x is, which isn't very relevant to me any more since I work with Netware 4.1x. He then goes on to describe Novell's problems marketing Netware 4 in a very fair fashion. The rest of the preface rather usefully describes the other chapters.
Page 3 in chapter 1 confirmed my worst
suspicions. This book is not aimed at
Netware 4 administrators at all. In fact,
Robert Thompson suggests that we take the
book back for a refund. The title of the
book should really be: Windows NT Server
4.0 for Netware 3.x Administrators. The
rest of this chapter forms a comparison of
Windows NT Server 4.0 with Netware 3.12.
This often left me wondering how on earth
I ever managed with such a primitive
operating system of course, Netware 3.12
was the bees knees in its day. Whenever
Windows NT 4.0 falls short of Netware
3.12, the author makes excuses and carries
on. Notably, he considers the lack of native
disk quotas to be of very minor importance!
In chapters 3 to 10, the workings of
Windows NT 4.0 are described in
considerable detail, but at quite a high level.
Often I felt that a subject was being
over-simplified, only to find that on the next
page the full picture was revealed. This
makes the book very readable. The author
often explains fundamental concepts in
considerable detail since he aims this
book at the administrator rather than the
engineer, this makes it a very useful
reference. Comparisons are made with
Netware 3.x wherever appropriate. My only
real complaint, directed more at Microsoft
than the author, is that confusion can so
easily arise because Windows NT Server
and Windows NT Workstation are the same
Operating System bundled with different
tools and services.
The next few chapters explain TCP/IP and
each of Windows NT Server 4.0's
TCP/IP-related services in easily enough
detail to get you up and running. In view of
the fact that hackers usually get into your
systems over IP, I think more space should
have been devoted to IP security. The
author doesn't make the assumption that you
will necessarily wish to manage all your IP
services Microsoft's way which is
heartening. The reader is very helpfully
referred to RFCs and other literature for
The last six chapters of the book describe the various methods Microsoft provide to
allow Windows NT 4.0 Servers to firstly,
co-exist, and secondly, emulate and finally
replace other operating systems. As before,
the author only really writes about Netware
3.x in any depth, although he does mention
UNIX, Netware 4 and others in passing. In
this case though, this is probably a mere
reflection of the nature of the methods
provided. My main concern is that the
author, again, treats some important issues
too lightly. All the migration methods, for
instance, require passwords to be re-issued
no mean feat for us with 25,000 users.
By comparison, migration from Netware
3.12 to Netware 4.11 retains existing
passwords. A chapter should really have
been devoted to the integration tools
provided by Novell (Workstation Manager,
NDS for NT etc.), but as they mainly rely on
NDS and consequently Netware 4.x or
above, I guess it was seen to be beyond the
scope of this book.
This is a good, very readable, book. It is
rather badly mistitled but well worth buying
if you wish to learn about Windows NT
Server 4.0 from the perpective of a Netware
3.x CNA or equivalent. Netware 4.0
administrators will find it a useful reference
whilst most current CNEs or equivalent
would get by with a much thinner volume.
Oh yes, there's a nice picture of a predatory
animal on the cover too.
Paul Rock is a Computing Officer at Cardiff University and spends much of his time tweaking Netware's NDS. He tries to maintain a healthy interest in other operating systems and an even healthier interest in getting home in time to cook tea. These interests are, of course, mutually exclusive.
(Reviewed by Phillip Young)
When I picked this book up, I was worried. The sheer size of it made me wonder how I was going to take in 1247 pages worth of information in 21 days. Luckily a quick search through the contents revealed that I was only expected to take in 548 pages worth; the rest is a bonus week and a large reference section which is only included with the professional reference edition. With the Java language expanding so rapidly, many books are now being published with specific areas in mind. The size of this book reveals why.
The aim of the book is, as it says in the title, and I must say that after going through the book, not necessarily in 21 continuous days, I felt very confident that a beginner could achieve a good grounding in the language. Unsurprisingly the book is split into three weeks, with a bonus week included at the end, followed by a large and useful reference section. In the first week one learns what Java is, basic object-orientated concepts and basic syntax. Week two then
explains how to write applets and, using the
graphics class libraries, gives a great
introduction to the class library structure of
Java. Week three covers more advanced
topics such as interfaces and packages,
threads and I/O, and has an under-the-hood
section which gives a gentle introduction
into the workings of Java. All concepts are
explained step by step with lots of examples
to work with which are all contained on the
included CD-ROM. The bonus week
includes details on Java programming tools
from various vendors, a small section on
sockets and client-server programming, and
a section on the new technologies emerging
from Sun, including Java microprocessors
The book is great for beginners who have
not programmed before in an object-
orientated language, but have a
programming background. With the large
reference section at the back, it is a book
that would be useful after you have worked
your way through the first 21 days and is
thus a good investment. For seasoned C++
programmers however, I would not
recommend this book. At £54.95, it is too
expensive to be used solely as a reference
manual, whilst there are far cheaper
publications which contain the same
Recommended for beginners.
Dr. Phillip Young is a research associate within the Computer Science department, at the University of Manchester.
(Reviewed by Ken Tucker)
Java has undergone a period of rapid growth in the last year, both in uptake by programmers and in the richness of its facilities. This second edition of Exploring Java sets out to give the flavour of Java 1.1. Compared to the first edition (which covered Java 1.0), there is a lot of new material in this book, including seven new chapters. As the authors state, Java is growing by leaps and bounds and this book provides a good overview of the capabilities of this emerging language.
The first chapter discusses what Java is and
what it isn't, and compares it to other
development tools. It quickly goes into the
nitty-gritty of its compiler methodology. If
you are interested in using the language as
soon as possible, this chapter can be
skipped. It is only of interest if you want an
overview of how Java handles its data types,
and memory management using garbage
collection (the removal of objects you are no
longer using). It also does a little crystal
ball gazing in order to attempt to predict
future growth patterns for the language, and
provides URLs where more information on
Java's development can be obtained.
This book takes the familiar approach of
starting with a basic application (actually an
applet), i.e. Hello World, but in this case
Hello Web, since Java is propounded as
the programming language of the Internet.
The examples then extend this basic applet
to make it blink and change colour, using
sub-classes. Java is object-orientated and
the book explains a lot of the jargon related
to object-orientation in an easily
understandable manner. It uses intuitive
real-world analogies to get the ideas across,
rather than (usually) dry computing science
examples. It is written in a friendly, easily
read style and there are a few quips dotted
about to relieve the dryness of the topic
being discussed. Java supports a simplified
object-orientated interface to sockets that
makes network communications
Basic classes and utility classes like strings,
math utilities and dates etc. are discussed. It
also covers threads, an important topic in
network applications. Threads allow an
application such as a web browser to display
images and/or text and play an audio clip at
the same time. Each part of the application
would have a different thread, and so a form
of concurrency is achieved.
Network programming is covered in its own
right, as is working with web browsers,
URLs and CGI programs. Finally, onto
what I think most people associate with
Java, the windowing toolkit. The Abstract
Windowing Toolkit (AWT) and Graphical
User Interface (GUI) components are
discussed as well as working with images
and audio. It shows how content and
protocol handlers can be incorporated into
web browsers and how to set up a security
manager for your applications. Finally the
book explains the changes required to
standard applications to turn them into Java
Beans (essentially stand-alone components
which can be combined with other
stand-alone components in a sort of building
block paradigm to construct more complex
If you are looking for an introduction to Java I don't think you will go far wrong with this one. It gives an extensive overview of the language. This is not a book to teach you how to program in Java, although there are sufficient worked examples to get you started. However, the more complex examples only define the core structure, so that you don't confuse the required Java constructs with the incidentals. I've learned a lot about the capabilities of Java by reading this book.
Ken Tucker is a UNIX and VMS system administrator
for Cardiff University and jealously guards his
AlphaVMS workstation, the only one left in the
Computing Services department.
(Reviewed by Andrew Cormack)
Information architecture is hardly a well-known phrase, even though it matters more to the web than Java, sound or video. This book, written by two consultants who make their living as information architects, will do a great deal to raise its profile.
So what is information architecture? The
authors describe it as the web, minus content
and images; in other words the structure,
navigation systems and labels which allow
readers to find their way from one page or
site to another. Most people can identify
sites with good or bad architecture, but
creating sites which work is often a matter
of chance. Another definition of
information architecture might be the
application of library science to the web.
Many of the issues are already familiar to
librarians, and borrowing their existing
solutions is much easier than re-inventing
One of the most important rules is not to be
overwhelmed by the technical possibilities.
Hypermedia systems give great flexibility in
arranging information but readers can often
feel confused and lost. We are most familiar
with hierarchical systems and, at least for
the overall structure of a site, it is probably
best to retain this traditional layout. For
smaller units within the site, other
arrangements may be appropriate.
Users should always be the main concern in
designing a site. The structure of the
organisation may not be the best structure
for the web site if it is not familiar to
outsiders. Similarly, technical jargon is only
appropriate for a site which is aimed at
readers from the same field; adding common
names, or even replacing the jargon entirely,
may make it accessible to a wider public. A
site with different groups of users should
provide alternative navigation routes to cater
for their requirements. Search engines can
be useful for some enquiries, but need to be
set up with care. An indiscriminate search
of all the pages on a site is unlikely to be
helpful: many of the pages will not contain
useful information, and those that do may
not be sufficiently similar for relevance
ranking to be effective. Above all, searches
should not be used as a substitute for a well
structured site; monitoring users' queries
may highlight problem areas for the site
Despite the authors' claim that theirs is an atypical O'Reilly publication (no source code!), the second half is an extremely practical guide to web site design. Everything is covered: from identifying suitable members for the project team, to
dealing with internal politics, to managing
the writing of the actual pages. There are
even sample questionnaires and topics for
brainstorming. Although written from the
consultants' point of view, this should be
even more valuable to internal teams, who
do not have the benefit of an independent
opinion. These ideas are put into practice in
the design of two different web sites.
My only quibble with the book is that the
resulting structures are very similar in a
perfect world the examples might have been
more different however there are also
illustrations of many other sites, both good
Anyone trying to navigate around the web
will be painfully aware of the need for better
organisation of information. In writing this
book, Rosenfield and Morville have bravely
revealed their trade secrets, giving the rest
of us a chance to do something about the
problem. The book has already soared up
Amazon.com's best-seller list: if all those
copies are read and implemented, they will
have done the web a great service.
Andrew Cormack tends the Cardiff University web
server, which could certainly do with a redesign!
(Reviewed by Mark Hale)
The book is well laid out with clear instructions. I found the text friendly and reassuring, and it covered basic commands to get you started and to feel comfortable with as soon as possible.
The topics in the first chapter cover logging
in via a number of methods, syntax of
command lines, types of commands, and
finally one which is close to my heart,
dealing with the unresponsive terminal.
The latter I am sure will encourage users not
to just get up and leave this process in the
fear that they have somehow broken
something, perhaps adding further to the
novice user's phobias.
Chapter two somewhat took me by surprise. Whilst I applaud the reference to the X windows system in this introductory guide and feel it is a good starter in itself, I feel it would have been better to leave this chapter to later on. My only thought is that the authors felt the need to grab the attention of
those PC/Mac users out there, to show them
there is more to UNIX than typing command
lines. My personal feeling was that after
chapter one, feeling eager to start dabbling,
I was suddenly side-tracked.
The rest of the book covers, amongst others,
finding your way around the UNIX
filesystem (which includes a good
explanation of the directory tree structure
and use of absolute and relative pathnames),
customisation of your account with a brief,
but at least mentioned, suggestion to beware
about editing your startup files until you
know a little more. Also covered are the
creation, protection, moving and sharing of
files, FTP, introduction to e-mail, running
multiple processes and, most importantly,
killing these processes as well as producing
output of your work.
The book ends with pointers for further
reading and a handy pull-out reference card
which is a duplication of one of the
Introductory guides must be easy to use and
not too off-putting with huge amounts of
information, but enough for the user to at
least feel happy and confident with this
new-found knowledge. I feel this book fits
this description quite well, and throughout
there are a number of brief exercises for the
reader to try. As the book states, its aim is
to tell you just what you need to know to get
you started, and no more. Certainly reading
it won't make you a UNIX guru overnight;
however it will help those new to UNIX
overcome the first few steps, and hopefully
encourage the user to delve a little deeper
into this system.
Mark A. Hale works at Cardiff University.
(Reviewed by Andrew Cormack)
As computer programs mature, they are sometimes afflicted by software rot. Examining the source code will show comments which no longer apply, redundant or duplicated code. In time, the original meaning of the program may be submerged under these accretions and there is nothing for it but to start again from scratch. I'm sorry to say that something similar seems to have happened to this book. The original aims, to teach shell programming and software engineering, are sound enough, but look rather strange companions today. Other comments such as Shell is the key to personal satisfaction and success and UNIX runs on more types of computers than any other operating system seem to date from an era pre-Gates and, indeed,
DOS is the only Microsoft product
The authors place the divide between shell
use and programming at a low level,
essentially the first appearance of a pipe or
re-direction. This should make the book
suitable for the beginner, but there are just
too many errors of layout, typeface and
typing. Nor is the sequence very helpful,
with lengthy descriptions of many
commands, and even regular expressions,
before any useful scripts. The main text
mostly describes the Bourne shell, with
Bash and Korn variants in boxes, but on
occasion the three are confused. The
C-shell puts in an occasional appearance
is in a list of loop constructs but
nowhere else) until getting chapter 10 all to
itself. Except, that is, for the occasional
command and the instruction
which could cause
This fourth edition, according to the cover,
includes the latest developments in Internet
... applications. In other words, writing
shell CGI scripts. Most webmasters will
shudder at the very idea and would be right
to do so. The example scripts make it trivial
for an intruder to execute any command of
their choice on the server. The hints for
securing scripts include, but do not
demonstrate, checking for pipe and
semicolon characters, but omit other horrors
such as backquotes, ampersands and
carriage returns. The high point of the
coverage of HTML is a table of
In the midst of this are some enthusiastic chapters on software design and rapid prototyping. The example of designing a personnel database is reasonably well presented, though the implementation does not mention the problem of file or record locking. Using scripts to generate input screens, using raw cursor positioning, is impressive as a demonstration of how far the shell can be stretched, but hardly practical. The software reuse section will be familiar from books on object-oriented languages.
The book seems to have lost its overall
structure making it a hard, if occasionally
surprising, read. It appears that new
sections have been inserted without regard
to the overall flow; some topics are even
covered twice. There are some good
sections, for example the explanation of
different shell quote characters, but these are
let down too often by basic mistakes. Some
memorable quotes, a PC is like the Old
Testament God: lots of rules and no mercy,
and a wonderful Dilbert cartoon in the
preface almost justify the price; but not
Andrew Cormack thought he was the only one to notice
the similarity between HTML and
(Reviewed by Gavin Inglis)
It's hard to be a system administrator for any length of time without coming across O'Reilly's range of Nutshell books. The concept is of the one of a well-thumbed book within easy reach providing a quick reference to everything, from command flags to obscure shell metacharacters. UNIX in a Nutshell has been around for ages, so why should you spring for this volume?
Well, Linux is different, for one thing, and
the text will guide you around any awkward
mismatches between variants. But, more
importantly, this book embraces GNU
software for the first time. Five and a bit
for the GNU C debugger and preprocessor
this should make for less fewer of the
annoying occasions when the detail you
need isn't in your catch-all reference book.
An obvious decision has been made to stick
to the core of Linux and omit value-added
features of particular distributions. This
being Linux, there will always be something
you want to know which isn't here, e.g.
. Given the alternative to try to
cover everything, this core approach is
The largest chapter occurs early and lists
Linux user commands. This looks mostly
like the manual pages stripped down to
provide only the useful stuff with flags and
examples. Browsing here is probably a
good way to find handy new commands; on
first encounter with a new command the
examples are what really convey the
Next we focus on shells. Good stuff appears in the overview, such as a single table comparing the syntactic differences between
. Then particular
shells get their own chapters. All the
features you might expect are covered:
history, variable substitution, built-in
commands. There is a sample
, a surprising omission. A
certain amount of duplication is present
between the shell-specific chapters, but this
is preferable to constant cross-references.
An impressive short chapter on pattern
matching and regular expressions presents
really quite a lot of information in only five
pages. Then it's on to editors with a
concentrated guide to Emacs. The
Absolutely Essential Commands table is
very welcome. Strangely enough, a
corresponding section does not appear in the
subsequent chapters on
these are solid enough.
It is the nature of the Nutshell series that a hard as nails approach is required to learn
from scratch using only those books. This is
well illustrated by the chapters on
. But it's all there, and you can
try if you like.
Other topics are crammed in towards the
back of the book. System administration
commands grab over eighty pages and there
is a significant chapter on programming.
It's nice to see that O'Reilly doesn't try too
hard to sell its own books
five pages, despite a separate volume being
available. Introductions to TCP/IP, NFS
and NIS are all packed into eight pages.
If Linux does indeed recapture the spirit of
early UNIX, this book no doubt destroys
some of that spirit by making all the
information readable and easily accessible
(insert smiley here). It is doubtful that there
is anything in Linux in a Nutshell which you
couldn't find online for free. The added
value comes in having all the essential
information extracted and compiled into one
book, particularly if you have a PC with a
small screen. In terms of sheer information
to the pound, you really can't lose.
Gavin Inglis works in the UNIX support team at the
University of Edinburgh where he provides help and
advice to departments around the city. Usually he
chooses Cherry Coke over Dr. Pepper but it's a close
(Reviewed by Robert Pitchford)
The most refreshing part of this very large and comprehensive book on the PL/SQL language, is the fact that it is not directly from the Oracle Corporation. Although the authors do confess to a large degree of cooporation from the employees of the said organisation, a certain amount of objectivity must be apparent. Even at a glance, the book is far more approachable than the standard manuals which usually accompany Oracle products.
The book itself is accessible to three
separate general audiences. Firstly, there is
the novice, who knows nothing about
PL/SQL, secondly, there is the experienced
user who may dip in to the book for
certain topics, and finally there is the
academic who may wish for a general
picture of the PL/SQL language within
There are seven sections within the book, each consisting of several chapters. There is a brief synopsis at the beginning of each
section explaining what is to be covered,
and each chapter begins with a listing of
topics covered. Nothing is assumed
throughout the book and every aspect of
PL/SQL is explained, from the basics, with
good examples given.
The first section consists of a general
introduction to the fundamentals of the
PL/SQL language and effective
programming habits. A few things did
irritate in this section. Firstly, an awful lot
of time was spend on the version history of
PL/SQL. While this may add to the
completeness of the book, I found it difficult
to understand the relevance of the state of
PL/SQL several years ago. Also, the
authors do have a tendency to self-indulge,
A Few of My Favorite (PL/SQL) Things
doesn't seem to say very much besides
referring you to chapters later on in the
book. Perhaps a book this size could do
without the extra padding.
It is really in the second section that the
book begins its usefulness. From chapter
four onward, the book gradually builds on
the complexity of the PL/SQL Language.
Section two investigate the fundamentals of
the language, including variables and
program data; conditional statements;
s and how they may be
combined. The section continues with
commands, such as
as well as
PL/SQL Tables. Good explanations and
examples are given throughout, useful tips
and comments being included in side-boxes
throughout the chapters.
The third section carries forward the
fundamentals with chapters discussing
PL/SQL built-in functions for Character,
Date, and Numeric translations, for
, as well as how to handle other
miscellaneous functions. There are also
useful comprehensive lists of parameters
which go along with each function.
Function and procedures are introduced in
section four and these build on what has
been taught in previous sections. Chapters
on how to modularise your code into
procedure and functions and, in turn, how to
turn these into packages, are included. Also,
instructions into how these may be stored
and accessed via an Oracle database is
The new PL/SQL 8 is revealed in section
five. This is an Object-Orientated (OO)
approach to the PL/SQL language. Nothing
is assumed as OO programming may well be
a new concept to some. Each step is
carefully covered with examples of how to
create, access, and manipulate
well as different data collection methods.
The penultimate section discusses the
writing and debugging of PL/SQL code.
Chapters include Code Design Tips,
Managing Code in The Database as well
as debugging and tuning PL/SQL
applications. There is also a chapter
concerning the Trace Facility which may
be used when tracking logic errors.
Three appendices make up the last section. Appendix A discusses the accompanying
diskette which contains both sample code,
found throughout the book, and further
explanations concerning PL/SQL. The
diskette was tried on two PCs; the first with
4M of memory failed, due to lack of space,
the second, with 32M of memory, loaded
successfully, but then proved very unstable,
crashing the machine several times.
Appendix B describes how Developer 2000
applications may call stored programmes,
while Appendix C is a quick reference and
description of all Oracle built-in package
On the whole this is a useful book. Section
one may be unnecessary and could be cut
down somewhat, but the rest of the book is
a good and comprehensive overview of the
PL/SQL language. For anyone wishing to
learn from scratch, or requiring a
comprehensive reference manual, this book
is highly recommended.
Robert Pitchford has worked for the University of
Manchester for the past 12 years and is involved in the
maintence of an Oracle Financial system.
(Reviewed by Chris Cook)
The author was originally contracted to write a Nutshell Handbook on Tcl and Tk. Rather honorably, in my opinion, he decided that the existing books on the subject by John Ousterhout and Brent Welch already covered the introduction to the language excellently, and instead proposed a book on some of the many extensions to the toolkits. The task of trying to produce reasonably current descriptions of so many different packages would be too much for any one person. Instead, it was decided to get the authors, or people sufficiently experienced in the package, to each write a chapter. The result is a collaborative book that acts as a showcase for more than a dozen different extensions, each written by someone with in-depth understanding of their subject.
The choice of extensions covered probably
reflects their popularity, but includes a good
cross-section and not just the graphical ones.
It starts with language extensions such as
object-oriented command sets for both
toolkits, through specific interfaces
including RPC and most Posix functions.
There are also chapters devoted to more
niche subjects like 3D-image rendering,
Oracle and Sybase databases, and a
groupware toolkit. The chapters on
graphical extensions contain a rich vein of
inspiration. There are toolkits that provide
invaluable widgets like the canvas-based
tree widget, spreadsheets, listboxes, graphs,
bar charts and even a hyper-help
mega-widget, capable of displaying HTML.
In addition, there are more generalised
extensions, such as mega-widget builders
and geometry managers, enabling a level of
control over layout, with previously unheard
of ease. Some examples were declared as
being impossible to achieve with native Tk.
I have to say that, considering there were sixteen different authors acknowledged inside the front cover, the standard was outstandingly good. Not all similar ventures have been quite so consistent. The style of
writing obviously varied, from the thorough,
structured technique, to the stream of
consciousness, excited, almost evangelistic
approach. Some authors simply laid out the
abilities of their package, whilst others
justified its existence by demonstrating how
you would have to achieve a given result the
old way, then reproducing it better, stronger,
faster with their method. The quality of
some of the images was a little poor; for
example, the 3D pictures were too dark to
do justice to their shading. This was an
exception, and a minor one at that.
The book ends with a group of chapters
related to development. They profile an
extension called TkReplay that allows the
recording and playback of a Tk session;
useful for demonstration purposes and
invaluable for regression testing. Another
chapter covers several forms of debugging,
in addition to the extract from a 1957
FORTRAN manual, exhorting the
programmer to insert a few cards containing
There is a helpful section on how to
augment the basic language with an
extension, with specific advice for the
serious shop, where code management is
an art. Finally, the various aspects of Tcl
and X security are covered.
This book is quite heartening to those of us
who are only occasional Tcl users. One had
always suspected that there must be a better
way of doing certain things in Tcl and Tk,
but these people demonstrate through the
extensions that some aspects of the basic
languages are overly restrictive. I felt it
justified all those procedure based
mega-widgets which I've always felt so
guilty about. This isn't a criticism of the
original language, as right from inception it
was intended to facilitate the building of
tools for other uses. One shining example
that I've so far omitted is Don Libes'
Expect. This really is in a league of its own
and anyone interested in interactive tool
automation should buy Exploring Expect,
also from O'Reilly.
Tcl/Tk Tools would make an excellent
addition to the library of all but the most
experienced Tcl and Tk programmers.
Furthermore, I strongly recommend it to
anyone who has ever harboured aspirations
to develop a graphical application but has,
quite understandably, been put off by the
sheer complexity of coding in X11. I
wouldn't for one minute suggest that it is a
tutorial to take you from the basics through
to the furthest recesses of the language.
Nevertheless, reading this before you get too
embroiled in your first big project, will save
you time and prevent an awful lot of wheel
Chris Cook is the Postmaster and a System
Administrator at Cardiff University. Amongst the
things that have given him joy recently is the successful
networking of his oldest Sinclair ZX-Spectrum. The
TCP stack will have to wait.
Tel: 01763 273 475
Fax: 01763 273 255
Queries: Ask Here
|Join UKUUG Today!||
PO BOX 37