Slashdot Mirror

Slashdot reader (and now reviewer) Mark Pruett sent us a book that has pretty critical importance, Linux Application Development . If we are really to win the world over, we must have more and more applications. That, and write them well. If you want to do that, read below. Linux Application Development author Michael K. Johnson and Eric W. Troan pages publisher Addison-Wesley rating 9/10 reviewer Mark Pruett ISBN 0-201-30821-5 summary

A clear, concise, practical book for C programmers trying to grasp the nuances of the Linux operating system.

Linux Application Development is one of the few 500+ page computer books published today that deserves its length. It was written by Michael K. Johnson and Eric W. Troan, two names that some SlashDot readers may recognize. These guys are developers for Red Hat Software.

This book fills the need for a concise, clear, no-nonsense book on how to write C programs that run well in the Linux environment. It is short on history and devoid of political diatribe.

Who Needs This Book?

This book is aimed at experienced programmers. It most definitely won't teach you how to program. But programmers moving from another operating system (other Unix variants or any Microsoft platform) will get a big boost up the learning curve.

Having come to Linux almost four years ago after a decade or so as a DOS/Windows programmer, I know this book can be invaluable. Linux (and Unix in general) is a different mindset than Microsoft Windows, and while this book spends no time directly comparing the two operating systems, it does provide the map a Windows programmer needs to make the transition.

The book is broken into four sections. Getting Started provides a brief history of Linux, an overview of the different free software licenses, an explanation of Linux documentation, and pointers to Linux information on the internet.

The second section covers Development Tools and Environment. Make no mistake: this is a book for C programmers. There's information here on the GNU gcc compiler, on vi and Emacs, on Make, on the GNU Debugger, and on memory debugging tools like Checker and Electric Fence. A highlight of this section is the chapter Creating and Using Libraries; this contains information especially useful to programmers new to the Linux OS.

Most of the information in this second section is not in-depth. Rather, it lets you know these tools exist. You'll need to find other references in order to master them.

Systems Programming in Linux

The third section, System Programming, provides the real meat of the book. It features chapters on the Process Model, Simple and Advanced File Handling, Directory Operations, Signal Processing, Job Control, Sockets, and a lot more.

You can tell these guys write code for a living. Their example programs are practical, and serve as good illustrations the topic they're covering. Their explanations are clear and precise; they don't waste your time.

For example, here's their explanation of the getservbyname() function:

Linux systems include the file /etc/services, which maps protocols to port numbers. The most common way to access this file is through the getservbyname() function, which returns information on a particular service.

#include <netdb.h>

struct servent * getservbyname(const char * name,
const char * protocol);

The first parameter, name, is the service name about which the application needs information. The protocol parameter specifies the protocol that will be used. The services database contains information on other protocols (especially UDP); specifying the protocol allows the function to ignore information on other protocols. The protocol is usually the string "tcp", though other protocol names, such as "udp", may be used.

I read arguments in the discussion that followed Arjen Laarhoven's review of Stevens' Advanced Programming in the Unix environment to the effect that the unix man pages are all that a programmer might want or need. I'll leave it as an exercise for the reader to compare the passage above with "man getservbyname". The latter tells you the how, the former tells you the why and the what.

This third section alone is, in my opinion, worth the price of the book.

The final section of the book covers Development Libraries. This section covers a collection of useful libraries, covering topics such as string matching with regular expressions, parsing command line options, and the db database library.

What They Left Out

The authors left out virtually any talk of graphics or X programming. In some ways, this is a good thing, and may extend the shelf-life of the book. The world of X windows and Linux is a bit fractured at the moment, with competing libraries jockeying for position. The authors could have avoided this by discussing X at a lower level (Xlib and the X Intrinsics), but there are other books that do this well enough. [A very good book for programmers interested in learning X is The X Toolkit Cookbook by Paul Kimball, ISBN 0-13-973132-6.]

The authors didn't discuss other languages popular in the Linux environment, such as Perl and Python. Again, I think this would have diluted the book. As it is, Johnson and Troan maintain a sharp focus on what's important to C programmers using Linux.

Compares Favorably

In style and in utility, this book reminds me of Richard Stevens' Unix books, particularly his great Advanced Programming in the Unix Environment (they even share the same publisher). There is some overlap between material in the Stevens' books and material in Linux Application Development. My inclination would be to read the section in LAD first, and then, if the subject was still unclear, look to the Stevens' books for more depth.

If you're a Linux developer, or if you're a C programmer thinking of diving into Linux, I can recommend this book without reservation.

Mark Pruett

To get this book, check out this spot brought by Amazon.

Slashdot reader (and now reviewer) Mark Pruett sent us a book that has pretty critical importance, Linux Application Development . If we are really to win the world over, we must have more and more applications. That, and write them well. If you want to do that, read below. Linux Application Development author Michael K. Johnson and Eric W. Troan pages publisher Addison-Wesley rating 9/10 reviewer Mark Pruett ISBN 0-201-30821-5 summary

A clear, concise, practical book for C programmers trying to grasp the nuances of the Linux operating system.

Linux Application Development is one of the few 500+ page computer books published today that deserves its length. It was written by Michael K. Johnson and Eric W. Troan, two names that some SlashDot readers may recognize. These guys are developers for Red Hat Software.

This book fills the need for a concise, clear, no-nonsense book on how to write C programs that run well in the Linux environment. It is short on history and devoid of political diatribe.

Who Needs This Book?

This book is aimed at experienced programmers. It most definitely won't teach you how to program. But programmers moving from another operating system (other Unix variants or any Microsoft platform) will get a big boost up the learning curve.

Having come to Linux almost four years ago after a decade or so as a DOS/Windows programmer, I know this book can be invaluable. Linux (and Unix in general) is a different mindset than Microsoft Windows, and while this book spends no time directly comparing the two operating systems, it does provide the map a Windows programmer needs to make the transition.

The book is broken into four sections. Getting Started provides a brief history of Linux, an overview of the different free software licenses, an explanation of Linux documentation, and pointers to Linux information on the internet.

The second section covers Development Tools and Environment. Make no mistake: this is a book for C programmers. There's information here on the GNU gcc compiler, on vi and Emacs, on Make, on the GNU Debugger, and on memory debugging tools like Checker and Electric Fence. A highlight of this section is the chapter Creating and Using Libraries; this contains information especially useful to programmers new to the Linux OS.

Most of the information in this second section is not in-depth. Rather, it lets you know these tools exist. You'll need to find other references in order to master them.

Systems Programming in Linux

The third section, System Programming, provides the real meat of the book. It features chapters on the Process Model, Simple and Advanced File Handling, Directory Operations, Signal Processing, Job Control, Sockets, and a lot more.

You can tell these guys write code for a living. Their example programs are practical, and serve as good illustrations the topic they're covering. Their explanations are clear and precise; they don't waste your time.

For example, here's their explanation of the getservbyname() function:

Linux systems include the file /etc/services, which maps protocols to port numbers. The most common way to access this file is through the getservbyname() function, which returns information on a particular service.

#include <netdb.h>

struct servent * getservbyname(const char * name,
const char * protocol);

The first parameter, name, is the service name about which the application needs information. The protocol parameter specifies the protocol that will be used. The services database contains information on other protocols (especially UDP); specifying the protocol allows the function to ignore information on other protocols. The protocol is usually the string "tcp", though other protocol names, such as "udp", may be used.

I read arguments in the discussion that followed Arjen Laarhoven's review of Stevens' Advanced Programming in the Unix environment to the effect that the unix man pages are all that a programmer might want or need. I'll leave it as an exercise for the reader to compare the passage above with "man getservbyname". The latter tells you the how, the former tells you the why and the what.

This third section alone is, in my opinion, worth the price of the book.

The final section of the book covers Development Libraries. This section covers a collection of useful libraries, covering topics such as string matching with regular expressions, parsing command line options, and the db database library.

What They Left Out

The authors left out virtually any talk of graphics or X programming. In some ways, this is a good thing, and may extend the shelf-life of the book. The world of X windows and Linux is a bit fractured at the moment, with competing libraries jockeying for position. The authors could have avoided this by discussing X at a lower level (Xlib and the X Intrinsics), but there are other books that do this well enough. [A very good book for programmers interested in learning X is The X Toolkit Cookbook by Paul Kimball, ISBN 0-13-973132-6.]

The authors didn't discuss other languages popular in the Linux environment, such as Perl and Python. Again, I think this would have diluted the book. As it is, Johnson and Troan maintain a sharp focus on what's important to C programmers using Linux.

Compares Favorably

In style and in utility, this book reminds me of Richard Stevens' Unix books, particularly his great Advanced Programming in the Unix Environment (they even share the same publisher). There is some overlap between material in the Stevens' books and material in Linux Application Development. My inclination would be to read the section in LAD first, and then, if the subject was still unclear, look to the Stevens' books for more depth.

If you're a Linux developer, or if you're a C programmer thinking of diving into Linux, I can recommend this book without reservation.

Mark Pruett

To get this book, check out this spot brought by Amazon.

In a truimphant sophmore return, Jason Bennett has sent us in a review of Software Project Survival Guide. Part of ongoing series of books reviwed by Jason, the goal is to walk through a number of valuable software engineering books. For the full scoop, check below. Software Project Survival Guide author Steve McConnell pages publisher Microsoft Press rating 9/10 reviewer Jason Bennett ISBN 1-57231-621-7 summary

Steve gives a good once-over of the software development process, and backs it up with good examples and on-line documentation.

Background

This being the second review in my series of software engineering books (process and management being key components of said concept), I thought it would be good to give an overview of where we are, and where we're going. Last week, we looked at Frederick Brooks' Mythical Man-Month , the seminal classic of software management. This week, we'll be looking at the latest book by a new classic author, Steve McConnell. Now, I might as well say right upfront that Steve is a Microsoftie (at least part-time). You can take that as praise or criticism, but it's truth nonetheless. Fortunately, Steve is above idol worship, and thus his books are quite palatable, even if you have to support the Evil Empire in the process. No matter who he consults for, however, Steve knows what he's talking about. In the end, that's what matters. We'll be staying in Steve country for this week and next (his Code Complete is next), after which we'll move on. For now, however, enjoy this review/summary of Software Project Survival Guide.

What's the book about?

To a large extent, this book is the culmination of many years of writing on Steve's part. His previous books are Code Complete, which focuses on the details of writing code well, and Rapid Development, which focuses on the software lifecycle, with some management thrown in for good measure. Now, with Software Project Survival Guide, Steve has written a quick-pass tutorial on how to deal with getting a program out the door. One major focus of this book is on process, that is following the steps of development closely to catch problems as early as possible. Echoing a sentiment expressed by Brooks, Steve points out that the earlier a problem is caught, the cheaper it is to fix. It's dang easier to erase a line on a whiteboard than to rip out multiple modules/objects full of code and correct them (a lesson which my project at work is currently learning).

The book is divided into four major parts:

1. The Survival Mind-Set
2. Survival Preparations
3. Succeeding by Stages
4. Mission Accomplished

The first part addresses the underlying concepts of the book (process, finding problems early, what a successful project looks like, etc), giving the reader an understanding of what it means to properly take a project through the valley of the shadow of failure. Steve also first mentions the concept of "staged delivery" in this part, something he will harp on throughout the book. Basically, staged delivery is how most open-source projects run: having multiple release dates with integral increases in functionality. For vertical or internal applications, however, this is a rarity. When software is driven to a releasable stage multiple times, it establishes the exact state of the software, allowing for better schedule estimation and allows the user to obtain a minimal, but possibly critically functional, piece of software early. Staged delivery differs from multiple versions released over time in that the final staged delivery fulfills one set of requirements stated at the beginning, while multiple versions will each have a unique set of requirements (which will typically bloat for every further release).

Part II addresses the initial, planning phases of a project, before actual detailed work is done. This includes oversight boards (of varying size, just as long as someone is reviewing the decisions), effective configuration management, risk analysis, and scheduling. Requirements are also done at this point, an architecture crafted, and QA/QC brought on board. At this point, everyone who will be involved should know what is going on, and all planning and infrastructure should be in place. Unfortunately, this stage has a tendency to drag on, as people waffle over who will do what, and what exactly will be done. My project in particular experienced some serious delays in this area, as the customers were incapable or unwilling to tell us what they needed, and when they needed it, beyond "everything, in a month." We finally got past this point, but not without wasting way too much time.

Part III digs into the meat of the process -- keeping on track while the software is being written. Brooks addresses this part of the process in MMM with his famous quote, "More programming projects have gone awry for lack of calendar time than for all other causes combined." The man speaks truth. Steve takes the project through stage planning, detailed design, construction, testing and release. These steps will then be repeated for each stage of the project, until all stages are completed. As discussed earlier, this will allow maximum delivery in a minimum time, especially of critical features. Steve also emphasizes "miniature milestones" to better gauge where the project is. There's a true saying that "90% of the project is done 90% of the time." Of course, what that really means is that no one really ever knows how much of the project is completed. However, setting small, concrete milestones all along the timeline will allow an excellent gauge of where the project is. "How does a project get to be a year late? One day at a time. (Brooks)"

Part IV discusses the project aftermath, especially learning from the project. This is a short part, and mainly emphasizes archiving all documentation and reviewing what went right and what went wrong. Steve also offers a nice list of project management resources, including other books and web sites.

What's Good?

Steve McConnell is a proven author, and as such does not disappoint. The chapters are clear and concise, with excellent checklists at the end of each. He also has an entire website devoted to supporting the book. He steps through the process methodically, making sure all parts are covered. For those of you interested in the SEI's CMM practices, Steve has drawn heavily from them for this book. My understanding is that Steve is not wedded to the model itself, although he certainly sees it as an excellent step forward. In fact, following the recommendations of this book will definitely bring a project closer to level 2 compliance.

What's Bad?

Well, if I thought the book wasn't useful, I wouldn't have reviewed it. :-) Anyway, the book does not have any glaring flaws. I think Steve tends to emphasize organizations that need five member change boards over those where the board is likely to be the manager (which is probably most organizations). If, however, you can adapt his ideas to your situation, you and your project will benefit.

What's In It For Us?

Once again, where does Open Source come into this? I'm going to end up repeating myself somewhat from last week, but I am firmly convinced that open source projects need more process and structure. The software community has managed to survive for forty years with little process, and open source has done the same for twenty. Now, however, that chapter must end. We need increased productivity and better organization to be truly effective. We need written requirements to keep the projects on track and stop the waste of time and effort that non-required code brings. We need solid design (and detailed design) to keep everyone on the same page. We already do staged delivery (to some extent), but we need to pre-document when and how this will happen, instead of putting out a release when we feel like it. Too many projects wander off into oblivion because of gold plating or lack of vision and purpose. The better we can focus our passions and efforts, the closer to victory we will come.

Purchase the book over at Amazon.

• Table of Contents

• Acknowledgements
• Preliminary Survival Briefing

1. The Survival Mind-Set
   1. Welcome to Software Project Survival Training
   2. Software Project Survival Test
   3. Survival Concepts
   4. Survival Skills
   5. The Successful Project at a Glance
2. Survival Preparations
   1. Hitting a Moving Target
   2. Preliminary Planning
   3. Requirements Development
   4. Quality Assurance
   5. Architecture
   6. Final Preparations
3. Succeeding by Stages
   1. Beginning-of-Stage Planning
   2. Detailed Design
   3. Construction
   4. System Testing
   5. Software Release
   6. End-of-Stage Wrap-Up
4. Mission Accomplished
   1. Project History
   2. Survival Crib Notes

• Epilogue
• Notes
• Glossary
• Index

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

A review of the venerable The Mythical Man-Month was sent our way by Jason Bennett. While this book has some years on it, the fact that it is still around is a testament to the strength of the text. This latest addition contains additional essays and thoughts about engineering. So, click below and enter into the wonderful world of software engineering. The Mythical Man Month: Essays on Software Engineering - Anniversary Edition author Frederick P. Brooks, Jr. pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Jason Bennett ISBN 0-201-83595-9 summary

As a classic software engineering text, this book is only helped by the addition of Brooks' latest essays and reflections on his original conclusions. Remember, it won't do you any good unless you read it.

Background

Before I lauch into my review of The Mythical Man Month, I would be negligent if I did not explain the meaning of the first edition of this book. It's 1975. Programmers slave over some of the earliest dumb terminals on massive mainframes from the Great Monopolistic Satan of computing, IBM. Maybe, if their lucky, the programmers can work on a minicomputer from that upstart company, DEC, and their PDP series of computers. FORTRAN and COBOL are your staples, with some PL/I thrown in for good measure. C is a blip on the horizon, just starting to make its way out of Bell Labs. Assembly language is still widely used throughout the industry. Enter Frederick Brooks, one of the industry's originals. Brooks is reflecting on his time at IBM, specifically his working on the System/360 and its operating system, OS/360 (unique names, no?) during the mid-1960's. Brooks is trying to figure out what was done right, and what was not, especially in how the overall progam was structured and managed. He thus sets out to write one of the first treatises on software project management, an indispensible part of software engineering. Twenty-five years later, we are still reading the book and learning from it. In an industry where most books are useless after six months, this book is almost prehistoric. Remember, though, what level a book must reach to last so long.

What's Good?

You might be wondering why this book has lasted so long. The answer is simple: the technology of the book is secondary to the people lessons. Simply put, Brooks' points are the following:

1. Programming must turn into software engineering in order to continue to improve the state of the art.
2. Any well-engineered product must be conceptually and architectually whole.
3. The tar pit of software development can only be escaped through a conscientious, dedicated process.

There are so many classic lines in this book that a simple review cannot account for them all. The most famous, of course, is Brooks' Law of adding people to a late project (hint: it doesn't help). Surgical development teams, the second-system effect, and the importance of documentation are all covered, sometimes for the first time, in MMM. Through the course of the book, Brooks covers all fascets of what must happen to successfully complete a major software project, and in all parts he gives a firm foundation for solid software engineering and project management. In fact, this was the first major book to accurately assemble the knowledge needed to engineer a large software project into one place, and relate it from the perspective of a finished project.

In addition to the original chapters, Brooks' essay from 1986, No Silver Bullet, is included, along with Brooks' thoughts on his book twenty-five years later. These essays alone are worth reading, as they give an accurate estimate of where the industry is now. Suffice to say, the easy part is behind us. It's real work from here on in.

What's Bad?

What's bad about this book is that people don't read it. There's no particularly good reason, they just are too busy reading the latest book on today's fad. The irony, of course, is that today's fad will be laughed at next year, while MMM will still be around a decade from now. If you were assigned this book in school, read it again (you probably didn't the first time :-). If you've never heard of it, read it tomorrow.

What's In It For Us?

Why should any of us read this book? What does project management matter to a bunch of semi-organized groups? Aren't we doing fine as it is in our striving for World Domination? Well, yes and no.

On one hand, we don't have the pressures of commercial software. If Apache comes out tomorrow instead of today, no matter. Everyone else is just as bad, so we just have to not be worse. For that matter, most open-source projects are blessed with one or a few leaders who keep everything on track and in one vision. We don't have too many projects with lots of different architects.

On the other hand, we've been blessed with low expectations. No one expected us to succeed, so any measure of success was a victory for the movement. Now, all eyes are on us. If a release comes out a month late, everyone will think we're no better at keeping a schedule than Microsoft. If we have to rewrite another application because we did a poor design job, we aren't offering a valid alternative. We have to be better than everyone else to prove ourselves, and we cannot do that in an individually-oriented environment. If the open-source community can learn the lessons of MMM better than the rest of the industry, than we win.

More to the point, we as an industry must raise our expectations of our software. We need to strive for accurate schedules. We need to avoid the second-system effect. We need to understand why you cannot just add people to a late project to speed it up. In short, we need to care about producing quality software on time, instead of just getting stuff out there.

More to Come

This is the first in what I hope will be a series of reviews of software engineering book. My current company is trying to move to CMM level 2, and as part of that our Process Group is reading a series of books. Some of them are business or interpersonal oriented, but some others (like MMM) are software related. Hopefully, I'll kick out a review a week.

The net effect of this, I hope, is to get the open-source community interested in producing a complete, quality product instead of just neat functionality. In order for a program and project to last in the spotlight, it must have solid underpinnings. Only through applying the principles of software engineering can open-source projects fully achieve greatness.

Purchase the book over here at Amazon.

• Table of Contents

• Preface to the 20th Anniversary Edition
• Preface to the First Edition
  1. The Tar Pit
  2. The Mythical Man-Month
  3. The Surgical Team
  4. Aristocracy, Democracy, and System Design
  5. The Second-System Effect
  6. Passing the Word
  7. Why Did the Tower of Babel Fail?
  8. Calling the Shot
  9. Ten Pounds in a Five-Pound Sack
  10. The Documentary Hypothesis
  11. Plan to Throw One Away
  12. Sharp Tools
  13. The Whole and the Parts
  14. Hatching a Cataastrophe
  15. The Other Face
  16. No Silver Bullet - Essence and Accident
  17. "No Silver Bullet" Refired
  18. Propositions of The Mythical Man-Month: True of False?
  19. The Mythical Man-Month after 20 Years
• Epilogue
• Notes and References
• Index

John "Kate" Looney has sent us a review of Tad Williams' new book Otherland. For those of you familiar with Williams, you can attest to his storytelling abilites. The first book in his new series, Otherland shows off his writing abilites. This new series blends in elements of Williams' view of future technology as well as interesting characters. If you want to laze away August with some reading, read the review below. Review of "Otherland"

Author: Tad Williams
Reviewed by: John Looney

I loved Tad Williams previous saga "Sorrow, Misery and Thorn", so when I saw this in a bookshop, I thought why not. I was very pleasantly surprised.

On the cover is a very pretty picture of a city. Another light hearted fantasy book I thought. Boy was I surprised. It starts off quite confusingly - an English World War I soldier in the trenches, feeling miserable. Ah. It's going to be one of those "He dies and goes to a dream world, with fairies, and leprachauns, and eskimos".

Surprise again. He ends up in a scary version of Jack in the Beanstalk.

Straight off, I knew this was going to be a unique book. Over the next few chapters, it introduced the main characters. A confused man with bad memories, travelling through wierd places, from the Somme to Mars. A Kalahari Bushman who comes to Durban. A Conan-type warrior called Thargor, who kicks ass. A South African woman that's a researcher in VR (suddenly you cop on that this could be set in the future). And, an old man, who can't leave his house because years ago, he was scalded badly by a Jet's exhaust, and has to stay inside, in a 100% humidity house.

The first few chapters of the book try and explain this muddle. Thargor is really a 14 year old that players VR muds all day. The Bushman is attending VR classes in a university near Durban. The South African has a younger brother that thinks he's an 3l33t cracker, and likes to dice with danger in VR worlds, and she finds herself taken back to her old [cr|h]acker days. And the confused man ? The key to everything.

There is a massive conspiracy (isn't their always) to be investigated. Everyone of the main characters have an axe to grind. In Thargors case, it's a big axe. The only clue they have is that all of them have seen a single gimpse of a city, that's in something called "Otherland".

It turns out that the the main characters are all heavily involved in the internet, or what Tad Williams thinks it could turn out like. This vision is not a William Gibson style "The internet would be like this because it would make a good book", but because it makes sense. So many times I've thought. 'Cool. I want that sort of technology now'. Tad Williams drops so many references to hacker and net lore that you know this man has pissed away months of his life, just like me, playing mud, searching for files, looking at newsgroups, talking on IRC. All the software the characters use are evolutionary improvments on what we have now - and some new stuff. Some really cool new stuff.

Everything from the conceited attitude of people on IRC, to a home for the alpha-hackers that worked on the software, that this VR-internet is based on described. The book seems to be quite slow in starting - like all Tad Williams stuff - it's another epic, but I loved it. The slow start lets you go "Oooh...nice idea" again and again. It's the story I've ever come across that didn't seem dumbed down, over hyped or inaccurate, like things like "The Net" and "Neuromancer" were.

I didn't realise that the book was a "First part of a series", until about 20 pages from the end, where I started to panic, wondering how all the loose ends would be tied up. I was left feeling a need for closure, and a need to get the next book. Very highly recommended for those that don't mind mixing realistic science fiction and a bit of fantasy...

Kate

Buy this book at Amazon.

John "Kate" Looney has sent us a review of Tad Williams' new book Otherland. For those of you familiar with Williams, you can attest to his storytelling abilites. The first book in his new series, Otherland shows off his writing abilites. This new series blends in elements of Williams' view of future technology as well as interesting characters. If you want to laze away August with some reading, read the review below. Review of "Otherland"

Author: Tad Williams
Reviewed by: John Looney

I loved Tad Williams previous saga "Sorrow, Misery and Thorn", so when I saw this in a bookshop, I thought why not. I was very pleasantly surprised.

On the cover is a very pretty picture of a city. Another light hearted fantasy book I thought. Boy was I surprised. It starts off quite confusingly - an English World War I soldier in the trenches, feeling miserable. Ah. It's going to be one of those "He dies and goes to a dream world, with fairies, and leprachauns, and eskimos".

Surprise again. He ends up in a scary version of Jack in the Beanstalk.

Straight off, I knew this was going to be a unique book. Over the next few chapters, it introduced the main characters. A confused man with bad memories, travelling through wierd places, from the Somme to Mars. A Kalahari Bushman who comes to Durban. A Conan-type warrior called Thargor, who kicks ass. A South African woman that's a researcher in VR (suddenly you cop on that this could be set in the future). And, an old man, who can't leave his house because years ago, he was scalded badly by a Jet's exhaust, and has to stay inside, in a 100% humidity house.

The first few chapters of the book try and explain this muddle. Thargor is really a 14 year old that players VR muds all day. The Bushman is attending VR classes in a university near Durban. The South African has a younger brother that thinks he's an 3l33t cracker, and likes to dice with danger in VR worlds, and she finds herself taken back to her old [cr|h]acker days. And the confused man ? The key to everything.

There is a massive conspiracy (isn't their always) to be investigated. Everyone of the main characters have an axe to grind. In Thargors case, it's a big axe. The only clue they have is that all of them have seen a single gimpse of a city, that's in something called "Otherland".

It turns out that the the main characters are all heavily involved in the internet, or what Tad Williams thinks it could turn out like. This vision is not a William Gibson style "The internet would be like this because it would make a good book", but because it makes sense. So many times I've thought. 'Cool. I want that sort of technology now'. Tad Williams drops so many references to hacker and net lore that you know this man has pissed away months of his life, just like me, playing mud, searching for files, looking at newsgroups, talking on IRC. All the software the characters use are evolutionary improvments on what we have now - and some new stuff. Some really cool new stuff.

Everything from the conceited attitude of people on IRC, to a home for the alpha-hackers that worked on the software, that this VR-internet is based on described. The book seems to be quite slow in starting - like all Tad Williams stuff - it's another epic, but I loved it. The slow start lets you go "Oooh...nice idea" again and again. It's the story I've ever come across that didn't seem dumbed down, over hyped or inaccurate, like things like "The Net" and "Neuromancer" were.

I didn't realise that the book was a "First part of a series", until about 20 pages from the end, where I started to panic, wondering how all the loose ends would be tied up. I was left feeling a need for closure, and a need to get the next book. Very highly recommended for those that don't mind mixing realistic science fiction and a bit of fantasy...

Kate

Buy this book at Amazon.

Danny Yee, interpid book reviewer and Slashdot reader has sent us a review of Sendmail. So, if you've always been intrigued by this wonderful util, click below. Sendmail

Bryan Costales + Eric Allman
O'Reilly & Associates 1997

AbookreviewbyDannyYee(danny@cs.usyd.edu.au),Copyright©1998

There is no doubt that sendmail is one of the more complex systems a typical Unix system administrator is likely to have to deal with; my first glance at a sendmail.cf file was certainly off-putting. Leaving aside whether this isn't an argument for using a different MTA entirely, it certainly makes sendmail documentation important. The O'Reilly Sendmail book opens with a slow-paced 190 page tutorial, designed to put the faint-hearted at ease. This goes through the construction of a simple cf file, illustrating the workings of rulesets, macros, and workspaces. Next are sections on installation and configuration - compiling sendmail from source, using M4 to create config files, using checkcompat() - and on administration - covering interaction with the DNS, security, the mail queue, aliases, .forward files and mailing lists, and logging.

This is excellent stuff for people like me, seeking a basic understanding of how sendmail works and a guide to simple administration tasks. There may not be much in it for serious gurus, but they will appreciate the second half of Sendmail, which is a detailed reference manual, containing far more than most people will ever want to know (I have only glanced at it myself). This could, perhaps, have been printed as a separate book: not only are some people likely to want just the reference manual or just the tutorial and administration guide, but bundling them together makes for an awkwardly thick volume. (O'Reilly also publish a pocket-sized Sendmail Desktop Reference, which is basically a summary of and index into the reference manual in Sendmail.)

This second edition of Sendmail covers version 8.8, but most of it (and certainly the tutorial sections) won't date that rapidly. If you actually administer sendmail then it is an obvious O'Reilly title to add to your collection, but it may also interest curious users - after all, almost everyone uses sendmail, even if indirectly.

Browse 430 other book reviews by Danny Yee
Top | Subjects | Titles | Authors | Keywords | Publishers | Latest Get Sendmail over here.

An anyonymous reader wrote in to tell us that the Hi Tech Graffiti article we ran on Wed. has been confirmed to be a hoax. If you are interested, you can look at the Hoax Image as well as the original image that it was based on. I'm not that surprised. Pretty good prank imho.

Reviewed by Brent Dearth SSG is an exploration into that wonderful industry that brought us such winners as Lost in Space. Yep, you guessed it: rampant stupidity, greed, and sex, hence the title. As Brent says: "Have you ever wondered why so many films suck? Ever want the low-down on many of you favorite Hollywood stars? Do you ever question the existence of common sense? If so, this book is for you.". Check the full review below.

REVIEW: Sex, Stupidity, and Greed:
Inside the American Movie Industry Ian Grey (1997 Juno Books ISBN 0-9651042-7-3)

Nutshell
Review: Have you ever wondered why so many films suck? Ever want the low-down on many of you favorite Hollywood stars? Do you ever question the existence of common sense? If so, this book is for you.

Rating: 10/10

Reviewed by Brent Dearth What's Good?

How this book managed to slip past the publishing media moguls, astonishes me. Never has social assimilation through media been portrayed in such a beautifully witty manner. Ian Grey mixes comical anecdotes with dark harsh truths that expose the underlying deception, deceit, and disorder of the United States' number two export, (second only to military enterprise) the mass-produced interwoven entertainment industry!

Since I can remember, I have been avidly watching movies; some good, many bad. After a bout of the latter, I usually find myself pondering how Hollywood is capable of pulling off such immaculate, overly hyped, overly marketed piles of shit. This book makes an answer quite evident. Through satirical firsthand insight into the industry, this book breaks the masquerade of top media barons and their less-than-subtle uses of corporate tying, product placements, and censorship, in pursuit of the almighty dollar.

For those who think, this book can serve as a reinforcement of sanity...

What's Bad?

...For those who don't, this book may seem a servant of pessimism. As one who thinks, I cannot see any faults in this book. However, if you are naive enough to believe everything you are told, and truly uphold these beliefs in your heart, mind, and spirit...you will dislike this book. This book will NOT tell you the latest interesting gossip on Mel Gibson, but rather focus on his self-righteous, demeaning, homophobic tendencies. Now don't get me wrong. This book will not cause you to hate movies (I am still a movie addict), just question them.

Who should buy this book?

As stated above, anybody who wants to peer past the teeny-bopper facade of the American movie industry from disillusioned or virgin eyes.

This book is available at Amazon. (of course)

Still Unsure?

Check out this RealAudio or RealVideo clip of Richard Metzger (of Infinity Factory and Disinformation fame) interviewing Ian Grey

Table of Contents

Introduction

1. Waterworld
2. Oscar Night, 1981
3. Stupidity
4. Raw Deal
5. Sex
6. Violence
7. Gossip Time!
8. Freaks
9. Sex: The Sequel
10. Techno
11. The Independents
12. Media Mauled
13. One. Enormous. Audience.
14. Corporate Structure Chart

As part of the on-going book reviews, Pater sent in a review of Peter van der Linden's Not Just Java. A good book for covering recent developments, this isn't a programming book per se, but provides lots of general knowledge. Read the review below. REVIEW: Not Just Java Peter van der Linden (Sun Microsystems Press ISBN 0-13-864638-4)

Nutshell
Review: Not a book for geeks, but many different technologies are covered. Clearly defines what each is/isn't capable of.
Rating: 7/10 Reviewed by Pater What's Good?

This book covers lots of new developments, such as Java, multi-tiered systems, thin clients, CORBA, IIOP, and ActiveX. This book is perfect for someone who is upgrading technology and needs a broad overview of what is available and where computers are headed in the future. I already know of many people who I would give this book to so that they can finally understand all the buzzwords they like to throw around. This book takes a hard look at each item, noting strengths and weaknesses.

I like the fact that the capabilities of each are cleary outlined, without going into a lot of detail. You can tell if something is going to work for you, without having to learn it all first. Also, the book takes a holistic approach when tackling topics. Ease of use, security, and feasibility are outlined for Java, ActiveX, and the rest.

What's Bad?

This book is different in that what's bad for some people is very good for others. If you remember surfing the web with Mosaic, you can skip the first two chapters, as they are basically glorified internet history. If the whole networking concept is new to you, then the beginning chapters are full of useful information that will give you a better overall understanding.

If you're looking for a lot of in-depth information, you won't find it. This book tends to skip over the gory details on many items, and even provides warnings to the novice reader when covering heady material.

Who should buy this book?

First of all, understand this. No one is going to learn Java, CORBA, or any of the other ideas discussed in this book. It doesn't teach them, nor does it try to. What it does try to do, however, is give one an overall understanding so that you can go on from this text onto other books, knowing exactly what strategy is right for you.

It is difficult to rate this book as good or bad, as it is good for some people (an IT manager planning corporate strategy) and bad for others (an experienced database or network administrator). Personally, I didn't get a lot out of reading this book, but I still thought it was nicely done, and made for enjoyable reading.

So, if you have a manager who needs an education, or you want a general base of knowledge get this book at Amazon.

Table of Contents

Preface

1. The Internet
2. The World Wide Web
3. Java Systemwide Features
4. Java Security Issues
5. Java Langauge Specifics
6. Java Libraries
7. Client/Server and the Intranet
8. Enterprise Computing and Databases
9. Industry Trends for the New Millenium

Loyal reader SEGV has written a review of Effective C++, the language we all know and love. A good book for people who have a grasp of the language and looking to deepen their knowledge. Click below to read more.

This also is my first book review for Slashdot, and I also have "reused" Rick Franchuk's review layout. The text, however, is mine: warts and all.

Effective C++: Second Edition Scott Meyers (Addison Wesley Longman, Inc. ISBN: 0-201-92488-9)

Nutshell Review Up to date revision of a classic book, highly applicable to real-world software development. Not a language reference or primer, but rather a series of essays on the trickier points of C++, how they can cause you grief, and how you can harness their power. Intermediate level, yet easily read.

Rating 10/10

review by SEGV

I've just finished reading the second edition of Effective C++, subtitled "50 Specific Ways to Improve Your Programs and Designs." I really should have read it a year or two ago, as was wisely recommended to me. In that time I've had to debug (others') code that illustrated several Items in this book, and it truly would have helped me then to fully understand what was going on.

What this->book Isn't, and Is

This book doesn't teach the C++ language. It isn't suitable as a reference, or as an introduction to the language. You are expected to know the basics of C and C++: what a class is, what inheritance does, and so on. Rather, this book aims to teach you how to use the language, effectively. It does so by presenting 50 Items, each of which is a simple guideline with several pages of explanatory text. [Check out Item titles in the table of contents below.]

Meyers supports each guideline with illustrative examples and lucid code. He clearly describes what is going on, where you (or others) might get tripped up, and why that is so. Practical man that he is, he even provides you with the safest way to bend the guidelines, for those rare times when you must. And he does all of this in a humourous style!

A Prayer Book for Developers

The Items don't state "Thou shall" or "Thou shalt not." All the same, this book can be read like a Bible. Perhaps read an item per sitting. Or skip to one that interests you (or is relevant to what you are currently coding). Submit an Item to serious study. Memorize the Items' prescriptions, philosophize over their inner meaning. And punish yourself if you sin.

Really, before a developer starts writing his own operator new he will want to read the Items on memory management in C++. There are a few gotchas there. In fact, read those Items before you even call new!

If you don't, you will surely end up in programmer's hell.

Standard C++

This book pretty much covers Standard C++, having been recently revised. In many cases Meyers shows why the new language features are superior to the old way (either C or pre-standard C++). Still, he is careful to show alternative implementations in areas where compilers are not yet up to spec. Although he provides an overview of the standard library and encourages its use everywhere, you'll need another reference to learn it. But you knew that already.

Anecdotal Evidence

I don't fondly remember the few days I spent debugging a particular memory related crash. In the end I discovered that the author of a "smart" pointer class had failed to provide a copy constructor. As it happened, his compiler had optimized out some temporary objects, and so did two of mine. But a fourth compiler created temporaries, and without the copy constructor a reference count was off. As the object was passed back up the call chain as return values, it was deleted out from under itself. Nasty.

Meyers brings up all these issues, and explains them better than I, in Items 11, 27, and 45. Following his guidelines, a copy constructor would have been written either as a matter of course, or made unavailable to users of the class. This bug could have been prevented.

I now keep a printout of the Item titles on the wall by my desk.

Recommendation: Learn it, Love it, Live it

Buy this book and take it to heart. Your co-developers will love you for it, or just not kill you, depending on their disposition. I'm assuming you are a developer, but if not, this book is suitable for any intermediate student of the C++ language. Language features are explained as they are used, just not in an exhaustive fashion. Rather, they are brought to bear when the design issue they are applicable to is being discussed.

Keep it handy, right between your introductory C++ book and Bjarne Stroustrup's The C++ Programming Language. You'll use it.

Online Support

The publisher hosts a web page to support the book: http://www.aw.com/cseng/titles/0-201-92488-9/. It contains the full text of the TOC, Preface, and Items 10, 21, 24, and 32. It also contains updates and errata, in case you're unlucky like me and have an earlier (second) printing. [I was hoping to get into the acknowledgements when I found a genuine error, but it has been fixed in the fourth (current) printing. Doh!]

More Effective C++

If you're like me and craving more, Meyers has it covered. I'm currently reading More Effective C++, subtitled "35 New Ways to Improve Your Programs and Designs." Again, the supporting web page at http://www.aw.com/cseng/titles/0-201-63371-X/ has available the full text of several Items, and also an auto_ptr implementation in case you're curious how a "smart" pointer works. A great candidate for another review. :-)

Check this book out over at Amazon.

Table of Contents

Preface

Acknowledgements

Introduction

Shifting from C to C++

Item 1: Prefer const and inline to #define.
Item 2: Prefer to .
Item 3: Prefer new and delete to malloc and free.
Item 4: Prefer C++-style comments.

Memory Management

Item 5: Use the same form in corresponding uses of new and delete.
Item 6: Use delete on pointer members in destructors.
Item 7: Be prepared for out-of-memory conditions.
Item 8: Adhere to convention when writing operator new and operator delete.
Item 9: Avoid hiding the "normal" form of new.
Item 10: Write operator delete if you write operator new.

Constructors, Destructors, and Assignment Operators

Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory.
Item 12: Prefer initialization to assignment in constructors.
Item 13: List members in an initialization list in the order in which they are declared.
Item 14: Make destructors virtual in base classes.
Item 15: Have operator= return a reference to *this.
Item 16: Assign to all data members in operator=.
Item 17: Check for assignment to self in operator=.

Classes and Functions: Design and Declaration

Item 18: Strive for class interfaces that are complete and minimal.
Item 19: Differentiate among member functions, non-member functions, and friend functions.
Item 20: Avoid data members in the public interface.
Item 21: Use const whenever possible.
Item 22: Prefer pass-by-reference to pass-by-value.
Item 23: Don't try to return a reference when you must return an object.
Item 24: Choose carefully between function overloading and parameter defaulting.
Item 25: Avoid overloading on a pointer and a numerical type.
Item 26: Guard against potential ambiguity.
Item 27: Explicitly disallow use of implicitly generated member functions you don't want.
Item 28: Partition the global namespace.

Classes and Functions: Implementation

Item 29: Avoid returning "handles" to internal data.
Item 30: Avoid member functions that return non-const pointers or references to members less accessible than themselves.
Item 31: Never return a reference to a local object or to a dereferenced pointer initialized by new within the function.
Item 32: Postpone variable definitions as long as possible.
Item 33: Use inlining judiciously.
Item 34: Minimize compilation dependencies between files.

Inheritance and Object-Oriented Design

Item 35: Make sure public inheritance models "isa."
Item 36: Differentiate between inheritance of interface and inheritance of implementation.
Item 37: Never redefine an inherited nonvirtual function.
Item 38: Never redefine an inherited default parameter value.
Item 39: Avoid casts down the inheritance hierarchy.
Item 40: Model "has-a" or "is-implemented-in-terms-of" through layering.
Item 41: Differentiate between inheritance and templates.
Item 42: Use private inheritance judiciously.
Item 43: Use multiple inheritance judiciously.
Item 44: Say what you mean; understand what you're saying.

Miscellany

Item 45: Know what functions C++ silently writes and calls.
Item 46: Prefer compile-time and link-time errors to runtime errors.
Item 47: Ensure that non-local static objects are initialized before they're used.
Item 48: Pay attention to compiler warnings.
Item 49: Familiarize yourself with the standard library.
Item 50: Improve your understanding of C++.

Afterward

Index

Loyal reader SEGV has written a review of Effective C++, the language we all know and love. A good book for people who have a grasp of the language and looking to deepen their knowledge. Click below to read more.

This also is my first book review for Slashdot, and I also have "reused" Rick Franchuk's review layout. The text, however, is mine: warts and all.

Effective C++: Second Edition Scott Meyers (Addison Wesley Longman, Inc. ISBN: 0-201-92488-9)

Nutshell Review Up to date revision of a classic book, highly applicable to real-world software development. Not a language reference or primer, but rather a series of essays on the trickier points of C++, how they can cause you grief, and how you can harness their power. Intermediate level, yet easily read.

Rating 10/10

review by SEGV

I've just finished reading the second edition of Effective C++, subtitled "50 Specific Ways to Improve Your Programs and Designs." I really should have read it a year or two ago, as was wisely recommended to me. In that time I've had to debug (others') code that illustrated several Items in this book, and it truly would have helped me then to fully understand what was going on.

What this->book Isn't, and Is

This book doesn't teach the C++ language. It isn't suitable as a reference, or as an introduction to the language. You are expected to know the basics of C and C++: what a class is, what inheritance does, and so on. Rather, this book aims to teach you how to use the language, effectively. It does so by presenting 50 Items, each of which is a simple guideline with several pages of explanatory text. [Check out Item titles in the table of contents below.]

Meyers supports each guideline with illustrative examples and lucid code. He clearly describes what is going on, where you (or others) might get tripped up, and why that is so. Practical man that he is, he even provides you with the safest way to bend the guidelines, for those rare times when you must. And he does all of this in a humourous style!

A Prayer Book for Developers

The Items don't state "Thou shall" or "Thou shalt not." All the same, this book can be read like a Bible. Perhaps read an item per sitting. Or skip to one that interests you (or is relevant to what you are currently coding). Submit an Item to serious study. Memorize the Items' prescriptions, philosophize over their inner meaning. And punish yourself if you sin.

Really, before a developer starts writing his own operator new he will want to read the Items on memory management in C++. There are a few gotchas there. In fact, read those Items before you even call new!

If you don't, you will surely end up in programmer's hell.

Standard C++

This book pretty much covers Standard C++, having been recently revised. In many cases Meyers shows why the new language features are superior to the old way (either C or pre-standard C++). Still, he is careful to show alternative implementations in areas where compilers are not yet up to spec. Although he provides an overview of the standard library and encourages its use everywhere, you'll need another reference to learn it. But you knew that already.

Anecdotal Evidence

I don't fondly remember the few days I spent debugging a particular memory related crash. In the end I discovered that the author of a "smart" pointer class had failed to provide a copy constructor. As it happened, his compiler had optimized out some temporary objects, and so did two of mine. But a fourth compiler created temporaries, and without the copy constructor a reference count was off. As the object was passed back up the call chain as return values, it was deleted out from under itself. Nasty.

Meyers brings up all these issues, and explains them better than I, in Items 11, 27, and 45. Following his guidelines, a copy constructor would have been written either as a matter of course, or made unavailable to users of the class. This bug could have been prevented.

I now keep a printout of the Item titles on the wall by my desk.

Recommendation: Learn it, Love it, Live it

Buy this book and take it to heart. Your co-developers will love you for it, or just not kill you, depending on their disposition. I'm assuming you are a developer, but if not, this book is suitable for any intermediate student of the C++ language. Language features are explained as they are used, just not in an exhaustive fashion. Rather, they are brought to bear when the design issue they are applicable to is being discussed.

Keep it handy, right between your introductory C++ book and Bjarne Stroustrup's The C++ Programming Language. You'll use it.

Online Support

The publisher hosts a web page to support the book: http://www.aw.com/cseng/titles/0-201-92488-9/. It contains the full text of the TOC, Preface, and Items 10, 21, 24, and 32. It also contains updates and errata, in case you're unlucky like me and have an earlier (second) printing. [I was hoping to get into the acknowledgements when I found a genuine error, but it has been fixed in the fourth (current) printing. Doh!]

More Effective C++

If you're like me and craving more, Meyers has it covered. I'm currently reading More Effective C++, subtitled "35 New Ways to Improve Your Programs and Designs." Again, the supporting web page at http://www.aw.com/cseng/titles/0-201-63371-X/ has available the full text of several Items, and also an auto_ptr implementation in case you're curious how a "smart" pointer works. A great candidate for another review. :-)

Check this book out over at Amazon.

Table of Contents

Preface

Acknowledgements

Introduction

Shifting from C to C++

Item 1: Prefer const and inline to #define.
Item 2: Prefer to .
Item 3: Prefer new and delete to malloc and free.
Item 4: Prefer C++-style comments.

Memory Management

Item 5: Use the same form in corresponding uses of new and delete.
Item 6: Use delete on pointer members in destructors.
Item 7: Be prepared for out-of-memory conditions.
Item 8: Adhere to convention when writing operator new and operator delete.
Item 9: Avoid hiding the "normal" form of new.
Item 10: Write operator delete if you write operator new.

Constructors, Destructors, and Assignment Operators

Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory.
Item 12: Prefer initialization to assignment in constructors.
Item 13: List members in an initialization list in the order in which they are declared.
Item 14: Make destructors virtual in base classes.
Item 15: Have operator= return a reference to *this.
Item 16: Assign to all data members in operator=.
Item 17: Check for assignment to self in operator=.

Classes and Functions: Design and Declaration

Item 18: Strive for class interfaces that are complete and minimal.
Item 19: Differentiate among member functions, non-member functions, and friend functions.
Item 20: Avoid data members in the public interface.
Item 21: Use const whenever possible.
Item 22: Prefer pass-by-reference to pass-by-value.
Item 23: Don't try to return a reference when you must return an object.
Item 24: Choose carefully between function overloading and parameter defaulting.
Item 25: Avoid overloading on a pointer and a numerical type.
Item 26: Guard against potential ambiguity.
Item 27: Explicitly disallow use of implicitly generated member functions you don't want.
Item 28: Partition the global namespace.

Classes and Functions: Implementation

Item 29: Avoid returning "handles" to internal data.
Item 30: Avoid member functions that return non-const pointers or references to members less accessible than themselves.
Item 31: Never return a reference to a local object or to a dereferenced pointer initialized by new within the function.
Item 32: Postpone variable definitions as long as possible.
Item 33: Use inlining judiciously.
Item 34: Minimize compilation dependencies between files.

Inheritance and Object-Oriented Design

Item 35: Make sure public inheritance models "isa."
Item 36: Differentiate between inheritance of interface and inheritance of implementation.
Item 37: Never redefine an inherited nonvirtual function.
Item 38: Never redefine an inherited default parameter value.
Item 39: Avoid casts down the inheritance hierarchy.
Item 40: Model "has-a" or "is-implemented-in-terms-of" through layering.
Item 41: Differentiate between inheritance and templates.
Item 42: Use private inheritance judiciously.
Item 43: Use multiple inheritance judiciously.
Item 44: Say what you mean; understand what you're saying.

Miscellany

Item 45: Know what functions C++ silently writes and calls.
Item 46: Prefer compile-time and link-time errors to runtime errors.
Item 47: Ensure that non-local static objects are initialized before they're used.
Item 48: Pay attention to compiler warnings.
Item 49: Familiarize yourself with the standard library.
Item 50: Improve your understanding of C++.

Afterward

Index

Pater has given us a write up on the famous panther book, Advanced Perl Programming. So, if you just can't get enough Perl, and who can, check it out. Besides, Slashdot is programmed in Perl, and we all love Slashdot, right? Riiigght. REVIEW: Advanced Perl Programming by Sriram Srinivasan (O'Reilly & Associates)

Reviewed by Pater.

Nutshell Review: More in-depth than Programming Perl, this book shows how powerful Perl can be whether designing solutions for the enterprise, or just trying to automate difficult tasks on your own system.

Rating: 7/10

What's Good?

After getting my feet wet programming in Perl (and reading the Camel Book) I wanted more, and a quick paging through this book showed me windows interfaces, networking calls, and more. When reading the book, I found some of the same topics addressed in Programming Perl, but the topics covered in both books are quite possibly the toughest Perl concepts to master. After reading the section on object orientation, I finally felt comfortable enough to due object-oriented programming in Perl. Advanced Perl Programming is, at it's very worst, a quick tour of several modules available for Perl. The book spends a considerable amount of time on Perl/Tk, with an appendix dedicated to Perl/Tk as well.

These sections alone justified the cost of the book to me, but it also contains instructions on embedding Perl into C and using C within Perl. The book also takes time out to compare and contrast Perl with other langauges. This helps those who may be making a transition to Perl from C/C++, Java, or Python. All in all, this book is a good reference for the power Perl programmer.

What's Bad?

One major downside is that many modules upon which Advanced Perl Programming is written are not part of the standard Perl distribution. Granted, most of the CPAN (Comprehensive Perl Archive Network) modules are accepted as "the ones to use," but they are not guaranteed to be on every machine that has Perl. My other biggest irritation is that often an extremely powerful module would recieve little attention, and the book acts as one giant pointer to CPAN. However, this isn't much of a problem to anyone with good internet access.

Why should I buy this book?

If you are a Perl programmer who wants to use Perl to it's fullest, this book is definitely for you. I don't know of a more advanced book on Perl that covers the same material. Advanced Perl Programming is not a book for the Perl hacker (no fancy one-liners here), but more of a guide to help an application developer get the most out of Perl.

So, if you'd like to pick this up, check out Amazon. Also, O'Reilly is doing a Linux survey about their books. Head over there and help them out.

Table of Contents

Preface

1. Data References and Anonymous Storage
2. Implementing Complex Data Structures
3. Typeglobs and Symbol Tables
4. Subroutine References and Closures
5. Eval
6. Modules
7. Object-Oriented Programming
8. Object Orientation: The Next Few Steps
9. Tie
10. Persistence
11. Implementing Object Persistence
12. Networking with Sockets
13. Networking: Implementing RPC
14. User Interfaces with Tk
15. GUI Example: Tetris
16. GUI Example: Man Page Viewer
17. Template-Driven Code Generation
18. Extending Perl: A First Course
19. Embedding Perl: The Easy Way
20. Perl Internals

Appendix A: Tk Widget Reference
Appendix B: Syntax Summary

Pater has given us a write up on the famous panther book, Advanced Perl Programming. So, if you just can't get enough Perl, and who can, check it out. Besides, Slashdot is programmed in Perl, and we all love Slashdot, right? Riiigght. REVIEW: Advanced Perl Programming by Sriram Srinivasan (O'Reilly & Associates)

Reviewed by Pater.

Nutshell Review: More in-depth than Programming Perl, this book shows how powerful Perl can be whether designing solutions for the enterprise, or just trying to automate difficult tasks on your own system.

Rating: 7/10

What's Good?

After getting my feet wet programming in Perl (and reading the Camel Book) I wanted more, and a quick paging through this book showed me windows interfaces, networking calls, and more. When reading the book, I found some of the same topics addressed in Programming Perl, but the topics covered in both books are quite possibly the toughest Perl concepts to master. After reading the section on object orientation, I finally felt comfortable enough to due object-oriented programming in Perl. Advanced Perl Programming is, at it's very worst, a quick tour of several modules available for Perl. The book spends a considerable amount of time on Perl/Tk, with an appendix dedicated to Perl/Tk as well.

These sections alone justified the cost of the book to me, but it also contains instructions on embedding Perl into C and using C within Perl. The book also takes time out to compare and contrast Perl with other langauges. This helps those who may be making a transition to Perl from C/C++, Java, or Python. All in all, this book is a good reference for the power Perl programmer.

What's Bad?

One major downside is that many modules upon which Advanced Perl Programming is written are not part of the standard Perl distribution. Granted, most of the CPAN (Comprehensive Perl Archive Network) modules are accepted as "the ones to use," but they are not guaranteed to be on every machine that has Perl. My other biggest irritation is that often an extremely powerful module would recieve little attention, and the book acts as one giant pointer to CPAN. However, this isn't much of a problem to anyone with good internet access.

Why should I buy this book?

If you are a Perl programmer who wants to use Perl to it's fullest, this book is definitely for you. I don't know of a more advanced book on Perl that covers the same material. Advanced Perl Programming is not a book for the Perl hacker (no fancy one-liners here), but more of a guide to help an application developer get the most out of Perl.

So, if you'd like to pick this up, check out Amazon. Also, O'Reilly is doing a Linux survey about their books. Head over there and help them out.

Table of Contents

Preface

1. Data References and Anonymous Storage
2. Implementing Complex Data Structures
3. Typeglobs and Symbol Tables
4. Subroutine References and Closures
5. Eval
6. Modules
7. Object-Oriented Programming
8. Object Orientation: The Next Few Steps
9. Tie
10. Persistence
11. Implementing Object Persistence
12. Networking with Sockets
13. Networking: Implementing RPC
14. User Interfaces with Tk
15. GUI Example: Tetris
16. GUI Example: Man Page Viewer
17. Template-Driven Code Generation
18. Extending Perl: A First Course
19. Embedding Perl: The Easy Way
20. Perl Internals

Appendix A: Tk Widget Reference
Appendix B: Syntax Summary

Reader and veteran book reviewer Danny Yee has written a review of Donald Knuth's The Art of Computer Programming. This book is a bit different from the normal pack, getting at the heart of how most computer systems function underneath, with much exploration into the algorithims and methods. So, for a better grasp of the fundament of computing, click below. The Art of Computer Programming
1: Fundamental Algorithms
2: Seminumerical Algorithms
3: Sorting and Searching

Donald E. Knuth
Addison-Wesley 1997, 1998

AbookreviewbyDannyYee(danny@cs.usyd.edu.au),Copyright©1998
Danny's Homepage

The tale of how Knuth took a decade off from writing The Art of Computer Programming to create the TeX typesetting language is one of the great legends of computer science. The appearance of a third edition of The Art of Computer Programming - typeset in you will never guess what! - is therefore a landmark event.

For those unfamiliar with the work, it is not about computer programming in the broad sense, but about the algorithms and methods which lie at the heart of most computer systems. Fundamental Algorithms contains background information for the series. Chapter one provides mathematical preliminaries and basic programming concepts, along with an introduction to the MIX assembly language, used throughout for implementations. Chapter two covers simple information structures: lists, trees, and related data structures.

The two chapters in Seminumerical Algorithms cover pseudo-random numbers - their generation and statistical testing - and numerical computation - doing arithmetic with floating point numbers, rationals, and polynomials. Almost everyone who has ever programmed has written a bubble sort at some point, but the full complexities of sorting algorithms are another story entirely. After an introduction to the mathematics of permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, merging, and distribution algorithms), sorting on secondary storage, and searching,

The Art of Computer Programming is not a work for everyone, not even for all programmers. It will be an valuable reference for those working on the implementation and optimisation of key algorithms and data structures, but the more mathematically inclined will dip into it simply for pleasure. Knuth himself clearly enjoys the subtleties of the mathematics as much as anything: he writes at one point

Even if sorting were almost useless, there would be plenty of rewarding reasons for studying it anyway! The ingenious algorithms that have been discovered show that sorting is an extremely interesting topic to explore in its own right. Many fascinating unsolved problems remain in this area, as well as quite a few solved ones. [ Sorting and Searching, page 3]

and he provides some gloriously learned historical tidbits and mathematical digressions. The mathematics is heavy going in places, but the more difficult sections are marked and the material is laid out in such a way that those seeking algorithms to implement and performance analyses can skip the proofs and derivations and the more esoteric material.

Exercises are liberally provided, along with proper answers, which take up around a quarter of each volume. The exercises are carefully graded in difficulty on a scale from 0 to 50, and range from trivial tests of definitions to unsolved research problems. Reading The Art of Programming is a serious enough undertaking in itself (I have only read about a third of it so far myself), but anyone who succeeds in doing all the exercises will probably have earnt themselves several doctorates!

There is plenty of new material in this third edition, including new algorithms, examples, and exercises. The somewhat archaic MIX language has been retained, but we are promised its replacement by a modern, RISC "MMIX" in the next edition. Another incentive to purchase this edition, for those who already have the second, is the vastly improved typesetting. But the most exciting news of all is that volumes four and five are finally going to appear, followed by another revision of volumes one to three and then maybe by volumes six and seven (on the theory of languages and compilers).

Browse 400 other book reviews by Danny Yee
Top | Subjects | Titles | Authors | Keywords | Publishers | Latest

Thanks to Danny for graciously submitting this review. If you are interested in picking this book up, grab volume one here, volume two here and volume three here. If anyone else is interested in doing reviews, please e-mail me, hemos.

Reader and veteran book reviewer Danny Yee has written a review of Donald Knuth's The Art of Computer Programming. This book is a bit different from the normal pack, getting at the heart of how most computer systems function underneath, with much exploration into the algorithims and methods. So, for a better grasp of the fundament of computing, click below. The Art of Computer Programming
1: Fundamental Algorithms
2: Seminumerical Algorithms
3: Sorting and Searching

Donald E. Knuth
Addison-Wesley 1997, 1998

AbookreviewbyDannyYee(danny@cs.usyd.edu.au),Copyright©1998
Danny's Homepage

The tale of how Knuth took a decade off from writing The Art of Computer Programming to create the TeX typesetting language is one of the great legends of computer science. The appearance of a third edition of The Art of Computer Programming - typeset in you will never guess what! - is therefore a landmark event.

For those unfamiliar with the work, it is not about computer programming in the broad sense, but about the algorithms and methods which lie at the heart of most computer systems. Fundamental Algorithms contains background information for the series. Chapter one provides mathematical preliminaries and basic programming concepts, along with an introduction to the MIX assembly language, used throughout for implementations. Chapter two covers simple information structures: lists, trees, and related data structures.

The two chapters in Seminumerical Algorithms cover pseudo-random numbers - their generation and statistical testing - and numerical computation - doing arithmetic with floating point numbers, rationals, and polynomials. Almost everyone who has ever programmed has written a bubble sort at some point, but the full complexities of sorting algorithms are another story entirely. After an introduction to the mathematics of permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, merging, and distribution algorithms), sorting on secondary storage, and searching,

The Art of Computer Programming is not a work for everyone, not even for all programmers. It will be an valuable reference for those working on the implementation and optimisation of key algorithms and data structures, but the more mathematically inclined will dip into it simply for pleasure. Knuth himself clearly enjoys the subtleties of the mathematics as much as anything: he writes at one point

Even if sorting were almost useless, there would be plenty of rewarding reasons for studying it anyway! The ingenious algorithms that have been discovered show that sorting is an extremely interesting topic to explore in its own right. Many fascinating unsolved problems remain in this area, as well as quite a few solved ones. [ Sorting and Searching, page 3]

and he provides some gloriously learned historical tidbits and mathematical digressions. The mathematics is heavy going in places, but the more difficult sections are marked and the material is laid out in such a way that those seeking algorithms to implement and performance analyses can skip the proofs and derivations and the more esoteric material.

Exercises are liberally provided, along with proper answers, which take up around a quarter of each volume. The exercises are carefully graded in difficulty on a scale from 0 to 50, and range from trivial tests of definitions to unsolved research problems. Reading The Art of Programming is a serious enough undertaking in itself (I have only read about a third of it so far myself), but anyone who succeeds in doing all the exercises will probably have earnt themselves several doctorates!

There is plenty of new material in this third edition, including new algorithms, examples, and exercises. The somewhat archaic MIX language has been retained, but we are promised its replacement by a modern, RISC "MMIX" in the next edition. Another incentive to purchase this edition, for those who already have the second, is the vastly improved typesetting. But the most exciting news of all is that volumes four and five are finally going to appear, followed by another revision of volumes one to three and then maybe by volumes six and seven (on the theory of languages and compilers).

Browse 400 other book reviews by Danny Yee
Top | Subjects | Titles | Authors | Keywords | Publishers | Latest

Thanks to Danny for graciously submitting this review. If you are interested in picking this book up, grab volume one here, volume two here and volume three here. If anyone else is interested in doing reviews, please e-mail me, hemos.

Reader and veteran book reviewer Danny Yee has written a review of Donald Knuth's The Art of Computer Programming. This book is a bit different from the normal pack, getting at the heart of how most computer systems function underneath, with much exploration into the algorithims and methods. So, for a better grasp of the fundament of computing, click below. The Art of Computer Programming
1: Fundamental Algorithms
2: Seminumerical Algorithms
3: Sorting and Searching

Donald E. Knuth
Addison-Wesley 1997, 1998

AbookreviewbyDannyYee(danny@cs.usyd.edu.au),Copyright©1998
Danny's Homepage

The tale of how Knuth took a decade off from writing The Art of Computer Programming to create the TeX typesetting language is one of the great legends of computer science. The appearance of a third edition of The Art of Computer Programming - typeset in you will never guess what! - is therefore a landmark event.

For those unfamiliar with the work, it is not about computer programming in the broad sense, but about the algorithms and methods which lie at the heart of most computer systems. Fundamental Algorithms contains background information for the series. Chapter one provides mathematical preliminaries and basic programming concepts, along with an introduction to the MIX assembly language, used throughout for implementations. Chapter two covers simple information structures: lists, trees, and related data structures.

The two chapters in Seminumerical Algorithms cover pseudo-random numbers - their generation and statistical testing - and numerical computation - doing arithmetic with floating point numbers, rationals, and polynomials. Almost everyone who has ever programmed has written a bubble sort at some point, but the full complexities of sorting algorithms are another story entirely. After an introduction to the mathematics of permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, permutations, Sorting and Searching presents and analyses an extensive array of algorithms for sorting in memory (insertion, exchange, selection, merging, and distribution algorithms), sorting on secondary storage, and searching,

The Art of Computer Programming is not a work for everyone, not even for all programmers. It will be an valuable reference for those working on the implementation and optimisation of key algorithms and data structures, but the more mathematically inclined will dip into it simply for pleasure. Knuth himself clearly enjoys the subtleties of the mathematics as much as anything: he writes at one point

Even if sorting were almost useless, there would be plenty of rewarding reasons for studying it anyway! The ingenious algorithms that have been discovered show that sorting is an extremely interesting topic to explore in its own right. Many fascinating unsolved problems remain in this area, as well as quite a few solved ones. [ Sorting and Searching, page 3]

and he provides some gloriously learned historical tidbits and mathematical digressions. The mathematics is heavy going in places, but the more difficult sections are marked and the material is laid out in such a way that those seeking algorithms to implement and performance analyses can skip the proofs and derivations and the more esoteric material.

Exercises are liberally provided, along with proper answers, which take up around a quarter of each volume. The exercises are carefully graded in difficulty on a scale from 0 to 50, and range from trivial tests of definitions to unsolved research problems. Reading The Art of Programming is a serious enough undertaking in itself (I have only read about a third of it so far myself), but anyone who succeeds in doing all the exercises will probably have earnt themselves several doctorates!

There is plenty of new material in this third edition, including new algorithms, examples, and exercises. The somewhat archaic MIX language has been retained, but we are promised its replacement by a modern, RISC "MMIX" in the next edition. Another incentive to purchase this edition, for those who already have the second, is the vastly improved typesetting. But the most exciting news of all is that volumes four and five are finally going to appear, followed by another revision of volumes one to three and then maybe by volumes six and seven (on the theory of languages and compilers).

Browse 400 other book reviews by Danny Yee
Top | Subjects | Titles | Authors | Keywords | Publishers | Latest

Thanks to Danny for graciously submitting this review. If you are interested in picking this book up, grab volume one here, volume two here and volume three here. If anyone else is interested in doing reviews, please e-mail me, hemos.

Brent Fulgham has written to us with a review of Expert C Programming: Deep C Secrets. While dated (1994), he does recomend it for those wishing to immerse themselves in C programming. Click below to read the full review. Book Review: Expert C Programming : Deep C Secrets

This is my first book review for Slashdot, so I have *ahem* borrowed Rick Franchuk's excellent review formatting and layout information. Any errors or omissions are entirely my fault.

REVIEW: Expert C Programming: Deep C Secrets Peter van der Linden (Prentice Hall ASIN: 0131774298)

Nutshell
Review: An excellent (and humorous) reference for the journeyman C programmer looking to expand his/her understanding of the C language. Although a bit pricey at $40, and somewhat out of date with respect to discussion of C++, it is well worth a read for anyone wishing to become a competent C hacker.
Rating: 9/10 Brent Fulgham

I tend to pick up books on programming fairly frequently, hoping that I will pick up a valuable tip or two, or identify some nagging little coding detail that has been the cause of problems in my own code. Generally, I find these types of books to be either too elementary, focusing on simple programming constructs that are rehashed from any of a number of Idiot's Guides, or overly code-dense at the expense of clarity. So it is a rare treat to read a book like Expert C Programming: Deep C Secrets. This book delves into the dark, cob-webbed corners of the C language to explain various language idiosyncricies, and why things work the way they do in the ANSI standard.

What's Good?

This book provides additional detail in many areas typically ignored in more introductory texts. For example, pointers are covered quite extensively in this document, and covers the often-overlooked cases in which C Arrays and Pointers are NOT the same. Yes, it's true -- C Arrays can't be assumed to act like pointers in all cases. What's more, the representation of Arrays and pointers in memory are two different animals, and programmers who treat them the same do so at there own risk.

Another particularly useful section is his description of how to define and understand C Declarations. This description was particularly useful for me, as I have always found these constructions to become virtually unreadable when defining pointers to functions, or similar. Mr. van der Linden provides some slick little mneumonics and tables to translate declarations into english meanings. Lots of fun!

Finally, an Appendix entitled Secrets of Programmer Job Interviews gives an excellent set of questions that van der Linden and others have used in job interviews. As a amateur programmer (that hopes to someday be gainfully employed as a Software Engineer ), I found this insight into what the interviewer is trying to accomplish to be highly illuminating. In fact, this section alone might make it worth your while to pick up this book.

Of course, the book contains a great deal more. Topics range from a discussion of the ANSI standardization process to the Obfuscated C Contest "greatest hits". You really haven't lived until you see the fully-functional BASIC interpreter coded in 1,500 characters of unreadable, unformatted C code. See below for a more comprehensive list of what is covered.

What's Bad?

Well, the short answer is not much. The more pointy-haired types might find the frequent use of humour (a mainstay of all of van der Linden's books I have read) to be a negative. In addition, at roughly $40 with no discounts available at the major on-line sellers the book is a bit pricey. However, these are minor quibbles.

In fact, the largest problem with this book (and it's a fairly small problem as well) is its discussion of C++. Since the book was written in 1994, and has not been updated, it is a bit out of date with the current state of the art with respect to C++. In fact, this section is a lot like the introductory Java chapters found in most current C++ books. This chapter could use a rewrite in light of the recent ANSI standardization of C++.

One final minor problem is that the book is highly Unix-centered (and especially geared to Sun's Solaris). Mr. van der Linden has some discussion of DOS protected mode and memory structure, but by-and-large we are presented with a Unix System V description of virtual memory. Now, since I do nearly all of my programming in Linux I did not have much problem with this. However, these sections of the book could use a rewrite in light of Windows 95/98/NT's virtual memory model.

So What's In It For Me?

I'd strongly recommend this text for anyone seriously interested to writing production-grade C. Probably the most important things you can learn from the book are:

• C Arrays are NOT the same as pointers
• How to decipher C Declarations
• Dynamic run-time data structures
• The recipe for Oobleck (from the Dr. Seuss story)

You can buy this over at Amazon.

Table of Contents

Preface

Acknowledgments

Introduction

1. C Through the Mists of Time

2. It's Not a Bug, It's a Language Feature

3. Unscrambling Declarations in C

4. The Shocking Truth: C Arrays and Pointers Are NOT the Same!

5. Thinking of Linking

6. Poetry in Motion: Runtime Data Structures

7. Thanks for the Memory

8. Why Programmers Can't Tell Halloween from Christmas Day

9. More about Arrays

10. More About Pointers

11. You Know C, So C++ is Easy!

Appendix: Secrets of Programmer Job Interviews

Index

Brent Fulgham has written to us with a review of Expert C Programming: Deep C Secrets. While dated (1994), he does recomend it for those wishing to immerse themselves in C programming. Click below to read the full review. Book Review: Expert C Programming : Deep C Secrets

This is my first book review for Slashdot, so I have *ahem* borrowed Rick Franchuk's excellent review formatting and layout information. Any errors or omissions are entirely my fault.

REVIEW: Expert C Programming: Deep C Secrets Peter van der Linden (Prentice Hall ASIN: 0131774298)

Nutshell
Review: An excellent (and humorous) reference for the journeyman C programmer looking to expand his/her understanding of the C language. Although a bit pricey at $40, and somewhat out of date with respect to discussion of C++, it is well worth a read for anyone wishing to become a competent C hacker.
Rating: 9/10 Brent Fulgham

I tend to pick up books on programming fairly frequently, hoping that I will pick up a valuable tip or two, or identify some nagging little coding detail that has been the cause of problems in my own code. Generally, I find these types of books to be either too elementary, focusing on simple programming constructs that are rehashed from any of a number of Idiot's Guides, or overly code-dense at the expense of clarity. So it is a rare treat to read a book like Expert C Programming: Deep C Secrets. This book delves into the dark, cob-webbed corners of the C language to explain various language idiosyncricies, and why things work the way they do in the ANSI standard.

What's Good?

This book provides additional detail in many areas typically ignored in more introductory texts. For example, pointers are covered quite extensively in this document, and covers the often-overlooked cases in which C Arrays and Pointers are NOT the same. Yes, it's true -- C Arrays can't be assumed to act like pointers in all cases. What's more, the representation of Arrays and pointers in memory are two different animals, and programmers who treat them the same do so at there own risk.

Another particularly useful section is his description of how to define and understand C Declarations. This description was particularly useful for me, as I have always found these constructions to become virtually unreadable when defining pointers to functions, or similar. Mr. van der Linden provides some slick little mneumonics and tables to translate declarations into english meanings. Lots of fun!

Finally, an Appendix entitled Secrets of Programmer Job Interviews gives an excellent set of questions that van der Linden and others have used in job interviews. As a amateur programmer (that hopes to someday be gainfully employed as a Software Engineer ), I found this insight into what the interviewer is trying to accomplish to be highly illuminating. In fact, this section alone might make it worth your while to pick up this book.

Of course, the book contains a great deal more. Topics range from a discussion of the ANSI standardization process to the Obfuscated C Contest "greatest hits". You really haven't lived until you see the fully-functional BASIC interpreter coded in 1,500 characters of unreadable, unformatted C code. See below for a more comprehensive list of what is covered.

What's Bad?

Well, the short answer is not much. The more pointy-haired types might find the frequent use of humour (a mainstay of all of van der Linden's books I have read) to be a negative. In addition, at roughly $40 with no discounts available at the major on-line sellers the book is a bit pricey. However, these are minor quibbles.

In fact, the largest problem with this book (and it's a fairly small problem as well) is its discussion of C++. Since the book was written in 1994, and has not been updated, it is a bit out of date with the current state of the art with respect to C++. In fact, this section is a lot like the introductory Java chapters found in most current C++ books. This chapter could use a rewrite in light of the recent ANSI standardization of C++.

One final minor problem is that the book is highly Unix-centered (and especially geared to Sun's Solaris). Mr. van der Linden has some discussion of DOS protected mode and memory structure, but by-and-large we are presented with a Unix System V description of virtual memory. Now, since I do nearly all of my programming in Linux I did not have much problem with this. However, these sections of the book could use a rewrite in light of Windows 95/98/NT's virtual memory model.

So What's In It For Me?

I'd strongly recommend this text for anyone seriously interested to writing production-grade C. Probably the most important things you can learn from the book are:

• C Arrays are NOT the same as pointers
• How to decipher C Declarations
• Dynamic run-time data structures
• The recipe for Oobleck (from the Dr. Seuss story)

You can buy this over at Amazon.

Table of Contents

Preface

Acknowledgments

Introduction

1. C Through the Mists of Time

2. It's Not a Bug, It's a Language Feature

3. Unscrambling Declarations in C

4. The Shocking Truth: C Arrays and Pointers Are NOT the Same!

5. Thinking of Linking

6. Poetry in Motion: Runtime Data Structures

7. Thanks for the Memory

8. Why Programmers Can't Tell Halloween from Christmas Day

9. More about Arrays

10. More About Pointers

11. You Know C, So C++ is Easy!

Appendix: Secrets of Programmer Job Interviews

Index

Okay... weds we asked for submissions of weird links for a conspiracy feature to coincide with the opening of the X-Files movie. What happened? Click the link below... Okay... let's face it - we all knew, maybe subconscously, that there was going to be a lot of weird stuff out on the web. I mean, that's the cultural stereotype - a geek with a bunch of comic-book inspired political philosophies creating a web page so that he can network with all the other geeks about alien abductions, cattle mutilations, whatever... We've all experianced these types of sites, we've all treasured the links as something to peruse when slacking off at work, etc.

As you can imagine, like everything else on the internet, the sheer volume of information on "nutcase" ideas has proliferated to such gargantuan proportions that trying to browse it and bang together a comprehensive overview over a couple of hazy evening hours is a staggering task. But goddammit, that's what I'm here for.

Sitting down in the poof chair with a Jack Ripper cocktail (purified rain water and grain alcohol) I proceeded to plow through the sites that had been submitted to me since weds, when this excursion was announced. And, through strength and perserverance - and a deep determination to disbelieve everything I read - I emerge to present to you some sites of interest.

Brian shot me a link to the Arc-Hive. It's a very well organized and catagoried index of conspiracy oriented papers. Highlights include the the Conspiracy Dictionary (hey, you need to know what a manchurian canidate is before you can have paranoid delusions of them breaking in your front door), also you can learn how Tickle-Me-Elmo is part of the new world order.

And while there are many archives of conspiracy material, a more direct source for material is the horse's mouth. On the extreme protestant end of that scale is the Flat Earth Society (thanks to Janne Moren for this one). I'll bet you never suspected your sixth grade geography teacher was part of the globalist conspiracy to discredit the bible. A bio for the "flat earth prophet" can be found here (thanks to Dan Hollis).

Another horse mouth would have to be Art Bell - a radio talk-show host who often discusses aliens and other paranormal goings-on. This link was sent to me by several people - probably working together.

From the kooky-bitshifted-copy-of-Slashdot category comes Parascope (submitted by Eric Maland). The site's major accomplishment is reporting articles like "Bigfoot in Russia" but still maintaining a sincere journalistism feel. And hey, when you can't wait for the next issue of Weekly World News to get the skinny - this is a great place to go.

On the other side of the conspiracy spectrum was Circle Makers. (submitted by Dan Hollis, who submitted just a few too many links to remain above suspicion) This website documents crop circles not as alien pasttime, but rather an art form that many overtly mathmatical and probably unstable crop-artists pursue. There are some fantastic pictures of crop circles, and even a mac program that will allow you to design agricultural destruction in your own home.

If preserving the American Way against the new world order, freemasons, etc is your thing then you'll probably enjoy Free America. Pay attention, because long after I'm neutralized by the Secret Government you'll be able to survive - provided you have a compound, a good water source, and lots of freeze dried food.

That's it. Enjoy going to the X-files movie tonight if you think that's the safe thing to do. I'm going to wait a few days, I think - to make sure the opening night audiences aren't reprogrammed subliminally, that is. So farewell - thank you to all who submitted links, and a tip from agent Kandalgaonkar: remember to tin-foil all your windows as protection from government microwaves.

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Intrepid reviewer Rick Franchuk has returned with another review, this time of the JavaScript Sourcebook. Yes, in full living text, read about how organization can sink or make a book. And, maybe, you can learn how to the mouseover as well. So, click below to read Rick's incisive review.

Another Slashdot denizen wrote to me and asked if he could do the honors of reviewing the next book I had on my list, which was to be TCP/IP Network Administration, another O'Reilly treasure trove. (Can ORA produce bad books? Yes, but I haven't bought any of 'em so I can't write about 'em!)

Since Eric will be doing the write-up for TNA (gotta love that acronym ;), I thought I'd mention a book that I wasn't too impressed with, the JavaScript Sourcebook.

REVIEW: JavaScript Sourcebook Gordon McComb (Wiley Computer Publishing ISBN 0-471-16185-3)

Nutshell
Review: Gordon is a talented coder and packs a wad of code gems into his work, but the organization of the book leaves a lot to be desired.
Rating: 5/10 Rick Franchuk - TranSpecT Consulting The Scenario

There's been some projects I've put together which required a little Jscript knowing, so I did what I usually do... head to the book store (deductions, deductions, deductions! ;). JavaScript was (is?) a very trendy technology, so naturally there were 6.02×10²³ different titles to choose from.

I pulled it off the shelf and gave it a quick thumb test, flipping through the pages to determine if the book would contain the information I was interested in knowing. It seemed complete, CD included all the source code (not that I've ever used a CD from a book), and appeared to cover the topics I was seeking enlightenment on.

At the time I bought it, I knew very little about Jscript (experience with the standard, packaged image-replacement onmouseover scripts and whatnot), so I was looking for a book that could achieve both the task of teaching me Jscript fundamentals and provide specifics about my area of interest. I'd already had considerable exposure to OO Programming, so thinking in terms of objects and methods wasn't foreign.

What's Bad?

Where everything here falls down is organization. The book feels as though it was thrown together by a novice editor. The index is not nearly as complete as it could be, given the bulk of data within the pages, and I found it frustrating trying to work my way through the book as a novice Jscriptor. Eventually, I picked up everything I needed to know from the steaming pile of examples strewn throughout... Computer novices and non-coders would probably have a harder time of it, and could easily get discouraged from Jscript altogether.

To make things more interesting, some of the code samples don't work quite as advertised, particularly if using any flavor of MSIE. That's not surprising, a lot of Jscript features were broken or left out of earlier MSIE revisions, and the book does suffer from that curious outdatedness common to all published computer texts. Some mention is made in the end of 'new' features in Netscape 3.0, which should give you an idea of when it was printed (for you 'Net newcomers, that's 1996.)

What's Good?

The book does pack a lot of handy codelettes in, all the way up to a primitive jscript-based adventure game engine. In fact, there's far more examples in there than the average webtech would probably ever find a use for. A full reference of the Jscript language particulars is included (up to date as of its printing) which also helps a would-be scriptor along.

So What's In It For Me?

I still use the book from time to time, primarily for looking up methods within the Jscript class information or to see how Gordon would tackle a particular or similar problem. However, other texts could give you a more complete examination of the language (like the JavaScript - The Definitive Guide from ORA, which apparently now has a 3rd revision printed in 1998) or a more down-and-dirty answer book (say perhaps The Netscape ONE Reference from SAMS). You might want to save your money and buy one of these other texts.

However, you can grab this at Amazon. Table of Contents

1. Introducing JavaScript
2. What JavaScript is All About
3. Stuff You Should Know: Basic Programming
4. Overview of JavaScript Programming

   Core JavaScript

5. Objects
6. Properties
7. Methods and Functions
8. Expressions
9. Statements
10. Variables
11. Events

    JavaScript in the Real World

12. Defining Functions, Objects, and Methods
13. How Do I?
14. "Plug-and-Play" Routines
15. Fixing Broken JavaScript Programs
16. Using JavaScript in Frames
17. Using JavaScript and Forms

    Extending JavaScript

18. Using JavaScript with Advanced HTML
19. Using CGI with JavaScript
20. Working with Java and Netscape Plugs-Ins
21. Using JavaScript for Sound, Animation, and Graphics
22. All About HTML
23. JavaScript Additions in Netscape 3.0

    Appendix A
    Appendix B

Nir Arbel has taken some time out of his reading of this vertiable compendium of software construction to give us a review of Object Oriented Software Construction, 2nd Edition. So, click below to read more about this behometh of words. Review of Object Oriented Software Construction, 2nd Edition
Author: Dr. Bertrand Meyer
Reviewed by:Nir Arbel

I have to be honest. I have not read the entirety of "Object Oriented Software Construction / 2nd Edition," although I did read most of it. The enormity of this thirteen hundred page behemoth is my official excuse. But first, a short introduction for the book and a good deal of why you, and myself as well, should read this book, cover-to-cover.

Object Oriented Software Construction / 2nd Edition, often acronymized by its fans to OOSC2E, was written by Dr. Bertrand Meyer, which is the designer of the Eiffel programming language, and head of Interactive Software Engineering, whose primary product is an Eiffel integrated development environment which they call Eiffel Bench. They have recently released a Linux port of their latest version of this product.

Now for the important stuff. OOSC2E is a must-read book for anyone who takes their programming seriously. This, however, might not be automatically gleaned out of its name. Object-orientation has generated as much mistrust and disbelief as it did praise and following. Take the hackers' development community and try to relate the object-oriented development model to it. Chances are you'd instinctively disregard this option as impractical, and there would be quite much to support this notion. For instance, the hacker's attitude of "everyone's code is everyone's code" seems to stand in opposition to the Object Oriented model's principle of "hide everything but that which should be absolutely necessarily exposed", but that may be a simple misinterpretation of this directive. The hiding principle's aim is not to support the anti-GNU notion of private code, but rather to help avoid misuse of code. I have no idea whether a true object-oriented development model would work for a disorganized group of hackers, but after reading the better half of OOSC2E, I'm not at all sure it's not worth a try. Furthermore, I am utterly convinced that the object-oriented method would yield numerous benefits in any software project large enough, if it were correctly implemented. But enough about Object Orientation. On with the book.

One thing that sets OOSC2E apart from other books that discuss the same subject is the non-condescending, all-telling manner of Dr. Meyer's writing. While many other books which deal with Object-Orientation hit you on the head with dry methodologies and principles, with little or not attempt to explain why you should even bother putting in the extra effort to correctly implement Object-Orientation, OOSC2E is written for the skeptic; for those of us who heard a bit too much about it and are beginning to suspect it to be a red herring. A conspiracy brought upon the heads of die-hard coders to diminish their belief in their abilities. Dr. Meyer does a brilliant job of stressing the importance of the Object Oriented method. First he begins with describing which areas in software development most direly need improvement at the moment, which he does by example, he then goes on to present feasible and reasonable solutions for the problems presented at their simplest and most abstract form. Then he goes on to define a set of more specific rules, from which he derives a set of principles. Thus endeth the book's introduction. By the time you traverse this part of the book (which is rather massive, actually), you're almost guaranteed to have acquired a better understanding of why and how the software development process should be improved.

Starting with the second part of the book, Dr. Meyer takes the reader through the process of implementing the principles that concluded the first part of the book. He does this by developing a rather simple, coherent notation which would allow the reader to better understand the ideas presented in the book. Little by little the notation is developed. Add a language construct here; insert a rule there. By the end of the book you have something which might as well be a programming language, although many programmers would consider it to be too simplistic to be of any use. There's also a dirty little secret concerning the notation which is kept from the reader until the very last page of the book, but most readers would catch on to it very quickly, if not while reading this review. If you'd rather find out for yourself then skip on to the next paragraph, as this may be considered a spoiler. As the book ends, the reader is told that the notation that was so meticulously developed as the book progressed is in fact Eiffel. Many would consider this a shameless commercial plug, since Dr. Meyer's company, as noted earlier, sells an Eiffel development environment. This would also explain why he chose to keep this a secret from the reader until the very last page of the book. Many would resent buying a book that claims to teach the Object-Oriented method, then discover that a good part of it teaches you Eiffel. But Morality aside, spreading Eiffel thin all through the book does nothing to harm its effectiveness. It may be argued that it's a big plus, because by the time you reach the last page, not only have you gained a better understanding of the programming practice as a whole, you've also learned another programming. Fact is that Eiffel is simple enough to aid the learning process rather than hamper it.

Luckily enough, the good writing that characterizes the first part of the book also carries over to the rest of it. But clarity of presentation alone does not make a book the classic that OOSC2E is. The book is virtually paved with mind-blowing and intellectually exciting ideas and concepts. So much that you'll often find yourself smacking your forehead and wonder why certain things have been, and still are, done so differently. Every page oozes uncompromising perfectionism. Ironically, that is exactly why some readers would find this book exasperating at times. One should understand that Dr. Meyer's point of view on the Object Oriented method is just that -- a point of view. There are many other conflicting views expressed by people no less creditable. And whenever the book comes to a debated or debatable point the reader often has to deal with a dogmatic, rather fanatic rationalization of the author's opinions. It is important to remember as one reads the book, not to take everything written as gospel. Dr. Meyer makes many, many excellent points and makes perfect sense most of the time. Just beware of the times he doesn't.

Another group of readers that may find this book exasperating is that composed of programmers of non-Eiffel, Object-Oriented languages, for the same perfectionism discussed in the previous paragraph. The book is filled with many examples taken from other programming, such as C++, Java and Ada, usually under the rubric of "how not to do things correctly". For instance, while it's true that automatic garbage collection is a very powerful programming aid, saying that its absence is unthinkable (C++ implementations, for example, almost never feature automatic garbage collection) may irritate programmers of languages which do not answer to Dr. Meyer's strict criteria, which have, in many cases, proved their usefulness as object-oriented programming tools.

A final note: A thorough read of this book may send you on the search for a good Eiffel tool. As mentioned earlier, ISE does sell a Linux version of their Eiffel Bench, but since I know many of you guys feel religious about the GNU license and since the Linux version is still rather unstable due to it being rather new, you might fancy an alternative. I can recommend two: SmallEiffel, which is a GNU-licensed Eiffel compiler, and Sather, which is a different language based on Eiffel. Sather, mind you, was originally conceived as a free product, which means that everything Sather is freely downloadable, including the language standard, the programmer's manual, tons of additional documentation, a compiler (which works just fine on Linux as far as I can tell), an Emacs major-mode and lots and lots more. It's quite a gem, really. Grab it over here.

Nir Arbel has taken some time out of his reading of this vertiable compendium of software construction to give us a review of Object Oriented Software Construction, 2nd Edition. So, click below to read more about this behometh of words. Review of Object Oriented Software Construction, 2nd Edition
Author: Dr. Bertrand Meyer
Reviewed by:Nir Arbel

I have to be honest. I have not read the entirety of "Object Oriented Software Construction / 2nd Edition," although I did read most of it. The enormity of this thirteen hundred page behemoth is my official excuse. But first, a short introduction for the book and a good deal of why you, and myself as well, should read this book, cover-to-cover.

Object Oriented Software Construction / 2nd Edition, often acronymized by its fans to OOSC2E, was written by Dr. Bertrand Meyer, which is the designer of the Eiffel programming language, and head of Interactive Software Engineering, whose primary product is an Eiffel integrated development environment which they call Eiffel Bench. They have recently released a Linux port of their latest version of this product.

Now for the important stuff. OOSC2E is a must-read book for anyone who takes their programming seriously. This, however, might not be automatically gleaned out of its name. Object-orientation has generated as much mistrust and disbelief as it did praise and following. Take the hackers' development community and try to relate the object-oriented development model to it. Chances are you'd instinctively disregard this option as impractical, and there would be quite much to support this notion. For instance, the hacker's attitude of "everyone's code is everyone's code" seems to stand in opposition to the Object Oriented model's principle of "hide everything but that which should be absolutely necessarily exposed", but that may be a simple misinterpretation of this directive. The hiding principle's aim is not to support the anti-GNU notion of private code, but rather to help avoid misuse of code. I have no idea whether a true object-oriented development model would work for a disorganized group of hackers, but after reading the better half of OOSC2E, I'm not at all sure it's not worth a try. Furthermore, I am utterly convinced that the object-oriented method would yield numerous benefits in any software project large enough, if it were correctly implemented. But enough about Object Orientation. On with the book.

One thing that sets OOSC2E apart from other books that discuss the same subject is the non-condescending, all-telling manner of Dr. Meyer's writing. While many other books which deal with Object-Orientation hit you on the head with dry methodologies and principles, with little or not attempt to explain why you should even bother putting in the extra effort to correctly implement Object-Orientation, OOSC2E is written for the skeptic; for those of us who heard a bit too much about it and are beginning to suspect it to be a red herring. A conspiracy brought upon the heads of die-hard coders to diminish their belief in their abilities. Dr. Meyer does a brilliant job of stressing the importance of the Object Oriented method. First he begins with describing which areas in software development most direly need improvement at the moment, which he does by example, he then goes on to present feasible and reasonable solutions for the problems presented at their simplest and most abstract form. Then he goes on to define a set of more specific rules, from which he derives a set of principles. Thus endeth the book's introduction. By the time you traverse this part of the book (which is rather massive, actually), you're almost guaranteed to have acquired a better understanding of why and how the software development process should be improved.

Starting with the second part of the book, Dr. Meyer takes the reader through the process of implementing the principles that concluded the first part of the book. He does this by developing a rather simple, coherent notation which would allow the reader to better understand the ideas presented in the book. Little by little the notation is developed. Add a language construct here; insert a rule there. By the end of the book you have something which might as well be a programming language, although many programmers would consider it to be too simplistic to be of any use. There's also a dirty little secret concerning the notation which is kept from the reader until the very last page of the book, but most readers would catch on to it very quickly, if not while reading this review. If you'd rather find out for yourself then skip on to the next paragraph, as this may be considered a spoiler. As the book ends, the reader is told that the notation that was so meticulously developed as the book progressed is in fact Eiffel. Many would consider this a shameless commercial plug, since Dr. Meyer's company, as noted earlier, sells an Eiffel development environment. This would also explain why he chose to keep this a secret from the reader until the very last page of the book. Many would resent buying a book that claims to teach the Object-Oriented method, then discover that a good part of it teaches you Eiffel. But Morality aside, spreading Eiffel thin all through the book does nothing to harm its effectiveness. It may be argued that it's a big plus, because by the time you reach the last page, not only have you gained a better understanding of the programming practice as a whole, you've also learned another programming. Fact is that Eiffel is simple enough to aid the learning process rather than hamper it.

Luckily enough, the good writing that characterizes the first part of the book also carries over to the rest of it. But clarity of presentation alone does not make a book the classic that OOSC2E is. The book is virtually paved with mind-blowing and intellectually exciting ideas and concepts. So much that you'll often find yourself smacking your forehead and wonder why certain things have been, and still are, done so differently. Every page oozes uncompromising perfectionism. Ironically, that is exactly why some readers would find this book exasperating at times. One should understand that Dr. Meyer's point of view on the Object Oriented method is just that -- a point of view. There are many other conflicting views expressed by people no less creditable. And whenever the book comes to a debated or debatable point the reader often has to deal with a dogmatic, rather fanatic rationalization of the author's opinions. It is important to remember as one reads the book, not to take everything written as gospel. Dr. Meyer makes many, many excellent points and makes perfect sense most of the time. Just beware of the times he doesn't.

Another group of readers that may find this book exasperating is that composed of programmers of non-Eiffel, Object-Oriented languages, for the same perfectionism discussed in the previous paragraph. The book is filled with many examples taken from other programming, such as C++, Java and Ada, usually under the rubric of "how not to do things correctly". For instance, while it's true that automatic garbage collection is a very powerful programming aid, saying that its absence is unthinkable (C++ implementations, for example, almost never feature automatic garbage collection) may irritate programmers of languages which do not answer to Dr. Meyer's strict criteria, which have, in many cases, proved their usefulness as object-oriented programming tools.

A final note: A thorough read of this book may send you on the search for a good Eiffel tool. As mentioned earlier, ISE does sell a Linux version of their Eiffel Bench, but since I know many of you guys feel religious about the GNU license and since the Linux version is still rather unstable due to it being rather new, you might fancy an alternative. I can recommend two: SmallEiffel, which is a GNU-licensed Eiffel compiler, and Sather, which is a different language based on Eiffel. Sather, mind you, was originally conceived as a free product, which means that everything Sather is freely downloadable, including the language standard, the programmer's manual, tons of additional documentation, a compiler (which works just fine on Linux as far as I can tell), an Emacs major-mode and lots and lots more. It's quite a gem, really. Grab it over here.

Rick Franchuk has written a review of Essential System Administration. As would seem apprent, the book covers (surprise!) Administration ranging from automating activities, maintenance to essential services. Click below for more info.

This is the second book review for Slashdot in my Path To Guru series. In retrospect, I should have reviewed this book first, but I wanted to get the latest edition and read through it to see what new stuff is in.

I'm reluctant to give ANY book a 10 out of 10 rating, but if there is any book in existence that deserves such, this is it. Every major aspect of Unix administration is covered in a concise and easy-to-digest format.

REVIEW: Essential System Administration Æleen Frisch (O'Reilly & Associates ISBN 1-56592-127-5)

Nutshell
Review: The name says it all... this book should be on the shopping list, on the shelf, or in the hand of anyone maintaining Unix boxen.
Rating: 10/10 Rick Franchuk - TranSpecT Consulting What's Good?

When I started dealing with serious administration issues, this book saved my bacon more times than I care to count. Nearly every facet of administration is covered, from the lowliest maintenance task (like emptying log files) through the essential services (DNS, Telnet, FTP, etc) up to an introduction of automating tasks using shell scripts and Perl. The author takes great pains to detail parallels between OS variants (which usually falls into a BSD way vs. SVR way arrangement), so the book can be used by virtually anyone in any *nix-ish environment.

Issues beyond that of purely technical matters are discussed as well. Æleen reveals some of the basic facts about being a Systems Administrator in a often comical, sometimes brutally honest, fashion. Real Life® examples of how certain situations were handled (or could have been handled better) to achieve the best results in the Admin->User interface are liberally sprinkled throughout.

What's Bad?

It's not easy to find any MAJOR faults in this particular text (hence the 10 of 10 rating), but there are a couple of minor annoyances.

Like all computer texts, this one too suffers from becoming quickly outdated. For most of the material, age isn't much of problem (chmod does the same thing it has done for quite some time), but specialized administration tools for your OS may have undergone major revisions since the release of ESA.

While the book gives you enough information to hold your own in most normal and many unusual/problem situations, it can't provide all information about everything. It operates best as a foundation text, supporting more detailed information in tomes written to cover specific topics. For example, ESA covers the use of sendmail in a short chapter about electronic mail services which can get you up and running, get aliases and forwardings going, etc. For serious sendmail work though, you'll need to consult a more complete writing on the subject (ORA's sendmail).

There's also a bit of overlap between this book and Practical Unix and Internet Security, my first review. While I personally don't find this so much of a problem (security should be on the mind of any good administrator), some people may resent feeling like they're paying twice for the same information.

What's In It For Me?

At the risk of repeating myself, buy this book. if you plan on doing anything more interesting on a *nix box than checking your E-mail. Even SiteOp veterans can get use from it if they suddenly find themselves administering another environment... I've recently taken on some Solaris boxes, and ESA has been most helpful to me in finding Sun equivalents to BSD tools.

Æleen offers advice to the newless clewbie administrator on the subtle power games involved in maintaining machines other people rely on to get work done. It's an odd sensation having suits twice your age act nervous around you, for fear of saying something that could upset you and suddenly make their quarterly report vanish (hmmm... what does 'rm -rf /home/blake' do? Whoops!) More often than not, interpersonal communication is the most important aspect of any Admin's job. Happy co-workers and management are also more likely to 'forgive and forget' when you perform the inevitable catastrophic fuck-up.

Wishful Thinking

I strongly believe every administrator should read this book... in order to facilitate that, I wrote an e-mail to Tim O'Reilly (the OR in ORA), asking him to HTMLize it and release it under GPA. I haven't received any response yet, but it has only been a couple of days and I'd expect he has a great many things to do with his time.

At present, I'm hoping he'll agree, but I expect that nothing will come of it. ORA deserves to make money, and ESA is almost certainly bringing in a substantial profit. There's a history of ORA releasing some of their work under GPA though, so you never know... I'll do a followup when I get a definitive answer one way or the other. Please don't start mail-bombing him (or me! ;) about it.

Purchase the book over here at Amazon.

Table of Contents

Preface

1. Introduction to System Administration
2. The UNIX Way
3. Essential Administrative Tools
4. Startup and Shutdown
5. User Accounts
6. Security
7. Managing System Resources
8. Automating Tasks with Scripts and Such
9. Filesystems and Disks
10. Backup and Restore
11. Terminals and Modems
12. Printers and the Spooling Subsystem
13. TCP/IP Network Management
14. Electronic Mail
15. Configuring and Building Kernels
16. Accounting

Afterward: Don't Forget to Have Fun
Appendix A: Bourne Shell Programming
Appendix B: Selecting and Installing Linux Systems
Bibliography

Rick Franchuk has written a review of Essential System Administration. As would seem apprent, the book covers (surprise!) Administration ranging from automating activities, maintenance to essential services. Click below for more info.

This is the second book review for Slashdot in my Path To Guru series. In retrospect, I should have reviewed this book first, but I wanted to get the latest edition and read through it to see what new stuff is in.

I'm reluctant to give ANY book a 10 out of 10 rating, but if there is any book in existence that deserves such, this is it. Every major aspect of Unix administration is covered in a concise and easy-to-digest format.

REVIEW: Essential System Administration Æleen Frisch (O'Reilly & Associates ISBN 1-56592-127-5)

Nutshell
Review: The name says it all... this book should be on the shopping list, on the shelf, or in the hand of anyone maintaining Unix boxen.
Rating: 10/10 Rick Franchuk - TranSpecT Consulting What's Good?

When I started dealing with serious administration issues, this book saved my bacon more times than I care to count. Nearly every facet of administration is covered, from the lowliest maintenance task (like emptying log files) through the essential services (DNS, Telnet, FTP, etc) up to an introduction of automating tasks using shell scripts and Perl. The author takes great pains to detail parallels between OS variants (which usually falls into a BSD way vs. SVR way arrangement), so the book can be used by virtually anyone in any *nix-ish environment.

Issues beyond that of purely technical matters are discussed as well. Æleen reveals some of the basic facts about being a Systems Administrator in a often comical, sometimes brutally honest, fashion. Real Life® examples of how certain situations were handled (or could have been handled better) to achieve the best results in the Admin->User interface are liberally sprinkled throughout.

What's Bad?

It's not easy to find any MAJOR faults in this particular text (hence the 10 of 10 rating), but there are a couple of minor annoyances.

Like all computer texts, this one too suffers from becoming quickly outdated. For most of the material, age isn't much of problem (chmod does the same thing it has done for quite some time), but specialized administration tools for your OS may have undergone major revisions since the release of ESA.

While the book gives you enough information to hold your own in most normal and many unusual/problem situations, it can't provide all information about everything. It operates best as a foundation text, supporting more detailed information in tomes written to cover specific topics. For example, ESA covers the use of sendmail in a short chapter about electronic mail services which can get you up and running, get aliases and forwardings going, etc. For serious sendmail work though, you'll need to consult a more complete writing on the subject (ORA's sendmail).

There's also a bit of overlap between this book and Practical Unix and Internet Security, my first review. While I personally don't find this so much of a problem (security should be on the mind of any good administrator), some people may resent feeling like they're paying twice for the same information.

What's In It For Me?

At the risk of repeating myself, buy this book. if you plan on doing anything more interesting on a *nix box than checking your E-mail. Even SiteOp veterans can get use from it if they suddenly find themselves administering another environment... I've recently taken on some Solaris boxes, and ESA has been most helpful to me in finding Sun equivalents to BSD tools.

Æleen offers advice to the newless clewbie administrator on the subtle power games involved in maintaining machines other people rely on to get work done. It's an odd sensation having suits twice your age act nervous around you, for fear of saying something that could upset you and suddenly make their quarterly report vanish (hmmm... what does 'rm -rf /home/blake' do? Whoops!) More often than not, interpersonal communication is the most important aspect of any Admin's job. Happy co-workers and management are also more likely to 'forgive and forget' when you perform the inevitable catastrophic fuck-up.

Wishful Thinking

I strongly believe every administrator should read this book... in order to facilitate that, I wrote an e-mail to Tim O'Reilly (the OR in ORA), asking him to HTMLize it and release it under GPA. I haven't received any response yet, but it has only been a couple of days and I'd expect he has a great many things to do with his time.

At present, I'm hoping he'll agree, but I expect that nothing will come of it. ORA deserves to make money, and ESA is almost certainly bringing in a substantial profit. There's a history of ORA releasing some of their work under GPA though, so you never know... I'll do a followup when I get a definitive answer one way or the other. Please don't start mail-bombing him (or me! ;) about it.

Purchase the book over here at Amazon.

Table of Contents

Preface

1. Introduction to System Administration
2. The UNIX Way
3. Essential Administrative Tools
4. Startup and Shutdown
5. User Accounts
6. Security
7. Managing System Resources
8. Automating Tasks with Scripts and Such
9. Filesystems and Disks
10. Backup and Restore
11. Terminals and Modems
12. Printers and the Spooling Subsystem
13. TCP/IP Network Management
14. Electronic Mail
15. Configuring and Building Kernels
16. Accounting

Afterward: Don't Forget to Have Fun
Appendix A: Bourne Shell Programming
Appendix B: Selecting and Installing Linux Systems
Bibliography

Rick Franchuk has written a review of Essential System Administration. As would seem apprent, the book covers (surprise!) Administration ranging from automating activities, maintenance to essential services. Click below for more info.

This is the second book review for Slashdot in my Path To Guru series. In retrospect, I should have reviewed this book first, but I wanted to get the latest edition and read through it to see what new stuff is in.

I'm reluctant to give ANY book a 10 out of 10 rating, but if there is any book in existence that deserves such, this is it. Every major aspect of Unix administration is covered in a concise and easy-to-digest format.

REVIEW: Essential System Administration Æleen Frisch (O'Reilly & Associates ISBN 1-56592-127-5)

Nutshell
Review: The name says it all... this book should be on the shopping list, on the shelf, or in the hand of anyone maintaining Unix boxen.
Rating: 10/10 Rick Franchuk - TranSpecT Consulting What's Good?

When I started dealing with serious administration issues, this book saved my bacon more times than I care to count. Nearly every facet of administration is covered, from the lowliest maintenance task (like emptying log files) through the essential services (DNS, Telnet, FTP, etc) up to an introduction of automating tasks using shell scripts and Perl. The author takes great pains to detail parallels between OS variants (which usually falls into a BSD way vs. SVR way arrangement), so the book can be used by virtually anyone in any *nix-ish environment.

Issues beyond that of purely technical matters are discussed as well. Æleen reveals some of the basic facts about being a Systems Administrator in a often comical, sometimes brutally honest, fashion. Real Life® examples of how certain situations were handled (or could have been handled better) to achieve the best results in the Admin->User interface are liberally sprinkled throughout.

What's Bad?

It's not easy to find any MAJOR faults in this particular text (hence the 10 of 10 rating), but there are a couple of minor annoyances.

Like all computer texts, this one too suffers from becoming quickly outdated. For most of the material, age isn't much of problem (chmod does the same thing it has done for quite some time), but specialized administration tools for your OS may have undergone major revisions since the release of ESA.

While the book gives you enough information to hold your own in most normal and many unusual/problem situations, it can't provide all information about everything. It operates best as a foundation text, supporting more detailed information in tomes written to cover specific topics. For example, ESA covers the use of sendmail in a short chapter about electronic mail services which can get you up and running, get aliases and forwardings going, etc. For serious sendmail work though, you'll need to consult a more complete writing on the subject (ORA's sendmail).

There's also a bit of overlap between this book and Practical Unix and Internet Security, my first review. While I personally don't find this so much of a problem (security should be on the mind of any good administrator), some people may resent feeling like they're paying twice for the same information.

What's In It For Me?

At the risk of repeating myself, buy this book. if you plan on doing anything more interesting on a *nix box than checking your E-mail. Even SiteOp veterans can get use from it if they suddenly find themselves administering another environment... I've recently taken on some Solaris boxes, and ESA has been most helpful to me in finding Sun equivalents to BSD tools.

Æleen offers advice to the newless clewbie administrator on the subtle power games involved in maintaining machines other people rely on to get work done. It's an odd sensation having suits twice your age act nervous around you, for fear of saying something that could upset you and suddenly make their quarterly report vanish (hmmm... what does 'rm -rf /home/blake' do? Whoops!) More often than not, interpersonal communication is the most important aspect of any Admin's job. Happy co-workers and management are also more likely to 'forgive and forget' when you perform the inevitable catastrophic fuck-up.

Wishful Thinking

I strongly believe every administrator should read this book... in order to facilitate that, I wrote an e-mail to Tim O'Reilly (the OR in ORA), asking him to HTMLize it and release it under GPA. I haven't received any response yet, but it has only been a couple of days and I'd expect he has a great many things to do with his time.

At present, I'm hoping he'll agree, but I expect that nothing will come of it. ORA deserves to make money, and ESA is almost certainly bringing in a substantial profit. There's a history of ORA releasing some of their work under GPA though, so you never know... I'll do a followup when I get a definitive answer one way or the other. Please don't start mail-bombing him (or me! ;) about it.

Purchase the book over here at Amazon.

Table of Contents

Preface

1. Introduction to System Administration
2. The UNIX Way
3. Essential Administrative Tools
4. Startup and Shutdown
5. User Accounts
6. Security
7. Managing System Resources
8. Automating Tasks with Scripts and Such
9. Filesystems and Disks
10. Backup and Restore
11. Terminals and Modems
12. Printers and the Spooling Subsystem
13. TCP/IP Network Management
14. Electronic Mail
15. Configuring and Building Kernels
16. Accounting

Afterward: Don't Forget to Have Fun
Appendix A: Bourne Shell Programming
Appendix B: Selecting and Installing Linux Systems
Bibliography

Rick Franchuk has written us a review of Practical Unix and Internet Security. Click below for the rest of the review:

This is the first of (probably) several reviews I'll be doing for Slashdot of books that I personally consider Essential on the path to Unix gurudom. Most of the books I'll be reviewing are not system-specific inside the definition of Unix, so should be equally useful for Linux, BSD, SunOS or any other flavor of nix-ish OS you might be handling.

I'll start this textual journey with Practical Unix & Internet Security. This book attempts to reveal, with some success, the whys and hows of hardening your servers against hostile attack, originating both from without and within your sphere of influence.

Practical Unix & Internet Security Simson Garfinkel and Gene Spafford (O'Reilly & Associates ISBN 1565921488)

Nutshell Review An excellent reference for anyone who doesn't consider him/herself as a Unix guru, but lacks enough detailed substance to satiate a seasoned hacker.

Rating: 8/10

Rick Franchuk - TranSpecT Consulting

What's Good?

There is an immense wealth of information regarding general security practices, detailing not just how things should be arranged for maximum benefit, but also WHY . As a neophyte administrator with only 'play-around' experience, I felt a little overwhelmed when I hired onto a new ISP to maintain a combination of FreeBSD and Linux machines. Because my use of linux to that point was primarily that of a single user with total machine control (a holdover from DOS experience), I didn't really know how to maintain multiple users so that they wouldn't collide. PU&IS helped resolve some of the more looming issues I had:

• File permissions (what is that sticky bit for, anyways?)
• UIDs/GIDs and how to assign them appropriately (why giving everyone group wheel is A Bad Idea®)
• How to enable and disable essential services (telnet, ftp, etc) without leaving the server wide-open or bringing the machine down totally

Of course, the book contains a great deal more. Topics range from the most simple, basic of tasks (like choosing a reasonably secure password) to semi-arcane (NIS+ administration and firewall setup), as well as non-technical security matters (reporting breakins and damage control, legal information, etc). See below for a more comprehensive list of what is covered.

What's Bad?

That being said, I should point out that this is NOT going to be the most useful tome to a seasoned administrator. A majority of the information contained within is geared towards getting new admins up-to-speed with the Unix way of life, and certain important areas are lightly glossed over (IP Spoofing, for example, is acknowedged to exist but absolutely nothing is revealed about how and why it works... you could get a better explanation written on the back of a napkin from a regular Phrack or 2600 reader).

Additionally, this book suffers from outdatedness, as are all computer-related texts. The 2nd Edition attempts to address more of the recent security concerns about the Internet (denial-of-service attacks get more exposure, packet sniffing concerns etc) but can't provide useful detailed information due to its age and the swift pace of software, OS, and attacker evolution. The most pertinent information revolves around unchanging security precepts and Unix foundations.

So What's In It For Me?

I'd strongly recommend this text, paired with another O'Reilly gem, Essential System Administration to anyone administering *nix-ish systems with experience below the "Advanced to Guru" stage. Probably the most important things you can learn from the book are:

• Be Paranoid - The more the better!
• Security through Obscurity Doesn't Work
• There's No Such Thing as Total Security
• Backups Save Lives (or at least jobs)

Personal Rant

<RANT Annoyance=mild>Unix is spelled "Unix", not "UNIX". It's not an acronym, it's a play on words from the name of its predecessor, Multics. See the History of Unix writeup, elsewhere in the annals of Slashdot. You'd think that O'Reilly and Associates, who consistantly make some of the best *nix books in existance, would figure that out by now.</RANT>

You can buy this over at Amazon. Table of Contents

1. I. Security Basics
2. Introduction (What is computer security, history of)
3. Policies and Guidelines

   II. User Responsibilities

4. Users and Passwords
5. Users, Groups, and the Superuser
6. The Unix Filesystem
7. Cryptography

   III. System Security

8. Backups
9. Defending Your Accounts
10. Integrity Management
11. Auditing and Logging
12. Protecting Against Programmed Threats
13. Physical Security
14. Personnel Security

    IV. Network and Internet Security

15. Telephone Security
16. UUCP
17. TCP/IP Networks
18. TCP/IP Services
19. WWW Security
20. RPC, NIS, NIS+, and Kerberos
21. NFS

    V. Advanced Topics

22. Firewalls
23. Wrappers and Proxies
24. Writing Secure SUID and Network Programs

    VI. Handling Security Incidents

25. Discovering a Break-In
26. Denial-of-Service Attacks and Solutions
27. Computer Security and U.S. Law
28. Who Do You Trust?
    

1. VII. Appendixes
2. Unix Security Checklist
3. Important Files
4. Unix Processes
5. Paper Sources
6. Electronic Resources
7. Organizations
8. Table of IP Services

Rick Franchuk has written us a review of Practical Unix and Internet Security. Click below for the rest of the review:

This is the first of (probably) several reviews I'll be doing for Slashdot of books that I personally consider Essential on the path to Unix gurudom. Most of the books I'll be reviewing are not system-specific inside the definition of Unix, so should be equally useful for Linux, BSD, SunOS or any other flavor of nix-ish OS you might be handling.

I'll start this textual journey with Practical Unix & Internet Security. This book attempts to reveal, with some success, the whys and hows of hardening your servers against hostile attack, originating both from without and within your sphere of influence.

Practical Unix & Internet Security Simson Garfinkel and Gene Spafford (O'Reilly & Associates ISBN 1565921488)

Nutshell Review An excellent reference for anyone who doesn't consider him/herself as a Unix guru, but lacks enough detailed substance to satiate a seasoned hacker.

Rating: 8/10

Rick Franchuk - TranSpecT Consulting

What's Good?

There is an immense wealth of information regarding general security practices, detailing not just how things should be arranged for maximum benefit, but also WHY . As a neophyte administrator with only 'play-around' experience, I felt a little overwhelmed when I hired onto a new ISP to maintain a combination of FreeBSD and Linux machines. Because my use of linux to that point was primarily that of a single user with total machine control (a holdover from DOS experience), I didn't really know how to maintain multiple users so that they wouldn't collide. PU&IS helped resolve some of the more looming issues I had:

• File permissions (what is that sticky bit for, anyways?)
• UIDs/GIDs and how to assign them appropriately (why giving everyone group wheel is A Bad Idea®)
• How to enable and disable essential services (telnet, ftp, etc) without leaving the server wide-open or bringing the machine down totally

Of course, the book contains a great deal more. Topics range from the most simple, basic of tasks (like choosing a reasonably secure password) to semi-arcane (NIS+ administration and firewall setup), as well as non-technical security matters (reporting breakins and damage control, legal information, etc). See below for a more comprehensive list of what is covered.

What's Bad?

That being said, I should point out that this is NOT going to be the most useful tome to a seasoned administrator. A majority of the information contained within is geared towards getting new admins up-to-speed with the Unix way of life, and certain important areas are lightly glossed over (IP Spoofing, for example, is acknowedged to exist but absolutely nothing is revealed about how and why it works... you could get a better explanation written on the back of a napkin from a regular Phrack or 2600 reader).

Additionally, this book suffers from outdatedness, as are all computer-related texts. The 2nd Edition attempts to address more of the recent security concerns about the Internet (denial-of-service attacks get more exposure, packet sniffing concerns etc) but can't provide useful detailed information due to its age and the swift pace of software, OS, and attacker evolution. The most pertinent information revolves around unchanging security precepts and Unix foundations.

So What's In It For Me?

I'd strongly recommend this text, paired with another O'Reilly gem, Essential System Administration to anyone administering *nix-ish systems with experience below the "Advanced to Guru" stage. Probably the most important things you can learn from the book are:

• Be Paranoid - The more the better!
• Security through Obscurity Doesn't Work
• There's No Such Thing as Total Security
• Backups Save Lives (or at least jobs)

Personal Rant

<RANT Annoyance=mild>Unix is spelled "Unix", not "UNIX". It's not an acronym, it's a play on words from the name of its predecessor, Multics. See the History of Unix writeup, elsewhere in the annals of Slashdot. You'd think that O'Reilly and Associates, who consistantly make some of the best *nix books in existance, would figure that out by now.</RANT>

You can buy this over at Amazon. Table of Contents

1. I. Security Basics
2. Introduction (What is computer security, history of)
3. Policies and Guidelines

   II. User Responsibilities

4. Users and Passwords
5. Users, Groups, and the Superuser
6. The Unix Filesystem
7. Cryptography

   III. System Security

8. Backups
9. Defending Your Accounts
10. Integrity Management
11. Auditing and Logging
12. Protecting Against Programmed Threats
13. Physical Security
14. Personnel Security

    IV. Network and Internet Security

15. Telephone Security
16. UUCP
17. TCP/IP Networks
18. TCP/IP Services
19. WWW Security
20. RPC, NIS, NIS+, and Kerberos
21. NFS

    V. Advanced Topics

22. Firewalls
23. Wrappers and Proxies
24. Writing Secure SUID and Network Programs

    VI. Handling Security Incidents

25. Discovering a Break-In
26. Denial-of-Service Attacks and Solutions
27. Computer Security and U.S. Law
28. Who Do You Trust?
    

1. VII. Appendixes
2. Unix Security Checklist
3. Important Files
4. Unix Processes
5. Paper Sources
6. Electronic Resources
7. Organizations
8. Table of IP Services

Rick Franchuk has written us a review of Practical Unix and Internet Security. Click below for the rest of the review:

This is the first of (probably) several reviews I'll be doing for Slashdot of books that I personally consider Essential on the path to Unix gurudom. Most of the books I'll be reviewing are not system-specific inside the definition of Unix, so should be equally useful for Linux, BSD, SunOS or any other flavor of nix-ish OS you might be handling.

I'll start this textual journey with Practical Unix & Internet Security. This book attempts to reveal, with some success, the whys and hows of hardening your servers against hostile attack, originating both from without and within your sphere of influence.

Practical Unix & Internet Security Simson Garfinkel and Gene Spafford (O'Reilly & Associates ISBN 1565921488)

Nutshell Review An excellent reference for anyone who doesn't consider him/herself as a Unix guru, but lacks enough detailed substance to satiate a seasoned hacker.

Rating: 8/10

Rick Franchuk - TranSpecT Consulting

What's Good?

There is an immense wealth of information regarding general security practices, detailing not just how things should be arranged for maximum benefit, but also WHY . As a neophyte administrator with only 'play-around' experience, I felt a little overwhelmed when I hired onto a new ISP to maintain a combination of FreeBSD and Linux machines. Because my use of linux to that point was primarily that of a single user with total machine control (a holdover from DOS experience), I didn't really know how to maintain multiple users so that they wouldn't collide. PU&IS helped resolve some of the more looming issues I had:

• File permissions (what is that sticky bit for, anyways?)
• UIDs/GIDs and how to assign them appropriately (why giving everyone group wheel is A Bad Idea®)
• How to enable and disable essential services (telnet, ftp, etc) without leaving the server wide-open or bringing the machine down totally

Of course, the book contains a great deal more. Topics range from the most simple, basic of tasks (like choosing a reasonably secure password) to semi-arcane (NIS+ administration and firewall setup), as well as non-technical security matters (reporting breakins and damage control, legal information, etc). See below for a more comprehensive list of what is covered.

What's Bad?

That being said, I should point out that this is NOT going to be the most useful tome to a seasoned administrator. A majority of the information contained within is geared towards getting new admins up-to-speed with the Unix way of life, and certain important areas are lightly glossed over (IP Spoofing, for example, is acknowedged to exist but absolutely nothing is revealed about how and why it works... you could get a better explanation written on the back of a napkin from a regular Phrack or 2600 reader).

Additionally, this book suffers from outdatedness, as are all computer-related texts. The 2nd Edition attempts to address more of the recent security concerns about the Internet (denial-of-service attacks get more exposure, packet sniffing concerns etc) but can't provide useful detailed information due to its age and the swift pace of software, OS, and attacker evolution. The most pertinent information revolves around unchanging security precepts and Unix foundations.

So What's In It For Me?

I'd strongly recommend this text, paired with another O'Reilly gem, Essential System Administration to anyone administering *nix-ish systems with experience below the "Advanced to Guru" stage. Probably the most important things you can learn from the book are:

• Be Paranoid - The more the better!
• Security through Obscurity Doesn't Work
• There's No Such Thing as Total Security
• Backups Save Lives (or at least jobs)

Personal Rant

<RANT Annoyance=mild>Unix is spelled "Unix", not "UNIX". It's not an acronym, it's a play on words from the name of its predecessor, Multics. See the History of Unix writeup, elsewhere in the annals of Slashdot. You'd think that O'Reilly and Associates, who consistantly make some of the best *nix books in existance, would figure that out by now.</RANT>

You can buy this over at Amazon. Table of Contents

1. I. Security Basics
2. Introduction (What is computer security, history of)
3. Policies and Guidelines

   II. User Responsibilities

4. Users and Passwords
5. Users, Groups, and the Superuser
6. The Unix Filesystem
7. Cryptography

   III. System Security

8. Backups
9. Defending Your Accounts
10. Integrity Management
11. Auditing and Logging
12. Protecting Against Programmed Threats
13. Physical Security
14. Personnel Security

    IV. Network and Internet Security

15. Telephone Security
16. UUCP
17. TCP/IP Networks
18. TCP/IP Services
19. WWW Security
20. RPC, NIS, NIS+, and Kerberos
21. NFS

    V. Advanced Topics

22. Firewalls
23. Wrappers and Proxies
24. Writing Secure SUID and Network Programs

    VI. Handling Security Incidents

25. Discovering a Break-In
26. Denial-of-Service Attacks and Solutions
27. Computer Security and U.S. Law
28. Who Do You Trust?
    

1. VII. Appendixes
2. Unix Security Checklist
3. Important Files
4. Unix Processes
5. Paper Sources
6. Electronic Resources
7. Organizations
8. Table of IP Services

Albert Strasheim writes"Programming Perl was written by Larry Wall (originator of Perl), Tom Christiansen and Randal L. Schwartz. It it also fondly known as "The Camel Book" because of the cute camel on it's cover page. It is published by O'Reilly.

The book retails for $39.95 in stores. You can order it from amazon.com for $31.96 (excluding postage and packaging) by going here. There is also a ton of reviews by other people available here.

This book isn't for everyone. If you're completely new to Perl this book will probably be a bit too much (unless you're one of those people who teach themselves a programming language by reading source code). It is aimed, I think, at the intermediate to advanced Perl programmer, and is more of a reference guide than a tutorial. If you're complete new to Perl you should get "Learning Perl" (The Llama Book) from amazon.com by going here.

The Table of Contents looks as follows:

1. An Overview Of Perl
2. The Gory Details
3. Functions
4. References and Nested Data Structures
5. Packages, Modules, and Object Classes
6. Social Engineering (deals with security issues)
7. The Standard Perl Library
8. Other oddments
9. Diagnostic Messages

This book is truely a must-have for anyone who wants to get serious about Perl, especially considering the release of the Slashdot code in a week or two. :)) "

Albert Strasheim writes"Programming Perl was written by Larry Wall (originator of Perl), Tom Christiansen and Randal L. Schwartz. It it also fondly known as "The Camel Book" because of the cute camel on it's cover page. It is published by O'Reilly.

The book retails for $39.95 in stores. You can order it from amazon.com for $31.96 (excluding postage and packaging) by going here. There is also a ton of reviews by other people available here.

This book isn't for everyone. If you're completely new to Perl this book will probably be a bit too much (unless you're one of those people who teach themselves a programming language by reading source code). It is aimed, I think, at the intermediate to advanced Perl programmer, and is more of a reference guide than a tutorial. If you're complete new to Perl you should get "Learning Perl" (The Llama Book) from amazon.com by going here.

The Table of Contents looks as follows:

1. An Overview Of Perl
2. The Gory Details
3. Functions
4. References and Nested Data Structures
5. Packages, Modules, and Object Classes
6. Social Engineering (deals with security issues)
7. The Standard Perl Library
8. Other oddments
9. Diagnostic Messages

This book is truely a must-have for anyone who wants to get serious about Perl, especially considering the release of the Slashdot code in a week or two. :)) "

Albert Strasheim writes"Programming Perl was written by Larry Wall (originator of Perl), Tom Christiansen and Randal L. Schwartz. It it also fondly known as "The Camel Book" because of the cute camel on it's cover page. It is published by O'Reilly.

The book retails for $39.95 in stores. You can order it from amazon.com for $31.96 (excluding postage and packaging) by going here. There is also a ton of reviews by other people available here.

This book isn't for everyone. If you're completely new to Perl this book will probably be a bit too much (unless you're one of those people who teach themselves a programming language by reading source code). It is aimed, I think, at the intermediate to advanced Perl programmer, and is more of a reference guide than a tutorial. If you're complete new to Perl you should get "Learning Perl" (The Llama Book) from amazon.com by going here.

The Table of Contents looks as follows:

1. An Overview Of Perl
2. The Gory Details
3. Functions
4. References and Nested Data Structures
5. Packages, Modules, and Object Classes
6. Social Engineering (deals with security issues)
7. The Standard Perl Library
8. Other oddments
9. Diagnostic Messages

This book is truely a must-have for anyone who wants to get serious about Perl, especially considering the release of the Slashdot code in a week or two. :)) "

Jeremy Rifkin, long known as a pundit against the biotech industry, and author of books like Declaration of a Heretic and Who Should Play God? continues to rail against the "thoughtless" biotech industry in his latest book The Biotech Century . And while he raises some very salient points, there are flaws to the arguement. Click below for more. Let's all be honest here-Rifkin is a smart puppy. He has done his research, and in the all years of lawsuits against biotech companies and raising public consciousness about the biotech industry, he has done good.

This book is especially well done in that respect, raising the issue of human gene therapy going so far to say "The new genetic technologies grant us a godlike power to select the biological futures and features of the many beings who come after us-the greatest shopping experience of all time." Very true-but also misses the point.

It is very easy to decry the biotech industry. The potential for harm is great, and the human sensitivity to this most private part of a beings is great. Rifkin raises the issue that many biotech scientists seem to view our DNA as source code, just there to be modified and recompilied for newer versions. And the abuse of the power must be avoided-no senseless manipulation playing in a field that we don't truly understand yet. But this is an area that research must continue forward in. Rifkin has toned down some of his older impassioned speechs against gene therapy of the past, but he challenges us to engage in "a great conversation" without giving any specific solutions.

He carefully steps around the precarious area of gene therapy that will the most hope-being able to fix things like CF, while focusing on environmental areas which might cause a disaster, a very politic approach. This scattershot approach does not serve him well. While he raises many fine issues, I find that I must at base disagee with him. Grab this book over at Amazon.

Jeremy Rifkin, long known as a pundit against the biotech industry, and author of books like Declaration of a Heretic and Who Should Play God? continues to rail against the "thoughtless" biotech industry in his latest book The Biotech Century . And while he raises some very salient points, there are flaws to the arguement. Click below for more. Let's all be honest here-Rifkin is a smart puppy. He has done his research, and in the all years of lawsuits against biotech companies and raising public consciousness about the biotech industry, he has done good.

This book is especially well done in that respect, raising the issue of human gene therapy going so far to say "The new genetic technologies grant us a godlike power to select the biological futures and features of the many beings who come after us-the greatest shopping experience of all time." Very true-but also misses the point.

It is very easy to decry the biotech industry. The potential for harm is great, and the human sensitivity to this most private part of a beings is great. Rifkin raises the issue that many biotech scientists seem to view our DNA as source code, just there to be modified and recompilied for newer versions. And the abuse of the power must be avoided-no senseless manipulation playing in a field that we don't truly understand yet. But this is an area that research must continue forward in. Rifkin has toned down some of his older impassioned speechs against gene therapy of the past, but he challenges us to engage in "a great conversation" without giving any specific solutions.

He carefully steps around the precarious area of gene therapy that will the most hope-being able to fix things like CF, while focusing on environmental areas which might cause a disaster, a very politic approach. This scattershot approach does not serve him well. While he raises many fine issues, I find that I must at base disagee with him. Grab this book over at Amazon.

Quite possibly, Good Omens or, as the subtitle reads The Nice and Accurate Prophecies of Agnes Nutter, Witch, is the funniest book I have ever read. The creation of the funniest British men since the spawning of Cleese and Palin, Neil Gaiman and Terry Prachett both make you laugh even that you forget to breath. But then again, how else should the world end? I tell you true, the Horsemen will come on Harleys... Click belong to read the full review. Both of these guys have long histories in the creative fields: Neil Gaiman has written other books, but is best known for his creation of one of the best comic book series ever written (er) The Sandman. The creative genius he evidences in that series is in full force in this as well.

Terry Prachett, the creator of the "Discworld" novels, writes in much the same vein. His ability to tell extremely dry jokes is often used in Egyptian mummification rituals.

So, the plot of the book is something along these lines: The End of the World is coming, but it is almost nothing like what you imagined it to be. Beyond that, it is almost impossible to quantify the story. But I think this text alone should convince you to buy the book:
"God does not play dice with the universe: he plays an ineffable game of his own devising, which might be compared, from the perspective of any of the other players, to being involved in an obscure and complex version of poker in a pitch-dark room, with blank cards, for infinite stakes, with a dealer who won't tell you the rules, and who smiles all the time."

You must buy this over at Amazon.

Quite possibly, Good Omens or, as the subtitle reads The Nice and Accurate Prophecies of Agnes Nutter, Witch, is the funniest book I have ever read. The creation of the funniest British men since the spawning of Cleese and Palin, Neil Gaiman and Terry Prachett both make you laugh even that you forget to breath. But then again, how else should the world end? I tell you true, the Horsemen will come on Harleys... Click belong to read the full review. Both of these guys have long histories in the creative fields: Neil Gaiman has written other books, but is best known for his creation of one of the best comic book series ever written (er) The Sandman. The creative genius he evidences in that series is in full force in this as well.

Terry Prachett, the creator of the "Discworld" novels, writes in much the same vein. His ability to tell extremely dry jokes is often used in Egyptian mummification rituals.

So, the plot of the book is something along these lines: The End of the World is coming, but it is almost nothing like what you imagined it to be. Beyond that, it is almost impossible to quantify the story. But I think this text alone should convince you to buy the book:
"God does not play dice with the universe: he plays an ineffable game of his own devising, which might be compared, from the perspective of any of the other players, to being involved in an obscure and complex version of poker in a pitch-dark room, with blank cards, for infinite stakes, with a dealer who won't tell you the rules, and who smiles all the time."

You must buy this over at Amazon.

Guns, Germs, and Steel: The Fates of Human Societies by Jared Diamond
reviewed by hemos

Chosen by Phi Beta Kappa as their science book of the year, Jared Diamond's take on world history has an unique point of view. Rather then looking at technology and society from the traditional mindset, he redirects it, effectively choosing to look at the rise of civilization from the point of view of some rather unlikely folks--like those of the New Guinea, amongst others. These basic frame shift greatly alters and upsets some of the basic assumptions that Western history has based itself on.

One of the most interesting portions of the book is its' postulation about why the West and East diverged, and what each respective area's advantage was. A large portion of the argument is that it was actually the West's ability to resist disease and infection that gave the West much of its' strength. An odd argument, considering that it was the East that had actually achieved urbanization earlier, but he does a credible job of defending his argument. As while, Diamond also considers one of the West's main advantages being diversity: diversity of geography, and hence of plants, lfe, resources--the whole thing. The advantage of Eurasia shows in the ability to grow more grain, support more people-who are more resistant to disease, and that the geography is better suited to communication and the spread of ideas.

The book obviously has some weight to it, considering the endorsements it has gained from groups like Phi Beta Kappa. It also does have some innovative arguments, ones that will stimulate and cause debate. If a bit overwhemingly, he does this area of study a service by focusing completly on provable scientific phenomena, beyond the theorizing that this particular field has often been victim to. Check it out at Amazon.

Running Linux, Second Edition
by Matt Welsh and Lar Kaufman
reviewed by hemos

Being a relative newcomer to the Linux world, I needed more assistance then one can obtain simply by reading Slashdot. Imagine my delight in finding/using Running Linux. The book will work for a variety of people , whether it be setting up Linux for the first time, or for those who feel more comfortable with Linux. The book's authors, Matt Welsh and Lar Kaufman, obviously understand Linux, and more to the point, the mentality behind the operating system itself.

The book was designed along with the fine folks at Red Hat and is available both with a companion disk, or separately. For someone just setting up Linux for the first time (and how many people haven't been converted ye t?) the first option is perfect. They can not only get a fairly recent build of the OS, but also have the knowledge base provided to them that will allow them to understand Linux in a non-threatening, and more importantly, non-frustrating way.

Because let's be honest here: most of us won't be buying new copies of the books, or at least rarely. And as well, most of us get our updates through different sources. But if we are truly committed to making Linux into a viable alternative for the world at large, we will need books like these, because we need to make Linux an understandable and workable alternative for the world at large, who aren't particularly concerned with which diffs have been issued and such. Running Linux is a step in the right direction--bringing it to the people at home, bringing it to where they live at. Running Linux is a perfect book for the introductory and med-level user. Get it at Amazon.

Microserfs by Douglas Coupland
reviewed by hemos

Acknowledged as one of the best young writers, Douglas Coupland earns his accolades in his fantastic book, Microserfs. Originally published as an except in Wired the original was so well written, and so believable that many people thought the story was a true one. And, in a sense, it is. As Alan Moore once wrote: "All stories are true." That is true for Coupland's works in particular. Part real-life, part creation, the stories are blended together in such a way that you believe it to be true--that it almost has to be true.

The story moves from working at Microsoft in Redmond to the excruciating agonies of making a startup company are all feelings that all resonant true. The beauty of Coupland's writings are that he makes people that we understand, and that we identify with In Microserfs whether it be the oddly obsessive nature of Bug, the human credentials of Daniel (the main character) or the genius of Michael, you can find people that you feel are you. That is rare--but Coupland has shown an amazing ability to understand people. He is the man who popularized the phrase Generation X in one of his earlier novels, although its meaning has shifted. Like the term or not, Coupland displays an unparalleled ability in making things not only clear intellectually, but making it feel like you are part of it.

That is probably what I loved most about Microserfs; the feeling of belonging. When the story is finished you understand, and want more. Reading some of the comments about the book at Amazon, I think the comment "The book IS me" is the most telling of them all. You want to be there, be part of it, and Coupland can make you feel that you are. Check out Microserfs for sale at Amazon.com.

Microserfs by Douglas Coupland
reviewed by hemos

Acknowledged as one of the best young writers, Douglas Coupland earns his accolades in his fantastic book, Microserfs. Originally published as an except in Wired the original was so well written, and so believable that many people thought the story was a true one. And, in a sense, it is. As Alan Moore once wrote: "All stories are true." That is true for Coupland's works in particular. Part real-life, part creation, the stories are blended together in such a way that you believe it to be true--that it almost has to be true.

The story moves from working at Microsoft in Redmond to the excruciating agonies of making a startup company are all feelings that all resonant true. The beauty of Coupland's writings are that he makes people that we understand, and that we identify with In Microserfs whether it be the oddly obsessive nature of Bug, the human credentials of Daniel (the main character) or the genius of Michael, you can find people that you feel are you. That is rare--but Coupland has shown an amazing ability to understand people. He is the man who popularized the phrase Generation X in one of his earlier novels, although its meaning has shifted. Like the term or not, Coupland displays an unparalleled ability in making things not only clear intellectually, but making it feel like you are part of it.

That is probably what I loved most about Microserfs; the feeling of belonging. When the story is finished you understand, and want more. Reading some of the comments about the book at Amazon, I think the comment "The book IS me" is the most telling of them all. You want to be there, be part of it, and Coupland can make you feel that you are. Check out Microserfs for sale at Amazon.com.

Craig Maloney has written up a great review of Java Game Programming for Dummies availible through Amazon.com. If you are interested in a book that is useful for both beginners or want to know more, click below. Java Game Programming for Dummies

Wayne Holder and Doug Bell

Review by: Craig Maloney.

Admit it. You've bought a "Dummies" book before, haven't you? You've probably seen such titles as "Chess for Dummies: or "Personal Finance for Dummies". (God help you if you bought "Sex for Dummies". :) ) Unfortunately, some of these "Dummies" books lightly touch on the subjects they try to educate upon. I found this to be true with "Crystal Reports for Dummies" (It was for work, OK?) The book was less helpful than the manual, and covered vastly less than what I needed to use it for. When I saw this book was going to be printed on Amazon.com, my first reaction was quite mixed.. Would this book be like the other game programming texts in my library? Would it touch on the same topics with the same brief introductions? Would it come up with some other crazy, unsupported framework? Happily, this book doesn't use the same stale examples (There isn't one single asteroids clone in this book, something that has been done to death in other books) It is also quite technical for a "Dummies" book. There isn't a tutorial on what object orient programming is in this book. There also isn't any mention of networked gaming in this book. What you will find, though, is a good introduction to 2D and 3D gaming concepts, as well as some different ways about achieving the same goals.

The book quickly takes the reader from a simple ball animation to a full fledged Pong implementation in two chapters. The example is quite straightforward, and the book takes very little time explaining it. The third and fourth chapter describe ball physics and how they relate to golf and pool. These chapters are why I picked this book up. Math discussions in school made me quite bleary eyed. This book, however, makes such subjects fun (with charts and diagrams even! )

Quite possibly the wildest part of this book is how they describe collision detection. Most books usually mention collision detection in association with sprite classes. This book, however, mentions it in the pool game example. In what is quite possibly the most math I have ever seen in a computer book, they use a function of time to compute the balls position.

Chapter five presents the sliding blocks puzzle, and a discussion on how to use images with applets. Pretty standard fare. The sixth chapter discusses the AWT in more detail with a blackjack example. There is a lot of information in this chapter, ranging from using a single image for graphics to differences between browser layouts.

I haven't read much past these chapters (the book just came out). The rest of the book looks just as interesting, though. Chapter 7 discusses 2D environments and has a Maze generating example. Sprites come into play in Chapter 8, with a action game. Animations, timelines, and sounds are covered in chapter 9. Chapter 10 does the obligatory 3D maze, and Chapter 11 is on how to texture the 3D worlds. I've seen better discussions on imaging than what's in chapter 12's "Advanced Imaging" (Read Kick Ass Java if you can find it), but the chapter does a good job explaining the basics.

The last three chapters are what really set this book apart from the rest. Each dummies book has a top ten list relating to the topic. This book has three such lists: Ten Secrets to making fun games, Ten Ways to Say 'Game Over', and "Ten Ways to Optimize your Java Code". Each of these lists bring up points many programmers miss in their game programming.

I recommend this book for anyone with experience in Java looking for a way to make a Java game. There is a lot of useful information in this book beyond the basics. The examples are well thought out, and give a broader treatment of the games Java is capable of. The examples also seem robust, and are all JDK 1.1.5 compatible (Most of the other books I've read are not JDK 1.1 compatible). Hopefully the authors will put some networked games in a future edition (or in a "More Java Game Programming for Dummies" book). Purchase it at Amazon.com.