5 comments about The Definitive Guide to JasperReports (Expert's Voice).

1. 218 pages, not a single example, less than 20 total lines of code. In my opinion you are better off just reading the api.



2. I've been using JasperReports for years, and periodically purchase the on-line PDF version. The APress printed book is the same as the on-line PDF version. The scope of the book is cleanly defined: JasperReports. It does not cover Eclipse plugins or related libraries such as JFreeChart. It does not mention JasperServer. The book is comprehensive, though more of a reference than a tutorial. I would have been pleased to see more tutorial information and chase a few rabbits for related topics. Other people may appreciate it's close adherence to scope.



3. I miss more Java code examples in the book, also it is too much an aseptic reference of the options of JasperReports, being really not a friendly or instructive book.



4. This book does not provide enough details about the JasperReport especially about how to use it. It also be lack of examples.
   
   I strongly recommand directly using iText for PDF file generating.



5. JasperReports is a great reporting engine which suffers heavily from its utter lack of useable documentation. I bought this book, written by JasperReports' author Teodor Danciu in the hopes of finally getting adequate documentation. Boy! was I disappointed!
   
   The book is an extremely superficial overview of the product; it's really no more than a glorified README file. Chapter 5 ("Large File Support") is a perfect case in point: The classes in the virtualization API are named, but nowhere is there any explanation on how to actually use them.
   
   It's quite unfortunate that Danciu has put his name on this poor excuse for a book. Luckily, I bought the PDF version, so I wasn't responsible for any trees dying...

4 comments about Game Programming All in One, Third Edition.

1. I will never know if this book is worth squat.
   You see, it relies on the open-source Allegro game programming library.
   The problem is, it's nearly impossible to get it installed and working!
   The catch-22 is, I can't return the book because I opened the seal on the packaged CD that supposedly includes all the stuff you need for the book.
   
   the book looks promising, but for now it's a big paper-weight made of paper.



2. I had to figure out by my self how to compile the codes under linux. The book doesn't go over compiling under Linux, other than using kdevelop.
   
   
   
   1 star: Readability. It was easy to read. While I found some typos, it wasn't such a big deal.
   
   2 star: There aren't many books out there on Allegro Library, and that deserves some recognition.
   
   2 star: I own another book written by Jonathan S. Harbor, which was also a good read. Beginning JAVA ... I forget the title but it was a JAVA book. Anyways, the 2 stars are for the author, and his experience in game programming.
   
   It's a nice book to have.



3. This book is intended for the ABSOLUTE BEGINNER. It assumes the reader has a very basic knowledge of C, and understands the basics of pointers, arrays and structs. No experience with other multimedia library/GUI toolkit/etc required, although it helps.
   
   From that point on, it will get you up and running really fast; in quite a few chapters this book will cover simple 2D game programming, teaching all the basics neededed for programming more complex games. Trough the use of Allegro library, the topics of handling input (keyboard, mice, joystick) and output (sound, graphics, sprites) are covered effectively.
   
   The later chapters, however, did not appeal to me at all; they deal with horizontal scrolling (classic mario-like games) and vertical scrolling (1942-like shoot'em up's), AI, multithreading... which is very cool stuff, but I don't think the approach chosen is very effective.
   
   It is read REALLY fast however, with very big fonts, and clear and neat writing. It dissapointed me a bit because although it seemed very nicely edited, one of the examples was misplaced.
   
   If you plan to work under linux, the code will work (most of the time), but compiling can become somewhat cumbersome. Under windows, it works fine.
   
   To wrap up, I quite liked what the author says about gaming and game design in general, and teaches very effectively what he intends, having the "All In One" covered; but examples are overall too simplistic or superficial.
   
   I'm rating four out of five because I expect a book on the subject to be a little more high-end; however, if you are new to programming in general, this book will prove quite helpful. And, Allegro can take you really far (it even has the bonus of being open source!).
   
   P.S.: as a side note, reading other reviews, the second edition looks better than third.



4. I tend to shy away from game programming books with the phrase "All in One." And not without good reason. Most of them are utter garbage. They simply try to do too much. Take the 1st edition of GPAIO for example--it was just awful. It had diagrams on the wrong page, tons of errors, etc. And it wastes way too much time going through the technical stuff. Very little on game programming.
   
   Not so with this book.
   
   While there is some technical stuff, the author utilizes it almost instantaneously to form a simple tank game along the way. Towards the end of the book, he covers horizontal scrolling (i.e., Super Mario Bros.) and vertical scrolling (i.e., 1942). While neither example is a complete game, both really explain the mechanics well enough that making a game of either type should be fairly easy.
   
   I was a bit reluctant to buy the book because it uses Allegro, rather than the more mainstream options of DirectX and OpenGL. But I really think Allegro was a great choice. It allows him to focus on the meaty stuff, you know, actual game programming stuff. I have way too many books that waste upwards of 150 pages on setting up a window with DirectX.
   
   My only criticism is that the book is more for hobbyists than professionals, but then again I have never seen nor heard of any such book. Anyone who wants to program games, albeit simple games should definitely check this book out.
   
   As for the reviewer who gave GPAIO one star, I'm really doubtful that s/he is serious. But if so, my advice to you is this: If you can't get Allegro up and running, then you shouldn't be programming games. It's that simple. Really. It's not any harder or easier to set up than DX, OpenGL or even SDL.

5 comments about Beginning Ajax with PHP: From Novice to Professional.

1. The author gives a good intro to Ajax and PHP combined. Gives you a good understanding of what those two are able to do together.
   Sadly this get ruined by a lot of mistakes in the sample code provided, one example being an SQL phrase that actually will make the script not work. Also he dump several pages of code right in your face, but fails at explaining properly what's going on, leaving you with the feeling he might have "borrowed" the code from somewhere and not really knowing himself what it does.



2. Wish I'd read the reviews more carefully before buying this book. Stephen Rider's criticisms are exactly right. I was particularly disappointed with excessive use of the innerHTML object. It's been deprecated and should not have been included in a book published in 2007. The long code examples are as Stephen says, too. At the very least, some way of highlighting the difference or addition in them to bring it to the reader's attention would have been better. I read "Head Rush Ajax" before this, and it does a much better job overall of teaching the right way to code Ajax--I was just hoping for a book with more PHP-specific coding in conjunction with Ajax.



3. I was excited about this book until I realized how many errors there are in the source code! It makes it very impractical to work with, too bad!!



4. Were the editors asleep when they put this out? A couple other people commented on the errors, but still gave it a 3 star rating. They were being kind. You can't learn anything when the examples are so completely riddled with errors. Others commented on the use of the deprecated innerHTML. For $35 I expect better from an author and his publisher. This one is being returned.



5. The samples you can download from apress are NOTHING like what the writer has written in his book. He mixes his languages in the code in the samples, then when things don't work, you can't go back to the code that you dl'ed from him, as it's nothing like the book. I had more headaches from this book than any other technical book I've ever owned.
   
   It's unfortunate apress didn't bother to really go over this book with a fine tooth comb, or they would have noticed the simple things like using a "try" in php... then catching it.

5 comments about Oracle Application Server 10g Administration Handbook (Osborne ORACLE Press Series).

1. As an administrator/implementor of these systems, there are many aspects to administering the 10gAS system. Although the authors do make reference the book intends to simplify the rather large amount of documentation, it falls short of a complete guide.
   
   It is good starting point for a default implementation--detailed installation steps, with moderate emphasis on design (ex. touching on distributed administration and delegation). Thus provides adequate groundwork.
   
   The forefront of administration of this product is design choices. For example, the Internet Directoy piece is major component to the architecture--its design greatly impacts administration of the entire system. Perhaps this book was not intended to be a design resource (since it is designated an "Administration Handbook"), but administration in the field of application servers is highly dependent upon design decisions.
   
   The book would be a fair addition to a reference library, but not necessary if one is willing to sift through the vendor "White Paper" documentation--as large and convoluted as it may be.



2. I have taken the iAS 10 Admin I course from Oracle, and wish that I read this book prior to the class. I found it very valuable especially if you are deploying iAS 10g (9.0.4) on Linux. I highly recommend the book to iAS administrators/DBA's.



3. I used this book to deploy Oracle Application Server 10g infrastructure on Linux and UNIX. I felt that it was a good book and overall I have little ill to say about it. The examples are well written and do a good job of reinforcing what you read in the handbook. You read a little then do an example, then read some more, then add to the example and so on. You don't need any Administrative experience to use this book just a decent understanding of application design. The only criticism I could offer is that the editor should have used arrows when content is being continued on a new line for reasons of page space so that readers will know and understand (beginners can have trouble with this). It's a good book for learning Oracle Application Server 10g as a whole from the ground up and for this reason it's worth the money. It's not an overnight crash course (if that is what you are looking for).



4. thanks this is Good book, but because I need quick reference for me this book rather not detail or too fast on explanation.



5. This is a great book to use for beginners in the administration of OAS 10g. It covers the basics well and provides enough examples to allow the user to get a good grasp on how to install and implement the application.

5 comments about Beginning Regular Expressions (Programmer to Programmer).

1. Regular expressions are one of those useful concepts that programmers have reimplemented in each new, aspiring language or software package. There has always been an abiding need for a compact notation that lets skilled users (and programmers) denote what they are looking for, in a set of textual data.
   
   Watt brings a lot of this work together, so that you can concisely find what you might need. Also, the book shows that much of the notation is common across the many implementations. Plus, once you've mastered a few of these, learning another is easy. Your experience transfers well.
   
   Chapter 2 has a good summary of the rest of the book. It points to a comprehensive list of packages and languages that have regexp, and which are covered later in the book. The packages include the open source StarOffice, and Microsoft Word and Excel. While the languages include JavaScript, JScript, VBScript, VB.NET, C#, Java, PHP and Perl.
   
   The heft of the book lies in supporting these examples. But the basic ideas are very simple.



2. I picked this book up because I had no idea just what a Regular Expression was. Turns out that regular expressions are nothing more than the "wildcards" from a lot of applications like Microsoft Word that have been generalized to fit a lot of applications in text processing.
   
   For instance you may want to examine an incoming field from an internet form. If the data is going to a social security column in a database, you want to be sure that the data doesn't say something like Fred-34-1234. It's the right format, but alpha isn't a good thing to have there. If this isn't checked form, it may wait until the SQL Insert statement blows up.
   
   The generalized form of expressions like this can be used to check things like SSN formats, the proper formation of an e-mail address and a lot of other things commonly needed in text processing.
   
   Many languages both programming and scripting have provisions built into them to handle this kind of text processing. This book provides the generalized background to use regular expressions in ways that that you haven't considered but which you'll find very useful.



3. As an introduction to regular expressions, this book does an excellent job of covering the many different ways in which regular expressions are used. Included are explanations of how to put regular expressions to use in client-side Javascript, Microsoft Word, Open Office, C#, PHP, Perl, ASP, etc (Just a few that I could think of off the top of my head). I especially like that the author didn't focus on only Microsoft products, or only on open source products. He gives an excellent introduction to how regular expressions fit in in both the world of programming, and simply using your computer from day to day. This is a huge book, and Mr. Watt does a fantastic job of covering both syntax (nuts and bolts) and real-world application. This is an excellent starting point for anyone wanting to more about Regular Expressions.



4. A good introduction, but I was disappointed with all the typos in the text and regex examples, as well as Figures being mismatched with the text (in one case a nonexistent Figure was referred to, and a totally irrelevant Figure was in its place). No coverage of modifier spans. But on the whole, adequate for rank beginners.



5. For years I have wanted to learn how to use Regular Expressions. But the short tutorials that I came across left me double cross eyed perplexed! I finally came across Beginning Regular Expressions. Now the whole process is a piece of cake. The author takes a very cryptic subject and makes it totally clear. Within two hours of reading this book while laying on the couch, I was able to hop up and write cryptic looking formulas as if it was my second nature. Regular expressions are so powerful and so helpful. I'm so glad I finally came across this book. Thanks to the author who painstakingly broke it down to the most basic levels and made everything crystal clear! If you have an interest in POWERFUL search and replace across a lot of files, this book is your ticket to search and replace paradise!

No comments about Tools For Structured and Object-Oriented Design (7th Edition).

5 comments about Systematic Software Testing (Artech House Computer Library).

1. Books on software testing are usually something you read because you have to, not because you want to. Authors Rick Craig and Stefan Jaskiel have set out to change that, and the result is the best current book on software testing. A combination of the timeless and the cutting-edge, Systematic Software Testing is all you need to get to work and to get the job done well.

   The authors begin with the basics of software testing, including the evolution of the discipline over the years. They continue on to discuss STEP methodology, and then launch into the fundamentals of testing. Among the covered topics: risk analysis, test plans, automated test design and implementation, IEEE/CMM/ISO guidelines and standards, and test execution. For those who are going to be managing their own test groups, there is additional material on who to pick for the job, what those jobs are, and how to organize your testing.

   For both the software engineer and the engineering manager, this text is an invaluable resource. The methodology is sound and up to date, and following the clearly enumerated steps in this book will surely result in a superior product. If this isn't enough to convince you, the text is also FUN to read. This isn't your typical bare-bones textbook, as exemplified by Rick Craig's amusing and memorable anecdotes and the occasionally apt quotation. The wording is clear, everyday English and key points are clearly visible. The book is very well organized by topic and subsections, making it great for refreshing your memory on particular details.

   Even if you are not directly involved in testing, this book is worth reading. Just understanding the software lifecycle process is a major help when it comes to improving software quality, and this excellent text will grant you that understanding.




2. What strikes me most about this book is its friendliness and readability. The book is written in an easy and flowing manner, using day-to-day language. It's assembled in template style, which makes it extremely easy to implement its ideas. While this may not sound like much, these attributes make this book quite an entertaining read that scores high on effectiveness. Supplemented by an effective website...it does still suffer from some lack of depth and detail, though.
   The fully detailed "Sample Master Test Plan" provided by the book serves as an example for its mixture of usefulness coupled with a relative lack of depth. While quite effective, and certainly a nice feature that's easy to learn from, it is not the most fully detailed test plan I have ever seen, nor is it a match for a big scale project's master test plan. However, it is the best example for a test plan that I have seen in any testing book.
   Further comparisons with other testing books I've used make it clear: Applying the Pareto principle on it, this book gives you the 20% that you need in order to perform 80% of all you will ever want when it comes to testing. It may not sound like much, but this is a mighty achievement.
   The bottom line: This book will probably serve anyone who is into software testing. However, if you are looking to kick-start your organization into proper testing methodologies, or if you are new to the software testing arena, it would be a sin not to give this book a try.



3. I rarely recommend a book just from skimming it, but "Systematic Software Testing" is an exception. I ordered it based on references from other good books and 5-star reviews on the Internet, to see if it would live up to its reputation. It does. "Systematic Software Testing" is a comprehensive but easy-to-read book on all aspects of software testing. And you don't have to read everything at once -- pick a topic and chapter that interests you and start there. You will be glad you did.



4. Although I am a Systems Engineer and therfore more interested in Acceptance and System level test I found this text to a very useful overview of software testing with much of relevance to systems test too. There is a also a very practical process to follow as well as much real world experience and practical advice in this test. Highly recommended.



5. The book gives a complete view of what software testing is about. But as an experienced software testing professional, I find this book boring. And the book is written with words connected together. I don't see the author's own voice. It is more suitable for a text book, rather than a 'book' book.

2 comments about Professional Oracle Programming (Programmer to Programmer).

1. This is an intermediate level book. It is intended for the application developer who already has some knowledge of SQL (which implies some knowledge of what databases do) and of programming (particularly Java). For instance, the first chapter of this book is on the internal structure of Oracle. That's a long ways from the standard beginning of this is what a database does.
   
   A thing this book is not for is the database administrator. There's very little on things like set-up, assigning users, security (there's a little on this); those kinds of administrative details. This book is, as I said at first, for developers.
   
   The book does go heavily into programming techniques like triggers, regular expressions, object types, XML, defining your own functions -- things like that.
   
   The authors all have extensive experience with Oracle, most of them work for or have worked for Oracle. As this series of books proclaims, this is a book written at the programmer to programmer level.



2. I have read all the books on Oracle and most seem pretty fluffy - lots of pages but the content is on a pretty basic level. This is the first book I have seen that really delves into the guts of Oracle - how it works, and how to program applications effectively for it. Just what I have been looking for!!!

5 comments about The Art of Computer Systems Performance Analysis: Techniques for Experimental Design, Measurement, Simulation, and Modeling.

1. This is an absolute gem. I really think that this book must be read by every CS/EE engineer. Performance analysis is always something that comes as an afterthought and engineers think that some some "mathematical" guy called a perf analyst will stop by after the product is completed and analyze the product. This is def wrong. PA should be done at every stage of production.

   This book has been written assuming a novice reader. Several parts of the book have to re-read to really understand what the author is trying to convey, but trust me you will really appreciate it.

   I suggest reading the following parts of the book(in order):

   Part I (whole)
   Part II (4, 5, 6, browse {7,8}, 9, 10 ) 10 is cool stuff..impress your peers with this
   Part III (whole) read, re-read, re-read till you have digested every line..worth it really!!!!
   Part IV (whole) read, re-read, re-read till you have digested every line..worth it really!!!!
   Part V : You can skip this if you are not into simulation.
   Part VI : Not really that easy to follow. I suggest Gunter's book for this.




2. I'm a performance analyst. I couldn't do my job properly without this book. It really is that simple.



3. A solid book indeed. It has the right mixture of theory and practical cases well dealt with. The techinques must be tried for performance analysis and implemented in real time projects.



4. This old book is one of the most valued on my shelf. I was first exposed to it in a graduate class, and I have to say that the book is so good I was not aware that my professor was not a good instructor until I had him a second time in a class where the textbook was less than stellar. Don't judge the book by a quick perusal either. At first glance, especially if you are looking at Part I, it looks like one of those books on Six Sigma that will put you to sleep. In fact, the vast majority of the book is quite interesting.
   
   Part II, "Measurement Techniques and Tools", are where things get interesting. The good part about this entire book is that it uses problems in the analysis of computer systems as the basis of presentation for all tools presented. The graphs are excellent, the mathematics are largely self-contained, and if algorithms are presented they are usually given in numbered steps and an actual computer program shown. This is one drawback of the book - it uses the ancient Simula language for its demonstration code. However, if you are familiar with C, Java, or any of the other mainstream procedural languages, you'll find that Simula looks like very readable pseudocode, so this should not be an obstacle to understanding.
   
   Part III is a section dedicated entirely to probability theory and statistics. Starting with the simple definition of the mean, this handy section not only derives all of the statistics you need in this book, it talks about common mistakes made in applying them.
   
   Part IV is about experimental design and analysis. Using the mathematics developed in part three this section talks about all aspects of designing a proper experiment for the measurement or simulation of a computer system, including common mistakes and the best choice for the size of your experiment.
   
   Part V presents the key issues in simulation modeling. First it discusses simulation terminology, simulation design criteria, and stopping conditions. Random number generation is the subject of three chapters in reference to inputs to your simulation. Finally there is a chapter on the commonly used distributions such as Bernoulli, beta, binomial, etc. that talks specifically about random number generation algorithms for each of the distributions presented. What makes this section so valuable is that although you may have possibly seen the math before, more than likely you don't know the value of each kind of distribution. This section makes that issue clear in terms of modeling computer performance.
   
   Part VI is on queuing models, and is probably the most difficult section in the book. Although it is one of the better written pieces I have read on queueing theory, it is not as easily grasped as previous sections based on reading the textbook alone. There are examples present, and the book does a good job of presenting "the big picture" as to the use of queueing theory in computer performance analysis, but you may need outside material to really grasp how to set up a queueing problem from a mathematical standpoint.
   
   No other book I've found does such a good job of discussing all of the topics covered and clearly tying it into practical issues in measuring and monitoring system performance. I highly recommend it.



5. I purchased Jain's "The Art of Computer Systems Performance Analysis" for a 3-month graduate course, and I must admit that, in retrospect, I was a bit daunted by its size upon receipt (we were to cover the entire text). Further, I had my doubts about the relevancy of the text in the current environment, given its age.
   
   But I must say, both of these initial questions proved wholly unfounded.
   
   I've never used a text quite like this one before; it is a significant departure from the standard engineering text that weighs heavily on the side of analytical proof and mathematical equations, while foregoing textual elaboration. On the contrary, this book adopts a conversational tone whereby the author develops all of the book's topics in great detail, relying on substantial insight and experience. Truly, a breath of fresh air.
   
   There's such a richness about this text, that a careful read--while admittedly quite time-consuming--is bound to give the reader a sense that he has just become the beneficiary of a heck of a lot of wisdom.
   
   All of this is not to say the text is overly-subjective; in fact, there is plenty of detailed analytical analysis. It is just to say that the book is different, and one that exudes quality communication: it reads more like a lecture than it does lecture notes.
   
   So, back to my initial doubts. It turns out that the verbose depth of material which constitutes the book's 720 pages is really a foundation of its main qualities: it is a very readable and highly-detailed exploration of the art and the craft of performance analysis. And it's for that foundational reason that its age is irrelevant.

5 comments about Software Creativity 2.0.

1. I was somewhat apprehensive about the book, but I took other reviews on faith and purchased it. I can't say that the ideas are groundbreaking, but glass presents both sides of the argument with a minimum of bias. A long story short, I highly recommend this book.



2. Too often pragmatic concepts in software fall victim to zealot practitioners whose ideology includes panacean promises of one-click programming and ideas that good process guarantees a good product regardless of personnel. Too many people still promote their ideas and methodologies as cure-alls. These people treat software as a franchise with a factory-line assembly and replaceable parts. It is anathema for many to think of software as a creative endeavor. However, this idea that software development lives and breathes with creativity is what software curmudgeon Robert Glass takes on in his sagacious book on software. This book is a newer version of his original 1995 "Software Creativity" which has been unavailable (cheaply) for many years.
   
   This book is divided into four parts. The first part (and I feel the most important of the book) is the exploration of software creativity. Here he takes on nine dichotomous subjects (discipline vs. flexibility, formal methods vs. heuristics, optimizing vs. satisficing, quantitative vs. qualitative, process vs. product, intellectual vs. clerical, theory vs. practice and industry vs. academe, fun vs. serious) and explores the advocates on both sides and tries to find definitive answers (or at least raise more questions).
   
   What I found fascinating about several of these chapters like quantitative vs. qualitative and industry vs. academe is that they can apply to many different industries and not just software. How many times has quantitative reasoning been used in business only to fail miserably in the hands of MBAs? How can academe differ so much from practice (like getting your Juris Doctorate compared to really practicing law)? These chapters are a plethora of interesting ideas that many of these chapters can be discussed at length (imagine the length of the review if we tried) and one fault (that has already been mentioned by several reviewers) is that some of the topics need more discussion.
   
   The second part deals with making creativity happen. I feel this is such a difficult thing to do in large organizations since it involves a paradigm shift in thinking, but it is a must for small companies. The third part deals with creativity in other fields and the fourth is the conclusion. And to give away the ending his thoughts can be summed up as "...is that our one-size-fits-all approach is wrong. No, it is worse than that. It is WRONG!" The one question that remains is how do you change a practitioner's mind that already has all the answers?
   
   I never read the original book; I did not get into Glass's writing until I received as a gift Glass's Facts and Fallacies of Software Engineering and became enthralled with his pragmatic point of view. That laconic work got me interested in his writings and when d.* brought out this book I bought it immediately. Software Creativity is not as well known as Frederick Brook Jr's masterpiece "Mythical Man Month" or Edward Yourdon's "Death March" (and many others) but it is such a great read that anyone involved in software can benefit from this book. I am biased though. After years of "software development" I have found it to be a very challenging and rewarding endeavor that does benefit from structured creativity. Apparently Robert Glass feels this way too.



3. Can I give it 10 stars?
   
   I could write volumes about this book, but perhaps the most important thing is that it allowed me to rid myself of guilt about not following rigid software process. In the back of my mind, I always knew that software process as I've learned it is impractical and in many cases infeasible. However, it was taught in school as if it's (obviously) the only way, and therefore I had a lingering guilt about not being able to follow it precisely.
   
   Glass speaks with a thundering voice from the practitioner's perspective exactly what is wrong with rigid software process and creativity-stifling management styles. He also explains the evolution of software process, and makes it very clear that we're no where near a satisfactory solution.
   
   Why should you care what Glass has to say? For one, he's been in the software industry longer than most current software developers have been alive. He's also spent many years in academia, and has excellent insights on what's wrong with that side of the fence as well. But, above all, because what he says is true. Every once in a rare while you read something that rings so loudly that it can be nothing else but true. If you're a frustrated software developer, this is that book.
   
   I applaud Glass for presenting such an honest discussion of the role of creativity in software process and management. I have no doubt he's made a few enemies along the way, but the discipline is certainly the better for it.
   
   In short, if you're in the software field, and care at all about the future of the discipline, go out and get a copy of this book and read it cover to cover. Your career and the discipline as a whole will be the better for it.



4. I am very interesting in the discussion of process versus product and standardization versus creativity. I was expecting some more specifics and industry results. Instead, the book ends up by being highly philosophical.



5. It's a quick, but heavy ready. However, this is a great little peak into the psychologies involved in software. It's something I recommend all developers, managers, etc. to read that work in the tech industry.
   
   You may not walk away with any new ideas, but you'll definitely have a better understanding of what's running through people's minds (and that applies for coders, architects and even managers). The topics covered on business vs. academia are priceless in terms of examining the current state of affairs in the tech world.
   
   Pick it up and give it a shot.
   
   If you're writing any papers/essays on topics related to tech, this would also provide a great reference and has many entertaining and potent quotes.