Enhanced Software Technologies Ltd.
(Reviewed by Drew Durkin)
The first thing that hits you with BRU is the ease of installation.
Even then, if you can't find your way around the configuration and
setup script, there's also a comprehensive user's guide which covers
pretty much everything in fine detail, even including entries into
your crontab for automation. The software comes shipped on a
diskette, and if you're worried in case you don't have the necessary
file system in your Linux kernel to mount the disk you need not bother.
BRU comes in good old
Everything you'd expect, and what you've possibly relied on
volcopy for, is here. As
well as your standard full or incremental backup, BRU
handles multi-volume archives quite well. You can specify to
backup across several tapes, prompted by the software to
change the media. However of course, if you perform backups
outside of office hours, you can also instruct BRU to switch
to another device without intervention.
BRU also generates some quite informative logs depending on the verbosity that you select, and tries to put explanation to any errors that might have been encountered.
The customisation of BRU is explained clearly in the user manual, which includes the fine tuning of BRU to increase speed performance. The manual also takes you step by step on recovering a complete system and has examples of most commands that are implemented within BRU. For users who would prefer a graphical interface, included with the package is an X11 interface with well laid out options. You also get a separate manual for the X11 interface, explaining the GUI which is already quite user friendly to use.
The area I see which BRU differs from say Amanda, is on a multi-server side. Amanda, another backup tool, emphasizes on being able to backup across a network. Amanda works by running on every server you wish to be backed up, and by sending the data with its own protocols to a central machine containing your tape/backup device. There is nothing wrong of course by using NFS or mounting Windows shares with Samba with BRU.
Overall, BRU has both the user requiring quick and efficient results in mind and the performance demanding one. It's X11 or console interfaces appeals to whatever preference you may have and the ability to span backups across several tapes gives it an advantage over Amanda. With BRU's manual, you also have the ability to be up and running in minutes, or spend your time to finely configure your setup.
Jason Hunter with William Crawford
O'Reilly & Associates, November 1998
528 pages, £21.95
(Reviewed by Richard Moore)
Servlets are the server-side equivalent of applets, they are small executable programs that run in the environment of a web server such as Apache. Servlets are becoming more and more popular as a replacement for the rather primitive CGI interface. Java Servlet Programming aims to be both a introduction and a reference manual for everything to do with servlets, and, as it turns out, pulls it off pretty well.
The book starts with an introduction to the basics of servlets which is well thought out. The examples and text provide enough information to allow you to throw out your CGI scripts, and replace them with servlets. This chapter also provides a few examples that demonstrate the extra facilities that make the servlet environment such an improvement over CGI scripting. The book is extremely thorough and covers all of the major parts of the servlet APIs in some detail; issues such as cookie support, session tracking and authentication are all well covered.
In addition to discussing the servlet API itself, the book also branches out a little to cover the basics of JDBC, the API used by Java to communicate with databses. The JDBC and servlet APIs, while not directly related, are often used together so this is a sensible topic. The discussion of JDBC is well suited to the most common uses of the API in servlets, and while brief, does touch on all of the basics.
The final chapters of the book cover more advanced issues, namely communication between applets and servlets, communication between servlets, and internationalisation. The final chapter of the book is called "Odds and Ends" and contains a few short topics, mainly to do with using other Java APIs such as native methods and RMI from servlets. The book finishes with a number of useful appendices, which include a detailed API reference, and a few useful tables of information.
As the tone of this review may have suggested, I like this book. I have made considerable use of it in my working life, and I have not found anything on the topic that rivals it. The (considerable) set of examples is well chosen and often provides exactly the solution you require. The only criticisms I would make is that some more advanced issues such as the use of servlets in load balancing environments are not covered, and that coverage of Java Server Pages is a little weak. All in all, though, if you are writing servlets then you want this book.
Richard Moore is a software engineer working on server-side web development in Java for Robocast Inc. Servlets form a significant part of his day-to-day life...
Prentice Hall, December 1998
600 pages, £29.99 including CD-ROM
(Reviewed by Crispin Miller)
Java Database Connectivity, or JDBC, is a standard for allowing Java programs to communicate with relational databases such as Oracle, Sybase or PostgreSQL. The book JDBC Developer's Resource is aimed at "an experienced programmer, but [one who is] not necessarily a Java programmer". This means that the first 47 pages consist of primers on the Java language and relational databases.
The last 391 pages of the book are taken up with a JDBC reference which bears a certain similarity to the JDBC API which can be found online at Sun, but is marginally more verbose. To be fair, it is decorated with some additional code fragments, and it also gathers together classes and interfaces from other packages which may possibly be of use to a programmer using JDBC.
Once the first and last sections have been taken into consideration, one is left with a 160 page tutorial on JDBC itself. (In reality, rather less, the book is printed with 3.5cm side margins in a 12-point font with a wide line spacing, reminiscent of a rather thin student project that has been padded out by the cunning use of whitespace). The section starts with an overview of the classes involved in the creation and execution of an SQL statement via JDBC. It begins:
This chapter provides an introduction to the JDBC APIwhich is clearly a good start for a discussion of JDBC programming, aimed at an experienced programmer. It continues:
One of the most common development architectures in use today is the client-server architecture. This is a two-tiered development architecture with the client being the first tier and the database server being the second tier. With the development of the Internet and object oriented remote communication facilities such as Java's RMI, the ability to develop robust three-tier or n-tiered applications is quickly becoming a reality. These issues are discussed in this chapter.Well at least that's clear, then (the terms two-tier, three-tier, and RMI have not been mentioned before this point -- tiers are explained 20 pages further on, RMI: 100 pages later).
The chapter provides a code example showing how to connect to a database and execute a statement using the Java SDK (rather than the JDK, which everybody else uses) before proceeding through a discussion of JDBC security and applets. The applet section is particularly informative: it gives examples of applets one could write, such as "Stock portfolio: A user could use this applet to see the state of their stock portfolio". It is important to stress that none of these applets are developed as examples later in the book, they are just examples of things one might wish to use an applet for. The chapter continues in a similar style, accompanied by low resolution diagrams and poorly formatted code fragments printed in an eye-catching black on a dark grey background. In Chapter 4 we finally reach the promised land: the JDBC tutorial. This contains "A simple JDBC application", which promises to show us how to create a Connection object, a Statement object and to deal with the results of the Statement in a ResultsSet object. Clearly the author has realised by this point that the explanation of the same set of classes in Chapter 3 might have been a little bit clearer. However, before we get to that, we must first learn about transactions, applets, CGI applications and Metadata. Apparently, "CGI applications are primarily written in C and C++", (nope, no mention of PERL anywhere), and "Java provides an attractive alternative to these languages". The chapter even gives an example of a CGI application written in Java. Maybe he should tell Sun about this idea; perhaps he could develop them into a robust API and give them a name (Servlets or something catchy like that, perhaps). There is little more to be said.
Crispin Miller has given up smoking very recently.
O'Reilly & Associates Inc.
(Reviewed by Tony Dixon)
The first thing you will notice about Michael Barr's book is that it is rather thin, weighing in at 174 pages. But don't let its catwalk model like stature put you off. In its 10 chapters you will find a wealth of information and tips for developing C and C++ programs for embedded systems. Books on embedded systems development are few and far between, yet embedded systems have a very important role in the fabric of modern society and the modern world would probably grind to a halt if they were to disappear. Dozens of embedded systems are to be found in the average home, business and vehicle, all going about their work unseen. If you stop and count how many TV's, VCR's, washing machines, dish washers, telephones, fax's, alarms, central heating controllers [and the list goes on] you have in your house you will start to appreciate how many of them there are.
As already said, there are few books on embedded systems development and I think the reason for this is the vast number of different microprocessors and microcontrollers used in the designs of embedded systems. These systems can have CPU architectures ranging from 4 to 32-bit wide, with memory constraints from two-dozen bytes of RAM and 512-bytes of program ROM to several megabytes of RAM and program ROM. The average embedded system has an 8-bit CPU/microcontroller, less than 1K-byte RAM and less than 32K-bytes of ROM of memory. Anybody who writes about such systems would either need a scatter gun approach to be able to discuss the width and breadth of embedded systems development, or would have to target a single microprocessor/microcontroller family, if they are to be successful in getting their message across. The first book would probable result in a text with insufficient detail to be of use to the practising engineer. While the second book would have too much specific microprocessor detail for it to be of much use on any project that doesn't use the processor the book is targeted for.
Michael Barr has elected to discuss the various program principles required for embedded systems development and has backed up his discussion by providing C/C+ programming examples for a middle-of-the-road 16-bit embedded system target. The target embedded system is a commercial product provided by Arcom and is typical of most single board computers (SBC). Targeting a commercial product means the author doesn't have to provide design details for an example system or aim his discussion to a theoretical design. However, it does mean a reader, especially somebody new to embedded systems, might feel they need to purchase the example system to get the most from the book. However, I feel Barr's programming examples are sufficiently detailed and legible for most developers to have little difficulty in porting the examples across their own target system.
The book has a number of good common sense tips and useful pieces of advice for first time developers (and for older developers whose memory may not be as good as it once was). The book also covers useful topics such as the addressing of memory mapped input/output devices, but the books appeal is diminish by author only discussing memory mapped I/O in Intel memory segment format. I think a discussion on non-segmented I/O memory addressing should have been included for completeness, after all Intel processors do not enjoy the same market share in embedded systems as they do in the PC market.
Engineers like myself will always raise an eyebrow when reading any book on embedded systems programming that doesn't discuss hardware. However, on the whole, the lack of any detailed hardware discussion doesn't make the book any less useful. It is in keeping with the books main objective of discussing embedded system software development and not hardware development. Although more programming detail on the various peripheral chips should have been included, especially for serial communications example.
The book has a good introduction to CRC (i.e. without the maths) and has source code examples the reader can take straight off the page and include in their design. However, the generating of a RAM table is not a good idea for embedded systems with limited RAM resource, although the author does mention towards the end of the section that the table can be copied into an array for storage in ROM.
The book also provides a good introduction to a simple Real-Time Operating System (RTOS) example designed by the book's author. However, the section is let down by Barr discussing various RTOS functions and then requiring the reader to go on-line to refer to the actual code implementation. I think the text should have been backed-up by more actual code examples or at least an appendix for the source code to reside, if the author didn't want the flow of his text interrupted by large sections of program listings. This is true not only for the RTOS implementation details, but also for the source code examples on how to use the RTOS services. For example, on one of the few occasions RTOS implementation detail is shown as source code, mutexes are discussed and code for their implementation shown, but no code is given on their actual use. I think it is a cop-out to tell the reader to get on-line to view examples. In a couple of year's time, Web-rot could well see the examples disappearing, just when the reader remembers that the code discussed would solve their current problem.
At one point in the book, GNU tools are discussed but then the discussion stops and the entire software development is done using commercial Borland C/C++ tools and tools provided by the SBC supplier Arcom. I think further discussion of GNU tools would have made the book even better value for money, perhaps as an appendix and targeted for a different target embedded system (as GNU are designed for 32-bit microprocessors and the example SBC used in the book is 16-bit).
Overall, I think the book could have done with one more edit (to tidy up layout and consistency etc.) before coming to publication, but on the whole, this is a good book. It's a good introduction to embedded systems development for the newcomer or student, and a good reference for the experienced developer. Personally, I especially liked the sections and examples on memory checking. Finally, I think if a second edition addresses some of the points I've discussed and perhaps adds a section on hardware, Michael Barr could have a book that would find itself on every embedded developers bookshelf.
Common sense, useful for first time developers (and older developers whose memory might not be as good as it once was).
#define FLASH_BASEon p. 81, not defined anywhere unless it is in the header file
unsigned int', while code c-code example shows it as an '
pRxQueueon p. 134, but again no code is shown to define their implementation - in
O'Reilly & Associates,October, 1999
268 pages, £12.95
(Reviewed by Andrew Cormack)
Reading The Cathedral and the Bazaar the day Microsoft was judged to have stifled innovation seemed especially apt. Most people now have a good idea how big business produces software: Eric Raymond puts forward an alternative approach. Open source software is not a new idea - the book is based on twenty years of personal experience - but it has only recently become familiar outside a small community of enthusiastic users and developers. Others may be puzzled by several paradoxes. How can an anarchic group of programmers produce an operating system as complex and well-engineered as Linux or a web server like Apache? What inspires these programmers to spend their time on something with no tangible reward? How can anyone base a business on giving away software?
As an active participant in the open source world Eric Raymond, too, was intrigued by these questions. His answers draw on philosophy, anthropology, engineering and economics. Even by O'Reilly standards this book has a very wide-ranging bibliography including Locke, game theory and Welsh myth as well as more traditional engineering and management texts. The surprising conclusion is not just that the open source method can be effective in some cases - Apache and Linux have already clearly demonstrated that - but that in a mature software industry, open source may actually be superior to the traditional model. As a self-proclaimed evangelist for open source, Raymond would be expected to reach a positive conclusion, but the strength of his argument suggests that it should be at least considered by anyone involved in developing or using mass-market software.
The open source method is stable. Contrary to expectations, and despite the written encouragement of the GNU Public License, open source projects rarely fragment into a multitude of different versions. Most open source communities seem naturally to concentrate on improving their software by evolution rather than adding innumerable new features as often happens with closed developments. The logical result of the traditional pricing model is to produce software that is marketable but not usable: with buyers but no users the vendor gains income from the sales without the need to provide expensive help desks! By contrast, open source development concentrates effort on the most expensive parts of the software life-cycle - support and debugging - which are also those where many people working in parallel can be most effective. With sufficient minds working on a problem, any bug will be "obvious" to someone. For any company developing software for its own use, the argument for "recruiting" open source debuggers to help with this phase is compelling. Open source projects have attracted many of the world's best software engineers. Managers who encourage their teams to emulate their programming style should perhaps try to provide the same productive environment.
The original 1997 version of the title paper was seen by many as the manifesto of the open source movement. This volume collects updated versions of that paper and four others into, perhaps, the first volume of the memoirs of the movement. The content is, of course, freely available on-line but the printed version is much more convenient and enjoyable to read. The production team at O'Reilly & Associates has done its usual excellent job, though the result will be almost unrecognisable to their regular audience. This book, in hardback and with a copyright image on the cover, is aimed at those interested in the work of the open source developers: the developers themselves, as noted in the book, are much too self-effacing to want to read their own story.
Andrew Cormack is currently trying to apply open source methods to security documentation.
O'Reilly & Associates, Inc.
(Reviewed by Adrian Wontroba)
Under Windows 98 with IE4, the CD auto-runs.
Under UNIX it is necessary to explicitly start the search engine,
and close it down after use.
There is a small installation step which copies
/tmp (by default) which you may have to repeat.
I chose to use the JDK I have installed,
rather than use the FreeBSD JRE on the CD,
with Netscape Communicator 4.61 and Lynx Version 2.8.1rel.1.
I've not tried any other platforms.
The top page of each book provides access to the search engine and index for the book, and a table of contents linking to each chapter and appendix.
Each chapter starts with links to each of its sections.
Every page is headed with the title (which links to the top page), a link to the search engine, and previous and next links. Footers contain links to the previous and next pages, the book index, the library home, and the other books in the library. In-text links are usually references to figures or other sections. In general, each page corresponds to a section.
This, along with the indices, gives an effective way of finding particular topics.
For those of you reading the web version of this review, the titles below are links to the catalogue entries for the books on O'Reilly's web site (www.oreilly.com). If you drill down a bit you'll find other reviews and, in some cases, sample chapters. In passing, aside from containing a vast amount of information about their products, O'Reilly's site also contains some entire books. Browsing about, I've so far found two entire books and a work in progress.
O'Reilly & Associates, Inc.
(Reviewed by Chris Ritson)
This review is a theoretical one, as we are only just about to order the servers from which we hope to co-ordinate our department's NT installation policy. Anyone starting to use these techniques to manage a windows cluster would be well advised to procure a test cluster containing a dedicated server and one or two clients. The utility of this book would be enhanced if it were possible to make available (either bundled or separately for a nominal fee) a time-locked evaluation copy of Windows NT Server, the Zero Administration Kit and any other scripts that may be necessary. I believe this has been done for some of the MSCE training products.
A considerable amount of effort would need to be expended to learn these administration techniques - it may not be worth it for a cluster where all the stations are absolutely identical, including all locally defined user accounts. This has been the case for us until recently, so we have been able to work quite well with the use of a test installation and third party disk cloning software. We are at the point of deploying NT workstations in staff offices, many of whom will have differing requirements. If we don't use some sort of zero administration technique we will face an administration task that grows in proportion to the square of the number of installed workstations.
On a more practical note, Chapter 6 only discusses in detail, Microsoft
applications which are, I hope, designed to fit in with the zero
administration method. It would be most helpful to find some examples of
applications that cannot easily be installed in this way. If it is felt
necessary, the name(s) involved should be changed to avoid accusations of
libel! One instance I have tried to deal with involved 280 registry
HKEY_CURRENT_USER, many of which
were only set up during the
reboot after installation, and some of which were delayed until first run.
In an environment where this registry key is reset to a known state at login
time, this package has so far proved impossible to install. With another
package, I contacted the manufacturer, and was told that it was normal for
all users to need access to the installation media to set up the
There are a number of URLs scattered throughout the book. It would be helpful to collect these together, and/or to provide some additional material at the O'Reilly web site to support this book. Maybe you could even have a mirror of recommended public domain tools and trial versions of commercial tools.
O'Reilly & Associates, Inc.
(Reviewed by Mick Farmer)
Here's a first for the UKUUG newsletter - a review of a comic strip, or rather a compilation of the strips drawn by one J. D. Frazer. It says on the back cover that he's a fan of both science fiction and technology and this shows in his comic strips, as does his participation (obsession?) with computer games. Quake features frequently in his strips, as does Minesweeper.
The characters in User Friendly work at a fictitious ISP called Columbia Internet and much of the humour revolves around the staff manning the help desk, as shown in this strip from July 1998.
Occasional product placements pop up here and there and you get the impression that the author is an open source/UNIX advocate. He certainly doesn't like Microsoft or Bill Gates nor, apparently, their products. Consider this strip from May 1998.
These comic strips also feature something called the Dust Puppy, which the author first drew in the late 70s/early 80s. These early strips were rejected for syndication and shelved until reappearing in User Friendly. All the characters display realistic attributes which helps the jokes and humour.
I recommend this book to anyone who likes computer-related humour, especially nerds and anoraks. This final comic strip is for you Linux afficionados.
Mick is currently cultivating a Beowulf CPU farm.
Tel: 01763 273 475
Fax: 01763 273 255
Queries: Ask Here
|Join UKUUG Today!||
PO BOX 37