Open Source Books

Great book, but the CD-ROM didn't come with it for some reason... slightly disapointed but will be able to read the html version online if I really need to.

The only reason I gave this book three stars is that most of this info regards GNU/Linux systems that are running a 2.2 kernel. The book points out in its text that the 2.4 kernel is upcoming. As I write this, the 2.4 kernel has been around for years now, and the 2.6 kernel (non-testing) is on its way. Likewise, some non-kernel material is also *completely outdated* (sound card configuration and NFS spring to mind). This book doesn't even mention kudzu, which is the bread & butter of RedHat, Knoppix, Mandrake, etc. Another way to put this: if kudzu can't autoconfigure your ISA hardware, this book may help.

However, the material in this book which is still relevent is worthwhile. If the author releases an updated edition, I'd be very tempted to buy it.

I've read (not just scanned) about 15 Linux reference books of varying depth and direction. Rute is the best. If you can have only one or simply can't live knowing you don't have the definitive guide then you must grab a copy of RUTE. Check out the TOC and Preface for an idea of why I'm so enthused. Briefly, let me just say that topics covered (many and well) are each treated with respect (at least a paragraph of text, not just usage summaries that parrot the man pages) and obviously were learned in the field, not from other books. There are other reasons, but I leave them for you to discover. ENJOY.

The best Linux book, period.

Theis title was chosen as the textbook for an introductory class on Linux. After several weeks the class concluded it was not a good choice for an introductory text. Although the book contains a wealth of information the book lacks any ordered teaching structure which a student can build on.

I really like Webmin and use it often since I'm not a Linux geek. There is good information in the book and it is well edited and presented. The problem is, the book describes an outdated version of Webmin. The program has a completely new interface which is sufficiently different to make this book much less desirable as a guide to the program.

In my view, this book contributes to understanding some of the Linux configurations for which Webmin provides an interface. But, if you are looking for help in using Webmin itself, you may be disappointed. I was. I probably won't return it, but I wouldn't have bought it had I known. I would love to see this book updated.

Being a fairly new Linux System Administrator, I find Jamie Camerons book a huge help. Not only does it cover evey aspect of Webmin, but also covers the essentials of Linux System Administration and how Webmin can be used to make things easier. The book follows a good sequence and builds upon previous chapters. I'm actually looking at purchasing another copy as I already have this one full of tabs and nearly worn out!

Gary Hull
Katterbach, Germany

Webmin is a pretty neat tool for administering a server using a GUI, particularly remotely. Managing Linux Systems with Webmin, written by Webmin's author Jamie Cameron, is an extensive look at using and extending it, a good guide not without flaws.

The book is structured as 60 chapters, without any division into sections and I have serious arguments with the order of chapters; why are the chapters about configuring Webmin at the end, for example. That said, the book has a fine index and the usual two-level contents make it a fraction easier to find what you want.

I do, however, have a little digression about the `Bruce Peren's Open Source Series,' of which this book is a member. Frankly, I think they all need, and deserve, a much stronger hand in editing. With this volume it is the bad structure and order; with "Intrusion Detection Systems with Snort" I found myself engrossed by the information and furious at the appalling grammar and sentence construction, particularly in the introductory chapters. The others in the series look significantly better at first glance but could still use better editing.

Once again we have an author or publisher who throws Linux into the title to make sure that it gets found by the greatest mass of likely readers while the tool described is more (not that I criticise the practice, they want to sell books.) Any *nix system can be controlled using Webmin -- including a great deal of Mac OS X not available through `System Preferences.' Indeed, I'd recommend the tool to all OS X users who want to gain better control and install better tools for the underlying BSD layer in OS X. I use it myself for just this reason. If you run any other *nix system don't be put off by the `Linux' in the title: very little of this book is Linux specific.

This one is well written -- Cameron has a light, informative style that I look for in a tech book. The book is well laid out, he gives good examples, good explanations and screen shots.

Cameron starts out with three introductory chapters on Webmin, its installation and security before launching into forty three chapters on using various Webmin modules, but with no real pattern to the order of most of the chapters. Why, for example, is the NFS module at chapter 4 while the Samba module is discussed in 43? I could list another half dozen examples without raising a sweat.

There is then a chapter on Usermin, the Webmin system for ordinary users. This is followed by three chapters on the server clustering system, a few on Webmin configuration and logging before the volume ends with chapters on building modules and themes.

Some of the chapters on the modules within Webmin border on merely stating the obvious, others are extremely useful. Overall they constitute a good manual to using the system, Webmin users who have not spent a great deal of time administering servers will find them particularly useful. The chapters on clustering, using Webmin on multiple servers to perform the same task at the once on many machines, are a good guide to administering and using this useful facility. I found the chapters on writing your own module more than adequate, I'm well under way to writing my first one after only a short time with the system and book.

One final complaint. Where in this book does it tell you how to start Webmin? I didn't want Webmin running from boot, so I answered No to that question and Webmin then ran. Nowhere did it tell me how to restart Webmin after I rebooted my computer and having the script `start' in the directory specified as the config directory is a little less than intuitive.

In conclusion, this is a good book. With a little work on the structure it would be an excellent book, rising from a rating of six to an eight or nine. the lack of structure makes it unduly hard to find what you are after. I would recommend Webmin, as a tool, to almost everyone running a supported server. If you have no need for the section on clustering and writing your own modules you could buy The Book of Webmin for a few dollars less or browse the same book (even download a PDF version free) at Swelltech, which is less comprehensive but much better structured (and tells you how to restart Webmin). If you want a guide to Webmin that includes notes on writing your own module then this will do until something better comes along, or they release a second edition with greater thought to structure and order.

Webmin is an open-source web application which puts a graphical user interface on the typically command line oriented tasks involved in administrating a Unix-based server. I personally have been using Webmin for many years already, although I initially acquired most of my administration knowledge by getting my hands dirty at the command line level. If administration is not your main job and you don't have all the administration tool syntax memorized or the time to wade through man pages, having a helpful interface like Webmin is a godsend.

The book's author, Jamie Cameron, is also the main developer of Webmin. When you read the book you realize that he is first and foremost a command line administrative guru. However, he wanted to develop something to help novice admins get important jobs done quickly without getting bogged down in learning syntax.

The book has a useful "Contents at a Glance" page at the start which is handy when you want to quickly look up a common administrative task. Then there is the main "Contents" section which contains all of the chapters' subtopics and titles. The end of the book contains a very thorough index. Although the book has 60 chapters, the author did not bother to explicitly divide them up into sections. On my first glance at the book, it seemed as though the chapters were not very logically ordered, but upon further inspection I realized that they follow the general ordering of the modules within the Webmin application. The one exception is that the chapter on configuring Webmin itself is found close to the end of the book although it is the very first module in the actual application. If I had to split the book up into sections, I would do so as follows: Introduction/Installation, System Modules, Networking Modules, Hardware Modules, Miscellaneous Modules, Server Modules, Usermin, Clusters, Webmin Configuration, Custom Module Development, and The API.

The book starts off with a rather short but efficient introduction, installation guide and security suggestions for Webmin. Maybe a few more ideas should have been included in the "Securing Your Webmin Server" chapter. I'm sure security is a topic which many admins would like to see emphasized because of the general mistrust of granting power to a remotely accessible administration system which might easily allow a hacker or ignorant admin to take down a critical server.

Webmin lets you perform many high-level tasks without ever knowing what files on the server are being affected. For myself, as a programmer who sometimes gets involved with administration work, I have configured sendmail services using Webmin many times and I have just let it work its magic without worrying about the file changes being made. This book, in addition to explaining usage of the application, fills in the details of what is going on behind the scenes.

I believe Webmin is a great tool for junior administrators or hobbyists to learn Unix-based administration as long as a book like this one is used so the processes are thoroughly understood. This book probably won't be of much use to a professional administrator with lots of experience and a repertoire of scripts to handle all daily admin tasks. Although, if you are a pro and have grown weary of tedious command line work, this book will help you quickly get up to speed with the Webmin interface.

I found that the book also introduced me to a few concepts I had only heard about but had not really bothered to delve into more, such as Usermin and Clustering. Usermin is basically a trimmed version of Webmin meant for use by the average user on a system. I can see this being used in cases where an administrator wants to give users enough power to control their own email and website settings without giving them shell access. The author devotes three chapters to clustering and explains its usefulness, management and configuration.

At the end of the book you will find a number of useful chapters on creating your own Webmin modules, including explanations of standard module flow structuring, API function descriptions, and a sample dissection of the default theme structure. This section alone may be reason enough for some to purchase this book.

The writing is fairly clear, although as I mentioned before, some of the unusual chapter ordering and missing section divisions are distracting. All in all, this book is a very thorough explanation of the Webmin administration interfaces as well as an introduction to the lower level work being done by the interface, and a short but informative section for those wanting to create their own modules.

Before buying this book, I used Webmin and thought it was pretty easy to use and didn't think I needed a book about it. Was I wrong.

Not only does this book teach you all the things that you can do with Webmin, it is an excellent general Linux tutorial. The author goes into details about each subject (including what command line programs are run or which config files are changed by Webmin) and provides the meaning behind each setting. Along the way, you learn things that you didn't know existed or couldn't figure out how to do. For example, I had no idea I could mount a folder from a Windows machine without using samba or NFS. If you need to set up Raid, LVM, Apache Web server, Samba, the list goes on... this is the book.

If you need to set up Linux in a home or small office with Windows file sharing, internet gateway, web and mail hosting, DHCP server, etc., you should buy this book.

This book is a great introduction to the topic of SELinux because of the information on its developmental background and lucid description of the objectives, advantages and maintenance of a SELinux system. I would recommend this book to someone who has a firm grasp of basic security concepts and programming principles and is interested in getting exposure to the security enhanced model of Linux.

Really only skimming over the problem, could be more in depth, since most online documentation about SELinux is really skimming over the subject too, or just overly dated.

Selinux is a conscious attempt to fundamentally rework and improve linux security. Previously, or more to the point, in most current linux machines, the security was somewhat of an ad hoc approach. This is mitigated by a formidable array of open source IDS tools like Ethereal and Snort that let a sysadmin often successfully depend her network and machines.

But as the frequency and virulence of malware attacks has increased, the Selinux of this book may be a timely reinforcing of the operating system. As McCarty explains, this book is geared towards a sysadmin, as opposed to a programmer. It discusses the new things you should know. Especially the concepts of role based access model and of domains. The former has shades of DEC's VMS, which had a very mature implementation. Or those of you with mainframe experience may also recognise familiar ideas.

Programmers may find the book a little sparse, as mentioned above. But possibly McCarty is devising a sequel for them.

Personally, I prefer books to focus either concepts or detailed implementation instructions not both. For complex topics like SELinux, you typically cannot fit the conceptual and pragmatic within one book. McCarty's SELINUX is no exception. SELINUX provides an excellent overview of concepts but struggles with policy implementation methods and procedures. I suspect the topic is simply too large for one volume. What implementation advice presented is clear and concise but you will have to search elsewhere for more detailed deployment advice.

Despite these issues, this book is recommended reading for anyone considering implementing SELinux. The conceptual overview is some of the best I've seen since SELinux got its start. Using charts, diagrams and examples, McCarty presents an excellent overview of the nuts and bolts of SELinux. Understanding the principles of Role-Based Access Control, Type Enforcement, and Security Objects is critical to both using SELinux and justifying its use. The latter may be a bigger hurdle than many anticipate. The chapters on these areas will arm you with sufficient understanding to make a clear case of why SELinux can and should be implemented in many Linux-based computing environments.

While there are brief examples throughout, the book's third chapter on SELinux installation presents a well-documented, step-by-step guide to installing SELinux. If you've never installed SELinux, these sections will prove very valuable. With clearly numbered steps and command line examples, you can have SELinux installed and configured with a default policy within an hour.

As a mix between the pragmatic and conceptual, SELINUX is a good start on this topic. Entry level SELinux users will probably not learn too much from this book, but if your are looking for a introduction to SELinux concepts along with some pragmatic advice for getting started, then this book may be for you.

So what makes Selinux more secure than standard Linux? Primarily it is the implementation of role-based access control, sandboxing, and an audit facility that allows the system to log any attempts to exceed specified permissions. It does all this without conflicting with the normal permissions of Linux. If you are able to access a file through normal discretionary access control then the role-based mandatory access control provides additional security to determine if you can run the file or not. The only way to open a file is if both systems agree that you should be able to open it.

The author covers installation, configuration, administering, and setting up a security policy. The presentation of SeLinux is straightforward and the security model is presented in a writing style that makes it clear and understandable to the reader.

SeLinux: NSA's Open Source Security Enhanced Linux is highly recommended as both a Linux security solution and an excellent book on how to utilize all the resources of SeLinux.

Brown did a great job of encapsulating a lot of entry-level and intermediate knowledge into this book. Each chapter stands along but furthers along the whole, which seeks to educate the reader about the various systems in SUSE Linux. Unlike many computer books, this book will age well because the information is specific but not tied to any one particular version. So what was relevant for 10.1 is equally relevant for 10.3 and beyond.

I read this book from cover to cover and learned a lot in the process. It is approachable and well written. It is technical but good at explaining and teaching.

Chris Brown is a talented writer, able to take a complex subject and both simplify and clarify it for everyone. Chris walks the reader through SUSE Linux step-by-step, explaining virtually everything you want to do with your system with ease and speed. If you're wanting to get up and running with SUSE Linux and enjoying your system and files, then this book even in the Summer of 2007 is well worth the money. I look forward to his next title.

'SUSE Linux' by Chris Brown is a perfect companion manual for any and all Linux enthusiasts looking to install, administer, configure and play with this distribution of Linux. Jam packed with 400+ pages of goodness, this is a must buy for anyone that isn't a SUSE Linux guru. Even for gurus out there, this book will no doubt improve your Linux abilities and get you up and running and/or super configuring your Linux box here and now!!

If you are looking to work with SUSE Linux now or in the future, pick up this book, you'll be glad you did!!

***** RECOMMENDED

I was (am) a complete noob to Suse and linux in general. I'm very experienced when it comes to OS-level stuff and computers, but I needed a good overall book to get my suse install going. Well, this wasn't the book to get. If everything works perfectly on your install, you're good to go - and you wouldn't need this book anyway! If, however, your install hiccups, then this book won't help.
Like the install section, the rest of the book is basics only. Not much in the way of troubleshooting, either.
I'm not saying it's not a good book. It may be perfect for the transition user, someone going from Win to linux and primarily interested in using desktop applications and doing simple admin tasks. Perhaps for that user segment, this is a five-star book. I wanted a bit more and for that, it doesn't deliver.
An example is during the install section. There's no info on dual-booting a machine. I don't want to speak for others, but I imagine that's a common install of linux. It's certainly what I wanted to do. No info was contained on how to do it, however. The install that is done in the book offers little in explanation of 'why' you would do things - just do them. Again, perhaps only a fault if you want something other than a vanilla single-boot machine installation.
Lastly, the book references version 10.1 and shipping version is 10.2. Some things have changed although not enough to say the book needs updating.

Ever since Novell purchased SUSE Linux there has been a whirlwind of activity, press releases, and articles everywhere about what they intend to do with it and where SUSE will go from here. In this book the author guides the reader through the details of the community distribution. The focus is on the desktop user who wants to migrate to SUSE but doesn't know much about Linux. Only minimal computer literacy is assumed and the author walks you through everything from the installation through setting up email, printers, network cards, users, and anything else you might want to configure on your desktop. The section on administration is well done and explains how to do things both from the command line and graphical interfaces. Other areas covered include graphics, audio, video, burning CDs and DVDs, installing and configuring on your laptop, package management, and network services including sharing files, remote access, configuring a web server, name resolution and everything else you would need to install and configure a small business server. SUSE Linux is highly recommended to those who want to learn the basics of this system as a desktop operating system. The server portion is useful for a small business server but for a high-demand server the proprietary version is preferred and not covered in this text.

Well done! Few computer books (I can only think of "Perl cookbook") have given me so much satisfaction. Very straightforward, the authors obviously know their jobs and they make a nice effort to deal with every issue worth mentioning. While I read it, every time a question/doubt popped in my mind, I was gladly surprised to find the clear answer some paragraphs later. Completely tuned with the style.
This is a book for people with some knowledge of the basics (Java-based web applications). I was planning to migrate from Struts1 to Struts2 and was frustrated by the available docs (the online book "Starting Struts2" was very weak for me); this book was exactly what I was looking for. Granted, Struts2 is not Webwork, but it is heavily based on it, so -in spite of some changes and dated bits- the heart of the information (and more important, the main concepts) are really here.

If you are doing Struts2 development, this is probably the best resource around. Hopefully that will change in the coming months. For the most part, the Webworks principals described in this book map over almost exactly to the Apache Struts2 project (with minor exceptions). I purchased this book for all of my developers and we were easily able to complete our project. I definitely recommend this book.

Really good book for webwork developers. Suggest to have next edition to reflect new changes,updates, and lesson learn(from previous edition) in webwork.

This book does an excellent job of explaining about WebWork straight from the developers of the project.

The online material about webwork gives you very limited knowledge about this fantastic framework. But this book takes care of all the gaps.

If the authors had replaced the velocity chapter with a corresponding chapter on Freemarker( which is now the official templating language of Webwork) it would have been fabulous. But in their defence, it should be stated that it is almost impossible to keep abreast of a framework such as this.

Struts 2 Integration seems to promise webwork a lot more potential. I have been involved in projects that are already using Struts 2. There is nothing to not love about this framework. This book does a brilliant job of revealing it to us.

Well, keeping in line with the AJAX in Action book I just read, this thing is a real cure for the insomniac. The authors of these books manage to drain every last bit of excitement out of even the latest of technologies. However, the topics do get covered if you can manage to keep your eyes awake. Through-out the read I often found myself rereading entire chapters because I just end up loosing interest. Also, it is written in such a manner that it begins to dig deeper into topics without first providing a strong foundation of the basics. For example, the first four chapters are using intercepts all through the code, however the reader still has very little or no idea what an intercept actually is. Examples are spread too far apart and sometimes there are no code examples to drive home a point. This will be my last In Action book purchase.

'Windows Developer Power Tools: Turbocharge Windows development with more than 170 free and open source tools' is one of the most cost-efficient books I have ever read in my life. As the title says, this book is jam-packed with some of the most helpful and needy tools that you can ever find for Windows all put into one huge TOME of a book (1250+ pages).

Spread over 23 chapters, content is broken up into topics like Windows Form, creating documentation, testing, bug tracking, XML, etc. etc. etc. etc. etc. There is so much here is would take quite a while to read but that's not a bad thing in this case. If you are an administrator, developer, or just anyone that wants to learn to use Windows more efficiently, you NEED to pick this book up today.

Love it Love it Love it Love it Love it!!!!!

***** HIGHEST POSSIBLE RECOMMENDATION

Windows Developer Power Tools: Turbocharge Windows development with more than 140 free and open source tools (Power Tools)

Overview

Open-source and free developer/performance tools can be found in abundance on the internet today but one of the few issues that generally comes up after you've gotten hold of one is "how does this work?".

On occasion you'll start to use a tool or add-in only to find out later on that there's a much better way to utilise the power you suddenly have at your hands - but by then, you've spent hours already "mis-using" the tool.

This book arms you with information, tips and tricks, how-tos and descriptions on a host of known, and possibly unknown, tools that will seriously help you speed up your development - so why not be the hero of the office and start developing smartly!

Over the last couple of years i've been in and out of windows and web development and felt that i was comfortable in both arenas. But after reading this book I knew that I could have been a much more efficient developer if only I'd known about the tools it explores.

The book is divided into suitable chapters, making it very easy to use the book for fast reference if you suddenly remember that you once read (somewhere?) about a tool doing exactly what you're trying to achieve in the old fashioned way - doing it yourself from scratch.

Each chapter (or tool/tip/add-in) is presented in an easily to understand english, with a logical order that makes reading this book a pleasure. Some books comes across with technical jargon without explanations for the varied levels of developers out there, but this book can easily be enjoyed by both the experienced developer and the starting rising star.

Some of my most favorite tools are included in this book, such as Anthem.Net, which encapsulates web forms and extends AJAX capability without having to write a single line of JavaScript.

Other tools which was new to me, included CopySourceAsHTML, and the experience with which i've had with posting code over the years, or including snippets in documentation, has just been greatly improved.

Conclusion

What i found most pleasing about this book, is the consistency in which it presents each topic for you. The authors has gone to great length to make it a flawless experience in reading this book and even though many has contributed to the content, the layout is flawlessly simple.

A very easy read and a bookshelf essential! Five stars...

I'm big into using the right tools for the right jobs. One can find a gazillion of tools out there on the internet, so it's hard to decide which ones are actually worth checking out. This book remedies that by giving you a consolidated list of tools that everybody developer should at least have a look at.

I also blogged about this book at:
http://claudiolassala.spaces.live.com/blog/cns!E2A4B22308B39CD2!356.entry

This book is an excellent source of useful tools and mini-howto guides. I especially like the layout where each tool is described along with links to the code, a summary of its abilities and a mini-howto on how to get started with the tool. The book gives a nice cross section of tools for all occasions, broken up by category. If you are new to development or are needing a tool to help you develop code then this book will probably point you in the right direction.

The reason for 4 stars rather than 5 is more because of the topic rather than the book itself or the authors. By its very definition some of the tools were outdated by the time of the book's release. It is a limitation of the publishing process. The authors simply have no way of knowing what tools will be available at the time of the books release. Therefore readers should not assume that each tool is the best in its category. Nor should readers assume that the howto guides are completely accurate for the current version. This book could have really used a CD containing each of the tools at the time of the writing so readers could get a feel for the tool without: a) having to download the tool separately, and b) try to match the current version of the tool to the version discussed in the book. Even better would have been a VPC image that users could run without having to install all the tools on their own system.

I'm hoping the authors put out a new edition later and, perhaps, include a CD of the tools. Until then this is one of the best books available for getting information on some really useful developer tools.

[...]

Until reading this book, I did not realize how much productivity I stood to gain.

When I first agreed to review this book I didn't know what I was really getting into. I expected a brief catalog of fairly standard, well-known tools which would only come as a surprise to fresh graduate. I expected I getting a small pocket-sized book which I could devour in one train ride. I could not have been more wrong.

The book covers over 170 Open Source tools across a wide variety of development domains from Windows Forms and Web Development, to working with Databases and XML data. Each tool will in some way enhance your productivity in some way, allowing you to do the things your really enjoy about writing software on the Microsoft Windows platform. The productivity gains vary from being able to generate the tedious 80% of your project to those 5 second boosts which all add up and prevent RSI.

Each of the 23 chapters is targeted at a particular issue or development task and opens with one or two pages describing this task. These are so well written that I think the opening of Chapter 9 [Analyzing Your Code], which gives a quick explanation of code metrics, is my favorite section of the whole book. This means that the book is not just an encyclopedic reference of tools, but also of modern development techniques.

After the introduction a very brief description of each tool follows. These are great memory refreshers once you have read the book and are repeated on the companion web-site. Each tool is then given its own section and the chapter closes with a bibliography for people interested in finding out more.

This structure of "Introduction, Overview data, Full text, Where to get more information" is repeated for each tool. The overview data includes such information as:

The version covered
The home page
The license type
Which versions of the .NET Framework are supported
A collection of related tools for cross-referencing purposes

The full text of each tool explains where to get the tool, how to install it and how to get started using it allowing you to jump straight in and leverage the tool. This section is often littered with useful screenshots which give you a glimpse at the experience you will find when using the tool. The text for each tool closes with instructions for getting support on the tool and often a brief passage from the tools creator explaining the thinking behind creating the tool.

If that weren't enough, the book also has a companion website at www.windevpowertools.com where all of the tools are listed and tagged, each with a download link enabling you to download one straight from the site. You can even create your own "toolbox" and add tools from the site to it, allowing you to quickly and easily provision new machines from the web site itself.

All in all I have thoroughly enjoyed reading this book. I would have liked to have seen more information about the selection process for the tools and readers would do well to remember that a tools inclusion (or lack of inclusion) in the text is not necessarily an indicator of its maturity or usefulness. Be sure that you have a lot of time if you buy this book as you are likely to download, install, and play with many of the tools. If you do then using a virtual machine is highly recommended. None of the tools did anything harmful to my computer, but having 170 tools running at once just isn't advised!

This is a good introductory book for Linux OS related programming concepts including memory management, files, IPC, signals and debugging. It does explain the concepts quite well and the code illustrations are very helpful. Its debugging and internalization chapters are noteworthy. As mentioned by others, this book does not cover threads and sockets.

It could be better to provide more complete coverage of the topics such as IPC and memory management. For example, the IPC chapter is limited to pipes and fifos (they are not even explained depth enough).

In short, I strongly recommend it as an introductory book for the topics covered.

I loved this book. It's earned an honored place on my bookshelf, and I'm going to recommend it to people who need information about Linux and UNIX development.

Many computer books are practically obsolete before they ship: within a few months, "Learn Foomatic 4.3 in 21 Days" is in the bargain bin at the Dollar Tree. Some books have longer lives, and a few can remain useful for years. "Linux Programming by Example" (LPE) is in this last category; this book can stand alongside Steven's "Advanced UNIX Programming" as an essential tutorial and reference.

LPE covers everything you'd expect (working with files, processes, signals, users) and some things you might not (internationalization). But it's this book's voice and unique perspective that make it truly a gem. LPE is written in a clear, friendly, authoritative style. As I read, I often felt that I had gained a new understanding of things I've known for years.

The long and twisted history of UNIX has given rise to multiple competing APIs. Perhaps the greatest thing about this book is the way that Robbins cuts through these thickets, explaining your choices, pointing out the best alternatives, and explaining why they're the best. LPE's modern vantage point means it can cover V7, BSD, POSIX, and GNU APIs. The chapter on signals alone is worth the purchase price of the book for the way in which it clearly compares and contrasts the various signal APIs.

I learned about this book from its sister book, Linux Kernel Primer: A Top-Down Approach for x86 and PowerPC Architecture. While the kernel book is not a good one at all, this one is a true gem. The writing is clear, lucid, and the examples are from the real world and thoroughly explained. In contrast, the kernel book gives overly broad and general introduction to a subject and then dives into the source code with disconnected commenting; there is such a big gap between the intro and the source code that it's not readable at all.
The auther Arnold Robinns also wrote a few other great books, including Learning the vi Editor and Learning the Korn Shell. With the achievement of this book, he ranks near the great, late Richard Stevens in terms of writing quality.

Linux Programming by Example: The Fundamentals is a great book that covers three main concepts in Linux programming: files, processes and debugging. In each part the author explains and gives several examples of functions, systems calls and APIs that will help the Linux programmer. He also includes several real world examples of how these concepts are implemented. Here are the some things that I found interesting:

The Good: 1) This book really focuses on the use of standards and good program design. Right from the beginning, the author goes out of his way to make the reader aware of standards from ISO and POSIX and how they apply to good programming and design. Along this line I also like that the author explains the benefits of - and promotes - the use of Gnu software. Being an avid Gnu user myself (as most Linux users are) I agree that Gnu software is generally better software.
2) I feel that knowledge is power, and the author goes along with this idea by showing how some things should *not* be done. He often points out several functions that are available but should be avoided. I appreciated this, and feel that it makes the reader an all-around better programmer. The author also frequently gives extra information and history which helps explain why things are the way they are. This was especially useful when explaining mount points and types of file system.
3) I liked the fact that the author uses real world examples to demonstrate the ideas being presented. I really appreciated the fact that he uses V7 code (older, smaller and less comlex code) to demonstrate his examples. This allowed me to be able to see how the features were implemented in simple code, without being overwhelmed by the modern equivalents. A great example is the V7 echo program - only 23 lines!

The Bad: There weren't too many things that I didn't like about this book, but if my arm was twisted I would say the following: 1) This book is called *Linux* Programming but really it is about Unix programming. I know they are similar, and maybe I am splitting hairs here, but the title could really be *Unix* Programming. Most of this stuff is generic Unix programming, and the author points out the special exceptions not only for Linux but for other Unix variants as well - such as BSD.
2) Don't confuse the word "Fundamental" with "Beginning." This book really isn't for beginning Linux programmers, but rather it teaches basic (or fundamental) concepts that Linux programmers should know and use. The reader needs to be moderately familiar with the C programming language if he or she is to be edified.

A great read, with some excellent examples of well written Linux programs. If you are interested in moving beyond basic Linux programming then you should definitely pick up a copy of this book!

This is an exceptionally fine book.

Robbins has supplied the reader with a vast number of
programs and a lot of elucidation. This is a primer in
Linux programming, but also serves as a tract on UNIX
programming. The illustrations stem, for the most part,
from actual GNU and Linux code.

This is an invaluable resource for those converting from
another system to Linux.

Amazon respondió muy rápido y completamente seguro y confiable. El libro lo recibí incluso antes de lo notificado por Amazon.

Mono, A Developers Notebook
By Edd Dumbill and Niel M. Bornstein
Published by O'Reilly
ISBN 0-596-00792-2
Reviewed by Steven Mullins-HuNTUG member

Another excellent developer's notebook is out and this is it.

I have found a lot of folks like myself that can't afford the subscription fees for the high end Microsoft products and for a cross platform environment. This works without the headaches of having to set a lot of rules and policies.
The book puts it all out there for you to get you ready to start real work, not having to learn where all the tools and the connections and repositories are. I have a small C# base and still get confused about certain things but this has really helped speed up with the basics. I have found that there are a lot of choices when we pick a language and the key to any good program is cross compatible and multiple language use.
This is extremely lightweight (you don't need a DVD worth of setup) I was happy to read this book and to get to the code samples that are always at the website.
This was another well thought out developer guide that O'Reilly is famous for.

I rate this 4 stars

Turns out there is more to making C# cross platform than I thought. Turns out the majority of the core of .NET is cross-platform when you use Mono, but the UI portion is not. So the book mainly concentrates on the use of GTK#, spending about 80 out of 250 pages on it. Other sections include XML processing, networking, core .NET, and installation.

The well written, concise, and focused. This is a strength, and a weakness. The book may be too focused by design. Which leaves you in a situation where you don't have enough book to be valuable on it's own. You will still need O'Reilly's Programming C# book to start learning C#.

I recommend this book to anyone looking to start with GTK#, or who is interested in porting their C# code off the Windows platform. I do not recommend this book for someone just starting out with C#.

Mono: A Developer's Notebook is an addition to O'Reilly's Developer's Notebook series, aimed at helping experienced programmers come quickly up speed on a new technologies and platforms. These books are heavy on code and examples, and light on theory. This book lives up to this mission well.

From the opening pages of the book, we learn that "Mono is an open source cross-platform, implementation of the .NET development framework." If you're an experienced programmer looking to take a dip into the .NET world, but not so eager to enter the Microsoft end of the pool, you're probably in for a treat with Mono: A Developer's Notebook.

This book gets going very quickly. The first chapter takes you through getting Mono up and running on your machine, with instructions provided for Linux, Mac OS X, and Windows. Although as Mono is such a moving target, much of what's there is likely already outdated. Even shortly after the book was released, I found discrepancies and differences in the process of getting Mono up and running on my own machine while following the book. Your mileage may vary. If you're the sharp arrow this book targets, that probably wont stand in your way. This chapter is followed by a whirlwind introduction to C#, aimed squarely at folks who already have a language or two under their belt.

The rest of the book provides examples of using Mono to accomplish common tasks such as working with files, strings, and regular expressions, GUI programming with GTK#, processing XML, and network programming. Each chapter has a number of "labs", in which a given task is explored, and sample code is provided to illustrate common ways to handle each task. The book is rather fast paced, and assumes a lot of its reader. Each chapter provides pointers to further resources about the given topic if you find yourself wanting to know more.

All in all, if you're the type who can skim over the basics and take it from there, then this book is likely to please. It gives you just enough information to get you on your way, but doesn't belabor the point with endless details. If, on the other hand, you enjoy probing through obscure corners of language references and exploring the nuances of syntax and expression, then this book is likely to leave you somewhat hungry.

The book is well written and easy to follow for an experienced programmer. Example code is plentiful, and clearly written. The code certainly takes center stage in the book. I did, however, notice a lot of typos and 'bugs' in the text. Perhaps that enhances the feel of a "developer's notebook", but even still the book could stand to have a little better proof-reading. One final nit-pick. Each page in the book is made to look like the page of a lab notebook, complete with a grid as the page background. A nice design touch, but a little hard on the eyes to comfortably read.

Bottom line, if you're an experienced developer looking to quickly come up to speed on C# and .NET development in the Mono environment, then this book will likely be a valuable investment.

All I wanted was to know how (difficult) would a .NET to Mono migration be. So - from a perspective of someone who has used .NET for a while and is curious about Mono - this book is a great read: concise, well written and sufficient. Not crusted with boring details - thank God! So, this certainly is not the only book on C# and Mono a newby needs.. It shouldn't be. To summarise - this book is a fast read and .NET-to-Mono migration much smoother than expected.

The Open Source/Free Software movement can be very confusing because it is a mixture of ideology, politics and business. To choose the proper license for your purposes you first have to understand the purpose of the various licenses. Some, specially GNU/GPL, are mostly political and ideological in nature in that they try to create a 'right to software.' Others are designed to further either academic or business interests through free software.

Except for Chapter 10, I found the book to be eminently readable. Unfortunately, Chapter 10: Choosing an Open Source License, which can be considered the core of the book, turned my brain to mush and was no help at all choosing a license. The author states:

"If you expect a checklist method to select a license, don't bother reading this chapter; it cannot be so easy."

While from an attorney's point of view this might be correct, from a developer's point of view you don't really have an alternative to creating your own checklist to pick a license. An attorney will give you the attorney's standard solution: "consult your attorney." When you do, your attorney will not pick a license for you, he'll rehash everything in the book and you still have the burden to pick a license. So why not nip in the bud this Catch-22 situation?

My own checklist, created mostly from what I learned from this book, is as follows:

1.- Ideological intent? What is your prime intent, to make a political statement or is it something else like promoting academe or running a business?

2.- Reciprocal licensing? What is more beneficial for your project, reciprocal licensing which limits contributor's choices or non-reciprocal which allows alternative licensing modes for derivative works?

3.- Can you afford an attorney? If not, pick a license template used by a very popular and successful open source project that meets your first two requirements.

Remember that you can always relicense and if your initial choice is not perfect, it can be perfected in time provided you don't chain yourself to some irreversible license.

I purchased this book 18 months ago, along with two other references. Since that time, I have learned that when I have a question, this is the book to turn to first. In fact, I haven't read the others since first buying them.

This week we had a request to license some code under the CPL. Not only does this book cover that license, but it has a chapter interpreting each of the clever sections, and its repercussions.

As both a licensee and licensor, I have yet to come across an issue which this book did not address. It is the single volume you need.

I have studied and compared Open Source licenses for a number of years. I came to the conclusion that the licenses created by Mr. Rosen were the best and I adopted one of them for my own Open Source projects. I have also read his book on the subject and I have concluded that it is also the best in its field. I recommend his book as a must-read for licensors of Open Source content.

Open source software is growing explosively around the world. The SourceForge web site now lists 87,006 projects being done by 912,545 people. That's almost a million people writing code, probably more than all of the programmers employed by Microsoft, Oracle, IBM, etc. etc.

The code being produced is distributed free of charge. Free of Charge, but not without restrictions. This book, written by the general counsel of the Open Source Initiative is intended to explain the various licenses that are in common use in the Open Source Community. It is written in English, not lawyer-speak, and intended for developers, managers, users and of course lawyers. If this is what you need to know, you'll not find a better source.

When I recieved this book I was excited, finally I could read a book which would help my brain really understand all the licenses! I sat down to read it, and was impressed with how the author took the popular licenses and broke them down into more easily understandable. I mean, they *are* fairly straight forward, but the author gets into what they actually mean in legal terms, and that's interesting.

Unfortunately it turns out that reading about specifics of Open Source law is not terribly interesting to me (I guess I'll never be a lawer) After the few introduction chapters I had to stop reading straight through it and skip around and skim the parts that interested me.

In my case this is not such a good book for snuggling up with in front of the fire (some computer books are), but it is a fabulous reference book, written for us mere mortals.

This should be considered a required resource if you need to learn about writing apache modules. It is the best introduction available to writing modules for Apache 2, and holds up well as a reference.

Apache is more than a popular Web server; it's a versatile and complex platform covered well in THE APACHE MODULES BOOK, the first guide for developers who already work with Apache and want to make the most of its features. From code security and basic processing to C-based shortcuts and techniques, APACHE MODULES BOOK uses real-world code examples and techniques to provide an excellent manual of basics. Perfect for any serious programmer's Apache reference collection.

I tried to write an Apache module using only the documentation and reference material available on the net, and failed. The documentation you can find on the net (even on Apache.org's own website) is either completely out of date or maddeningly vague. If you spend enough time in trial and error you might get your module to work. Then again, you might not.

If you're trying to write or maintain an Apache module, this book is an invaluable tutorial and resource. It saved me a great deal of time and frustration.

This book came recommended to me from a well-learned Apache module developer, and I can't laud it enough. It is simply impossible to find another reference text out there that covers this topic with this level of completeness. I'm not really sure why the HTTP RFC and the Apache Software License is tacked on to the end of the book, but the real content of the book make it well worth the relatively hefty price tag.

This book easily earns five stars despite a few glaring issues. Why? It's the best, most consitent, and approachable guide you'll find to writing Apache modules.

I spent two weeks scouring the net for APR examples and explanations. I started with the O'Reilly books only to find they are incredibly out of date. I moved on to Apache sanctioned module source code. I dissected source code for other modules only to find that the examples fluctuated on approach and, apparently, on the author's grasp of the entire APR libraries. Some folks wrote against previous APR version libraries and macros. Others used the updated APR. Still others rolled their own versions of functions that were already written, just not discovered. Tutorials varied in reliability with similar issues. And my desk quickly filled with highlighted and sticky-noted annotated examples.

This book replaced all those loose inconsistent notes with a solid example-centric nicely bound guide. Five stars. Just for that.

This book is not without problems though. First, it makes reference to programming paradigms which, frankly, I've never heard of before and which this book inadequately explains. Brigade buckets is an example. Bridage buckets are incrementally explained as a ring data store (eh?), a doubly linked list (okay, firm ground), and then a mechanism for passing data through layered IO (another eh?). I couldn't get much from the explanation. Googling "brigade bucket" led to IEEE DSP circuit design and a heated debate on using solid state delay effects for guitar pedals. Apparently brigade buckets don't quote share the same prolific status as, say, something more Knuth-ess.

The book explained thread safety in a similarly gap toothed summary. It offers this fatherly advice: avoid shared memory and make sure functions are reentrant. That wasn't much help for me. I'd prefer to have a detailed explanation of why the APR libraries have both reentrant and non-reentrant versions of the same functions. Wouldn't any reasonable programmer always use the reentrant version? If not, I'd like to know why... with some precision.

The final gripe: the book includes RFC 2616 in it's entirety. This needlessly adds 200 pages of non-original and otherwise easily (and FREEly) accessibe volume. Granted, the publisher formatted the RFC nicely. It's a bit easier to read than the fixed format of the real RFC. But why not add a few notes? The author could have taken the edge off of the RFC-legalese and made it a bit more approachable (think learning bible with more notes than text). At the risk of discouraging future books of this level, the RFC is a blatant copout and just a really disgusting way of bumping page numbers.

So, those are the issues I had. I'm still giving this a solid five as it outshines any other information I've found to date.