[UKUUG Logo] Copyright © 1995-2004 UKUUG Ltd



Newsletter Section 3


Perl Resource Kit – UNIX Edition

O'Reilly & Associates, Inc., 1997
ISBN 1-56592-370-7

( Reviewed by Mick Farmer)

This heavyweight “kit” consists of four books, a recent copy of The Perl Journal, and a CD-ROM.

The first book, Programming with Perl Modules by Nate Patwardhan and Clay Irving is an introductory tutorial on Perl modules, the Comprehensive Perl Archive Network (CPAN), and a tour through some of the more popular modules found on CPAN.

The introductory tutorial is useful if you're not familiar with the structure of Perl's packages (a module is simply a package) or with the object-oriented style of programming employed by the majority of the modules. There is also an overview of how the CPAN is organised and maintained.

The bulk of the book consists of examples using various modules. These include parsing command-line arguments, file manipulation, electronic mail, date and time, graphics modules, and network-oriented modules. There's also an excellent chapter describing how a module should be designed and constructed for possible inclusion on CPAN.

I read all the chapters with interest, but spent most of the time using the chapter devoted to building graphical interfaces with Perl/Tk. I was familiar with the Tk library from early use of Tcl/Tk and wanted to update a number of my Perl scripts to use GUIs. However, the coverage was patchy and didn't provide sufficient information. When I searched the other books in this kit for reference material, I found that the Tk module was omitted! I eventually returned to Sriram Srinivasan's superb book Advanced Perl Programming for help in this area.

It also didn't help that some of the figures didn't match the sample code! I know Tk reasonably well and can see the mistakes, but a beginner might doubt his or her reasoning and assume that Perl/Tk does magical things behind their back – for example, always generating a “Quit” button!

The Perl Module Reference comes in two volumes and is edited by Ellen Siever and David Futato. The documentation of a module is embedded in the code itself using a markup language called POD (Plain Old Documentation). The notion behind this is a belief that programmers will document their code as they develop the code if the two sit side by side. These two volumes merely extract the POD material from the most useful (in the

authors' view) and stable modules into print. This means that the quality of the text is variable to put it mildly. As you would expect in such a large amount of text, there are numerous spelling mistakes and errors. However, it's nice to have the documentation in printed form – it certainly saves having to run pod2man over the appropriate module and read the text on a screen.

The Perl Utilities Guide by Brian Jepson describes the software that comes on the CD-ROM as part of the Resource Kit. First, there's a graphical setup tool that allows you (as root :-) to install and maintain CPAN modules on your system. This comes in binary for Linux and Solaris platforms, but instructions on how to do these tasks manually is also included. The screen snapshots looked cool, but I didn't have time to run it on my Sun box.

Second, the remaining chapters of this book are concerned with a Java/Perl tool called JPL which allows programmers to write Java classes with Perl implementations. This tool was written by Larry Wall (the originator of Perl) and permits Java and Perl to be integrated. For example, there's a chapter on using Java's Abstract Window Toolkit (AWT) with Perl and a chapter on including Perl code in Java applets. There's a final chapter in which JPL brings together Java's JDBC (Java DataBase Connectivity) and GIFgraph (a Perl module that generates graphs) to produce a graph from data contained in an SQL database. I didn't try running any of the examples, but they looked interesting, especially if you need to integrate these two popular languages.

The first appendix is A JPL Reference, and the second is Selected Articles from the Perl Journal, including Jeffrey Friedl's seminal chapter on Perl regular expressions. If you don't subscribe to this Journal, then I suggest you read these articles and subscribe immediately! Also included in the kit is a reduced-size copy of the Fall 1997 issue (Volume 2, Number 3).

As I mentioned earlier, the CD-ROM comes with a current snapshot of the CPAN, together with search and install tools. There are also binaries of Perl for Linux and Solaris, plus the full Perl source.

This kit is not cheap! Most of what it contains can be downloaded from the web for free. Although I personally enjoyed reviewing it, I suspect most people will balk at the price. However, if you're heavily into integrating Perl and Java, with a reliance on Perl modules, then this might be the reference work for you.

Cookbook for serving the Internet – UNIX version

Philip E Bourne
Prentice Hall
ISBN    0-13-519992-1
( Reviewed by Raza Rizvi)

I have a reasonably large collection of books that purport to be a one-stop shop at providing all you need to know to get your company on the Internet. With the benefit of having read all of them, it is fair to say

that I actually liked this book and thought it managed to tread the careful track between information and patronisation very well.

The author does not try to bog down the book by describing in detail, things that are better served by telling you the URL or FTP site or mailing list address and letting you get on with deciding whether it is appropriate to what you are trying to do at that point in time. This is in keeping with other titles from the same author (I still have his VMS to UNIX conversion book on my desk at work for those times when I regress to thinking in DCL).

The analogy with cooking is a brilliant one, but one that is not ridiculously stretched to fit – rather he has a tasty smorgasbord of all the bits you need to know. He covers what the main information vehicles will be, what sort of browsers and viewers you need to consider, what sort of server hardware you need to consider, as well as the obvious “how do I get it on the Internet”.

Examples of server software installations for FTP, Majordomo, NCSA (perhaps a bit long in the tooth now) and wn , together with the Harvest search tool software, provide the basis for an Internet site that the user can configure.

There is a concise two-chapter summary of HTML production which doesn't leave out the importance of “look and feel” before a walk through how one can use forms with Perl to handle user feedback.

The chapter on Java is perhaps a little too awe-inspiring for the intended audience of the book but it isn't too long and remains interesting throughout.

The final chapter deals with log file handling and the processing of statistics to give information of web hits – useful for senior management!

The only thing I thought was lacking was information on security. It is there and there is a very good list of references to the now standard texts, but perhaps slightly more in the main text would have benefited the readers.

The style and layout is such that you will want to come back for seconds, and the author has thought of that as well. There is a companion web site that keeps the ideas and information you learn from the book up-to-date with new links and documents.

Recommended to those new to the field, or those who seek a “non-tabloid” approach single volume overview of what to do next to the services that you are providing for your company on the Internet. It is a shade slimmer than Managing Internet Information Services from O'Reilly, but the two complement one another and in my opinion, this should be considered a better first starting point for the uninitiated.

Raza Rizvi is technical support manager at REDNET. He is still recruiting experienced networking and UNIX staff so that he can play with new toys more often.

Step by Step ISDN – The Internet Connection Handbook

Ben Catanzaro
Prentice Hall
ISBN 0-13-890211-4

( Reviewed by Raza Rizvi)

This is a blatant amalgamation of promotional and user guide material from Ascend and Sun Microsystems to produce a book that is so biased to the American audience that it is virtually useless for purchasers in the UK.

There is the obligatory introduction to the Internet and to American ISDN services (which are significantly different to the services available in the UK or Europe) with, as one might expect, justification of when an ISDN connection is a good idea and what benefits it brings over a modem connection. To be fair, 56K modems are mentioned, in passing, just.

Now starts the advert. There is a long introduction to the Ascend Pipeline family of ISDN routers followed by an equally long section that deals with the IP stack that you might choose to use on your Windows/Windows 95/Windows NT platform. Of course the obvious answer is Solstice Network Client from Sun (did you ever doubt it!).

We now have four chapters, a total of over a hundred pages, which tell you how to configure the hardware and software with your Ascend router before you finally make your connection to the Net. A few details on twiddling the knobs to fine tune the connection lead to a reasonable final chapter on troubleshooting.

I saw nothing in this book that would make me recommend it to others. If you wanted to make an ISDN connection, then this book would only be of use if you had an Ascend Pipeline router, and even then, only if you had lost the manual that comes with the product in the first place. Oh, and you would have to emigrate to the USA to understand why on earth you needed to know about SPIDs (Service Profile Identifiers) in the first place.

Raza Rizvi is technical support manager at REDNET. He is still recruiting experienced networking and UNIX staff so that he can play with new toys more often.

UNIX Power Tools (2nd Edition)

Jerry Peek, Tim O'Reilly and Mike Loukides
O'Reilly & Associates, Inc.
ISBN 1-56592-260-3

( Reviewed by Elliott Atkins)

UNIX by it's very nature is a “power tools” operating system, but how many amongst us can say that we've mastered all that UNIX has to offer? Over the last 25 years, countless great little utlities have been written, and this book aims to cover both the old and the GNU (sorry, terrible pun!).

UNIX Power Tools sets itself a mammoth task, and handles it remarkably well. This is largely due to the layout of the book –

the first 40 pages are a general introduction to the operating system (history, shells, pipes, redirection, etc). At the end of the basics, rather than continuing towards the back cover, the user is invited to start browsing through the book until they find interesting articles. I did just that, and found myself reading articles and then following cross-references to elsewhere in the book, much like browsing the web.

Inside the back cover of the book is an ISO-9660 format CD-ROM containing literally thousands of scripts and programs – a true collection of some of the best “power tools”. As with most books these days, the scripts and programs on the CD-ROM are freely available on the Internet; however the explanations and examples of their usage given throughout the 1100 pages of text set this book apart from many others in this field. The examples are refreshingly based on real- world problems which I whould expect most of us have experienced at one time or another. Additionally, the CD-ROM also contains pre-compiled binaries for Solaris, SunOS, Digital Unix, IBM AIX, HP/UX, Linux (i86) and SCO Unix.

For those amongst us who are familiar with the first edition of this title, (written in the early 1990s) the main difference is that 550 of the 800 original articles have been revised or rewritten. The POSIX utilities are now covered in greater depth, and the tcsh and bash shells are referred to more frequently. The seperate chapter on awk has been removed in favour of Perl. All of these changes reflect the constant development and improvement of UNIX as an operating system.

An excellent glossary and chapter containing short descriptions of each script on the CD-ROM nicely round off this well presented book. The “browsing” layout makes this a worthwhile read for all users of UNIX, whatever their experience. In fact, I would go as far as saying that UNIX Power Tools makes good reading for anyone who uses (or plans to use) UNIX for more than just running pre-written applications.

Elliott Atkins is UNIX Systems Administrator for REDNET, an Internet Provider and Network Integrator based in High Wycombe. He has spent the last month performing painful Sendmail 8.8.8 upgrages and trying to get his Certified Solaris Administrator certificate to hang straight on the wall.

Designing with JavaScript – Creating Dynamic Web Pages

Nick Heinle
Songline Studios, Inc and O'Reilly & Associates, Inc., September 1997
ISBN 1-56592-300-6

( Reviewed by Phil Gregg)

This book is aimed at web page designers who may want to add a little bit of spice to their pages with a minimum of effort, that is, without learning Java. Like most O'Reilly books it treats a hands-on subject in a very practical way. The reader is able to navigate easily between example JavaScript code, explanatory text and

“asides” which deal with parts of JavaScript in slightly more detail. The numerous examples are explained in detail and are all on the accompanying CD. Unfortunately, it does contain quite a few errors and typos.

Some of the web pages referred to are no longer available and generally it looks as though the book was rushed ( http://webcoder.com/book/err ata.html lists most of the errors). This may be because web technologies like JavaScript and Java are changing so quickly that the task of getting a book to press before the content becomes out of date is virtually impossible. It may be because JavaScript is not totally browser independent or maybe, it just wasn't proof-read properly.

The first example URL in Chapter 1 has a typo (“manhttan” instead of “manhattan”), the “Manhattan Project” page doesn't actually work as it should and the code given in the book isn't what is downloaded. It should provide a gentle introduction to event handlers such as onMouseOver and onMouseOut . Chapter 1 goes on to describe briefly the JavaScript object hierarchy starting from the document object, how objects are referenced, how their properties are changed and how they are programmed using methods and functions. The remainder of the chapter shows how to use the Date object to tailor your web page content depending on the time of day and how to display the number of days until the fourth of July.

Chapter 2 deals with how JavaScript can be used in the creation, control and communication between windows. It contains an example for creating a “remote control” window that is used as a floating menu.

Frames are covered in Chapter 3. One nice example shows how to change the frame content backwards and forwards using the window.history.go() function. Another explains how to automatically switch the contents of a frame, a technique much favoured by Excite, Alta-Vista and Lycos for selling advertising space.

Chapter 4 describes how JavaScript can be used to process and validate data from HTML input forms. The example provides a neat way of validating user input before the form is submitted to the server. This is used to detect and flag mandatory fields that have not been filled in by the user.

The next few chapters deal with the use of arrays, how the navigator object is used to determine which browser, operating system and plug-ins are being used, how to create dynamic images and how to create and retrieve visitor-specific information on the local hard disk in “cookies”. Each chapter has two or three JavaScript examples. The example in the chapter on cookies shows how to conserve your cookies by storing multiple “chips” of information within a cookie. This is useful because, as the author points out, “each domain ( yahoo.com , for instance) is allowed only 20 cookies on your hard disk”.

Chapters 9 to 11 describe how JavaScript can be used to harness the power of the most recent extensions to HTML such as style sheets, data storage, the expanded event model and layers. Most of the examples will only work with either Internet Explorer version 4 (IE 4) or Netscape Navigator version 4. Chapter 9 is about “Dynamic HTML” which, according to the W3C (the people who attempt to define web standards), “is a term used by some vendors to describe the combination of HTML, style sheets and scripts that allow documents to be animated”. The DHTML used in Chapter 9 is specific to IE 4. Chapter 10 on Layers, is specific to Navigator 4. Chapter 11 brings it all together in a game called “The Show” which requires Navigator 4 (Chapters 10 and 11 first appeared as Web Review articles in March and May 1997, see http://webreview.com ).

The final chapter demonstrates how to create your own objects and how to write object-oriented JavaScript code.

Appendices A and B provide a quick reference for the document object model and event handlers in JavaScript 1.1 and 1.2. Appendix C lists some of the features supported by the most common browsers (Navigator 2, 3 and 4, IE 3 and 4) and Appendix D some JavaScript syntax diagrams. Owing to the speed of change of JavaScript and web browsers, the reader is directed to the authors web-site ( http://webcoder.com ) for full reference material.

This book contains some very inventive and skillful chunks of JavaScript code that will be copied ad infinitum. Its major drawback is that the subject matter is a rapidly moving target. My advice is to check out the web-site and wait for the second edition.

Phil Gregg heads the Systems Group in the Department of Computer Science, Birkbeck College, University of London.

Windows Annoyances

David A. Karp
O'Reilly & Associates, Inc., June 1997
285 pages
ISBN 1-56592-266-2

(Reviewed by Raza Rizvi)

This is written by the maintainer of the Windows95 Annoyances Web Site ( http://www.creativelement.co m/win95ann/ ). It will surely in time be known as the warty toad book due to its cover design.

Both Windows 95 and Windows NT are covered with clear indications of when a particular 'feature' is pertinent only to one of the operating systems. The book includes information on the OSR2 release of Windows 95, but unfortunately slightly predates the beta release of Windows 98.

Split into seven chapters, the book methodically and clearly deals with areas like the registry, system performance, troubleshooting, and networking. After a short introduction to the basics, and a shorter guide to the future for Microsoft

Windows operating systems, we move into the first of two chapters on customisation.

These chapters are going to be a boon and a bain to those people charged with looking after multiple PCs. As long as only you see the book, you will be treated like a guru for knowing minutiae of detail on how to correct problems that ought to have blindingly obvious solutions (but don't). If. however, your users see this book, then expect to be confronted with know-alls who did not heed the clear warnings about fiddling with the registry...

It isn't all registry hacking (O'Reilly have another book on that); there are some excellent tips pointing out areas and configuration items that you might well have overlooked.

The Network section could perhaps have been slightly longer as the majority is spent with Dialup Networking problems, although this subsection is excellent.

A comprehensive FAQ and a crash course on MSDOS complete the main text of the book. A thirty page glossary (!) is included in the appendices.

Inevitably there will be some people who know some of the things covered in the book, but the benefits of having all the information in a single place makes this a recommended read for all Windows 95/NT users.

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.

Windows NT in a Nutshell

Eric Pearce
O'Reilly & Associates, Inc., June 1997
348 pages
ISBN 1-56592-251-4
(Reviewed by Andrew Cormack)

Many UNIX administrators keep a Nutshell book at hand for checking command names, parameters or flags. With this book, those responsible for Windows NT systems can do the same. Like all the series (and despite hints in the introduction) it is a reference work and aims to provide information rather than understanding. The book concentrates on version 4.0 of the operating system but much of the content will also be useful to those who have not yet upgraded from version 3.51. Differences between the client and server options are noted throughout the text and are also summarised in a table.

Most people will start using NT through its Windows interface, so this is where the book begins. The control panels and administrative tools are illustrated in full with diagrams mapping out the often complex menu hierarchies. Where the purpose of a menu option is not obvious from its title there is usually some additional explanation. For each tool there is a brief summary of its purpose and a list of any other services it requires.

GUI systems can be clumsy for familiar or repetitive operations and most administrators will soon begin to use the equivalent commands listed with each menu. The commands have their own

reference sections which include both full details of flags and parameters and also examples of how they can be combined in scripts. The sample scripts are realistic and should provide a good introduction to automating common tasks.

Windows NT provides dial-up IP networking as a standard service using the PPP protocol. Since this is likely to be unfamiliar territory for many readers the reference material is supplemented by a tutorial on configuring it. However this deals only with the client end of the connection and assumes that the server end is already working. There are few examples and the advice on debugging suddenly introduces PPP packet dumps with only minimal explanation of how they may be used. The remainder of the chapter returns to more natural Nutshell material with tables of modem scripting commands.

This illustrates a problem which recurs elsewhere in the book: NT is new ground for O'Reilly and there seems to be some uncertainty in finding an appropriate level. On the one hand there are basic tables of the different classes of IP address and their subnet masks, but at the same time DNS resource records and TTLs are mentioned without further explanation. There is a warning of the difficulty of setting the correct file permissions to make the system secure but no help in doing so.

Reference books must be easy to use, and this one provides several ways of locating information. There is an extensive index and also a glossary of common terms, though readers transferring from other operating systems might welcome more translation of NT-specific words like “share” and “registry”. In practice the table of frequent tasks, listing relevant commands and menus, will probably be most used. Existing NT administrators should find the book useful as a concise and comprehensive reference, particularly as their systems outgrow the GUI controls. Those who are new to NT administration will probably find an easier introduction elsewhere in O'Reilly's NT series. While it is possible to read this book from cover to cover, as suggested on the back flap, I needed sixteen hours on a train to manage it!

Andrew Cormack has an NT system on his desk, but uses UNIX for all his real work (webmastering, newsmastering etc.).

Java Multimedia Cyber-Classroom (First Edition)

Harvey Deitel and Paul Deitel
Prentice Hall, 1997
CD-ROM with 34 page accompanying booklet
ISBN 0-13-271974-6
(Reviewed by Andrew Cormack)

What a difference the medium makes! This CD-ROM presents the same material as the authors' book “Java: How to Program” but the two versions have very different effects. On paper, the 1200 pages of text are a solid, though occasionally fussy, introduction to Java (does window alignment really need three separate programs?). On CD, the

continuous text is hard going, especially as it is presented in small chunks with no control over page or text size. Some of the in-line diagrams and code fragments are almost unreadable. Sidebars and figures are replaced by pop-up windows with appropriate icons to indicate common bugs, good practices, performance, debugging, software engineering and portability tips. Most of the content is good, but the background colours, and the fixed font size, could benefit from a “readability” tip.

The chapters follow the usual sequence for an introductory programming book, beginning with an introduction to computer languages, simple statements and control structures, then introducing object-oriented programming before considering more advanced features such as exceptions, threads, files, and data structures. The Java libraries for graphics, GUIs and networking are not forgotten. Each chapter has a list of objectives, a summary (with hypertext links into the chapter) and exercises. These are simply re-printed from the book, with no interactivity, though there are sample answers to the programming questions. Although there are navigation icons to move between pages, sections and chapters, there is no indication of the length of each chapter nor, once you begin reading, how much progress you have made. There is an extensive alphabetical index, with links, which would probably be quicker to use than the paper version. Unfortunately some links lead to figures with no route back to the accompanying text.

The presentation of example programs is much better. Source code is displayed in a window, and both the page and font can be re-sized. There are also icons to run the program, save it to disk, or listen to the authors' commentary. The last is very useful, since it is much easier to listen while looking at the program than to flip between pages of code and description in a book. The commentaries are helpful and generous in length: they can be paused and replayed using the media player control panel which appears on the tool bar. The authors suggest modifying programs to see the effect of changes, but this must be done manually since the save to disk icon does only that. The copy of Cafe Lite on the CD is not linked into the course in any way. The Java applet viewer is supposed to be linked in, but this requires careful setting up before it will work. The installation process had not added the location of the program to the path, nor set up the JAVA_HOME environment variable. These could be fixed from the control panel, but I never managed to persuade the program to accept my own login directory, and eventually created c:\users\default\ just to keep it happy. Installing the program under a long filename also turned out to be a mistake!

The CD-ROM has various good ideas for the presentation of training material, but fails to take full advantage of the medium. The audio annotations to the example programs are excellent and, along with the ability to actually run the programs, are a clear improvement over anything a book can offer. However the linear text is much better suited to its original, paper, form.

The disk would be a useful supplement to the book (the two are now available as a package as the Complete Java Training Course), or as an alternative viewpoint for someone learning Java from another source. However it is not suitable for use as a training course on its own. Purchasers should wait for a new version of the CD-ROM covering the version 1.1 Java Development Kit.

Finally, a look at the publisher's announcement for the latest version ( http://www.prenhall.com/
), does appear to show they've addressed several of the problems I highlighted with this first edition.

Andrew Cormack is currently learning Java and Catalan. Hola Món!

Java 1.1 Developers Guide, Second Edition

Jamie Jaworski
Sams.net publishing, 1997
1000+ pages
£46.95 including CD-ROM
ISBN 1-57521-069-X
(Reviewed by Graham Riley)

This book promised to be a developer's guide, so, as that is what I thought it was, I was hopeful of finding something useful in its many pages. I did want to build applications: distributed ones using Remote Method Invocation (RMI) in this case. I refused the offer to use the software on the CD-ROM, as the software is Microsoft's J++ and, given Microsoft's (anti-) position on portability, I hope you will understand why.

I was looking for something that provided a more detailed general reference to the APIs than does “Java in a Nutshell”, which is quite terse in this respect, and, specifically, I wanted information about RMI and more general network programming techniques. As these subjects are out of my normal area of expertise, I really was looking for clear explanation and good, useful examples.

As far as the API overviews go, the book is quite useful. Each API has a small, illustrative code sample with it, and these do help to clarify the intended use of methods sometimes. Certainly, this section gives a better view of how to use an API than “Java in a Nutshell” (though that book is an easier quick reference if you just want to know what is there. (The moral is: one book is never enough!).

On the Networking/RMI side, there are around one hundred pages of general networking information, which gave quite a good overview of sockets, etc. Of these, RMI has eleven dedicated pages. This section had examples that worked and were reasonably useful, but I found it all a bit “thin”, especially on aspects such as having the RMI stubs downloaded from the server.

This information was contained in the “using the API” part of the book, which mainly covers application-based programming (as opposed to applet-based programming). There are just over thirty

pages in the “developing distributed applications” section covering applet-based aspects.

I supplemented my RMI reading with one of the excellent O'Reilly series Java books on Network Programming, which is reviewed below. I could not have completed my work without this and the Web-based FAQs (again: one source is not enough).

I have not used the AWT chapters in anger, but they look full of useful, illustrative examples too. I suspect these do not lack the depth of treatment that the RMI sections suffer from. Given this is what, to many people, Java is all about, there is a lot more space dedicated to this subject (and maybe the author has more experience in this area?).

In summary, this is a useful book to have as part of a reference collection. It does give a good feel for what is in the language and the index is good but, for me, it lacks the depth of treatment to call it a “developers guide”, at least for distributed applications developers. Further, this is not a book for those of us like to browse books on the train or bus; it is too heavy to be portable! I also think it is a bit expensive for an individual to buy. It would not be my first choice if I had to buy just one book.

I think Java is simply too large to be covered in-depth in one book, as this one tries to do. I would sooner spend my money on a couple of thorough books on the specific aspects of Java I needed at the time. (If only someone would write them; the O'Reilly series is probably the closest at present). For the time being, I don't think there is any substitute for having access to the wealth of good online documentation that exists, including the tutorial and FAQs found at Sun's Java site for example. The FAQs are an invaluable source of wisdom. If you don't have access to the Web, your money might be better spent paying someone to print them for you!

Graham Riley is a research fellow in the Centre for Novel Computing in the Department of Computer Science at the University of Manchester, England.

Java Network Programming

Elliotte Rusty Harold
O'Reilly & Associates, Inc., February 1997
422 pages
ISBN 1-56592-227-1
(Reviewed by Graham Riley)

I “borrowed” this from the Book Editor's pile, thinking I could return it before she noticed. It was really good, so I reviewed it and kept it...

This is a good book. As you read it you get the feeling that the author really has practical experience of the subject. It was exactly what I was looking for as it expects familiarity and some experience with Java and object-oriented concepts, as well as some experience of using computers in a networked environment.

What it promises is to introduce you to network programming, network concepts and network application development, and, for me, it did just that. Again, the index is good and, at only (!) four hundred pages, it is one you can carry around easily.

The first three chapters cover basic network and web concepts. These give good background information on what is possible with some nice historical footnotes.

The rest of the book is divided into sections dealing with the insides of Java's networking facilities. These cover: Internet Addresses, URLs and Applets; the underlying socket and datagram classes; protocol handlers (e.g. URL and Mime) and content handlers (e.g. text, gif files , jpeg files, etc.); and finally three chapters on multicast sockets, RMI (which I was interested in) and servlets.

Each section ends with a part entitled “Some Useful Programs”. I found that these really were useful. In particular, the examples investigating basic socket protocols in chapter 7, which use telnet to investigate facilities such as your local SMTP (mail) server, finger and whois , provide real insight into how it all works.

The chapter on RMI was equally illuminating, with good information on security managers and remote exceptions. Again, the example codes worked and were useful in developing more complex applications. So, this is a book worth having if you need to get to grips with network programming.

However, I still needed the on-line Java FAQs to provide answers to problems such as why, even though my client could contact the RMI registry on a remote server machine in a completely different domain and happily return a reference to a remote object, the connection to the server was refused when I tried to use it! This was disappointing, considering all was well when the client and server machines were in the same domain. This, the FAQ told me, was in fact due to a bug in Solaris, the operating system on the server machine. It aslo provided me with three workarounds! Still, I don't expect any one book to anticipate every problem I will encounter... one source is never enough.

Graham Riley is a research fellow in the Centre for Novel Computing in the Department of Computer Science at the University of Manchester, England.

Graphic Java: Mastering the AWT, Second Edition

David M. Geary
Prentice Hall, 1997
877 pages, including CD-ROM
ISBN 0-13-863077-1
(Reviewed by Andrew Cormack)

The really clever bit about Java is not just being able to transport executable programs between computers of different kinds, but doing it with windowing applications. This magic is achieved by the Abstract Window Toolkit (AWT); even if it cannot simplify writing a graphical user interface, at least there is only one set of obscure subroutine calls to remember

rather than three or more. Most Java books mention the AWT, but few give the toolkit their undivided attention as this one does.

Windowing programs have to work with two sets of things: the components which appear on the screen and the events which these generate when they are touched (and occasionally when they are not). The author chooses to describe events first, which inevitably involves some reference to components which have not yet been mentioned. However, most readers will at least be familiar with the appearance of components on the screen, so this is not too confusing.

The second edition covers the new event model used by version 1.1 of the Java Development Kit, but also retains the description of the previous model for the benefit of users who do not yet have access to the new JDK. This also permits a discussion of the problems with the old model and the reasons for the changes.

The different types of component available in the AWT are sensibly grouped into chapters. As befits a book on serious programming there is a strong emphasis on the behaviour of components rather than their appearance: each new type is presented with a complete table of the events it can generate. There is also a brief diversion to cover images and how to filter them. A great deal of source code is incorporated into the text with mostly clear descriptions of any new material. Many of the examples are taken from the Graphic Java Toolkit which is developed in the second part of the book. Common programming errors are highlighted as “AWT tips”.

Adding components to windows is easy enough, but working out where they will appear is another matter. The layout manager classes which deal with placement are generally misunderstood, especially the most powerful, GridBagLayout . The book does an excellent job of de-mystifying the built-in layout managers: providing descriptions, illustrations and applets to experiment with different settings. It even provides guidance in when, and how, to write your own layout manager and gives three simple but useful examples.

Most programs rely on the host computer's own windowing systems to display components such as menus and buttons. Where these are inadequate, or closer control is needed, JDK 1.1 allows lightweight components to be implemented wholly in Java. The book provides some examples and discussion of these, but mainly as an introduction to the technique of double buffering which is used to reduce flicker when re-drawing images. This makes a pleasant change from the normal approach using animations to demonstrate the problem.

The second half of the book shows how the basic AWT components may be used to build a library of higher-level graphical tools. The resulting Graphic Java Toolkit includes common functions such as bargauges, rubber-banding and several types of dialog box. These tools should be useful in building more complex programs as well as providing a good example of object-oriented development. Each complete class has a test applet and the use of perspective drawings to illustrate how nested components fit into their containers is excellent.

Graphic Java is not a book for beginners. Readers need to be familiar with the Java language, inheritance and over-riding methods before they start. For such programmers it provides a good introduction to the AWT and should continue to be useful as a reference, though it does not replace the class library documentation. They should also, incidentally, absorb much good programming and design practice. The first edition was well received and this new edition, with a great deal of new material, is even better.

Andrew Cormack is currently learning Java and Catalan. Hola Món!

Electronic Publishing on CD-ROM

Steve Cunningham & Judson Rosebush
O'Reilly & Associates, Inc., July 1996
383 pages
£25.95 including CD-ROM
ISBN 1-56592-209-3
(Reviewed by Gavin Inglis)

It's a pleasure to read in a volume about electronic publishing that the paper book offers many advantages over new media and should be around for the indefinite future. In fact this is typical of the content throughout this book; a down-to-earth and realistic explanation of publishing on CD-ROM.

Having established the roots and trekked through the general scope of electronic publications, Chapter 2 presents some very interesting ideas about the relationship between technological and traditional publication. The authors don't envisage a three-way struggle between paper, CD-ROM and on-line publishing; more a menage à trois. Interesting hybrids get a mention, such as a flight simulator which lets you exchange plane designs via the net.

Two actual CD-ROM products appear as case studies. Isaac Asimov's The Ultimate

Robot is a compilation of short stories beefed up with Asimov audio, robot non-fiction and a robot builder toy. The details on this illustrate a range of design decisions and touch on acquiring the rights to use movies and other licensed properties. The second case study focuses more on technical decisions and concerns the electronic version of the proceedings from SIGGRAPH.

Anybody who hankers to create their own CD-ROM will be salivating by the end of this chapter. The half a million dollars cited immediately afterwards as normal development costs for one title will probably dry that up. Actually these following chapters are perhaps the most useful ones for anyone who truly intends to produce a title. They cover staffing, financial planning and the entire course of the CD's life from conception to production. Later chapters even explain the manufacturing process, marketing, and how many units you can expect to realistically sell. The contact lists for manufacturers and bureaux in the appendix would be handy were they not almost exclusively North American.

This is not purely a business book however. There is a significant technical midsection which covers standards and tradeoffs for file formats, plus standards for CD filesystems such as ISO 9660 and HFS. Karaoke CDs get a surprise mention. Another good sign is that the text makes concessions to its own temporary nature. There is some information and some speculation about the new Digital Video Disc format and how it will move the boundaries.

And of course there is a CD-ROM with the book. The abstracts of each chapter are of limited use, but all the images throughout are supplied for viewing. Tantalisingly there are also movies of the CD production process, but the Quicktime player supplied is only for Mac or PC.

Electronic Publishing on CD-ROM does a pretty good job of taking you from absolutely no knowledge at all to a relatively informed position about the CD-ROM industry and electronic publishing in general. Certainly it would be a valuable book to read through before scheduling that appointment with the business advisor. Neither will it date that quickly – enough of it is general enough to be useful even if the format changes. The numbers will change, but not this month.

Gavin Inglis spends all his time throwing out old Sun manuals for the UNIX group at the University of Edinburgh. He used to like Geri best, but now he prefers Mel C.

Scripting Languages: Automating the Web

World Wide Web Journal, Volume 2, Issue 2
Rohit Khare (Editor)
O'Reilly & Associates, Inc., June 1997
219 pages
ISBN 1-56592-265-4
(Reviewed by Raza Rizvi)

This is Volume 2, Issue 2 of the World Wide Web Consortium (W3C) Journal. This is also available online at http://www.w3.org/pub/WWW/

Following the normal format of headline interview, work in progress, calendar of W3C events and reports, and rounding off with a series of technical papers, this issue covers interesting territory. There is discussion of five separate programming languages, a handful of Web editors or development environments, and a smattering of CGI for good measure.

Larry Wall and Tom Christiansen are interviewed about the merits of the language that they developed as a half-way house between C and shell scripting, Perl. It is clear that they were as surprised as anyone with the success of the Web and are delighted that Perl has become, for many, the construction tool of choice in the development of the data manipulation processes behind the HTML front-end. Tom in fact mentions that the Perl web site, http://www.perl.com , is actually all Perl, a total of some three to four thousand pages!

The Work in Progress section provides an overall view of work on WebTV and collaborative or distributed authoring primarily by focusing on the individuals leading the relevant projects within the W3C.

The W3C reports start with an article on client-side scripting by Dave Ragget of HP, who was responsible for the HTML 3.0 specification. The script element specification detailed supports not only JavaScript and VBScript but is extensible to include other scripting systems with some examples provided in Tcl code. The specification takes great care to outline how scripts can be included in pages without detrimental effects on either non-compliant or outdated browsers.

Amaya is introduced in the second report as a browser-cum-authoring tool designed to serve as a testbed for experimentation in new web protocols and extension development in “older” web protocols. This HTTP 1.1-compliant browser supports the new developments in, for example, the PNG graphic format support and style sheets. It has also been designed never to reject a document that it is downloading even to the point that it can make assumptions of the original creator's intentions. The authoring tool is not an HTML editor, but rather a sophisticated word processor which checks the validity of the tags against the HTML specification. Multiple windows show the structural representation of the code as well as the normal output. It is possible to view

the output simultaneously as it would be seen on a text-based terminal. Editing is possible in all views and the format of the view is extensible by the developer. Once documents are complete, they can be published on the web as though they were local files by specifying a URL rather than a filename (and of course included documents and links are saved intelligently...).

Having earlier given a high-level overview of WebTV, a well-written third report returns to the subject of multimedia on the web and in particular the problems in attempting to deliver synchronised information of the form “n seconds after starting, do x and then if the user does y then start z” in an open manner. Discussion of products from a variety of vendors such as Apple, Microsoft, VDO, Pointcast, and Macromedia illustrate that some of the components are already present to allow use of both declarative and scripted languages in combination to meet the goal.

Onto the technical papers, starting with a discourse on VBScript, with an introduction on how it is positioned against JavaScript. The point is made that VBScript can be used without ActiveX controls and the article leads on from client-side to server-side scripts and their role within Active Server pages, with a number of well thought out examples and code snippets.

Balancing the scales, the next paper deals with JavaScript! The paper shows how code has been used in real web sites to good effect, concentrating on the Prentice Hall book site which is located at http://www.prenhall.com .

The next two papers deal with the programming languages Python and Curl. The long Python paper covers the language elements (by showing how to create a web link checker) together with server scripting, HTML generation, and details of Grail, a web browser written in Python. Curl is shown to be a rather TeX-like manipulator of primarily text- or table-based screens. Syntactically it is somewhat reminiscent of what I can vaguely remember of LISP and Dylan (itself an Apple offshoot of LISP).

Two papers on CGI follow, the first covering maintenance of state using CGI and cookies, the second on the benefits and features of Win-CGI. The journal concludes with a rather long dissection of the LWP (Library Modules for WWW access in PERL) and a somewhat too brief example of some well-commented Perl to write an NNTP front-end.

Overall, this issue shows once again that the frontiers of what can be achieved on the web are being rapidly pushed forward. The journals provide a timely snapshot of the state of play and I recommend that you keep a weather eye on their contents.

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 .

Software Portability with imake, Second Edition

Paul Dubois
O'Reillly & Associates, Inc., September 1996
387 pages
ISBN 1-56592-226-3
(Reviewed by Alec Clews)

I had wanted to read this book after I recently worked at a site that used imake , to the general confusion of most. I was looking for information on a) What imake could do and b) the correct way of using it.
Before discussing the book in more detail, the bottom line is that this book gives you a good introduction and tutorial to imake , both its principles and use. It helps to have some UNIX development experience as the style of prose and occasional leaps of logic are easier with the correct background. It should be read by all build and configuration managers and by any developers who need to use imake and have no previous experience. If you are choosing build tools then, after reading this book, you should also take a look at other portability tools, such as GNU Autoconf.

The book starts off with a brief look at the issues of building software for multiple platforms and then explains in overview how imake creates a Makefile for use on different UNIX platforms. It discusses the basic toolkit required to use imake and how to use it.

The book then looks in some detail how the imake configuration, template and rule files are created and maintained. This is the area that always seems to create the most confusion and this is the real “meat and potatoes” of the book. The approach taken is to gradually build up a template file and rule file and add more pieces as they are needed so that the reader gains an understanding of the principles involved as well as the arcane syntax and structure.

The book looks at the files supplied with X11R6, the home of imake , and how to troubleshoot imake problems. A final section covers imake on other platforms. Useful appendixes cover obtaining imake from the Internet, installing and bootstrapping imake , and other miscellaneous issues.

Basically a good book that explains imake well.

Alec Clews is a Principal Consultant for SQL Software Ltd.

Oracle 8 Design Tips

Dave Ensor & Ian Stevenson
O'Reilly & Associates, Inc., Sept 1997
115 pages
ISBN 1-56592-361-8
(Reviewed by Adrian Cummings)

Now here's a rare sight; a current technical computing book which is slightly smaller than the original edition of K&R. Better still, no floppy discs, no CD-ROMS.

First of all, this work is a companion to Oracle Design (same authors and publisher) and as such is not a complete text on database design. Version 8 of the Oracle database management system was released mid 1997 and contains a fair number of new and improved features. In practice some of the “new for 8” features were also included in the final releases of version 7.

It would be all too easy for this sort of book to turn into an advert for a new release of a product and fortunately the authors have avoided this temptation. The same reasoning also applies to a review of a book on new features so I will avoid listing the new features of Oracle 8 in this review. Instead, they give concise descriptions of the new features and the areas of an application where they might be sensibly employed.

If you already have Oracle Design you should obtain this companion guide. If you design or administer Oracle databases and don't already have Oracle Design then I would venture to suggest that you have a couple of gaps on your bookshelf that need filling.

Adrian Cummings is the keeper of a flock of Oracle 8 databases at the University of Manchester Department of Computer Science.

Panic! UNIX System Crash Dump Analysis Handbook

Chris Drake & Kimberly Brown
Prentice Hall
ISBN 0-13-149386-8
(Reviewed by Virantha Mendis)

A UNIX system that has been running smoothly for months suddenly crashes. The System Administrator reboots the machine and life is back to normal or is it really back to normal? The system might continue to function without further crashes or this may be the first of many crashes. Every system administrator has experienced system crashes and many have developed their own tricks to handle the situation and to get more information about the crash. However, when the situation gets really bad, usually several system crashes a day, the time has come to call it a day and get assistance from the system vendor. This is usually achieved by sending a crash dump of the system to the vendor's support centre.

Chris and Kimberly, both from Sun Microsystems, have pooled their expertise in UNIX and crash dump analysis to produce this book, which is a first of its kind.

The book is presented in three parts. The first part, “Getting Started”, introduces a panic and the symptoms of a panic. This

is followed by an explanation of how to use the savecore command to capture the core dump on SunOS and Solaris machines. There are a couple of neat tricks that can be used to crash your own SunOS or Solaris machine (these should not be tried on a live system!). The rest of part one is used to illustrate the use of the strings command to perform an initial analysis of the core dump and the use of the adb debugger to gain more information from the core dump.

Part two of the book illustrates the Sun SPARC specific topics and SunOS/Solaris specifics. These include the SPARC Assembly and the SPARC instructions. On the operating system side, topics such as scheduling, virtual memory, file system, Streams and trap handling are covered. The final part of the book looks at several case studies which have been dealt with by the authors of the book.

The book is well presented and there is a wealth of information for the system administrator that can be used to hunt down the reasons for system crashes. In my opinion every Sun system administrator should have a copy of this book.

Virantha is working for Bioscience Information Technology Services, Biotechnology & Biological Sciences Research Council as a UNIX technical support analyst.

Windows NT User Administration

Ashley J. Meggitt & Timothy D. Ritchey
O'Reilly & Associates, Inc., 1997
ISBN 1-56592-301-4
(Reviewed by Phil Docking)

Why did the authors write this book – well, they make an attempt to tell us why in the preface, but I'm still not so sure about their reasons.

I'm not particularly sure that this book is aimed at “experienced NT administrators” as they claim, since most experienced administrators would probably ask “Why did they want to write a book on that?...”. I suspect this is their first book; the authors thank almost everybody.

Chapter one starts out fairly badly with some hot air about “resource management, auditing and user customisation” which are not particularly practical in nature. However, since they plan to use Perl extensively throughout the book the following exposition of the outlines of the Perl language is, in my opinion, far better in a couple of paragraphs than the whole of O'Reilly's “Learning Perl” book. There is some question as to whether it's a good idea to list the entire set of Win32 Module functions within the text, without

explanations; but this is what the authors have decided to do.

Chapter two gives a fairly basic description of user creation methods and ways of using the “User Manager for Domains” for single and multiple user management. It includes descriptions of Command line, GUI and bulk methods of adding users.

Chapter three concentrates on groups. A useful discussion of Access Control Lists (ACLs), leads into the group management section. It may be a little simplistic for more experienced users, since it sometimes goes down to the level of telling the user exactly what to type into a dialog box. The chapter, however, doesn't cover Usr2grp , which is a useful addition from the NT resource kit.

Chapter four deals with the use of scripts to manage users. These are generally Perl scripts. The text deals with creating user-id's and passwords, logon scripts, checking file security and deleting users. Substantial in-line listing of Perl scripts makes the chapter appear longer than it really is.

Chapter five focuses on domain users, and in particular covers trust relationships between domains; giving outlines of strategies for domain models to use in particular circumstances. This is another useful exposition of the nature of trust relationships, and includes a section on how to structure domains depending on your organisation type.

Chapter six gives a basic introduction to the registry and registry keys which are relevant to user administration. It covers the use of the Win32 module of Perl to modify the registry as well as talking about the two regedit implementations.

Chapter seven is probably the most useful chapter in terms of enforcing security controls on the user – the Policy editor is covered here, along with methods of creating policy template files for local controls, along with a treatment of User profiles. Particularly useful is the description of how to build policy template files, something which Microsoft's documentation appears to make more obscure than it needs to be.

Chapter eight deals with auditing of NT objects, including files and resources, such as printers and registry settings. It deals with methods of using Perl to scan the event logs to highlight potential hazardous or malicious user actions, and how to filter event logs to gather meaningful information.
Chapter nine appears to be a continuation of chapter eight, with more Perl scripts to filter event logs – creating scripts which write to the event log and outputting event log information into Excel format.

In general, this book provides a good introduction to User Management in an NT installation for novice users, with a good, detailed account of more advanced procedures for maintaining and auditing the system. The book is fairly slim at 197 pages, but a book on user management cannot really be too extensive, since there are a limited set of operations which NT allows administrators to perform in the user context.

Phil Docking is a member of the Systems Group in the Department of Computer Science, Birkbeck College, University of London.

Tel: 01763 273 475
Fax: 01763 273 255
Web: Webmaster
Queries: Ask Here
Join UKUUG Today!

UKUUG Secretariat