[UKUUG Logo] Copyright © 1995-2004 UKUUG Ltd

UKUUG


Previous Next

Reviews

Programming Internet Email

David Wood
O'Reilly & Associates, Inc., August 1999
362 pages, £23.50
ISBN 1-56592-479-7

(Reviewed by Andrew Cormack)

This book has a rather curious title which perhaps needs an explanation. It is not just programmers who should benefit from a clear explanation of all the standards, both formal and de facto, used in the representation, storage and transfer of electronic mail messages. The intention is not to replace the many Internet RFCs on the topic (an appendix listing these occupies four pages) but to provide a more rounded, less detailed overview with illustrations of common usage. Given the number and complexity of the standards, this kind of coherent volume is well worth while.

Electronic mail is plagued with a multitude of acronyms, and the initial review of how mail gets from one place to another suffers from introducing too many of these at once. MUAs, MTAs, MDAs and MRAs are useful shorthand once the process is understood, but could be overwhelming on a first encounter. Fortunately the rest of the book is based on a simpler structure: what a message looks like, how it is stored, how it is moved from place to place and how to write programs to influence each of these.

The description of mail messages is paradoxical: headers and structure are made to sound more complex than they are and two printing errors, omitting essential line breaks, add to the confusion. However the explanation of MIME and content encodings is admirably straightforward. This is illustrated by particular applications -- S/MIME, OpenPGP and vCards -- at the same time suggesting how decoding programs should cope with common errors. Mailcap files can be used to keep track of all these MIME types, though there should be a health warning against setting up over-powerful "viewer" programs which may inadvertently execute untrusted attachments. Mail messages themselves may be collected in mailboxes of many different formats. The most common types are reviewed with comments on their advantages and problems.

The Simple Mail Transfer Protocol (SMTP) is one of the original components of the Internet, now approaching 20 years old. In that period it has gained many extensions, but the basic protocol is still sufficient to get mail from one machine to another. This basic exchange is described in words and pictures and then extended to show the new facilities of ESMTP. The author comments on the use by spammers of forged message addresses, but does not mention the common response by server administrators of disabling the EXPN and VRFY commands. The Post Office Protocol and Internet Message Access Protocol are used to fetch mail messages over intermittent connections. These are described in similar style: successfully in the case of POP but less so for IMAP. An example IMAP transaction is described briefly, but only after twenty pages listing all the possible commands. Anyone struggling this far could probably gain as much by reading the full standard. The description of the Application Configuration Access Protocol is better, but would benefit from some concrete examples of the sort of data which might be stored in an ACAP dataset.

Few people have the time or inclination to write their own mail client or server, but there are many opportunities for small utility programs to interact with parts of the mail system. Perl and Java are the languages of choice for writing such utilities, at least on UNIX systems, and both have libraries to make such programming easier. In fact Perl has a choice of libraries so the book describes those which are most actively maintained. Their use is illustrated by code fragments and two complete applications: a replacement for /bin/mail and a program to remove large MIME attachments from mailboxes. In fact, neither program makes the fullest use possible of its libraries: hand-coded operations may be more efficient but miss the point of an illustration. Java encapsulation prevents such short cuts so the examples using the Java Mail API are cleaner. These are another /bin/mail replacement and a monitor for IMAP mailboxes in the spirit of biff.

Not all mail programs are beneficial so the author includes a chapter on SPAM, warning readers against generating it and suggesting how recipients and network providers can cope with it. Such social responsibility is most welcome.

The book could appeal to many different types of reader: administrators, programmers, students and even interested users. All should find something of interest, particularly in the simpler systems: MIME, mailboxes, SMTP and POP. Reviewers seldom ask for books to be bigger, but the sections on IMAP and ACAP would certainly benefit from more room to breathe, to avoid the current tension between description and completeness.

Andrew Cormack wishes he could get a program to read all his e-mail...


Oracle Distributed Systems

Charles Dye
O'Reilly & associates, Inc., April 1999
530 pages, £26.50 incl. floppy diskette
ISBN 1-56592-432-0

(Reviewed by Adrian Cummings)

Any organisation of any size probably already uses distributed databases. For many years Oracle have provided a number of mechanisms to support this. Seemingly each revision of the database brings a new way of achieving this while enhancing the existing methods. Oracle Distributed Systems begins with an introduction to the benefits and pitfalls of distributing a database to guide the reader through the many options and appropriate areas for their use.

Clearly, distributing data is going to involve the transference of data by some mechanism. Whether this is by the tried and trusted "station wagon full of tapes", or some sort of network, depends on your particular circumstances. For the those with an appropriate network available there are descriptions of SQL*Net and Net8 and a guide on their tuning and configuration. The book describes both networked and non-networked approaches.

The author then moves on to discuss configuration and administration issues paying particular attention to the security and design of a distributed system. As you would expect from the title, Oracle's implementation methodology is described in detail.

Throughout the book there are plenty of good quality worked examples, covering all the network based replication methods (basic and multi-master), snapshots and procedural replication.

Another major issue that appears when distributing data is conflict. The author not only covers methods to avoid this but also details strategies for conflict resolution.

There are two appendices. The first constitutes nearly a third of the book and describes, in some detail, the built-in packages supplied by Oracle for distributed systems. The other appendix contains listings of the scripts and utilities contained on the accompanying floppy (in DOS format... what else?). The scripts are mostly for SQL*Plus but with one ksh script for good measure. Rather alarmingly the creation date for the disc was reported by one of my machines as 31/15/2107 31:63 -- looks like some fundamental changes to the calendar are on the way!

I found Oracle Distributed Systems to be a readable work filled with good quality examples, many of which are somewhat more lengthy than are often found in books of this type. While not every site that uses Oracle will have a need for a distributed database, for those that do this book should prove useful.

Adrian Cummings may be found distributing Oracle thinly and can be reached at acummings@cs.man.ac.uk.


Using Samba

Robert Eckstein, David Collier-Brown & Peter Kelly
O'Reilly & Associates, Inc., November 1999
398 pages, £23.50 incl. CD-ROM
ISBN 1-56592-449-5

(Reviewed by Adrian Cummings)

Samba is an open source implementation of the CIFS (formerly known as SMB) protocol used by Microsoft for file and printer sharing. Samba turns your UNIX box into, effectively, a Windows NT server but without the costs and other overheads of using the real McCoy. The resulting emulation is very convincing, indeed one of the users at this site was somewhat surprised at discovering what he believed for some time was a Windows NT server was actually a Solaris box.

After detailing the operation of MicroSoft networking, the tasks of building and installing Samba is described. The CD-ROM included with the book contains both the source and pre-compiled binaries (the version included with the review copy is 2.0.5 which, at the time of writing, isn't too far behind the current production release).

Having built Samba, you then need to know how to configure the clients. In the case of Windows NT this is minimal but for Windows 3.1, 95 and 98 you may need to take account of the limitations of their respective filesystems.

The primary functions of Windows networking are disc shares, network browsing and printing. In addition Samba can act as an authentication server or pass such requests onto another machine. The setting up of users, appropriate security and domains is covered. Conventionally this is done by modifying Samba's configuration files by hand, but if you are more comfortable configuring software with a GUI interface Samba comes with SWAT (Samba Web Administration Tool). One thing Samba currently doesn't provide is the functions of a primary domain controller; this is under development although the protocols to allow Samba to act as a backup domain controller are not expected to be included in this.

Windows networking is a mixture of some good ideas and some really strange design decisions so the chapter on troubleshooting could prove invaluable when it doesn't quite work as expected.

There are appendices covering using SSL with Samba for secure conections between server and clients. The other appendices include performance tuning, quick reference for the smb.conf file, instructions for downloading newer versions and sample configuration files.

One of the major difficulties experienced by someone setting up a Samba server is creating the configuration file. Documentation is included with the source but it is difficult to follow and in a few places contradictory. This book bridges the clear gap -- another of those books I wish had existed several years ago.

Adrian Cummings cannot be found doing the Samba around the University but he can be reached at acummings@cs.man.ac.uk.


The Networking CD Bookshelf

O'Reilly & Associates, Inc.
CD-ROM + Book, 1st Edition, March 1999.
ISBN 1-56592-523-8

(Reviewed by Huw Gulliver)

The Networking CD Bookshelf like its stablemates the UNIX and Perl CD Bookshelves provides six books on CD-ROM, plus a hardcopy of one of the six. The six in this case are Building Internet Firewalls, DNS and BIND (3rd edition), Practical UNIX & Internet Security (2nd edition), Sendmail (2nd edition) and Sendmail Desktop Reference. The hardcopy book is DNS and BIND These are all well known O'Reilly titles many of which have been reviewed in news@UK.

The CD Bookshelf uses HTML format so accessing the Bookshelf is as simple as putting the CD in the CD-ROM drive and starting up your favourite Web browser. I have tried the CD Bookshelf on MS-Windows 95/Netscape 3.10, MS-Windows 98/IE-4 and Linux (RedHat 5.1)/Netscape 4.05 without problem. From the main index page you are a click away from the contents and index page for each book, have access to the combined index of all six books or can the search all six books using the CD-ROM search engine provided. If you are familiar with a particular book and know roughly where to look for a bit of information then generally it only takes a couple of mouse clicks to locate the page in question. Looking for a particular bit of information or can't remember quite where you read that useful snippet. This is where the combined index and the search engine can come to the rescue.

The search engine uses a dedicated web server written in Java. Java Runtime Engines for various platforms are included on the CD. The MS-Windows Java Runtime Engine is located under the netresults directory and is automatically started by MS-Windows AutoPlay feature along with your default web browser. UNIX users who do not have the necessary Java interpreter will have to install one of the Java Runtime Engine kits provided to use the search engine. A script run_me.sh is also provided to start the server. I had a few problems at first using this script, basically it did not seem work, I think this was me being in too much of a hurry rather than the kit though. After reading the trouble shooting page, which is a link from the search page I did get it to run. It would be nice if O'Reilly could provide this trouble shooting & Java installation information as a traditional README on the CD where I, and I am sure others, would look first.

The CD makes a great reference source partly because the CD is laid out using the familiar O'Reilly lay out used in the hardcopy books. And being able to search across all six books, being able to run multiple instances of your browser and so view different pages at the same time is a boon. Easier than flicking from one section to another and back again using your fingers and thumb as bookmarks. However it is very tempting to cut and paste when putting together your own work. When it comes to studying a text personally I do not find it enjoyable to read pages and pages from the screen. You can print off sections although this can take time due to the way chapters are broken into multiple short sections.

The titles selected for this collection go together well although including the Sendmail Desktop Reference appears a little superfluous. It would be nice to see this replaced by Internet Core Protocols once this is published. As a means of acquiring six O'Reilly books it costs less than buying the equivalent books in hardcopy and takes up less room on the bookshelf. Although I guess most will spend a good deal of time in a CD drive.

Huw Gulliver is a member of the Networks and Computer Systems Group in Information Services at Cardiff University.


MySQL & mSQL

Randy Yarger, George Reeae & Tim King
O'Reilly & Associates, Inc., July 1999
487 Pages
ISBN 1-56592-434-7

(Reviewed by David Hallowell)

Many web sites around today rely on a database backend, whether it's an e-commerce site which keeps all its customer and stock details in a database or a news site like Slashdot which keeps its stories and user comments in a database. Most commercial databases are too expensive for small to medium size sites, however MySQL & mSQL addresses this need. Although they are not free software in the GNU sense, they are free of charge for non-profit use and fairly inexpensive for commercial use.

As these two databases are fairly similar, O'Reilly produced a book to cover both; this makes it easy to see the similarities between the two products and the differences are always clearly pointed out. The book aims to meet the needs of database administrators as well as covering the programming APIs for a range of languages (C, Java, Perl, Python, etc).

The book starts off by discussing the differences in the two products which will help you decide which one is right for you if you haven't made the decision yet. The book also lists other alternatives to MySQL and mSQL, which you may be interested in. The book goes into detail telling you how to get your database set up and running, as well as outlining routine maintenence tasks such as backing up the database. It the goes on to discuss relational database design, and serves as an excellent introduction for the uninitiated. A very useful guide to those with very little knowledge in this area.

As MySQL and mSQL do not implement all the SQL commands in the official standard, this book explains in Chapter 6 the basics of SQL as supported by these database engines. It serves as a useful reference to those with little SQL experience as well as those SQL experts who are making the change to MySQL and need to know what commands are supported as well as what additional (non-standard) commands these databases offer.

The database programming section covers most areas in enough detail to meet most people's needs, covering the APIs for Perl, Python, PHP, C, C++ and Java as well as giving a brief introduction to CGI. However, this book could do with more references to books that cover each of these topics in more detail. The reference section does give a complete reference to SQL and the APIs, which tends to be the area of the book which I use the most.

So, in summary this book is ideal if you are setting up a database system in a small to medium sized organisation or you're generally just interested in database programming. Even experienced MySQL/mSQL users will find the reference sections invaluable and this makes the book well worth the money.

There is very little wrong with the book apart from the fact that the authors don't mention many other books which can expand on the information in this book.


Excel 97 Annoyances

Woody Leonhard, Lee Hudspeth, & T.J. Lee.
O'Reilly & Associates, Inc., September 1997
320 pages
ISBN 1-56592-309-x

(Reviewed by Jenny Pedler)

Like most long-term users of Excel, I've experienced my share of frustrations. I've found myself wondering whether it's me or the software; been convinced that there must be a better way to do things. As a trainer, I've observed the struggles of my students and looked for ways to make their lives easier. So I was interested to see what help the three Office gurus who wrote Excel 97 Annoyances (along with Word 97 Annoyances and Office 97 Annoyances, also published by O'Reilly) had to offer.

The "best weapons in the fight against Excel annoyances" are, we are told, command bars and VBA. Each has a chapter to itself. The approach here is hands on. If you work through 'Tales of the Toolbar and Other Aides-de-Camp' you'll have customised standard and formatting toolbars which eliminate the annoyances that came out of the box. Or so the authors claim. If you don't agree with them, you'll know enough to set things up in a way that suits you.

The chapter on VBA is the longest in the book, 60 out of just over 300 pages. Even so, as the authors admit, this is insufficient for a full introduction. Their goal is to give the reader "an idea of the major chunks of the language that are available, and how they all fit together." That's still quite a lot to achieve in 60 pages and despite reassurances, such as "If you've never written a program, don't panic", it probably goes too fast for a non-programmer. But for those with some previous programming experience the chapter does provide a good overview of the VBA editor and several working modules to experiment with.

Ways of working more efficiently with Excel are given throughout the book. These cover both the user interface and data entry and manipulation. For example using zoom, the Name box and keyboard shortcuts help avoid the time wasted scrolling around when navigating in a worksheet. An inbuilt annoyance appears here though. The key combination CTRL+End takes you to the "lower rightmost cell that defines the last row and the last column with contents." Well, usually. If rows and or columns are deleted this cell will change but, unless you close and re-open the workbook, Excel still retains the previous value so the hot keys dump you in a cell somewhere off the end of your worksheet. Not helpful. The book's verdict? "...since this behaviour has remained unchanged since Excel was a sapling, don't look for it to get fixed anytime soon."

The section on cell formatting introduces the new Merge cells checkbox (which used to be known as centre across columns). While it may be true that the new ability to merge cells "...gives you a tremendous amount of control over your worksheet's appearance and layout" this feature also introduces what seems to me to be a major annoyance (not mentioned in the book). If you do this (for example to create a heading across two columns) you are then unable to select the columns individually to hide or copy them.

I would not dispute the authors' claim that "you'll never get out of the minor leagues of spreadsheet building until you are completely comfortable with the difference between [an absolute and relative cell address]." It's something I have been teaching my students for years. I'm not so sure that I agree that "If you really want to get a feel for what formulas are all about, turn on the R1C1 reference style for a month or so. You may never turn it off." (But then I haven't tried.) For one thing it means you've got to get used to referencing the row first. I think I'll stick to the $ sign notation.

My pet Excel annoyance is the Office Assistant (code name Robert, we are informed). Personally I find whole idea of talking to an animated paper clip an annoyance, but I have met those who find it amusing and even useful. At least, it might be useful if it did what it was supposed to do. The book gives what it describes as a "classic example of a 'doesn't work like it's supposed to' annoyance." This is Robert's failure to find the Help topic "Microsoft Excel 97 Specifications" if the full name is typed in the search box although it is found if "specifications" is entered as the search criteria. I tried this example and found that my version of Excel did not work quite the same as the one described. In both cases I was directed to the required topic although in the latter case it was buried amid a lot of irrelevant information and not visible until I clicked on the more... button at the bottom of the first listing. All this serves to convince me that Robert should be dismissed as an annoyance per se. I'll stick with the Help menu and advise my students to do the same.

The book's mixture of chat, tips and tutorial make it easy to read; almost like having a conversation with your own personal Excel guru. But like a conversation it can seem unstructured at times. Topics are often covered in more than one place which makes it difficult to use as a reference book. (For example the R1C1 reference style is also covered in the section on auditing where it seems to fit much more comfortably.) Nevertheless anyone with some experience of Excel should find some useful tips to increasing their productivity. It's also comforting to feel that you are not alone in the struggle.

Jenny is a Teaching Assistant in the School of Computer Science and Information Systems, Birkbeck College.


The C++ Standard Library: A tutorial and Reference

Nicolai M. Josuttis
Addison-Wesley
780 pages
ISBN 0-201-37926-0

(Reviewed by Joe Thornber)

The C++ standardisation process finished in 1997 with the production of a 750 page standards document. Much of this document was taken up with the specification of the C++ standard library. This library is much bigger than the C standard library, gone are the days when we could flick to the few pages at the back of K&R where the C library reference was found.

There should be a large market for a book that covers the C++ Standard Library in the detail required by professional programmers, especially since one appears to be expected to pay $20 for an electronic copy of the standard. Nicolai Josuttis's book aims at this market.

We find that the author is an independent technical consultant who designs object-oriented software, as well as being an active member of the C++ Standard Committee library working group. He has also written several C++ books published in Germany. Josuttis certainly sounds qualified to write this book, and the acknowledgements section at the start of the book lists many famous names who have reviewed or provided input to the book.

As you would expect of something covering a big subject, it's a big volume with over 750 pages in a hard-back cover. It is printed in a clear readable typeface as you would expect from Addison-Wesley.

Since this book is meant to be covering a set syllabus I think it would be useful to have a contents listing. I've also included the number of pages for each chapter as a rough indication of how thoroughly each topic is treated.

  1. Introduction to the book (6 pages).
  2. Introduction to the standard C++ library (16 pages).
  3. General concepts (11 pages). Mentions a few conventions that have been adopted throughout the standard library, such as the use of the std namespace, the naming of header files, the exception class hierarchy and a brief description of allocators.
  4. Utilities (39 pages). Still setting the scene, this details various miscellaneous classes from the library that don't really fit into any of the later chapters. Such as pairs, auto-ptr's, numeric limits - I was pleased to see auto_ptrs given prominence so early on in the book.
  5. STL Overview (69 pages). Explaining the container/iterator/algorithm architecture, functors, and a section on error and exception handling.
  6. 6 STL containers (108 pages). Including a good section on reference semantics.
  7. STL iterators (40 pages).
  8. STL function objects (28 pages).
  9. STL algorithms (113 pages).
  10. Special containers (36 pages), i.e. stacks, queues, priority queues, bitsets.
  11. Strings (57 pages).
  12. Numerics (53 pages).
  13. IO streams (101 pages).
  14. Internationalization (41 pages).
  15. Allocators (15 pages). A terse treatment of allocators, it would have been nice to have given more examples of why one would like to provide user defined allocators, along with a more realistic example implementation (e.g. one that allocated resources in shared memory, or one that was based on a free list or arena implementation).

Practically every other page contains code examples to illustrate the points begin made in the text. These are an essential part of the tutorial, giving the beginner and professional alike access to a lot of idioms for using the various template classes.

The book is careful to define what state all the classes will be in after exceptions have been thrown, information that is essential for writing robust code. Tables summarise this information for several classes at once putting it in an accessible form.

Each chapter follows the same general format of having an introduction, a lengthy discussion/tutorial packed with examples and short tables summarising the aspects of the classes being discussed. Finally an "in detail" section describes the classes by having a bullet pointed list of properties for each class method.

These can be overly verbose at times - not only are there bullet points stating that a constructor is a constructor, but the following bullet often tells us that this initialises the object:

string::string(const string& str)

Classes do not always have complete descriptions available in one place. For instance the chapter on STL containers has an "in detail" section which contains common method descriptions where the last bullet point of each method then lists the classes which have this method. Subsequently there is a section, which adds the few extra methods for the "list" template which haven't previously been mentioned. Nowhere can I find a quick answer to the question "what methods does a vector have?" - the information is there but you have to hunt around for it.

This brings me onto my main complaint about the book.

There is no doubt that Josuttis knows his stuff, however I think he has done himself a disservice by attempting to write a book that is both a tutorial and a reference, at the very least I would have liked to see a more definite split between tutorial and reference material. The tutorial material sometimes gets bogged down by the author's attempt to be comprehensive, the reference material has to be dug out from various pages spread throughout the book.

Information is often repeated which is again due, I think, to the dual nature of the book, for instance page 24 tells us the new policy regarding the lack of extension on header filenames. Thereafter there appear numerous reiterations of this information, normally in the form of footnotes, e.g. "These are introduced by the header file (footnote: In the original STL, the header file for iterators was called )."

This isn't so bad with footnotes, you can make a conscious effort not to read them, but there are many of other repetitions in the body of the text. Sometimes whole groups of sentences are repeated only a few pages apart, I would have expected these things to be picked up during the editing of the book.

The book can be laborious to read at times, with rather curious English. Presumably this can be attributed to English not being Josuttis' first language, again this is something the editor should have corrected. For example, while talking about the set and multiset classes: "Unlike with lists, the erase() member function does not have the name remove()"

I wonder if this is true if you have a German accent: "It is only a mere accident that deque sounds like hack", or even some words translated literally: "Finally this section subdiscusses some aspects ...".

To summarise: there is a lot of useful information in this book, information that all C++ programmers need access to, and as such I can recommend this book (especially since I haven't seen any other books exhibiting this depth of knowledge). It also received a good reception from the other programmers in my office who spotted it on my desk and removed it for a quick read, a sure sign of a good book. However there is a lot of room for improvement on the accessibility of the reference material.

Rating: 7/10


LaTeX for Linux. A Vade Mecum

Bernice Sacks Lipkin
Springer Verlag
£34.00
ISBN 0-387-98708-8

(Reviewed by Paul Webb)

Where should the Linux neophyte go for information if he wants to learn about LaTeX? One possible source is LaTeX for Linux - a book which aims both to address the needs of the user who comes to LaTeX for the first time and the person who wants to get to grips with teTeX.

The book is divided into nine parts and an appendix which move from the introductory to the more advanced. Part One describes basic LaTeX concepts whilst Part Nine provides a tutorial on the construction of style sheets. Many LaTeX ideas are introduced through the medium of practice.tex - a sample file which the reader is encouraged to augment as his experience with LaTeX increases.

Sacks Lipkin explicity states that this book is not meant for the 2% of LaTeX users who are into higher mathematics. Her determination to look at the possibilities of LaTeX from a broader perspective can only be praised when it is borne in mind that many people avoid LaTeX precisely because of its association with mathematical typesetting.

It therefore comes as no surprise to find the author discussing topics as diverse as the inclusion of graphics and the intricacies of MetaPost.

In addition to generic LaTeX type information, Sacks Lipkin shows the reader how to modify the ~/.emacs file in order to create LaTeX templates and briefly alludes to xdvi customisation.

Yet it is precisely the balance between generic and Linux-specific information which is the book's greatest weakness. My own feeling, after a couple of readings, is that the book alternates between being an introductory text and a tool for more advanced users. Moreover, this dual focus leads to an uneven treatment of a number of topics which can be confusing at times. I personally found the discussion of fonts in Chapter Twelve extremely informative but I think that this topic could have been more profitably placed towards the end of the book. Sacks Lipkin also oscillates between an introductory treatment of LaTeX and a discussion which assumes that the reader is familiar with a number of LaTeX concepts. Many techniques are for example taught in relation to the idea of a minipage - a concept which is not fully explained until Chapter 23.

Another slight reservation that I have is that one expects a book which is about LaTeX to be pleasing to look at. Unfortunately, all of the illustrations are in black and white and some of the examples - notably the printout for the \colorbox command - are decidedly ugly. When one thinks how colour is used in Goossens et.al.'s The LaTeX Graphics Companion, the contrast between the two books becomes very marked. But this aesthetic criticism is not directed towards the author but towards Springer who - for $pound;34.00 - should have produced a more beautiful piece of work.

So what do I think of LaTeX for Linux?

It's an extremely comprehensive book which is well written but suffers a bit from attempting to address a very diverse readership. Any reader who has been using LaTeX for a while will undeniably gain much from its pages but I think that the content is still too detailed for the average punter - not withstanding the author's intention of making LaTeX accessible to all.


Virtual Private Networks (2nd edition)

Charlie Scott, Paul Wolfe and Mike Erwin
O'Reilly & Associates, Inc.
211 pages, £21.95
ISBN 1-56592-529-7

(Reviewed by Adrian Wontroba)

A Virtual Private Network (VPN) is a secure private network, run over a public network, for example, the Internet.

Traditionally, if you wanted a secure Wide Area Network (WAN) you bought, expensively, private leased lines between your sites and were very careful about what equipment, where, could connect to the notoriously insecure and hostile Internet. As the business needs for connectivity, bandwidth, and supporting remote access for road warriors and tele-workers increase, so do the costs of upgrading and supporting the WAN approach. VPNs, replacing WAN private lines with dedicated and dial up Internet connections, potentially offer reduced costs and problems in some areas, and the opposite in others. VPN technology is quite young, and is evolving rapidly. Various competing, proprietary, incompatible, commercial and free products exist. Most VPN solutions will use a mixture of products.

This book, after a quick tour of some of the underlying concepts and technologies, presents quite detailed background information and implementation instructions for the following four approaches. In each case this should be a considerable aid to anybody faced with implementing a VPN using the approach.

The book concludes with brief but useful chapters on VPN management and maintenance, a real multi-approach solution, and appendices touching on IPv6, IPSec, S/WAN, the IETF and information sources.

Overall, I found it interesting and of benefit, largely because I started out thinking that I needed a VPN, but the book convinced me that I didn't! A much less favourable review from a very more expert UKUUG reviewer may be found at http://www.ukuug.org/newsletter/83/n83-03.shtml.


Advanced CORBA Programming with C++

Addison-Wesley, 1999
1042 pages, £39.99
ISBN 0-201-37927-9

(Reviewed by James Youngman)

Contents:

This is another book in the Addison-Wesley Professional Computing Series, whose distinctive cover design and high quality makes them stand out in the computing book field. Other well-known books in this series include the Gang of Four's Design Patterns book, Stevens' Advanced Programming in the UNIX Environment, and more recently Kernighan and Pike's The Practice of Programming. Addison-Wesley have of course also published many well-known books outside this series, for example Knuth's The Art Of Computer Programming, Stroustrup's The C++ Programming Language, and many others.

Uppermost in my mind when I began to read the book was the question of whether this book would live up to the high standards set by its fellows. It's a thick book, containing more pages than Advanced Programming in the UNIX Environment.

CORBA is a technology for making OO programs insensitive to geographical location; a program can use an object unaware that it's actually implemented in another language on another machine running a different operating system on the other side of the world (alternatively it may be in the same program -- you can change your mind without changing the code). This independence completely removes implementation ties (e.g. of language or design) between objects, and so CORBA is still useful even for programs which are part of a single software system running on the same machine.

The book begins by providing an outline of the way it is organised (chapter 1) and explaining that it covers CORBA 2.3 (currently the latest version), which is described in overview (chapter 2). This is immediately followed by a working CORBA program, or rather a pair; a client and a server. One of the major difficulties for a book like this is that although the CORBA standards provide for compatibility at the source-code level, the way in which you compile programs to use CORBA is vendor-specific.

Despite the fact that the book couldn't offer much guidance in this area, I had my first CORBA program up and working with the ORBit ORB in under five minutes (not including the time taken to type in the code). This was very reassuring, and had the benefit that I could always stop to try something out as I read through the book. Source code is available for download, making it unnecessary to type in all the code yourself (nevertheless the initial example was only 122 lines including the client, server and the interface definition).

The CORBA Interface Definition Language is presented in detail next, followed by a complete description of how this is mapped to a C++ class interface both in the client and in the server. This section of the book takes up 250 pages, because it describes everything in full, and doesn't hold back complexities until later. This makes the book especially valuable for reference, but in hindsight I should have skipped much of this section at the first reading. After all, one of the bonuses of the C++ CORBA binding is that CORBA objects are made to look just like (and in fact actually are) C++ objects.

The enormous level of detail in fact means that I have only managed to get to the half-way point in the book in time for this review. However, this is enough coverage to describe the book's approach, even though I didn't cover the later sections which, predictably, cover the more advanced material.

The necessity to cover a great deal of material leads to what would ordinarily be a lack of example code. However, this is not as great a problem as it may at first appear. Working code for both a client and its server is provided at a very early stage, and it is quite simple to adapt it to try out material presented later on in the book.

As the material becomes more complex, examples become much more frequent, and so for example the coverage of the OMG Trader service has code examples on almost every page. By presenting the material in this way, and by explaining new concepts clearly in chapter introductions, the authors allow the use of the book as a reference even for those readers who have not yet read the book through once. This can be a great advantage for those contemplating buying the book to meet an immediate need to understand some aspect of CORBA.

A table of contents for this book is available on the Addison-Wesley web site (at http://www.awl.com/cseng/titles/0-201-37927-9), along with some sample chapters and the table of contents.

Even at over a thousand pages, the book manages to cover only the C++ mapping for CORBA. I wondered at quite a few points how particular details of the operation of CORBA are treated in the C language mapping. This narrowness of focus could be considered unfortunate, but the material presented in the bulk of the book is still useful even if you must implement in another language. Some parts of Part II are devoted to the C++ language mapping, but the material presented in most of the rest of the book appears to be reasonably useful to people using other languages, even though all the examples are in C++. It would be unfair, of course, to claim that this is a disadvantage; after all, the book is called Advanced CORBA Programming with C++.

If you're not using CORBA, or you're not using C++, then naturally this book will not be for you. Otherwise, however, this book functions well as both a tutorial and a reference. If the book has a disadvantage, it might be that the book is paperback and therefore prone to wear out after extended use.


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

UKUUG Secretariat
PO BOX 37
Buntingford
Herts
SG9 9UQ