Open Source Books

Samba is great and this book covered the subject thoroughly. Very pleased.

This is not an introduction to Samba but a technical reference written by those who know it best - the Samba Team. If you already know something about Samba then this is the place you will find very detailed explanations of all the internal and external capabilities of Samba-3.0.11 and higher. While it is easy enough to find information on how to set Samba up as a file and print server, how to use its other features is harder information to come by. This book details setting up Samba as a domain controller, backup domain controller, or domain member, network browsing, access controls, record locking, securing Samba, interdomain trusts, printing support, user profiles, administration, monitoring, and tuning. A voluminous tome, most people will not be inclined to read through it but would more likely read the sections relevant to their current needs and the book is organized so that it is easy to use that way. A true technical reference it has everything you are likely to ever want to know about Samba-3 and how to set it up correctly as well as how to resolve common problems. This is a reference that I will be keeping close at hand and you will want to too if you use Samba-3. The Official Samba-3 Howto and Reference Guide, Second Edition is highly recommended.

I tried to get started with SAMBA, but could never get off the ground using material printed in many Linux books. After going through this book, I realized many key concepts that I was missing, such as windows domain accounts to Unix account mappings and such.

This book has an abundance of information in it. Some things that look exciting were some information about the PDC/BDC style integratrion and also Active Directory Kerberos integration. There's also a section on CUPS integration.

Overall I found this resource quite invaluable. Maybe there's online material that is better, but for printed text this is one of the best books out there...

Anxious to set up samba at home I headed down to the local bookstore and picked up this book at full price (perhaps the only samba 3 book there). I think I read about 1/4 of the book and have now decided it will be going back tomorrow. It's easy to read if you have some Windows and some Linux/UNIX experience, but every chapter is plagued with sentences an 8th grade student failing English could have pointed to problems! Sometimes it was difficult to determine what the meaning of some statements should be. In one chapter a discussion of non-encrypted passwords repeated advantages from the discussion of encrypted passwords, advantages that clearly do not exist!

It feels likes the HOWTOs from the Internet were simply copied, so why wasn't there time to edit?

This book reports the Samba 2 configuration examples and seems to ignore that Samba 3 "talks" directly with LDAP without the numerous "scripts" that are reported in the examples. This ia a Samba 2 daptation to the LDAP directory service and simply sucks!
If you want to make a donation to the Samba "father" John Terpstra, then buy the book but for real stuff, simply go in Internet, you will find exactly the same obsolete documentation, not a word more nor less.

I bought this book several years ago for my son when he was in high school. Since then I've kept it in work and it's been borrowed many times by ASP and Java programmers looking to broaden their knowledge, modify existing systems or to customized any of the many PHP based applications and frameworks that are available on the internet.
It's a great book to learn what is still one of the most commonly used language on the web.

After a long search and 3 PHP books later, I have finally found something that was perfectly structured and EASY TO UNDERSTAND. If you are looking to learn PHP fast, start with this book. 4 stars instead of 5 only because its a bit dated, though still an excelent foundation.

Perfect for a newbie programmer. I had more trouble installing PHP than using the book.

This thing was the best computer book that I have ever purchased. The way it was layed out was the easiest I've ever had to learn anything in computers...and I'm a network engineer, and have been for 10 years.

Great book...get it!

This book is a must have reference to PHP programming. It's a bit difficult to read, but it's great to have around. If you are an absoulte beginer looking to learn PHP, this isn't your book right away...wait a couple of months and then buy it.

It nicely covers the 2.4 version of gimp. The book is well structure and pleasant to read. It covers all the basic functions of the gimp.

The book is very well written and provides a lot of background information that is helpful.

For instance, in primary school (pardon the pun) we were taught about primary colours and how Blue plus Yellow gave you Green. The RGB system however has Red, Green, Blue as its basics, and Yellow becomes a Red Green composite.

I enjoyed it, and will obtain the basic online GIMP documentation and another text from Amazon to get me going.

I want to create some derivative sketches from photographs, and creating layers which derive from the original, and merge together to form a basic sketch.

I was looking for a 'cookbook' approach, but this book tries to give more depth without getting so technical that you lose interest.

Thanks Klaus Goelker for writing it.

This is a book that I did like. And yes Grokking the Gimp the online book is about as good and free. But if you want a book by your side for gimp. Get this book.

Sherm

The Gimp has evolved over the years, with pieces tacked on here and there to add features that help it keep pace with Photoshop (at a much lower "price.") Originally a program written by propeller-heads for propeller-heads, the program has actually become useful for photographers who don't have a computer-programming bent. Even so, the interface can be confusing, and that's where this excellent book comes in. It helps you sort out all the features of The Gimp so you can get up and running and actually use this program. Then, it shows you what you need to know to move into more advanced image editing. Highly recommended.

I found this book a good start for beginners but not sufficient to address the need of intermediate or advanced image editors. Well written but poorly binded.

This handy book takes common tasks and presents how to accomplish them, but it does more than that - it puts context around the dry reference material I usually end up using. That context makes a difference and ends up saving me time when I want to accomplish some task I don't do every day.

This book is a time and headache saver.

I find this book a good mate for everyone who likes more reading on printed paper rather than a pc screen.
Through the pages you'll find plenty of examples and advices, expecially in the FAQ sections, but on the other side every single word is already available on the samba's official site.
Maybe, if this book was cheaper, people could buy it and place it on their desktop as a trusted fella.

The name says it all. This book is an excellent guide for the latest version of Samba. From small networks to enterprise level integration, Terpstra walks the user through examples.

I recommend this book not only for the great examples, but because it is great at instruction. In the first chapter it reviews network scanning and nessus as a way of troubleshooting and understanding the protocols. This kind of instruction is hard to find in most books.

Another great feature of this book is the breadth of the subjects covered. From active directory to ldap to kerberos and security - I was impressed with just the table of contents.

Overall, you can find more in-depth coverage of any of the individual topics in the book, but no one source quite like this one. It is a great book both for novices and for experienced administrators newly faced with unix/windows integration with samba.

Most books either provide untested examples for how to do this sort of thing, and so can only be taken as illustrative, and/or they cover a very narrow range of tasks. Terpstra has done neither: he's provided examples that actually work, that have been tested in operational environments, and he has provided a broad range of examples, examples that are useable regardless of the network type in place.

Further, he has written this book in a very accessible way. While Samble-3 is targeted at Readers with experience in networking, this book is useable by newbies, as well. Although Terpstra provides some rationale for his setups, his step-by-step directions simply can be followed in cookbook fashion until experience teaches more broadly.

Using Linux in a Windows desktop environment requires the use of Samba for file and print sharing via the Windows explorer. But Samba has grown up as a full-fledged package for communicating between Linux and Windows over the last few years. Installing Samba as a Primary Domain Controller, implementing ldap for easy directory integration, or just installing it as a file and print server are all easy to do with the help of this book. The author takes a much easier to follow approach than most other writers on this subject. Instead of trying to go through each of the features and discuss them in detail he organizes the book by the type of installation and then walks you through a correct setup for that situation. For example some of the sections are: No-frills Samba Servers, Small Office Networking, Secure Office Networking, The 500-User Office, A Distributed 2000-User Network, Migrating NT4 Domain to Samba-3, and Migrating Netware Server to Samba-3. For each one of these situations the author dissects the technical issues, discusses each one, and then walks the reader through the implementing. The author also includes sections on things like performance, reliability, LDAP, and updating Samba. Nothing is left unexplained but each time you are told to check something or do something the exact syntax for doing it is given. Even with only very little or no Linux experience you can walk through this book and install a correctly functioning Samba server. Samba-3 by Example is highly recommended.

This is the best available source on SQLite 3. It thoroughly covers how this junior version RDBMS differs from the big boys (like Oracle, MS SQL, PostgreSQL, etc.) It covers especially well the unusual variable typing and the special role of SQLite as an embedded relational database. For my purposes, the book spends too much time on the internals and the background C and C++. I wish it had covered in more detail the language extensions for embedding SQLite in Perl, Python, Ruby, Java, Tcl, and PHP; but I did learn a great deal about these extensions that I have found nowhere else. Free open source software can only document so much: at some point, one must consult a book written for profit such as this one.

I read this book cover-to-cover, except for most of the C API material. It contains a useful SQL overview, along with Sqlite3 specifics. I have done corporate database programming in my younger days; but even so, the overview was a helpful refresher. However, a person current in SQL would consider this material fluff.

That said, the Sqlite3 specifics make the book worth the price. It is written well enough, and I enjoyed the read. I'm a perl guy, and I was disappointed that there wasn't more perl-related info. I got the feeling that the author was unfamiliar with perl, and lifted the information from elsewhere.

Other reviewers have complained about the index, and they are right. It is incredibly inadequate. This fault makes the book annoying to use as a reference. I have been penciling page numbers into the index as I use the book.

I am writing this review after 4 weeks or so of receiving the book. I have been developing a project on the weekends during that interval.

I bought this book to use in conjunction with TCL for organizing a lot of online data obtained from web scraping for my business needs. I am an experienced C programmer (20+ years), but relatively new to both TCL and SQL. I was under the impression that SQLite was a fairly complete subset of MySQL, both from this book and other online hype. But from my limited exposure thusfar, there are gaps in thinking that one can apply most MySQL syntax to SQLite. I also bought O'Reilly's "MySQL Cookbook" hoping to find some good example code to springboard from, but many of these examples didn't work with SQLite. That said, the old adage that one can do a lot with a little is still true, so don't necessarily give up on SQLite. I've yet to find some missing feature that couldn't be handled with a little added script programming.

After reading through the introductory chapters of the book, I was ready to start trying things. This is where the fun began. I quickly learned that the command line interface so well illustrated in the book either did not work when used with TCL queries, or had a very different syntax. This mainly applies to the dot commands of the shell (i.e., .help, .schema, etc.), but I have also found it true for some SQL statements that were used in the examples. (FYI: the subset of dot commands are called methods when implemented by TCL). This is not a fault of the book so much as it was a realignment of my expectations that one should be able to do anything with a script that one can type in from the command line. However, it would have been nice if there had been sections of the book alluding to the fact that all that was demonstrated for the command line is not possible with TCL scripts (I have no experience with the other scripting languages and the C interface). It would not surprise me if this deficiency is news to the author (hint for version 2 of the book).

Here is one simple headache I encountered: I had a long battle (many fruitless hours) trying to deal with entering records and getting the PRIMARY KEY value to increment automatically as advertized - I cannot make it do that consistently without having to specify the incremented index value myself (I was using SQLite 3.5.1) when adding records. The examples in the book that show how to do this flat did not work in my TCL script based versions. Autoincrementing would sometimes work once the database was primed with existing records entered from the command line, but not for a brand new table. I may have also uncovered a bug, since this is supposed to be such a basic feature.

In fairness, I've not tried all the command line statements with the shell as specified in the book to see if they work, but I would suspect that they do. What I have tried did work as described, so I have a good confidence in the book. To be clear, these problems are not so much the fault of the book but really my high expectations for what could be done with the scripts. If there is another syntax to allow these things, I've yet to find documentation on it.

I also learned that many features in the syntax for MySQL will not work with SQLite, and this is not made clear from the limited set of things mentioned on the http://www.sqlite.org/omitted.html page. You will have to find a way to accomplish those tasks with your scripts in addition to what the SQLite commands offer.

Regarding highlights of the book, I really liked the introduction to SQL under the heading of "The Operational Pipeline". The author takes the standard SELECT statement and breaks it up into the steps that SQLite must go through to parse and sequentially execute the statement. This is tremendously helpful in understanding the capabilities and potential pitfalls that are inherent in the syntax vs. what you are trying to accomplish. The book also has what appears to be good advice (although I've not read that portion) dealing with database design issues. That may contain further information that could have reigned in my expectations.

I also really liked the example databases and the tremendous flexibility that was illustrated with the examples. This is a help for a newbie learning the capabilities of a data base manager, and getting some ideas for what sort of things SQL could handle versus what should be done with external programming. I thought the author did a very nice job coming up with the examples, and the wide variety of things one could do to process the data. These explanations of capabilities made it worth the price of the book for me.

On the neutral side, I felt the pages dedicated to how to compile your own version were a little pointless given the number of binaries that are supplied by SQLite.org ready to go. However, if I'd been a Linux newbie, or had an unusual target environment, this may have been more appreciated.

On the deficit side, another negative is that the book's index is not as comprehensive as it might be. I went looking for things that I had read only to be disappointed by not being able to find a reference for them. It would be nice if the printed version could be supplemented by Apress online with an electronic concordance (easy to generate these days). This was promised by their ad for the online "SuperIndex" in the back of the book, but I found it woefully lacking in practice. They do offer an eBook PDF version of the book for only $10, so if I was willing to buy this, I could solve the problem (assuming the PDF is fully searchable).

Since I was using TCL, I can't vouch for the Python, Perl, Ruby, Java, PHP or C API interfaces, but its nice to know there is some information there. I was disappointed with the limited TCL information (only 3 pages) but thankfully, this is the best documented script interface with online sources, given SQLite's author's personal dedication to supporting it. Given all the problems I had, I must give the book low marks for not doing a better job of warning would be developers of the pitfalls. While the TCL syntax for commands is trivial enough, actually getting things to work is another issue and should be better explored, since most applications will want to use this inconjunction with an external language.

While I've griped about the problems I've encountered, I must say that I have been able to accomplish my original goals of setting up databases to manage the reams of information I have been amassing. Without a database, this would have been a formidable task indeed. I can't complain about the price of the software (free!), although one has to pay for this with a lack of complete documentation, and much trial and error in figuring out how to make things do what they are supposed to do. As with many open source projects, one has to do with what one is given. To the best of my knowledge, I think the online documentation for SQLite in conjunction with this book is the best that is available thusfar (as of fall 2007). Given my inexperience with SQL, I don't think I would have been nearly as successful if I had relied solely upon online documentation - rather I'd still be slugging it out. The book has enough shortcuts, explanations of capabilities and other information to make it worthwhile.

For application development, I'd also highly recommend the use of an alternate tool for checking what your databases look like after they have been built. The standalone SQLite browser on the SQLite.org website has proven to be a very useful tool. I understand there is also a good Firefox extension/plugin that has similar functionality.

Best wishes to your development projects!

Whether you are new to SQLite or even new to SQL genereally, this book will have you using SQLite -- fast. SQLite is used in products and projects ranging from mobile devices to Firefox to Apple's Leopard to Google's Android. Getting to that level might take a little longer. :) A neophyte, I read straight through and found the quasi-historical introductory chapters on data modeling helpful. If you already know SQL and the theory behind it, go ahead and dive right into the details of SQLite. The API reference is extensive.

The text is relatively free of serious errata. The biggest complaint I have is the weak index. The index is so weak as to make me wonder if APress deliberately neglected it as a strategy for selling the companion e-book. The e-book is $10 if you have purchased the book and worth it to get something searchable. But I would have gladly paid $10 more for the paper book with a comprehensive index. Also, be advised that the e-book is a password-protected PDF. This is somewhat insulting to honest customers, since anyone lacking respect for copyright could quickly find a free PDF-cracker on the 'Net. Taken together, these minor annoyances clip one star from what would otherwise be a perfect book.

Folks, I don't have a lot of time to write a long review. I usually don't bother writing them at all. But, this is a *terrific* book. My advice: Use Sqlite. It's awesome for its size! Use Python. What an amazing language! Use PySqlite for the binding to Sqlite from Python. And, *read this book*!!!!!! You won't find better documentation on this wonderful product. Thanks to Dr. Hipp for Sqlite and to Mike Owens for the original PySqlite and this book. Happy reading!

This book is great! Eubanks ranks with my other favorites: Marinacci, Bloch, and Zukowski.

Part of the book covers nuts-and-bolts skills like new Java 5 API's, Cyclic Barrier, regular expressions, and Robot. My favorite part of the nuts-and-bolts skills was his examples of sophisticated regular expressions.

The rest of the book explains broader topics like the Semantic Web, charting, genetic algorithms, and programming directed graphs. My favorite part of the broader topics was his example of propagating signals through a directed graph.

We all need to keep up with the nuts-and-bolts of Java. On the other hand, we need a Big Picture of what's going on in our world. This book gives both. (And even his puns are neat!)

Lot of cool info is provided in the book. I still haven't spend as much time as I would like to with the book as I was busy with other stuff.
But so far so good.
Look at this book as a pointers to cool stuff you can do with Java rather than a resource on how to do each of those cool stuff. Pick up the one of your interest and start off on it.
I was already working with many of the techniques mentioned but some like the sound API was pretty cool to try out.

Are you a Java developer who is looking for interesting and useful APIs or for project ideas? If you are, you're in luck! Author Brian Eubanks, has done an outstanding job of writing a book that will help you enhance your code.

Eubanks, begins by discussing some of the core API features--some that are older, but less well known and some that are new to Java 5. Then, he discusses String processing techniques. The author continues by showing you how to process XML and HTML documents and other types of structured text. Next, he explores the Semantic Web, a next-generation web where the links are between concepts rather than documents containing text. Then, the author explores scientific and mathematical applications in Java. He continues with a discussion on how APIs make it easier to develop graphical applications or to add new features. Next, he deals with sound and music APIs; as well as, advanced thread synchronization. Finally, he looks at miscellaneous open-source projects and discusses ideas for creating your own projects and integrating code.

Not intended as a basic tutorial by the author, this excellent book will help developers and system architects capitalize on their preexisting knowledge and take advantage of everything the programming language has to offer. Filled with example code, this book will definitely be a welcome find for anyone who enjoys experimenting with Java code--and, who wants to make their code wicked cool.

While this book is not a typical tutorial or reference, it does give the reader a brief glimpse into a wide variety of Java topics. Some of them are code tips like how to use "for" to iterate over a collection or how to use "enum" from Java 5. Other topics introduce the reader to open source libraries for use in managing Xml documents, using RSS feeds, creating graphics, working with sound, and more. The focus is on learning something new and having fun with it.

The topics are grouped into chapters around a similar theme. The first chapter focuses on the language tips and the core API. The succeeding chapters cover string processing, xml (and html), RSS, math applications, graphics, multimedia, and project ideas. The organization of the book is quite good. It has an good table of contents, glossary and an index. Within each topic, any additional library that is required is listed along with the minimum version of Java to be used. The topics themselves are well-written and easy to follow.

The website for the book conveniently provides links to the open source projects that are needed for the topics. However the download page for the example code does not have running examples for all of the topics. Furthermore, I did not see a file for downloading an archive of the examples.

Each topic is only a few pages long, just enough to become acquainted, but not enough for industrial-strength use. For me, I found this format worked well for most topics, and somewhat less effectively for some. But on the whole, this book is definitely a keeper.

OK, I admit it .. I've become jaded like most Java programmers. Ruby, Python, Groovy .. wow, all those "agile" languages making Java so, I don't know, .. so 90's right?

Wrong! Bring me your sad Java hackers, .. give them this book .. and wham! .. they'll be back on line, humming like happy campers.

Read this book.

I've dabbled with what I consider to be all the major web frameworks: TurboGears, Pylons, Rails, and Django. Religion and other biases aside, what really made me finally settle on Django was the documentation (though community/all-in-one-ness/robustness aspects are also nice factors). What's notable out about Django documentation? Precision, attention to detail, comprehensiveness, and general emphasis on polish.

To many people, a book is what makes a new technology both accessible and credible. A couple years ago when I thought TurboGears was the framework I wanted, I got the book, and it was crap. Subsequently, other things about the framework started to feel lacking. Then with Pylons, there is no book, which reflects the constant state of flux of the component mix. Cool framework, admirable ideals, but no book. Now with Django, there is *the* book, and it's beautifully done, and you discover that the framework is, too.

I see this book as a true community resource. Its examples directly extend *the* tutorial. Being available in its up-to-date entirety as a living document, anyone can simply answer a question by consulting a link to a book section. I applaud the authors opening this book up to be accessible to everyone, both in ease of reading, and in being free for download. It is always reassuring to find a book about a tool being written by the authors of a tool, and that should contribute to making it the canonical Django resource.

Even though I'm not a real world user of Django (I'm a Grails guy), I thought I'd give this book a try as Django is in the same category of web development frameworks as Grails. After reading this book, I had a solid foundation knowledge about how Django works and principles behind it. And it is well written. I would recommend it for any serious real world user of this framework.

This book basically covers all the parts of Django, and will give you a good overview . It misses some details though, such as middleware, which is just skimmed through. There's also not much on customizing Django, i.e not using it's built in authentication but if you try to roll out your own.

Django is a framework I've long (in web years) held in some esteem, despite never having used it before the past few weeks. The framework's creators' many well reasoned contributions on all manner of debates about the web suggested a thoughtful approach, and the range of high quality sites powered by Django has kept growing, with the recent launch of EveryBlock being a prime example of its capabilities. So I was delighted to receive a copy of The Definitive Guide to django: Web Development Done Right for review.

Authored by two of the creators of Django: Adrian Holovaty and Jacob Kaplan-Moss, the book is carefully structured, initially placing django in context by exploring various approaches to web development, and then stepping through initial project creation, templates, models, url configuration, django's famed admin interface, and so on. After eight chapters it changes tack and switches from basic tutorial to more in-depth exploration of areas like the ORM, session handling, caching and deployment. Several appendices provide supplementary material.

The first few chapters do a good job of laying out the foci of the framework's architecture and it's Model Template View (MTV) approach. Its pace is measured and while I wonder if it might be a little too much too soon for those totally new to full stack web frameworks, it would work well for those coming from a background building web apps with PHP, Java, or for those of us who are used to working with Rails. There are new techniques to learn and I found the book particularly useful for grasping the deeply pythonic approach, favouring flexibility over convention.

A clear example of that comes in the use of Context objects for passing values between Views and Templates. The authors initially show us the most verbose and rudimentary way to do it and gradually develop that to show how they've provided for various common cases. By going through those steps there's a good chance the reader will be well equipped to work out ways to simplify their own workflow and/or create new subclasses to promote reuse in their code.

Where the book is lacking is in the examples. The introductory material, and much of the reference content is excellent, but as a newcomer to the framework I felt a little lost in how I should structure my code and how different components relate; it's clear how models relate to the database, but how do I pass them around when building associations?

I recognise that django deliberately avoids the strong conventions of the Rails community (though even there you frequently find newcomers unsure where in the directory structure to place certain components) and there's no need for lengthy tutorials on building a shop or how a magazine cms could work, but when I come to a book like this I'm looking for a guide to best practices at the project architecture level, not just the component level, and I was sorry not to find it. The authors clearly have a lot of experience of structuring django sites of all shapes and sizes and it would be good to learn more about how they keep those sites organised.

That said, this is a solid introduction to django for web developers; a solid contribution in a so-far underserved market and it's likely to come in handy for a number of people. Just be prepared to supplement it with a fair amount of time in search engines working out good strategies for connecting the pieces.

Disclaimer: I was sent a copy of this book for review by the publisher.

Although you can read this book for free online, I like having it around for easy reference. The first eight or so chapters are good for learning Django; with the subsequent chapters and appendixes good for reference.

I will say that the online document is updated regularly, with sometimes useful comments from readers. That said, I would still buy this good.

"JBoss: A Developer's Notebook" is a great introduction to getting up and running on JBoss. Instead of just dumping code and mounds of text at you, it quickly walks through setting up a "ToDo" application, including connecting to a mySQL database, logging, monitoring and security. None of it is in-depth but it's enough to point you in the right direction.

Be warned that the chapter on persistence uses XDoclet whereas things are moving towards EJB3 now so that chapter is not quite as useful as the rest of the book.

Overall, I would recommend this book if you are looking to set up a JBoss development server. Using it, I was able to tweak my installation of JBoss quite a bit.

This book is an example for all modern book writers to follow.

Most writers seem to want to write books weighing a few pounds, try to cover every conceivable topic and eventually do not do sufficient justice to anything.

On the other hand, this book is the book when you know "what" you want to do, and then "how" to do that with JBoss.

JBoss: A Developer's Notebook continues with the pragmatic appproach followed by the other books in the series. A series of clear, succinct examples on getting up and running with JBoss are the primary method used to present the content of the book. Most examples build on a previous example so it is best to cover them in a linear fashion. After execution of the examples, the user should have a good understanding of how JBoss operates, what it takes to deploy an application on JBoss and how to use the built-in features such as the Web Console.

If you are trying to dive into the details of JBoss in order to solve a complex setup issue or trying to fully understand one aspect of the application, then this is probably not the book for you. The depth of the information in the book is appropriate for it's scope as a developers notebook but it is not a reference manual.

Overall, if you want to learn the basics of JBoss quickly or stand up an instance with minimal research, you have come to the right place.

Excellent book on JBoss, the book is a easy read covering the ins and outs of JBoss from writing your app to, securing and managing the container. Very well presented with the cool notes on the sidebar which are worth reading all by themselves. The chapters are concise and to the point in presenting the ideas, this has become valuable resource on my desk.

If you are just now considering using JBoss then this is definitely the book for you. It covers the installation, configuration, and deployment of a J2EE application in a very concise and useful format. It presents the unique and useful features of JBoss in a simple format. If you are looking for a reference book that covers every little detail of JBoss then keep looking.

So I have had this book a little over a year and I come back to it time and again rather than going to the JC online docs. The book is reasonably well written but the subject matter is stellar. I am confident that using JC has given me increased confidence in my own projects and saved me countless hours of work. If you find yourself using other components that require the JC jars [Spring, XFire etc] and you are not using them yourself already, don't you think you could. Get the book and improve your code.

If you want a in-depth, head's down, nuts and bolts explanation of the Commons components, this is NOT the book for you. Doesn't even discuss some of the more powerful features of the Collections component such as Predicates and Closures.

As for the other stuff, a lightweight overview, at best.

Easy to use book, very clear examples. I now have better understanding of Jakarta Commons. Thanks Harshad Oak.

Jakarta Commons have done a superb job of harnessing the collective intellect and know-how of the great group of contributors who build them. I found Pro Jakarta Commons to be a great introduction to the commons classes. If you are like most working programmers,you will most likely need to use a few features in commons before you know much about them. Not only does the book do a very nice job of organizing the classes and methods in all of the commons packages, but more importantly, it gives you excellent examples to use many of them.

Mr. Oak does an amazing job of "getting down" on this material. Diagrams, tables and lots and lots of Java code examples make this handy and a valuable keeper of a book. By definition, once a common package leaves the sand box and becomes production ready, they strive to keep the interface backward compatible so these examples will serve you a good long while. It's also a very good read should one want to go cover to cover as the writing is clear and has that "just right" balance of simplicity and detail.

This is a must have book for Java Developers. I already have found many components/code that I can reuse to make my life easier. For example, the File Upload component is simple to use and saves a great amount of coding. The XML component (Digester) is fantastic! The author writes to the point and shows great examples. The examples on the Jakarta Commons website are lacking, so this is why this book is needed!

this book covers all of modern open source license which i wanted to know. also, it explain them very easy understanding way.

People don't realize how important licensing is with open source, but there is a lot.

Understanding Open Source and Free Software Licensing is a very needed book and well written.

Understanding Open Source & Free Software Licensing
Andrew M. St. Laurent
http://www.oreilly.com/catalog/osfreesoft/

When sharing with others that I was reviewing an O'Reilly book through their User Group & Professional Association Program, the first question was always the same: "What book are you reviewing?" After saying the title was "Understanding Open Source & Free Software Licensing", responses ranged from "What's that?" to "Well, you won't have any trouble sleeping!" One might think that this list of people included relatives and coworkers who were not attuned to the open source community and its issues. On the contrary, the responses came from those within my circle of acquaintances that include software developers, system administrators, and even an intellectual property lawyer. Licensing is not exactly the sort of topic where people slide forward in their seats and ask to be told more. Such is the appeal of software licensing; however, the importance of understanding licensing, particularly within the context of open source development, cannot be overstated.

Those familiar with the O'Reilly product offerings have no doubt seen or purchased one or more their Pocket Reference series (http://pocketrefs.oreilly.com/). They are not comprehensive references, but rather convenient guides for a specific topic to provide the sort of information one is not likely to have committed to memory, particularly as the trend of having cross-disciplined technologists continues. This book could be considered the analog of pocket guides for open source and free software licensing. Open source licenses and their legal interpretation are subject matter that easily warrant a "pocket reference" that is a full-sized book of nearly 200 pages.

Frankly, reading through a software license and maintaining a reasonable level of comprehension is a rather tough job. The author manages to make the task far more bearable and fruitful at the same time; a difficult balance to strike. The pace of the annotation works well to break up the various licenses (twelve in total) into bite-sized chunks. Chapters 2 and 3, which address the BSD/MIT family of licenses and the GPL/LGPL/MPL family of licenses respectively, each end with a section titled "Application and Philosophy" that serves as a sort of reward for making it through the license and establishes a touchstone to summarize and provide meaningful context for what has been covered.

The annotations of the different licenses are a great introduction, but the book should not be considered as a complete reference for open source licensing issues. The book seems to affirm this at points where the author indicates that particular topics fall outside the book's scope, even to the point of recommending experienced legal counsel for certain issues. It also has a wonderful collection of footnotes and reference to other resources to allow the reader to flesh out topics of interest beyond the focus of this work.

One subtlety of the book that should not be missed is how the history of the open source movement is woven throughout the book to provide the context in which these licenses came into being and were modified to accommodate the vibrant, emerging world of open development models. The book's last two chapters bring that context to the foreground, fully developing the consequence of the licenses in daily development activity. It is far too easy to view these licenses and as mere legal documents that exist in and of themselves; the author reminds us that these licenses are the manifestations of a spirit of selfless contribution and work toward social good made possible by the considerable sacrifice of quite gifted individuals. For those passionate about the open source and free software movements, the section of chapter 7 titled "Models of Open Source and Free Software Development" is a poignant and stirring encapsulation of the first years of the GNU and Linux projects and the work that brought them into being. The cliché rings true; we do indeed "stand on the shoulders of giants."

The number of editorial errors involving misspelled and/or missing words seemed relatively high; this is a trend that seems to have developed in technical books in recent years, to a point that the technical community has come to accept it as some sort of side effect of the rapid pace with which books must be produced in order to keep pace with the rate of change. Given that this is an issue present in other works as well as this one, it should not particularly count as a mark against the work, but rather serve to underscore an issue publishers should consider improving.

"Understanding Open Source & Free Software Licensing" is a book which strikes a balance between completeness of subject matter coverage and manageability of size. Given the amount of attention the average open source user or developer has given to licensing, reading this book would be a considerable improvement. This book is recommended for a couple of audiences. First, it serves as a great foundation for developers either active in or contemplating participation in open source development. Searching most any open source mailing list for the term "license" can usually turn up some of its hottest flame wars. If most developers had this introductory level of understanding about the main open source licenses, hundreds of message threads arguing about licensing could be avoided.

A second audience for this book is the project manager and/or CTO in most corporate IT shops. Most corporate projects are making use of numerous open source libraries and frameworks. This is particularly true with J2EE, but also with .Net as a number of .Net counterparts to popular J2EE resources arise, e.g. NAnt, NUnit, etc. This book can dispel unnecessary apprehension regarding the use of these libraries that often arises from fear, uncertainty, and doubt (FUD) propagated in much of the mainstream technology media. It can also equip managers to make informed decisions about team members' potential contributions to open source projects and the potential legal implications.

I am an attorney who does open source software license work for a living. When this book came along, I picked it up, mostly because I was interested in seeing how O'Reilly does branching out well beyond its usual technical subjects. As you are probably aware, 2004 was the year of open source, according to some publications. Well, it was also the year of open source books. I have seen at least five that deal with the topic directly.

Getting to the merits of St. Laurent's book, I struggled with whether to give it three or four stars. You see, even as a lawyer I found it lacking in clarity and flow. Overall, I am opposed to the route he took in excerpting almost every term of each license and then providing exposition of his own that was a lot of times hardly more helpful than the original license language. A better approach to explaining the licenses can be found in Larry Rosen's wonderful book "Open Source Licensing." However, this downside becomes an upside when using the book as a reference, instead of an educational guide (justifying the fourth star). St. Laurent's approach here is useful for going into more depth on a particular license. Perhaps that was the goal all along.

Another advantage this book has over Rosen's is its broader treatment of the growing array of licenses and license types. St. Laurent covers more licenses and for that I am thankful. In the end, I would recommend having a copy of both Rosen's and St. Laurent's book handy. And whatever you do, skip Rod Dixon's "Open Source Software Law."

Software licensing can be one of the most confusing issues of software installation and development. Most people assume that there are few if any issues with Open Source and Free Software Licensing but that often is not the case. While it may be free to install you wade into murky waters when you change the code, make a new program that uses some of the coding of the open source program, make a derivative program, or a host of other situations. Part of the confusion is that all Open Source or Free Software licensing is not the same. For example there are the MIT, BSD, Apache, and Academic Free Licenses. Or what about the GNU license? Most people don't realize that there are two different versions of GNU licenses, the GNU General Public License (GPL) and the GNU Lesser General Public License (LGPL)? Then there is the Mozilla Public License, Q Public License, Artistic License, and Creative Commons License.

Author Andrew M. St. Laurent does an excellent job explaining all these various licenses, what you can do and can't do, the various benefits and shortcomings of the licenses and pitfalls to watch for. If you are doing development in this arena, have made an improvement to one of the programs, or have written a program for internal use that might have resell value you can't afford to not understand the nuances of the various licensing agreements. Understanding Open Source & Free Software Licensing is highly recommended and required reading for anyone in this situation.