5 comments about Java 2D Graphics.

1. This book's content is great even though it spends a lot of ink regurgitating the doc (symptomatic of O'Reilly). Even with this it touches on everything within 230 pages while showing many examples.

   My issue with this book is the way that the examples are written. It uses inner classes left and right requiring more careful reading of the code. I know this is a philosophical issue; but in general inner classes are a lazy programmer's tool which tends to confuse code and make it harder to read/maintain. It is bad enough that they are used in documented public APIs - in a didactic text, there's no need to exacerbate this.

   Content gets 4 stars. Examples get 1 star. Since code examples are really 1/2 the content, it gets only two stars. Previous book by the author (on cryptography) had much better examples - and didn't use inner classes.




2. I really enjoyed this book. It covers two dimensional graphics very well. The code will challenge you. I like all books by Jonathan Knudsen. I think he is a good writer. If you a beginner, you might want to buy a primer on JAVA first before buying this book. I would recommend this book to anyone who wants to learn JAVA Graphics2D



3. This is a not worthy buying book. I bought it in Amazon, so, without flipping pages. The author expends much of the time showing things you can find in Sun's javadoc, with tiny examples. For example, I read on and on looking how to create a BufferedImage and came to nothing! If I wanted only commands, I could look in at Sun's javadoc. I bought the book expecting to find out how to stuff, not bla bla bla.



4. The book gives a very good introduction to java 2D graphics programming. I bought in in order to come up to speed in a new project involving display and analysis of dicom images. It did not fail me! Highly recommended.



5. In computing, Java 2D is an API for drawing two-dimensional graphics using the Java programming language. Every Java 2D drawing operation can ultimately be treated as filling a shape using a paint and compositing the result onto the screen.
   
   This book, although seven years old, is the best in print on learning the basics of Java 2D. Several other reviewers have said that the Java docs for the API from Sun are just as good, but I disagree. This book does a good job of taking a complex API and laying out what it takes to produce graphics using it.
   
   It starts out explaining the architecture of the Java 2D API, and includes a very long "Hello Java 2D" example showcasing what the API can do. The author admits at the time it is presented that it is likely the reader will not understand the code until the book has been read.
   
   Next, the author introduces the drawing of shapes, and then adds painting, stroking, transforming, compositing, and clipping to the equation, one by one, while explaining the nuances of each feature being added. Next, the author goes into adding text to your figures and also explains how to do simple image processing with the Java 2D API, even explaining how to "roll your own" image transform operations.
   
   The book concludes with a discussion of printing, animation, and measuring performance with Java 2D. The author includes a flexible framework for performing animations using Java 2D. There is example code throughout the book that can be downloaded from the publisher's website. If you are looking for a book of image processing tricks and recipes in Java, this is not the book that you want. In that case you might want to read Hardy's excellent but out-of-print work, "Java 2D API Graphics", after you read this book. However, if you want a good foundation in programming with the Java 2D API and understanding its architecture, this is a very good source. I highly recommend it.

4 comments about eXtreme .NET: Introducing eXtreme Programming Techniques to .NET Developers (Microsoft .NET Development Series).

1. This book gives a fresh insight into the world of XP and it's application to techniques suitable for .NET developers.
   
   Vote Clinty.



2. Dr. Neil Roodyn's "eXtreme .NET" is a book aiming at showing how to apply the Extreme Programming development techniques to .NET development. The approach is very much example-driven, meaning that the book is full of examples both in the form of programming tasks and dialogs between the members of a fictional .NET development team.
   
   Looking at the table of contents, the book would seem to cover all the essential stuff, including Refactoring, test-driven development, pair programming and testing, as well as some supporting practices such as automated builds. While I enjoyed reading Dr. Roodyn's writing and the content is quite nice a mix indeed, I am still left with this itch that I'm missing something -- I suspect that something is more discussion about the low-level techniques, tools, etc. that I'm so at home with when doing Java. It also might be that while the book focuses so much on the examples with a relatively light overview on the forces driving the practices, I'm feeling like I'm being shown the "what" and "how" but not the "why". Having said that, the examples (both user stories and development tasks as well as the code snippets) used in the book are excellent and well chosen in terms of complexity. Dr. Roodyn managed to avoid the most advanced features of the language of choice, C#, which made my life a lot easier, being new to the platform.
   
   In summary, I wouldn't recommend this book as an introduction to Extreme Programming because it doesn't go down that road far enough. I also wouldn't recommend it as a reference or tutorial for setting up the development environment to support XP because it doesn't cover nearly enough details. I would, however, recommend it to follow up that introductory "generic" XP book a .NET developer should read first. Dr. Roodyn's description of the development process is definitely worth the effort if you're not quite sure about how test-driven development works in practice or about how those stories are broken down to tasks.



3. A book like this was inevitable. .NET is rising fast as an impressive programming environment. And Extreme Programming has garnered wide attention for several years, in writing C++ and Java code. So the book addresses a logical intersection of the two trends.
   
   Roodyn uses simple code examples to show how you might apply XP to C#/.NET development. The code is easy enough that his messages should be clear. He also talks about the general ideas of XP. Like a systematic use of unit testing for improved robustness. Of all the features of XP, this may be its strongest and least controversial point.
   
   You should be aware of widespread dissent in the programming community about XP. Many experienced programmers have deep reservations (to put it politely) about some features of XP and about how broadly XP can or should be applied. These qualms have nothing to do with .NET, per se. So if you are reading this book, it will certainly teach you XP. Just be wary of thinking that it is the best way to program.



4. This book deserves 2 stars for the effort it makes in introducing XP to .NET programmers. After that introduction, it drops way south. Author takes the reader through exercises that are more of your "hello world" type. How many developers will you see earn a living writing these small kiddie programs? Author makes absolutely no efforts to familiarize the reader on how the concepts of XP can be used in their daily work.
   
   I thought that this book will tell me how to do TDD in a business application. Getting a class to return a string and writing Unit Tests for that is lame. Of course in business applications we deal with data. But there is much more involved, database, messaging, UI, etc. No mention of any of these.
   
   Oh yes! and the most idiotic chapter was on writing test code for UI.
   
   Overall, it was an absolute waste of money. I got tricked by other reviews here, and bought the book. Big mistake.
   
   I'm annoyed by the fact that this book has wasted my time, by promising to be something totally different than what it really is. I cannot give it anymore than 1 star.

4 comments about Photodiode Amplifiers: OP AMP Solutions.

1. This book lives up to its title by giving a thorough review of photodiodes driving op-amps. It does not consider specialized, discrete photodiode amplifiers. By limiting the coverage to op-amps, the bandwidths are necessarily those of op-amps, a few tens of megahertz at the time most of the book was written, perhaps 100 MHz or so today. Truly wide bandwidth solutions (GHz) are left to the imagination of the reader.



2. Excellent book for design of optical measurement etc type of application and undrestand noise and errors in the circuit.



3. This book is an excellent reference for understanding the Photodiode circuits. It is gives good coverage of the limitations of the transimpedance amplfier, gives good comparision of different schemes for I to V convertors and covers noise in photodiode circuits extensively. It is a good text for low frequency application . Not meant for real high speed design reference.



4. Basic stuff. This book collects dust on my lab shelf. Transimpedance amplifiers - you can find this stuff on the web for free. Absolutely no talk of charge integration.

1 comments about Foundations of ASP.NET AJAX (Expert's Voice in .Net).

1. This book is good for somebody that hasn't seen AJAX before, but I have been working with it for a little while and was hoping for something more. However, it is a foundations book, so my expectations were probably set too high. A book that has better AJAX information (though not nearly complete) is Pro ASP.NET 3.5 in C# 2008, Second Edition.

4 comments about Beginning Visual Web Programming in C#.

1. This is an end-to-end introduction to the world of .NET development. The coverage, which starts with the architecture and ends with deployment, is never comprehensive, but is always thorough enough to get you started.
   
   Graphics are used extensively, which is not appropriate for a reference, but which works here because of the introductory nature of the text. The book doesn't pander though.
   
   I recommend this to anyone who is starting with ASP.NET, and who wants an introductory text in the step by step style. If you are experienced in other web application development technologies then you would be better served by one of the O'Reilly ASP.NET reference books.



2. The book shows how to write a C# web application on a server running .NET. Perhaps the most succinct description of the book is its cohesiveness. It describes using two crucial packages, ASP.NET and ADO.NET. ASP.NET essentially handles the client-server interaction, by making dynamic HTML pages and handling the user's input. While ADO.NET controls the interaction between the application server and the database.
   
   As you go through the book, if you keep this simple demarcation in mind, then it helps your understanding of the many lower level details in each chapter.
   
   It is clear from the book that Microsoft is pushing hard to have the entire web development process done on their .NET machines, by offering a tight and consistent tool integration. Gives the open source movement a serious challenge.



3. I found this book to be a very good source of overall C# information. It was not an exhaustive resource, nor did it delve in minute detail to all the points, but I have not found a better book to get a complete picture of the web programming world.
   
   The code samples are very easy to follow, and the reader can download the code from the publisher's web site. I chose to input the code samples manually and only had a couple of minor issues along the way.
   
   One example late in the book (Chapter 11 or 12) left the code in a state where it would not execute.
   
   I also had problems with the web service examples but that can most likely be attributed to the proxy/network configuration at my place of employment.
   
   The only other issue I encountered was with the stress testing tools like ACT. I was unable to access the site and still have not been able to determine why. Of course, that's not a failing of the book or the author, just a configuration issue, I'm sure.
   
   If you are looking at starting ASP.NET development, this book is a good, solid read.



4. I had a great deal of C# Windows forms programming experience. What I needed was a book to help me leverage that into Web programming. This book fit the bill.
   
   You will not learn C# in this book (it assumes you already know the language); but it will get you quickly into building Web applications.
   
   The examples are clear, well organized, and most importantly run properly when typed in correctly! The examples also have one important feature I prefer, which is a lack of over embellishment. They show only the code needed to complete the given task, not additional bells and whistles that can confuse the point of the example.
   
   After completing the book, I found it easy to adapt the examples for use in building my own web site.

5 comments about Agile Development with ICONIX Process: People, Process, and Pragmatism.

1. I was totally shocked at how horrible the "Refactored" book was written. That book was loaded with unsubstaintiated anecdotal claims written by anonymous "informants?" versus actual and highly selective quotes from XP practitioners lifted from usenet postings with misspellings included that struck me as character assassination. It was opinion disguised as analysis and pseudo-scolarship.
   
   This book seems a bit more measured. It seems like the authors finally embrace the core tenets of Agility but they are still (I think unfairly) knocking some of the things that XP in particular touts, based on some strange assumptions. One assumption that runs through the Iconix folks writings is that robustness and responsiveness are opposing forces. They are not, or at least need not be. I know this becuase I've seen a highly robust and highly responsive XP team at work. The root of this thinking is in the belief that developing software is like any manufacturing endeavor, where quality and cost are also trade offs. Oddly, with Agility in general (and XP in particular), increasing the quality actually is shown to reduce cost. Also, I know this because I've seen this. And XP doesn't mean that there are no documents and no diagrams. It just means that they aren't as valuable as executing code. I still can hardly recognize the thinly-disguised invective of the last book as coming from the same authors as this book. I would say the authors have grown up a bit.
   
   I think the Iconix people's departure with XP originates in Pair Programming. My in-the-trenches experience with pairing is that if you've never really done it, ie, given it a real chance not killed the baby with preconceived notions, you won't ever get it. Most anti-XP people are simply against pairing because they don't understand how it actually works in practice.
   
   One example of how pairing works is to hear my friend tell what it was like to program PROM / PAL code as an embedded-systems programmer way back. They ALWAYS pair programmed because you can't afford to screw up a couple of PROMs a day, that would be blowing $400 or so. The same holds true today with an IT developer coding off a cliff alone on his workstation, blowing several hundreds or even thousands of bucks a day because nobody is reviewing his code BEFORE he checks it in.



2. About two years ago, I reviewed Doug's books and contacted him to help me on a new software development effort I was directing. I had low expectations because my team was just learning professional software methods period. Doug came in and taught the five main diagraming techniques, including robustness diagrams. After the class, he pitched-in to help with documenting all of our use-cases and thoroughly disambiguating our problem domain. This was the most successfull software project in the history of the company. As a direct result of Doug's methodology and consulting, we delivered a reliable and re-usable core product line. Because of this, we have been able to consistently deliver great software based on the original core time-after-time.



3. I'm a big fan of Doug's methodology and books, so I'm biased. I'm a fan because I know his process works... I've used it in a number of medical device projects. In the area of safety critical or mission critical systems, you can't throw out requirments and process; it isn't an option. I would argue that it is also not smart.
   
   This book does a great job of explaining how to achieve the core ideals of agile without sacrificing the up-front work (requirements and modeling) that are necessary to achieve a high quality system within a reasonable schedule and cost. I love the fact that the book harkens back to core software engineering principles and shows how this process enforces those principles while encouraging just the right amount of agility to react in a timely manner to mid-course corrections that every project (accept the very small) experience.
   
   The book demonstrates an important aspect that I have used in my own projects; the core process is robust to the needs of different projects. For example, adding a release plan for scheduling the implementation of individual or groups of use-cases or expanding use-cases using interaction design. Extensibility is the mark of a solid, well thought-out core design; whether it be a process or software.
   
   The approach was very balanced in light of the fact that Doug and Matt have been some of the most vocal detractors of the Agile/XP neuvo processes. It takes someone from outside the religion to bring balance; they have done that with this book. Their "sweet spot" is within reach!
   
   Best!



4. First beware that books with almost the same titles have been written by the same author and some of his fellows between 1999 and 2007:
   
   1999: "Use Case Driven Object Modeling with UML: A Practical Approach": This is the "reference" book although it seems ICONIX has evolved since if we consider later books and various articles online. I am considering acquiring this one after disapointments about "Agile Development with ICONIX Process."
   
   2001: "Applying Use Case Driven Object Modeling with UML : An Annotated e-Commerce Example": This seems to have been written to illustrate the first book with a web example.
   
   2005: "Agile Development with ICONIX Process, People, Process and Pragmatism": This is the book we are talking about here. I bought it because of its relative recentness and was quite disapointed: a bigger part of the book is dedicated to defend the ICONIX process on one hand (this is what many other comments denounce about the 1999 book), and to explore new extensions that obviously have not yet stabilized.
   
   2006 and 2007: Two new books published only a few monthes apart, from two different editors, and especially with almost identical titles: "Use Case Driven Object Modeling with UML - ICONIX Process in Theory and Practice" (Addison-Wesley, jun. 2006) and "Use Case Driven Object Modeling with UML - Theory and Practice", (Apress, jan. 2007). The first is unavailable at this time on Amazon and is very expensive ($160). Given the titles, these two new (and identical ?) books might be a rewrite of the 1999 reference.
   
   What I liked in the book:
   
   1. The process is explained quite clearly
   
   2. Whether you adhere to ICONIX or not (I do), the messages it carries is worth it: use a small and consistent subset of UML and the rest when only needed. It also helps to understand the "why's" of diffrent diagrams, that are not necessarily well explained by quality books such as UML Distilled.
   
   3. For those who did some reading beforehand, the book shows what have been the minor evolutions (and the presistent doubts) in the process compared to what Rosenberg and Scott wrote online around 2001 (DrDobb's and InformIT.
   
   2. An example is given (web), with som code, stressing the explorations around the robustness diagrams.
   
   What I disliked about the book (this the three stars):
   
   1. It is not a reference book :a) Robustness diagram rules aren't even exposed/reminded. b) Almost nothing is said about the milestones leaving (thus the need to consider buying the other books)
   
   2. It is to some extent a too much propaganda book: The book is divided in three parts and only one is about the core process. The first part is ICONIX propaganda and the third part is about forrays into new [and probably immature] extensions.
   
   3. There is a persistent ambiguity about whether use case text should be written as they are identified (before requirements review) or should these be left for the Analysis & Preliminary design phase (and checked at the preliminary design review).
   
   
   Conclusion: If you'd consider buying a book about the ICONIX process, I'd advise you to buy the 1999 book or one of the two new ones. They most probably would contain precise guidelines on how the method works than this 2005 volume. You should buy this book only as a second read for 1999 or as complement for 2006 or 2007 if needed.



5. This Text is a very well targeted book for the novice as well as a reference for experts in agile software development. This book when combined with "Use Case Driven Object Modeling with UML: Theory and Practice" creates an excellent package if both documents can be obtained for use simultaneously.

3 comments about Software Radio: A Modern Approach to Radio Engineering (Prentice Hall Communications Engineering and Emerging Technologies Series).

1. This book is a one-stop source for everything you need to know about Software Radio. So, this is an excellent text-book for a 1-semester course on software radio. Some of the concepts such as analog-to-digital conversion are discussed in detail, although the relevance of a 70 page chapter on smart antennas in a Software Radio book still eludes me. A good introduction to RF implementation issues is provided. There isn't too much Math in this book, which is both good and bad. My only complaint is that there are lot of errors, both conceptual and typographical, in this book and many of these errors are not addressed in the webpage maintained by the author. Otherwise, it is a very good book.



2. I give this book a 5, despite the errors, because of how well it covered such a broad topic. The reviewer above mentioned the chapter on RF implementation issues, which was very good. The chapter on smart antennas is pretty good also. I think that it is included because the "software" part of a software defined radio is where beam-steering and space-diversity algorithms are implmented. It's not totally out of place and provides for some breadth. All of these VT profs (Reed, Durgin, Rappaport) tend to put out books that facilitate understanding and then, when you are ready for the underlying mathematics, they'll cite you the places to go for that. IMHO, that's a good approach- otherwise, they might as well not write books and just slap together a bunch of papers, bind 'em and call that a rigorous text.



3. I usually expect any book coming out of a university to be highly theoretical and math-centric, but this book is neither. It's a clear exposition of software radio concepts and issues, with a great deal of attention paid to signal generation and processing. Unlike another reviewer, I was happy to see 70 pages devoted to smart antennas, since any multi-protocol transceiver operating in the GHz range is going to need them. The exposition is clear, well developed and well written. More editing would have helped, but overall highly recommended.

2 comments about C# Software Solutions: Foundations of Program Design.

1. If you know Java or C++, much of this book will seem familiar. In any object oriented language, the same basic concepts come thru. Here of course, you see them implemented in C#. At this level, a lot of the code will also look familiar, if you squint a little. The syntax has considerable commonality with Java. No surprise, since it was put together after Java became successful in the marketplace. So for example the Java "import" is replaced by "using". Once you get used to stuff like this, then you can fluently deal in both languages.
   
   The widget library is well fleshed out and easy to start programming in, from scratch. If any of you have ever tried writing a graphics program in C and using the X11 widget library, then C# has a far easier learning curve.
   
   C# has one distinct difference with C++. Multiple inheritance from parent classes is not allowed. Just as in Java. Readers from a C++ background might find this to be the biggest adjustment in thinking.
   
   Keep in mind that no advanced topics are dealt with here. It is primarily an introductory text.



2. This is one of those books that you can know just a little about the programming language and have the author step you the learning process. Plenty of examples, and excercises to work through in order to retain information contained in the text.
   
   The book is presented in a very gradual manner that will allow a novice to come away with a better understanding of C#
   
   If you are already a master at C#, then this book more than likely isn't for you, but if you want to learn the basics of C# and not be dropped of in the middle of generics by the second chapter - this is a very good choice.

5 comments about Software Cost Estimation with Cocomo II.

1. We are attempting to use this methodology for planning and review of onboard Aerospace Software, will give an update when we have actually used it in anger!



2. The latest revision of the well known COCOMO constructive cost model is calibrated with a Bayesian approach that balances 161 industry reference points with the determination of software development experts. Software engineers use the COCOMO model to make financial decisions, set project budgets and schedules, negotiate tradeoffs, plan to maintain or upgrade legacy products, and decide where to implement process improvement. The model equations are provided including normative calibration using 5 scale factors and 17post-architecture effort multipliers. The criteria described for assessing your project for scale factors and effort multipliers are fuzzy in some cases (Default to the nominal level when in doubt). The model can accept estimates of either logical lines of code or function points as the primary input parameter. The book is accompanied with a CD that contains the USC implementation of the COCOMO model and some instructional videos. The final 2/3 of the text covers emerging extensions such as object point data, application point data, phase schedule and effort model (COPSEMO), dynamic COCOMO, RAD schedule estimation model (CORADMO), commercial-off-the-shelf integration model (COCOTS), quality estimation (COQUALMO), and productivity estimation (COPROMO). Read "Software Engineering Economics" published in 1981 for additional background information on the COCOMO model.



3. I was first introduced to the precursor of CoCoMo II when I ftp'd a whitepaper on estimating from the old decwrl site maintained by DEC in the mid 1980s. That led me to Boehm's seminal book, "Software Engineering Economics", ISBN 0138221227. Over time CoCoMo started to show its age, especially in environments with heavy GUI development, so I opted for function points as my sole estimating technique. With experience I discovered that technique alone was useful for estimating scale, but was weak on sizing estimates. Version II of CoCoMo rectifies this, and this book is an exhaustive description of software cost estimating in general and CoCoMo version II in particular.

   The contributing authors to this book read like who's who in software estimating, and the contents of this book will not only get you up-to-speed on using CoCoMo II as an estimating tool, but will also explain its inner workings, how to calibrate it, and its inherent strengths and weaknesses. Among the parts of this book that I found especially useful are Chapters 2, Model Definition, and 4, Calibration. These are the keys to understanding and using CoCoMo II to its best advantage. Real world examples are given in Chapter 3, and emerging extensions and future trends provided in chapter 5 and 6 round out the body of this book.

   Significant added value is provided in the appendices and on the accompanying CD ROM. The appendices include how to use CoCoMo II in environments ranging from the older waterfall SDLC, RUP, incremental and iterative development, and give project planning considerations and data collection templates. The CD ROM itself contains a full working copy of the 2000 version of USC COCOMO II, complete documentation, and data collection forms, and trial copies of commercial versions of the application.

   This book is one that every serious project manager, software engineer and cost estimator should read and keep in their work area.




4. COCOMO represents a unique and applicable methodology for process estimates. A goal-driven approach with realistic progress indicators to conducting software estimates represent the way processes must be managed.
   
   The continuity between COCOMOI and COCOMOII is far from being evident. My prime interest is the indentification of the impacts of the Economic Adjustment Factors (EAF) on the economic evolution of a project. An attempt is made to complement COCOMOII with additional tools. There is however an impression of a lack of a common vision.
   
   The book is a major reference in my business development approach. I was privileged to deal with Amazon.com for a fast turn around for the timely delivery of the book at my door.
   
   Bernard Carrier P.Eng.
   President OpsPro Inc.



5. If you not in Dr. Boehm's class at USC, then more than likely your a project manager for a software engineering firm trying to better estimate how much your next project is going to cost.
   
   Either way the book is dry, but the informaiton is great. Its given me insight to CMM and other Software Engineering models.
   
   The COCOMO tool has merit, so does CSCI 577a.

1 comments about Creating Mobile Games: Using Java ME Platform to Put the Fun into Your Mobile Device and Cell Phone (Technology in Action).

1. This is a pretty good book on creating mobile games for the Java platform. The author does not assume that you already have a working knowledge of the tools involved, so she starts by introducing you to these tools to give you a general idea of what is involved. Next she covers what you must do to set up your computer for Java Micro Edition game development and how to get your games running on an actual target device. Then, once you have your development environment up and running, you can begin building and modifying the book's examples. The book website at Apress has all of the source code for the examples available for you to download. The author assumes you already know Java programming with Java Standard Edition, and that you already know something about designing a game - this is not a book on the theory of game design. The point of this book is to show you how to do all of this with Java ME. Even multi-player gaming is explored by showing how to write a program for a game of checkers using Java ME. The following is the table of contents:
   
   1. Getting Started 1
   2. Using MIDlets 21
   3. Using the MIDP 2 Games API 53
   4. Using Threads and Media 95
   5. Storing and Retrieving Data 131
   6. Using Network Communications 193
   7. Advanced Messaging and Data Access 263
   8. Securing Your Applications 305
   9. The Mobile 3D Graphics API 317
   10. Adding a Professional Look and Feel 351
   
   You can carry some of the ideas into other types of applications, but this book is very much focused on Java mobile games. For that purpose it is highly recommended.