Copyright © 1995-2004 UKUUG Ltd

UKUUG

Newsletter Section 2

Reviews

Applixware For Linux

Release 4.37

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 review).
.     Spreadsheet.
.     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 also installed.

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 little easier!

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 documentation) are:

.     A WYSIWYG (What you see is what you get) display.
.     Live links between Spreadsheets, Data, Graphics, and other wordprocessing documents.
.     Templates.
.             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 Ghostscript.

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.

Learning Perl on Win32 Systems

(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 ( if / then / else , etc).

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 using the Win32::Process module to 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 Win32::ODBC modules.

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 PerlScript.

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 to Perl.

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 the text.

Phil Docking looks after the PC systems in the Department of Computer Science, Birkbeck College.

Windows NT File System Internals: A Developer's Guide

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 earlier.

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 for developers.

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 this context.

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 do.

Phil Docking tends the NT systems in the Department of Computer Science, Birkbeck College.

SuSE Linux 5.1/5.2

(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:

.     Easy installation.
.     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 loadlin or, with the correct BIOS, directly from the CD.

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 yast, 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 apsfilter and ghostscript . 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.

Oracle Database Administration on UNIX Systems

(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 clearer.

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 inches.

Managing Mailing Lists

(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.

Learning Perl on Win32 Systems

(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 winning formula.

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 “/” or “\” 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.

Advanced Perl Programming

(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 spud 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 existing variable.

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, Data::Dumper , 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 persistent storage.

“Networking with sockets” and “Networking: Implementing RCP chapters” introduce and use the object interface to socket communications. The module is used to implement Msg, a messaging toolkit. The Msg 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.

Practical C Programming , Third Edition

(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 full competency.

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 several modules.

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 system.

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 grasp.

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.

TCP/IP Network Administration , Second Edition

(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 Edition?

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 often required.

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 gated , named , dhcpd , 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 ( .com , .edu, etc), it fails to mention that many non-U.S. sites can be found amongst them. The named reference referred to four quotas that are controlled by the limit command, but 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 “jungle green”.

Managing IP Networks with Cisco Routers

(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 http://www.red.net

Essential Windows NT System Administration

(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 public domain.

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.

Windows NT Server 4.0 for NetWare Administrators

(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 advanced information.

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.

Teach Yourself Java in 21 Days, Professional Reference Edition

(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 and JavaOS.

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 information.

Recommended for beginners.

Dr. Phillip Young is a research associate within the Computer Science department, at the University of Manchester.

Exploring Java , Second Edition

(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 considerably easier.

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 applications).

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.

Information Architecture for the World Wide Web

(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 them.

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 maintainers.

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 and bad.

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!

Learning the UNIX Operating System , 4th Edition

(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 appendices.

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.

UNIX Shell Programming. 4th Edition

(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 mentioned.

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 ( foreach is in a list of loop constructs but nowhere else) until getting chapter 10 all to itself. Except, that is, for the occasional export command and the instruction setenv noclobber which could cause severe disappointment!

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 equivalences for nroff commands!

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 quite.

Andrew Cormack thought he was the only one to notice the similarity between HTML and nroff ...

Linux In A Nutshell

(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 pages on gcc options, for gzip commands, 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. tcpdump . Given the alternative to try to cover everything, this core approach is sensible.

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 knowledge.

Next we focus on shells. Good stuff appears in the overview, such as a single table comparing the syntactic differences between bash , csh, and tcsh . Then particular shells get their own chapters. All the bash features you might expect are covered: history, variable substitution, built-in commands. There is a sample .cshrc but not a .bashrc , 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 vi or ex , although 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 sed and GNU awk . 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 – make still gets 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 thing.

Oracle PL/SQL Programming , Second edition

(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 Oracle.

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; NULL s, GOTO s and how they may be combined. The section continues with chapters on DATABASE interactive commands, such as ROLLBACK and COMMIT as well as CURSOR usage, EXCEPTION HANDLING ; RECORDS and 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 example, TO_DATE , TO_CHAR, and ROUND , 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 given.

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 OBJECTS as 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 procedures.

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.

Tcl/Tk Tools

(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 PRINT statements into the deck, to take snapshots of pertinent information. The tracing facility within BLT is covered, as are two external debugger tkdebug and tkinspect .

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 reinventing.

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.