Programming Books

This is the greatest book I have ever read (excluding Bert Silverman's "Bert's Eye View: Coping with Macular Degeneration. I can only find it coincidental that they are related and that both of them have great dedications to Dan Afergan.

This book has everything you need, just only a few description about every class of the java API, but enough to use it. besides it is cheap.

The book's title is somewhat misleading. It's not an extensive reference to Java as a whole. If you're looking for that in a small book, you might want to see David Flanagan's book, Java in a Nutshell instead. However, where Java Quick Reference really shines is in referencing the Java API. In contrast with Flanaga, Afergan tells more about what each method in each class actually does, and the values they return. All extensively indexed. Assuming you're generally familiar with the Java APIs, this is a hand book to keep handy while you're actually programming.

this book, released in 1996 was definately one of the BEST Java references available at the time. Java in a Nutshell gave some in depth discussions about Java topics, however this book was the perfect reference guide.

although old, it is a classic for JDK 1.0

Heave an egg out of an open window almost anywhere in the world today, and the odds of striking a Netscape user are in your favor. The odds are even better that this person either knows nothing of Java or believes that it is safe. Pick up almost any book on Java programming, and you will see the same superficial and misleading treatment of security issues. This important book is the first one to address the myriad problems raised by Java. It clearly and concisely explains past problems, current issues, and future risks. McGraw and Felten grab the high and mighty Java industry by the ear, and they offer sane and sensible advice to every level of Java programmer and user. One can only wish that this book had appeared a year earlier and had been widely read by Java's cheerleaders and hucksters. Perhaps then more of the problems would have been solved by now, and fewer risks would remain.

This book is wonderfully written and full of good information. It would be useful for anyone from novice users to managers to Java Programmers who are concerned about security. In fact, I strongly recommend them buying a copy to read as this is one of the best technical books I've read in a long time. The only audience I wouldn't recommend it for are the people who are doing very advanced Java Security work such as writing their own Security Manager, but they may even learn something from it.

I'm writing this review in April, 2002 when IE 6.0 became a standard browser and Netscape is RIP.
This book was written 6 years ago in the days of NN 2.0 and IE 3.0 .. Although it's more then
outdated by now it clearly explains what security risks exist for Java-enabled browsers
and answers my (and may be your) question "How the hell applets can break through Security Manager ?!"
It's main idea is to explain readers what harm applets can do, why is it possible at all
and what is done about the subject by the browser manufactures. Good work for 1996.

Note that it's not "Java security book" in the terms you may think today - in 1996 Java
was only understood as a flashy applets popping-up in the Web.

If you use a web browser that is Java enabled (versions greater than Netscape Navigator 2.0 and Microsoft Internet Explorer 3.0) ,and are concerned about Java security, this book is required reading.

At under 160 pages of text (not counting the appendices), Java Security provides a superb overview of security issues involved with using Java. The authors are security veterans. Felton heads up the Princeton University Safe Internet Programming Team and is famous for discovering quite a few holes in the Java security model.

One might think that two security experts who know the depths and implications of Java security may come out with a reference with suggestions that are overly restrictive and perhaps paranoid. That is not the case here. The recommendations that the book suggests are rational and reasonable. Java Security provides commendable guidelines on how to use Java more safely and what the future holds for Java security features.

The 6 chapters of the book provide an excellent and comprehensive analysis to all aspects of Java security. Chapter 2 provides a significant amount of detail about the Java Security Model, with in-depth coverage of the 3 prongs (as they call it) of the security model, namely: the Byte Code Verifier, the Applet Class Loader and the Security Manager.

Chapter 3 follows with a discussion detailing serious holes in the security model. The authors consider a flaw to be serious when the breach has the potential to corrupt data, reveal private information, or infecting the workstation with a virus. They fittingly note that all of the flaws detailed in the chapter have been fixed by Netscape and Microsoft. The function of the chapter is to show what sort of things can go wrong. Chapter 3 concludes with a summary of 8 significant security problems that were discovered last year in implementations of Java.

The book also goes into great detail on what developers and end-users can do to make Java much more secure. Their six guidelines for Safer Java use are:

1. Know what web sites you are visiting 2. Know your Java environment 3. Use up-to-date browsers with the latest security updates 4. Keep a lookout for security alerts 5. Apply drastic measures if your information is truly critical 6. Access your risks

Fenton has his doctorate in computer science, nonetheless, the book is written in a very clear and coherent manner. Add this to your bookshelf.

This is it, the complete and authoritative definition of the Java programming language. This edition covers the Java language up to 1.5, so it gives a full description of generics and type parameters, boxing and unboxing, enums, annotation, and all the latest. If you develop Java language tools - debuggers, compilers, etc. - you simply must have this book. If you care about Java details that much, you must have the newest edition.

The typical programmer, someone who uses Java for application development, probably won't find much of interest in this book. This isn't a programmer's how-to manual. Nearly nothing describes how to use the language features. The code samples just illustrate language syntax and subtleties. There's nearly no discussion of the Java APIs, not even the java.lang.* packages or language-dependent reflection features. These are not flaws in this reference manual - this simply isn't a book meant to serve those needs.

Despite its 650+ pages, this really is a concise, precise definition of the Java 1.5 programming language. If you care about the internals of Java or about OO lnaguages in general, then this book is for you.

//wiredweird

Are you the type that has to know the "why" and "how" behind how a language behaves? Then this is the book you need... The Java Language Specification, Third Edition by James Gosling, Bill Joy, Guy Steele, Gilad Bracha. Provided you're buying it for the right reason, there's nothing close to it.

Contents: Introduction; Grammars; Lexical Structure; Types, Values, and Variables; Conversions and Promotions; Names; Packages; Classes; Interfaces; Arrays; Exceptions; Execution; Binary Compatibility; Blocks and Statements; Expressions; Definite Assignment; Threads and Locks; Syntax; Index

So why do I say "for the right reason"? Because if you pick it up expecting something else, you'll be highly disappointed. This is *not* a tutorial of the language, nor is it an easy-to-read conversation or discussion of Java. Instead, it's a computer engineering level coverage of how Java is structured and how it works, from the people who wrote it. As such, you're going to find information in here that you'll have a hard time getting elsewhere. You'll find out how the nitty-gritty of how things like classes and interfaces work, and how they *should* be structured. If you're just getting started in Java, you'll likely be over your head by the second chapter. The target of this type of writing would be people who are Java journeymen, and who have gotten to the point where they need to know some of the theory behind features and structure. You'll also need a book like this if you write development tools that target the Java environment. Armed with this book and a solid background in Java, you'll be able to produce software that behaves just as developers would expect.

Don't let the depth and complexity of the material steer you away from the book if you're ready to go deeper with Java. Just don't pick up the book expecting to learn Java for the first time. There are better books out there for that purpose. But if you need to understand the guts of Java, this is it.

The Java Language Specification, The Java Programming Language Guide (4th Edition), and the SJCP Study Guide for Java 5 (Sierra, Bates) are essential to passing the SJCP exam. The Java Language Specification gives you the important technical details that textbooks tend to leave out. The best way to use this book is to make small, simple test programs for each chapter or topic (the programs that the authors provide are too cryptic for my taste). This book is not a tutorial and you should have the level of knowledge aquired by studying the Java textbooks by Walter Savitch and/or Daniel Liang. It's also a good idea to have Head First Java (2nd Edition, Sierra, Bates) in your bookshelf with the others - plus anything by Cay Horstmann (Core Java I and Core Java II.)

Just the book for the java hungry community. For those that are pressed for cash and cannot afford the book just yet you can visit the java dot sun website to download a pdf version of this book with minor cosmetic changes dealing with copyright. The integrity of the book is otherwise intact. The directory to look for is docs->books->jls. Cheers

Easy to follow, very concise examples, wide variety of topics

I wanted to learn JavaScript, up and rearing to go. So I got David Flanagan's book "The Definative Guide". But the concepts flew over my head. Its the best book on JavaScript, without a shadow of a doubt, but simply fearful to the poor old newbie like myself. Don't get me wrong, its well written, but if he had written it the way I needed it to be, it would have taken up 100000 pages. Shipping would be a nightmare!

Anyway, about this book.

It's a good book, great for newbies. I don't know why the other author review mentions that you need to have prior experiance with a programming language. That's rubbish IMO. Sure he mentions Javascript having a simularlity to C/C++/Java, but its not like you gotta learn those languages, its just a mention, thats all.

He explains basics, like what a token is, how if/else/for statements work. You know, basic stuff for a newbie to learn. If you are a programmer already, just skip the first five chapters, and you'll be in the meat of the book about JavaScript, so its just as relevant for experienced programmers too.

Anyhow, once you are finished (and applied the concepts with a mock up webpages) you are no longer a newb. Then move on to that gem which is David Flanagan's Definative Guide. After going through that and applying it, you'll be well on your way to becoming a "good" JavaScript Programmer.

P.S: Becoming actually Good is no mean feat. Take JavaScript seriously folks!

P.P.S: You MUST learn HTML and CSS before reading these books. JavaScript is almost entirely based in the real world on manipulating markup and style sheets. To attempt to learn JavaScript without knowing them properly (I do mean properly) would be a major folly.

This review is based only on a quick glimpse of the book, so read this with some reservation. I might follow up with a more thorough review later.

This book looks very comprehensive, and seem to be very much up-to-date with latest browsers and W3C standards, including DOM 1 and DOM 2.

But more than a 1000 pages probably makes it very difficult to read in bed ! ;-)

Giving 5 stars might seem a bit optimistic without further investigation, but I'm pretty sure it is a at least a 4-star book.

Firstly, this book does a great job of introducing the javascript core language in a thorough and engaging way. The author goes to great lengths on topics that will concern real-world developers and discusses in depth the right and wrong way to write code.

This leads on to a more general reference on the language. It is here that the book really shines. As well as lots of examples, the fundamental principles behind the langauge and any associated technologies are mentioned. All this is done in a very avuncular style and I must admit I enjoyed reading the book, and trying out some of the examples/topics on my PC.

There are some caveats:

This is not a book for pure novices. Previous exposure to other languages is inferred and the author(s) point out similarities with Java and C++.

Netscape is the preferred browser here, but unlike some other tomes, at least IE gets a mention and differences are noted, though the writing does favour the NS browser.

These are small gripes with what is otherwise a much needed and well scripted (sic) resource.

I usually don't write reviews, but I read tons of them. However, after starting "jQuery in Action" I just have to write about this book. After reading the first two chapters I could tell that this book is a "keeper". The interactive "lab" exercises (starting in Chapter 2) help explain jQuery's capabilities and features quickly and conveniently, using your computer browser. This method of teaching is terrific; very intelligent, yet simple.
I started out by reading the Appendix: "Javascript that you need to know but might not!". This helped to fill in my understanding of Javascript and was a good way to ease into the book. I am not a Javascript expert but I am a seasoned programmer and I have read dozens upon dozens of technical books over the years, and I know a well developed technical guide when I see it.
Kudos to the authors and the publisher for a fine book about jQuery.

jQuery is a Javascript framework that aims to let you think structurally and conceptually, rather than worrying about syntax and other details. In that largely succeeds, and so does this remarkable book.

Every technical book should be like this one; having written a few myself, I know that's a tall order. "jQuery in Action" is concise but clear, humorous but not silly, and answers all the questions it raises, quickly. The reader is never left wondering "But what about..." for more than a sentence or two. The authors clearly gave a lot of thought to pedagogy, because things are explained in a clear way which progresses naturally from chapter to chapter. Factor in the extremely readable style and the handsome diagrams, and it's easy to see why reading this book is a sheer joy.

For each major feature of jQuery, this book provides a "Laboratory page", a kind of interactive HTML playground where you can try the feature out using different options. The remarkable flexibility of these pages is a testament to both the power of jQuery and to the imagination and creativity of the authors.

Perhaps the most commendable feature of "jQuery in Action" is, however, its unflinching honesty. All too often authors are interested in selling you on an approach or a product, and they tend to gloss over the rough spots to win you over. These authors refuse to do that. They present their topic just as it is, describe its merits, and let the reader decide. You should, of course, decide to buy this book!

jQuery in Action is a practical book that explains how to use, and what's behind the magical framework known as jQuery. It's teaches by example, so you're never reading 20 pages of theory. The writing is clear and it really shows you how to get through some of the "gotchas" of javascript, like timing, animations, and our good friend Ajax. Good for beginners to Javascript, jQuery, and experts.

I purchased this book as soon as it was available. I knew very little about JavaScript then and jQuery in Action does not assume that you know anything about it. The examples are very clear and the book is very carefully written without unnecessary words. But you get more. The authors lead you to show how to think, they designed the samples to advance from trivial to professional knowledge. Often, scanning through the example code, I found myself asking "why is it this way?" and immediately in the next paragraph, there was the answer. I am impressed with the quality of writing, I think every serious professional should read this book whether or not he/she plans to use jQuery.

When I received this book, I was impressed by the fact that it contained 943 pages on Kylix - without covering any database or internet development. Now that I finished the book, I'm even more impressed. Not by what's not in the book, but by what's actually covered in the book.
Somehow, the book reminds me of the years I spent at the University of Amsterdam (back in 1983), and first learned to work with UNIX and Minix.
I'm not sure why. Maybe the fonts, maybe the quality. But one thing is for sure, like the cover said: this is not a Delphi book 'ported' to Kylix. This
is a true Kylix/Linux Development book, and as such, I'm sure every Delphi developer can learn something from it.

The book consists of four sections, and a number of appendices. The first section contains about 250 pages about Object Pascal. But before we
start the first section, there's chapter 0: Hello Kylix, in which the author explains why Kylix is great, and what this book will offer (and what not -
so you'll know right away). It also explains where to download the sample code, and then continues with a first hands-on getting started tour in
Kylix.
The first real section of the book consists of four chapters (252 pages) and is about Object Pascal. From data types and datastructures to program
syntax and structure. As a Delphi developer, it was the 'least interesting' section of the book to read, although I would still recommend browsing
through the pages, since there are numerous tips or footnotes that are worthwhile to read (as the back cover says: "even long-time Delphi
programmers will find some surprising details here", such as the part on libraries and dynamic linking). In fact, it reminded me of the excellent Pascal
textbooks I read during my study (mentioned before), and I can recommended it to anyone who wants to learn Object Pascal.
The second section of the book extends the 'simple' Object Pascal languages and moves on to Kylix - the RAD Development environment on Linux.
In five chapters, we'll learn how to use Kylix (the IDE, designing, debugging), and the components that can be used with Kylix. When I say
components, the author has split them in a few different chapters. First, we get the Visual Objects (VisualCLX components on top of Qt), followed
by a chapter about Foundation Objects (the non-visual components and support classes such as collections and streams, as well as threads), and
finally library routines (only the most important ones, like Strings, Dates, Maths, etc.), and component building in Kylix. Although - like I mentioned
before - this is not a Kylix 'port' of a Delphi book, the author does place 'cautions' and notes in the chapter to highlight some of the differences
between Delphi and Kylix that are important to Delphi developers. The repeated reminder in the border that keeps telling us that "Kylix is not Delphi"
grows a bit tiresome after a while, but the notes themselves are good points.
The third section of the book is about Linux - for Windows developers, and using Kylix. It covers Linux and Linux programming from a Windows
programmer's perspective, explaining the differences, and showing what to do (and how to do it differently) under Linux. Subsections include files,
memory, processes, regular expressions and scripts (this brought back some fond memories when I first used UNIX almost two decades ago). The
final chapter in this section introduces X and Qt (we've seen Qt before in the previous section). It's only a short chapter, which is good, since I
consider this only background information (to give an architectural overview of X and Qt). VisualCLX is build on top of Qt (and X) and in theory you
should seldom have to sink down to the API level.
The fourth section of the book is about entire projects, and contains two chapters: one about a visual find utility (imitating Windows' Find Files),
and a chapter on Mandelbrot 4 (I wasn't too interested in this, but the results look very nice).
Fortunately, the book wasn't finished after this last chapter, since we still have a number of interesting appendices. Covering topics such as "Kylix
for Visual Basic programmers" (there may be more than you think), "Kylix for Delphi programmers" (a bit late if you read the entire book already, but
it gives a short summary of the most important changes and gotchas, including references to chapters that cover these in more detail). So Delphi
developers may want to start reading the book with Appendix II. Other appendices cover topics like Optimization and a BASM quick reference,
although these two are too short to be of real use I'm afraid. Appendix V on Deployment is a whole lot better, especially since this is indeed an ever
returning Kylix developer's FAQ. Well written, and helpful for deployment on systems that don't have Kylix installed.
Apart from the regular text, the book contains numerous little "notes" that contain tips, background information or just useful techniques worthy to
highlight. The index seems complete, but could use a smaller font to get a better overview. Syntax highlighting is used in source code listings,
which I always consider to be very helpful. Unfortunately, on a few places it was missing or inconsistent (just as I sometimes didn't agree with the
source code indentation and layout, but these are personal feelings of course).
Back in the beginning of the book, in Chapter 0, the author explains that he wants to write a 'classic' book. The book that a bookstore would carry
if it had only one Kylix book. I'm not sure if this book is the classic Kylix book (not without database or internet coverage), but it sure is a great
book to learn Kylix as well as Linux - for everybody!

And when it comes to the missing sections (on database and internet): I can also recommend Delphi/Kylix Database Development by Eric Harmon, as well as the Kylix Developer's Guide (for which I wrote the web development chapters).

There are an infinite number of ways to skin any given cat, and when covering a new RAD environment, which one you use depends almost entirely on who your target audience is. Jon Shemitz has written his book for the experienced programmer coming to Kylix from other RAD environments on platforms other than Linux/X. This, I feel, is the source of Kylix's user base: Not the casehardened command-line Unix-lifer gcc guys, but people who have been using Delphi, Visual Basic, or Visual C++ under Windows.

For people like that, it's a natural. Jon begins with a "Hello Kylix!" project to let people get their bearings within the Kylix idea, and then systematically explores the programming language (object Pascal), the environment and toolset (Kylix itself) and finally the underlying platform (Linux, Qt, and X.) People who already have their Unix scar tissue can skip the Linux section, but Windows expatriates will be glad it's there. The coverage of Object Pascal skims the simple stuff and emphasizes the subtleties that most books gloss over: inheritance, properties, class references, and the rest of the OOP machinery that far fewer people understand than claim to. (For that part of it, I recommend this book even to people who are sticking with Delphi under Windows!) The Kylix coverage, again, goes for depth: The section on threads is clearer than anything else I've read on that topic. The Unix material is well-chosen, and I learned far more about Qt from this book than I did from the Qt doc.

The overall quality of the book is very high. The writing is superb, and the screen shots are well-chosen and clearly reproduced. Scattered throughout the text are "Kylix is not Delphi!" tips, which people coming to Kylix from Delphi had better read. The text is set in smaller type than many "fat books" on programming, so I would guess this 950-page book represents about 1100 pages using conventional layouts. No fluff, good example code, fine index. Finally, APress has at last dropped the CD stuck into the back page. The example code may be downloaded in tarball form from the publisher Web site.

My recommendation? No matter how many Kylix books you end up buying, buy this one first. Then go for the specialty texts like Eric Harmon's Delphi/Kylix Database Development.

This book is a whopping 1000 pages and never did I get the feeling that _any_ of it was fluff. Not only does it give you a thorough exposition on writing programs in Kylix, it also delivers vital information on writing and running programs under Linux. Many programming books come with source code as does this one, but I almost always never use such code because of poor quality or a lack of relevance to my project. Within 10 minutes of starting this book I had found critical uses for several of the modules Shemitz provides, and I see a lot more that I'll be using in the future.

There's a wonderful chapter on Kylix that existing Delphi programmers will find absolutely invaluable. In addition, programmers coming from the Windows environment like me, will find some terrific chapters on the Linux knowledge you need to get up to speed fast, saving you from torturous safaris through the Internet. Without question, a terrific book.

Well done, Jon Shemitz. Two things jump out from this book: first, lots of text and virtually no screen shots. That means a LOT of very erudite content. Second, brilliant organisation. It's not a feature of many Delphi/Kylix books, even the worthy ones, and it is manna when it droppeth.

The book touts itself as "a comprehensive guide for developers wishing to make quick inroads into developing native applications for the Linux platform". Comprehensive it is, but this is no quickie how-to. This author goes the extra yards and provides good, lucid explanations for why a certain thing is as it is. It reflects excellent research, meticulous QA and the trait of the true teacher, to share what he knows. As a result, I'm finding topics in this this book that have eluded me for years of Delphi work - being absent from the popular titles, the Borland help and the Borland knowledgebase.

When (not if!) you buy this book, pay attention to the Notes panels and the footnotes. Shemitz (or his editor) has been very tight about delivering the story. His post-its and those vital snippets of experiential background are not buried in the main story but are distilled out expertly and consistently into these two reader aid devices. The plot stays right on target and those tricky bits are just where you want them, without having to dive off to a cross-reference.

Because I live in a remote area, I have to buy books "sight unseen". Hence, my tech library is a "lucky dip" of useful titles and doorstoppers. With this one, I really lucked in. I think it was a gutbuster to write and consider it worth every drop of blood, sweat and tears.

This book is not pretentious about what it tries to do. It has no grandiose notions of explaining theories behind architecture, capturing history of the field, how to select architecture to enhance certain architectural qualities, trade offs to consider or patterns to choose from.

It is simply a guide on what architectural views are more relevant than others when trying to build large scale systems, what the view points guiding the generation of those views are, how to use these views effectively when guiding software projects. This it does admirably well, to the point.

It does point to other reference material of relevance for other topics on architecture that is useful for deeper knowledge.

Apart from avoiding pitfalls, this is a good book to help train senior developers and leads who want to move to architect roles. Also helps in developing shared vision on architectural deliverables to be generated among stakeholders.

4 Stars since it is rather pricey.

An excellent reference on what UML diagrams to use to capture the achitecture of a large software project. And this isn't based on the authors' ivory-tower opinions, but on their actual experience of using these diagrams in the real world. We have since used their approach to successfully capture (and thereby communicate to others) the architecture of software projects at our company.

The writing style is a bit dry (there are no humorous anecdotes), but this is more than made up for by being concise.

The book also includes an excellent primer of the various roles a software architect (and other software managers) should take within a large project.

This book presents a very practical guide to designing and developing large-scale software systems. I've been involved in a number of large-scale projects and this is the first book I've found that includes many of the things you usually find out the hard way. Things like how to effectively communicate the design to the team, how to manage iterations and how to document designs and changes to the design.

Since the topic is large-scale systems, the book focuses more on techniques than on specific examples, but it more than makes up for that by providing practical tips and recommended reading references. If you are leading a software development team or plan to, this book will help you on a very practical level.

[Review duplicated from Amazon.co.uk]

Jeff Garland and Richard Anthony have written a very practical and accessible explanation of the process of designing and describing the software architecture for a large information system. All of the major architectural structures are covered and the depth of experience of the authors is evident from the solid, practical advice given throughout. There is also a huge amount of practical advice as to how architectural structures can be described using UML, which is particularly valuable.

The only significant criticism I've have is that they don't talk about the quality properties of the architecture all that explicitly. The focus in most of the book is about capturing architectural structures rather than talking about the required architectural qualities that led to the structures being selected. The reader is left to discern this for themselves.

This said though, I'd still recommend the book to any practicing information systems architect.

I like the way Ms. Lemay wrote the book, She makes it easy for a beginner like me in VBscript easier to understand the language. It is like one of her Teach Yourself books! I highly recommend this as a good reference!

If you want to learn vbscript quickly (and correctly), pick up this book. Vbscript is rapidly becoming a great scripting language for MS internet web sites. This book gives tons of great examples that actually work when you type it in! And there's several thorough programming references in the appendices

Excellent step by step lessons on using ActiveX and VBscript. This book cleared up alot of questions I had. I just bought this book a week ago (May 1999) and I wish I had bought it a long time ago. Although this book was published in 1997, it is unbelievably useful today!

This book does a very good job of getting you right into ActiveX, and then slowly adds the VBScript. While the examples on the CD are well documented, I couldn't get a few of them to work (SelectedIndex) for one. However, I would recommend this book as both a good reference and usuable tool. Note that you should have a pretty good understanding of HTML. If you don't, you'll have problems, but the CD has an HTML book on it that is easily indexed. It helped me out greatly.

It would be pure gold like this one. This book won the Shingo Award: http://bigblue.usu.edu/shingoprize/AboutUs/index.htm. The selection committee clearly knew what it was doing. The author has created an excellent exposition of how lean manufacturing methods can be applied to create abstract intellectual assets such as software and, by implication, systems engineering plans and designs.

Overall the book is an excellent, well written discourse on lean methodology with numerous examples of its application. The authors explain in clear detail how best to apply several lean tools to plan and to perform major systems and software projects, e.g., TRIZ, Analytic Hierarchy Process, SCR, Blitz QFD, Theory of Constraints, Agile practices, high integrity UML, language selection to support lean production (SPARC Ada), load leveling, and Kano Modeling. The cases where this approach was used provide consistent evidence of success; software productivity was significantly improved over previous practice by roughly a factor of four even though the requirements churn in those same contracts was significantly higher than in other successful projects. It is critical to note that software production was stabilized against serious requirements instability by the lean practices being described. Further, that stabilization was a major contributor to successful completion of the contracts!

In the first few chapters, the author spends some time explaining the niche in which lean methods live and work most effectively. In chapter 5 the author analyzes the SEI's Software CMM model to determine the manufacturing paradigm for software. One should note that, since the publication of the book, the Software CMM has been replaced by a newer model, the Software/System/etc CMMI that addresses several of the lean concerns: http://www.sei.cmu.edu/cmmi/.

After some thought it is clear that the fundamental criticism of the Software CMM is that the implementation of any business model by practitioners of the manufacturing paradigm is the principle problem. Such practitioners will likely take a relatively low risk, evolutionary, incremental approach to introduce change. They will therefore initially implement a set of organizational processes that promote and support the manufacturing paradigm in a way that minimizes necessary change, the nearest "as is" state. Such processes should not be expected to be particularly lean until after performance needs drive significant changes to support a leaner approach, the "to be" state. This incremental approach, while fairly smooth and stable can take a decade or more to reach a lean paradigm even if that is the intended end state.

If the authors choose to write a second edition it would be useful to discuss how the CMMI model that has come into use since the writing of this book provides potential synergy with the lean approach. To understand what is improved over the software CMM, one should note that the new CMMI model includes systems engineering process areas rather than being focused exclusively on software. Like its predecessor the CMMI is a process framework and is thus process and performance agnostic. The model is not quite paradigm agnostic; it clearly votes against the craft paradigm by labeling such practices "initial" or "capability level 1". One might speculate that a fully integrated lean approach would garner capability level 5 ratings for the relevant process areas. Further, there is no performance aspect to the CMMI SCAMPI appraisal as there would be with a company performance audit model such as the (Malcolm) Baldridge National Quality Award: http://baldrige.nist.gov/. The CMMI SCAMPI asks if there are specific and generic practices (documented processes) in place to address a set of basic business capability questions (goals), but it does not ask how well those processes perform. It is left entirely up to company management to track and manage process performance. In that respect the CMMI model is independent of the lean manufacturing approach. Synergy with lean methods is both possible and desirable. If the authors choose to write a second addition, it would be valuable to devote a chapter or two on how to develop such a synergistic approach in building and maintaining a comprehensive set of organizational business process assets.

It would be pure gold like this one! This book won the Shingo Award: http://bigblue.usu.edu/shingoprize/AboutUs/index.htm. The selection committee clearly knew what it was doing. The author has created an excellent exposition of how lean manufacturing methods can be applied to create abstract intellectual assets such as software and, by implication, systems engineering plans and designs.

Overall the book is an excellent, well written discourse on lean methodology with numerous examples of its application. The authors explain in clear detail how best to apply several lean tools to plan and to perform major systems and software projects, e.g., TRIZ, Analytic Hierarchy Process, SCR, Blitz QFD, Theory of Constraints, Agile practices, high integrity UML, language selection to support lean production (SPARC Ada), load leveling, and Kano Modeling. The cases where this approach was used provide consistent evidence of success; software productivity was significantly improved over previous practice by roughly a factor of four even though the requirements churn in those same contracts was significantly higher than in other successful projects. It is critical to note that software production was stabilized against serious requirements instability by the lean practices being described. Further, that stabilization was a major contributor to successful completion of the contracts!

In the first few chapters, the author spends some time explaining the niche in which lean methods live and work most effectively. In chapter 5 the author analyzes the SEI's Software CMM model to determine the manufacturing paradigm for software. One should note that, since the publication of the book, the Software CMM has been replaced by a newer model, the Software/System/etc CMMI that addresses several of the lean concerns: http://www.sei.cmu.edu/cmmi/.

After some thought it is clear that the fundamental criticism of the Software CMM is that the implementation of any business model by practitioners of the manufacturing paradigm is the principle problem. Such practitioners will likely take a relatively low risk, evolutionary, incremental approach to introduce change. They will therefore initially implement a set of organizational processes that promote and support the manufacturing paradigm in a way that minimizes necessary change, the nearest "as is" state. Such processes should not be expected to be particularly lean until after performance needs drive significant changes to support a leaner approach, the "to be" state. This incremental approach, while fairly smooth and stable can take a decade or more to reach a lean paradigm even if that is the intended end state.

If the authors choose to write a second edition it would be useful to discuss how the CMMI model that has come into use since the writing of this book provides potential synergy with the lean approach. To understand what is improved over the software CMM, one should note that the new CMMI model includes systems engineering process areas rather than being focused exclusively on software. Like its predecessor the CMMI is a process framework and is thus process and performance agnostic. The model is not quite paradigm agnostic; it clearly votes against the craft paradigm by labeling such practices "initial" or "capability level 1". One might speculate that a fully integrated lean approach would garner capability level 5 ratings for the relevant process areas. Further, there is no performance aspect to the CMMI SCAMPI appraisal as there would be with a company performance audit model such as the (Malcolm) Baldridge National Quality Award: http://baldrige.nist.gov/. The CMMI SCAMPI asks if there are specific and generic practices (documented processes) in place to address a set of basic business capability questions (goals), but it does not ask how well those processes perform. It is left entirely up to company management to track and manage process performance. In that respect the CMMI model is independent of the lean manufacturing approach. Synergy with lean methods is both possible and desirable. If the authors choose to write a second addition, it would be valuable to devote a chapter or two on how to develop such a synergistic approach in building and maintaining a comprehensive set of organizational business process assets.

I have read "Software Lean Strategies" from cover to cover and believe it is of truly "outstanding value" I'm a highly experienced software engineering professional and each work day have the responsibility of ensuring complex safety-critical systems functionality controlled by software is of high integrity. I try to read, learn and see perspectives of all. It is refreshing to see a real world book with many examples and lessons learned in Software Lean Strategies. Why do I feel this is an outstanding book? First, it has given me a new perspective on how to integrate systems more strategically. It is all about the long haul software life cycle strategies and not about day to day tweeks and tactics. It is all about real world systems and the constant struggles in software. Also it is kind of like Fredrick Brook's famous book "Mythical Man Month" first written over 30 years ago about IBM and the 360 computer. Software Lean is more about software and systems integration developed a few years ago and how to apply the value stream and to focus on essential priority tasks and work products. Software Lean shows software development is still plagued with inefficiencies and the authors are not saying they have the silver bullet, but are only sharing some of their experiences, lessons learned and what seems to work best. When I look at Software Lean conepts in totality the authors are simply communicating and suggesting some areas to focus on for cheaper, better (higher quality) systems and higher technical integrity. I firmly believe folks who will read this book with an open mind will get new ideas. It stimulatated my thinking and helped me apply some of the principles to prevent costly rework. When compared to other books on the Lean subject this one has specifics and many principles and examples grounded in fact. It is truely non-fiction. Some other books on the subject are way off the mark and have some rather odd concepts that are counterproductive. I did learned to think more strategically after reading this fine book. I try not to slam anyone's opinions in books, especially when they are so open and honest about what works in software development and what does not. Software Lean "earned" a recent prestigious award. I read it a year earlier and touted it amongst software leaders, coworkers and collegues as a darn good read. Final point: I am normally a little critical of new concepts and fad books, but in this case found no fads and agree with 95% of what is written in Software Lean. It is somewhat innovation and very logical and I believe one can benefit by seeing many persopectives and not being so close minded. The other 5 % I disagree with is either what is lacking or perhaps simply philosophical differences based on my biases and inability to see the point. My hats off to this book that has helped to stimulate some actionable ideas. I've loaned it to a couple of enginners on my staff and they like it. The more we read, the more we learn. I keep "Software Lean Strategies" on my desk on top of The Mythical Manmonth and right next to several latest editions of software periodicals, such as Embedded Systems Design with the Star Trek crew, Maxwell Smart taling into a shoe phone, and others on cool covers to grab attention of software and systems engineering geeks like myself.

Barry Hendrix

My dear old mom--or someone at least as authoritative; I can't quite recall whom--once said that you should always begin a conversation by saying something nice. Especially when you are responding to a *slanderously* bad review. :-)

Great advice, mom. Here goes...Reviewer Steele indeed seems to know what SCR, CoRE, and SPARK Ada are. There; mom was right. That felt *good*.

Obviously not everyone agrees with Steele...starting with the judges of the Shingo Prize, which Business Week has called "the Nobel Prize of Manufacturing." Their professional credentials are pretty good. The review from stickyminds.com (the encyclopedic software development community) is also very positive. Why is Steele's review in such stark contrast to these expert opinions?

It is because every one of Steele's points is in blatant error. In each case he either gets easily-checked facts wrong, misrepresents something about the book, or misunderstands something fundamental about Lean Production. A few points below will give you the idea. Whether this happened accidentally or on purpose only Mr. Steele can answer. If you want a complete analysis of his review, contact me through our publisher. Amazon reviews are the only visible way for authors to respond ("comments" get lost), so, though giving a rating to my own book feels strange, hopefully enough reviews will eventually be posted to bury both my and Steele's numbers.


1) Steele: "This book... never offer[s] a single specific example of lean application on a software development effort."

I'll let the professional reviews lead. From the Shingo Prize review:
* "Multiple examples...show how lean software development improves...software projects"
* "The authors explain different lean techniques, for example load leveling, and show how they can be applied in the software development process"
* "This book focuses on the specifics of lean IT, down to choosing the programming language"

And from the stickyminds.com review (emphases mine):
* "It is extremely well-written with liberal use of real-world examples"
* "Parts two and three provide a detailed manual on building lean software"
* " `Lean Software Strategies' includes many helpful examples and analogies"

Here's some of the specific examples these reviewers are talking about:
* Requirements analysis: SCR method. Also names the programs on which it's been used. (pp 125-129)
* Design: an actual architecture I developed and used on multiple named programs. (pp 401-406)
* Verification: a powerful, time-saving tabular approach (pp 246-251)
* Customer analysis: Kano Modeling, others (pp 104-108, 137-152)
* Planning program work: Analytical Hierarchy Process, others (pp 112-119, 177-193)

There's several more, many visible in the online Table of Contents through Amazon's "Search Inside" feature. I got my start on many of these techniques with less guidance than is given in the book.


2) Steele: "It was widely understood among certain circles that the C130-J team...was made available for the 382J development and the real software lean story was the use of the small now experienced team."

I know we haven't had a chance to become friends yet, Steele...but that's no reason for me to withhold a little friendly advice. Put a "stop payment" on your latest inner-circle dues check. They're not earning their keep. The C-130J military-aircraft development started up two years after the civilian 382J. Not vice versa.


3) Steele: "The author's experiences...are in fact applications of techniques that have been around since at least the mid 80s."

That would be true if the techniques in the book all originated in the 1980's. However, the book also addresses model-based development (late 1990's on), Blitz QFD (late 1990's on), high-integrity UML (2000 on), several current programming languages, Agile development, and many other current techniques. This is, again, made abundantly clear in the book's pages and in the online Table of Contents.

More serious, though, is the reviewer's implication that "latest tech" is the only legitimate way to go. Under mass production that was generally the case. It's how Detroit dominated the world's auto industry for decades. But 1950's post-war Japan couldn't afford Detroit tech...so to survive, Toyota developed a way to use older technology to its advantage. Today we call that way, "Lean Production" (it addresses more than just technology, of course). All described in the foundational Lean books by Womack et al, i.e., "The Machine That Changed The World" and "Lean Thinking." Good background reading for reviewers of Lean books.

Moral: Sometimes older tech does a better job than newer tech. In those cases, don't be afraid to use it. (By Lean criteria, SCR remains more advanced than most of today's popular software methods.) Our book discusses why this is so, and how software-development organizations can use this dynamic to their advantage.


4) Steele: "The book spends a chapter maligning the CMM practice in which nothing good about it is said."

Short answer; pages 61 and 73 (among others):
* "The SEI [the organization that created the CMM] is a very competent and diligent organization, and has always based its work on sound research" (pg 61).
* "The CMM is...almost completely compatible with the mass production [principles]" (pg 73)

But that mass orientation was so complete that in many ways it prevented organizations from adopting Lean.

The SEI seems to have agreed with at least some of our observations. They replaced the CMM with the CMMI, improving many of the very problem areas I pointed out. I'm not claiming cause and effect; only similar thinking. Indeed, a couple of national leaders in the CMMI community have told me they agree with my analysis. Finally, for the last two years I was a leader on my company's CMMI initiative. They wouldn't have picked me for that position if I had been completely anti-CMM or -CMMI.


Mom also said I should know when to give things a rest. That point has certainly arrived, if not long passed. I'll call this response done. Thanks for reading.


Jim Sutton
Author, "Lean Software Strategies"

I have this wonderful iMac that does everything but make coffee. To navigate all the apps, this book is short & sweet.

Very easy to follow, not overly techie. RW & JT have a good writing style and aptitude for clear explanations. The book's illustrations (screen dumps) are well chosen and relevant to the text instructions and explanations. A good teaching tool for IT's to provide for staff or clients.

Luckily I read most of the chapters before my co-worker's permanently "borrowed" it. Now I need to buy another copy. Hope RW & JT are busy writing the next edition for the recent upgrades to some of the iLife apps announced at '04 MacWorld. I'll buy that book also as soon as it's available. Howevery, most iApps have have had only minor changes to them with Panther (and the new iLife), so this current book is still very useful and well worth purchasing.

This book is `hot off the presses,' having been published on April 10, 2003. I guess I was thinking about iLife, because I expected it to cover only iTunes, iMovie, iPhoto and iDVD. But to my surprise, it covers them and much more.

It also covers Mail, Address Book, iCal, iChat and Rendezvous, Safari, Appleworks, Omnigraffle, FaxSTF, Inkwell and all of the .Mac features, including iDisk, iCards, HomePage, WebMail, Backup, iSync, Slides Publisher and Virex. Phew! I'm glad I don't have to say that - I'd run out of breath.

I get a lot of questions from people who are converting from other e-mail apps to Mail, so I looked through Chapter 5 (Mail and Address Book) to see if the most common questions were covered. They were. The AppleWorks Chapter (17) is divided into six sections: Word Processing, Database, Spreadsheet, Painting, Drawing, and Presentation. They cover all the basics you need to get started with these tools.

Tollett and Williams tell us how to rip CDs, import and edit movies, work with iPhoto, create a chat room in iChat, edit, publish and subscribe to calendars using iCal, make a web location from any link in Safari, publish a slide show on your .Mac account, customize the button bar in AppleWorks, and so much more. the information is presented in simple, logical, straight-forward steps.

This book ought to come in the box with every new iMac, eMac and iBook. It covers everything the beginning user of these apps needs to know.

When you buy a computer, you get an operating system with it. When you buy a Macintosh, you get an operating system and an impressive set of most useful applications with it. You should have a book about using the Mac OS X operating system. You also need a guide for using the applications that came with it.

The Little Mac iApps Book is about the separate applications that come with Mac OS X that were not covered in Robin Williams' The Robin Williams Mac OS X Book, Jaguar Edition. In this one book you will find a helpful guide to:
* iLife applications -iPhoto, iTunes, iMovie, and iDVD
* OS X apps - Mail, Address Book, iCal, iChat and Rendezvous, and Safari
* .Mac apps - iDisk, HomePage, WebMail, Backup, iSync, Slides Publisher, and Virex
* More Cool apps - AppleWorks Word Processing, Database, Spreadsheet, Painting, Drawing, and Presentation, plus OmiGraffle, FAXstf, and Inkwell.

More complete coverage of the iLife applications is available elsewhere, but this first section is enough to get you using these applications. If you want more information or to see a demonstration you might consider The Macintosh iLife with a DVD by Jim Heid.

The section on Mac OS X apps is, I believe, the only source that covers all of these applications and it does so with enough information to really use them. It is presented so that it is easy reading and the beginner can understand it.

Safari is still in Beta but is quite stable and has already become the favorite Internet browser for many of us. This is the only book I know of with Safari information like these two examples: To save or e-mail a link, drag the icon that is immediately to the left of the URL. To open a link in a new window behind the current window shift-Command click on it. "I can go to a search results page and open a dozen windows in five seconds."

The section on .Mac apps may be enough to get you to sign up to become a .Mac user.

The section on AppleWorks applications is presented as a tutorial. For example the chapter on the AppleWorks database compares records to recipe cards and tells you how to construct an address book which you can easily modify to fit other collections. There is a minor error where it advises you to use a character field for a telephone number and a number field for a ZIP code. The ZIP code should also be in a character field so that leading zeros display.

This is a well written and clearly presented book which should appeal to most Mac OS X users because you really should have a guide to all of the applications that come with Mac OS X.