4 comments about Simply Java: An Introduction to Java Programming (Programming Series).

1. Learning JAVA can be a very steep learning curve at first, but this book takes a great approach to making it as easy and painless as possbile, mainly due to the Authors genius.



2. This is the first Java book that I've been able to read. The author starts off saying 'Why write yet another introductory Java book?' Good Question. The answers he said were that existing Java books were simply too tedious to read (I agree.), second, they immediately start talking about things like object orientation and classes which are useless at the beginning and are treated in those books almost like a mantra.
   
   This book starts out writing a program. This gets you familiar with the constructs of the language before giving meaningless (at this time) definitions. In writing the program it says you have to have a bunch of words that are required, just put them in and we'll talk about them later.
   
   The author says that he has had better experience with this approach than with other books. As one who learned programming in procedural languages more years ago than I like to remember, this approach certainly made sense to me. I'm still not a Java expert, but a lot better than I was.
   
   The CD that comes with the book includes both the Sun Java 2 platform and the NetBeans IDE. All that you need to begin programming.



3. This book is intelligent, well written, and a gentle introduction to programming using java. Perfect for beginning programming students and intro classes, the text is clearly written and the examples illuminate the concepts put forth.



4. I teach Java at the undergraduate level so I am always on the lookout for new books. It would be unfair to say it was a bad book, but I certainly don't believe its a good one. As the author points out on the first page there are plenty of other intro Java books; however, I feel he fails to make a case for adding this one.
   
   The author states that he had three reasons for writing the book, I will take them up in term before adding my own criticisms:
   1) He thinks current books are tedious to read - here the author has a point and has made some improvement. His prose style is breezy and easy to read. It's very conversational and after reading it I think I would enjoy taking a class with him or for that matter having a beer with him. His personality comes out and that's a good thing, particularly among intro Java books that do usually read as if they were written by committee.
   2) He thinks current books do not get into objects quickly enough. He says that he is unable to find books that start with objects. My problem has been that I can't find books that don't. I give him credit for following through on his convictions. This book is certainly as object first as a book can be. The problem is that he provides no understanding of what an object is or why one would use them on a conceptual level. I admit that motivating objects the first week of an intro course is a tough nut to crack. But if you believe objects first is the right way to go, as the author does, then it is a hurdle that you have to overcome. This book doesn't. We are left only with the syntactically correct use of keywords like class and new and no understanding of where we are going.
   3) he believes a modern IDE should be used from the beginning. Ok, but other than an appendix and including it on the CD I don't see any evidence that the IDE effects the book.
   He closes his intro by mentioning that his students like the book. Here I suspect he hits the classic problem of educational research of being unable to separate different factors. I suspect it has a lot more to do with him than the book.
   
   So what do I find wrong with the book?
   First, the examples are undistinguished. He introduces classes by discussing an bank account class with a with get, set and withdrawal method. This is developed into a bit more complete bank example after taking time out for misc. applets. I don't find it very interesting.
   Second, advanced topics are introduced but breezed over. Example, a multi-threaded application is done in 10pages in chapter 9.
   Third, basic topics are postponed, and then breezed over. Example, arrays are introduced in chapter 11 (two chapters after multi-threading) and receive 4 pages of coverage.
   
   IMHO - the author's quest to find a good intro Java textbook remains unfinished.

5 comments about Java 2 Programmer's Interactive Workbook (Interactive Workbook Series).

1. This book is for the "absolute beginner" and it is a good book for someone taking a class in Java, but not for someone hoping to study it at home. As is often the case, an inexperienced person trying to install development software at home will be simply out of luck.

   If the "absolute beginner" wants to install Java and learn it from home, they will need a cable modem to get all the downloads, a lot of patience to figure what patches are needed, and a couple hours help from an experienced person to set it up.

   Although Chapter 1 Compiling and Running a Java Program is supposed to help the "inexperienced user" "hit the ground running," the Java2 standards changed after the book was written, so the setup instructions do not work. Chapter 1 suffers from several problems: 1) Obviously written at the last second, it is garbled mess. 2) It uses the overly cute device of emphasizing how easy it is by showing nonworking examples, then the right way to do it. Does this need to be part of the installation process? 3) The "right" examples don't work. 4) You won't find this out without going to the companion web site. 5) The companion web site provides some examples, but not clear solutions. Source code examples were not updated. 6) Users will need to find, download, and install the HTML Converter patch from the Java website.

   Java works across platforms, but the hurdles to getting something running at home are as high as they've ever been.




2. I bought this book to help me with a class I was taking, in which I was quickly falling behind. The book introduces a concept in a few pages and then follows that introduction with a short quiz so you can test your understanding and review the material you didn't understand before moving on to more complicated concepts. This way you don't ever get "left behind". At the end of each chapter is a "Test Your Thinking" exercise which helps you learn to apply the knowledge you just gained. So you also learn the "whys" and not just the "hows". I had some programming experience, self taught, when I bought this book, and it has helped me fill in the gaps in my knowledge and extend my programming skills. It has increased my confidence immensely. Java's a cool language and this is a great way to get started.



3. I have been working through this book with my husband (C Mills) - he's experienced and I'm a beginner.

   I have found many errors and it seems obvious it was originally written for an earlier version of Java. If it weren't for my husband's expertise and other reference materials I would have given up with sheer frustration. Some of the things they say just don't work in Java 2, others are plain wrong (warnings that Java would throw errors in certain circumstances when it doesn't, for e.g.) and some simple, basic things (like ASCII code 62 for A, it's actually 65) show the inexperience of the authors.

   The book needs serious proof-reading, updating and editing (e.g. the simple exercises on a topic should come BEFORE the complicated ones) and then it could become a good book.

   The 4-and-a-half star rating I found here is wrong - no doubt an anomoly caused by the very small sample it was created from.




4. As others mentioned this book is not for J2SE/J2EE and should be thrown into the garbage now. The style is good but it is outdated now. I recently picked it up from our company's library and quickly found that most of the examples won't work as they are saying in the book. One Star Rating for Style!!



5. this book was so poorly edited as to make the information the authors present difficult to understand. no little problems either. for instance entire sections are duplicated; section titles are repeated with new information. not worth reading for anyone, especially a new programmer.

5 comments about JavaScript: In an Instant.

1. Complicated Explainations. If you are new to javascript , this book
   will give you a headache.
   If you have experience this books is ok



2. I needed to do some work in Javascript that required a moderate skill level. I already know "real" Java as well as HTML and didn't want to get a 500+ page manual detailing every single aspect of Javascript...I simply don't need that level of knowledge for what I'm doing. I've been working with Java for just over five years, and programming for just over twenty years. If you're like me and simply need to solutions quickly and you are an experienced programmer, this book is quite good. I was able to extract the information I needed in just a few hours. On the other hand, if you're a complete novice to programming or Java is foreign to you, you might want to look at books that are a little less aggressive in their approach. It would be nice if they added an appendix of the Javascript classes and methods used, but for as little as this book costs, I can't complain.



3. The book lives up its name. The book is not for beginners, it does not explain javascript syntax. The book shows, however, practical jscript implementation. I am a vbscript programmer and I needed an ultra quick tutorial in Javascript (something like jscript in 20 minutes). The JScript5.5 documentation from Microsoft is only good for syntax reference. This book showed me exactly how to take the syntax into my html pages in a short, efficient way.
   An affordable desktop reference.



4. this is a very practical book for those who learn best from examples. i'm a certified internet professional and I favor these visual books a great deal cause they just cut to the chase.

   It's a no-nonsense approach that teaches you all the fundamentals of javascript without boring you with excessive details.

   for those who need details or more explainations on javascript, get a companion book with this one and you should be all set.

   overall, a book that you can learn javascript from scratch, very easily, and a reference for the more advanced programmer.

   highly recommended.




5. Covering the application of JavaScript, it is probably the most concise and reasonable representation I have used for instruction!

1 comments about Java for the Beginning Programmer.

1. We used this book for a class I took this summer. It is very introductory, and spends most of the time talking about concepts like loops, arrays, etc, and only gets to GUI programming at the very end. It provided a good introduction into the Java language.

3 comments about A Numerical Library in Java for Scientists and Engineers.

1. This book contains some much needed source code of a comprehensive numerical library in Java. This provides a basis for students and researchers to evaluate different numerical methods. For beginners, the library can be used as a black box for solving a wide range of numerical problems. More experienced users can build new modules based on the existing ones, or modify the source code for experimentation.



2. It is indispensable to have the source code of such a
   high quality numerical library to experiment on the PC.



3. A true alternative to astronomically expensive numerical Java libraries. It contains a great collection of various algorithms, explains which one to choose, how to use it and what it does. In addition the Java source code is printed which is reason for the high page numbers and should answer even the most specific questions. Finally, there are many references to classic publications for further reading.

   This book provides all the information you'll need to solve most numerical problems (linear algebra, non-linear equations, ordinary differential equations, Fourier transform, special functions, time series,...) but unfortunately barely covers interpolation and approximation (e.g. no splines !). Oh, and the typesetting is a bit rough.

   Similar to open source projects, I expected the CD included with the book to contain source, a jar file and javadoc ready to be used. Instead you will find the Java sources (in a single "numal" package) and pre-compiled classes only. Algorithms are invoked via static methods in chapter-based classes such as "Basic", "FFT", "Linear_algebra" etc.
   I found the usage of "double[1]" rather than "double" a bit confusing. But fortunately the non primitive data types passed on to these methods are defined via interfaces, so no real restrictions when integrating to your project will apply.

   I suspect that the author has strong skills in older programming languages such as Fortran or C which may have influenced his Java style (no offense).
   So depending on how high your Java skills and expectations are, you might have to spend a few minutes re-organising and refactoring the sources, running javadoc on it and packing it into a jar.

   Summarizing I'd say that I would not like to miss this book as it has saved me many hours implementing the methods by myself. If it also covered splines and presented the code more nicely I would definitely give it the missing extra star. The crucial information is there and at the end, that's what you need, right ?

1 comments about Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer).

1. One thing you gotta love about the Java crowd is their naming philosophy. Now there is SWT, the Standard Widget Toolkit.
   
   This book covers SWT as used in conjunction with Eclipse. It first compares SWT with other user interface packages, then it goes on to detail how to use the widgets to facilitate the writing of GUI's. It's a tutorial style book that completely covers Version 3.0 of SWT/JFace in a clear and informative manner.
   
   This book is timely, clear and well written. It will quickly get the reader up to speed on these packages.

3 comments about Machine Vision Algorithms in Java: Techniques and Implementation.

1. If you need to learn and apply machine vision techniques this is a good place to start.



2. This is a good book on algorithms in machine vision, not computer vision. It is important that you know the difference before you buy this book. Machine vision is used in manufacturing plants for detecting the parts according to your needs. On the other hand, computer vision is integrated into AI where you can create vision input for your robotics or AI system.
   
   That's why this book is good for those who wants to create Photoshop-like effects or implement systems for part analysis. If you are looking for something related with robotics, look for elsewhere.



3. There are better books on Java imaging and better books on machine vision. However, where this book stands out is in its catalogue of machine vision algorithms. The book is really a vehicle for the author's machine vision application, complete with user interface, entitled "NeatVision". You can download it off the web complete with a developer's guide on how to extend the application. There's really nothing unique about the built-in transforms. If you are already familiar with computer vision- and you should be if you buy this book- you will most likely already have heard of most of them. What it does enable you to do is to chain transforms together to perform larger more complex machine vision tasks.
   As for the book itself, the first chapter is a forgettable overview of machine vision, and the second chapter is an equally forgettable chapter on Java and imaging in Java. Chapters three through six comprise the meat of the book. These chapters talk about the specific algorithms for machine vision transformations divided into the categories of general machine vision techniques, morphology, texture analysis, and color analysis. Chapter seven switches gears and talks about the author's full visual application, Neatvision. Details are given on how to use and and to extend the application. The appendices are about NeatVision's graphic file formats, API specification, and visual interface components respectively. My advice to the potential buyer of this book is to visit the application's website, and if you find NeatVision very interesting you will find the book valuable. I would type the address into this review myself, but Amazon usually kicks out reviews with web addresses in them. The search engine keyword is just "NeatVision".

3 comments about Java Programming: Advanced Topics, Third Edition.

1. This is the kind of book that gives you a ton of useless classes to install on your system, along with about 50 pages of how to install the ... on your computer. If you don't watch it or read the fine print, one of the IDE's that the accompanying cd installs, will go and screw up your classpath during its install. The simple installing procedure to install some jar files is so complicated that you will spend a half a day getting it installed. And once it is installed the docs, make it impossible to generate the docs you need to use the stuff.

   From the beginning of the book, there is no smooth transition about how to use java, it just jumps all over the place. The examples you are suposed to do in chapter 2, ask you to do IO things which aren't even covered until chapter 8....? Why do people do that?

   The writer of the book did not take the end-user into account, but just wrote to get the job done.

   It is a terrible book.




2. As Java is my sixth programming language I have a fair bit of experience with these type of books, and all I can say is that this is the worst I have ever come across. It has no sense of progression and it does not seem to have the idea of learning in mind at all - ie progressing from simple to more complex... It seems to be written for people who already know Java entirely and are wanting some kind of refresher, but its not very good as a reference either, so I actually don't know who would find this book useful....whats particularly annoying is that its not actually an advanced book, but the authors manage to make simple concepts as obscure and complicated as possible, so you struggle for ages trying to understand, and once it finally clicks, you feel almost cheated.

   The writing is very repetitive too - by chapter 15 why are they still telling you that "the structure of the package mirrors the file system, so you can find the code for this example in ...."before EVERY single code example? It sounds like a stupid complaint, but I swear that sentence alone is responsible for about 5 pages of this book.

   If you are forced to buy this book by your uni or college as I was, my advice is that you read it cover to cover several times, and don't be too concerned with understanding it the first or second time... you need the later chapters to understand the earlier chapters properly. I think the best way to read it is to start with the chapter end summary, then try and figure out the code example and discussion, and only after that confuse yourself with the actual chapter. It is not comprehensive and you are likely to spend a lot of time on the net (your cash would be better spent printing out Suns java tutorial) and using other books instead.

   It is also horribly biased to IBM VisualAge for Java, as Wigglesworth was one of the developers, and the first bit of advice given to me by senior students at my uni was to rather use anything else, even javac, than that peice of...

   To be fair, the questions are quite good and challenging, but as others have said, its kinda pointless without access to the answers.

   The unfortunate effect of all this is that you end up frustrated with Java itself rather than just this badly put together book.




3. This is a book for those who have a solid base in java now. Don't even think about using it as a beginner. I used it in a senior level course and it was the first book I worked with that dealt adequately with threads. Use this to polish your java skills. If you want a beginner's book try one of the head first books. The books that develop progressive skills are a dime a dozen out there, few will bring you into the advanced topics like this one does.

5 comments about Java Modeling In Color With UML: Enterprise Components and Process.

1. I often test the utility of a book by one of two ways:
   
   
   1) Did it expand my thinking?
   
   2) Do I constantly refer to it after reading it the first time?
   
   
   The seminal patterns book, Design Patterns - by Gamma et al, (also known as the GOF) passes both tests. This book does not.

   I haven't had much use for this book since purchasing it in 1999. It seems Ironic, somehow, since enjoyed the Togethersoft UML refresher training I received in 2000.
   Together/J, supports the UML methodology, and also supports for the these models outlined in the book.

   That said, it's worth borrowing a copy to see for yourself. I'd also recommend downloading the current 'whiteboard' edition from Togethersoft.

   Jeff Grayson borrowed my copy when he was working on a project to improve VIANT's software development methodology with the Rosetta project.




2. Though "Java" is in the title, this book is not limited to Java, and, indeed, there are no Java code examples. Usage of UML, however is extensive. The book presents an approach to generalizing business components (modelliing patterns - referred to as archetypes) that really helps one to understand the structure and interaction of business components. I use this book as a regular reference. It includes a near-complete business component model through 12 compound components.



3. This is an excellent book. It is, however, terse and has taken me a long time to get to grips with its content and language. I have had to read several of the Coad books to 'get it' but it's finally coming together. I would recommend you read it in conjunction with (or maybe after reading) "Streamlined Object Modeling" by Jill Nicola (and would love to see her do a follow-up book). To those that say there is no Java in the title: look at the CD.
   To be honest I think all the Coad books are good (the "Java Design" book is really good too and was my first contact with Coad's books), some are dated but still stand up. They do take a lot of the guesswork out of modelling.



4. The book's UML diagrams are very necessary for understanding the book but the diagrams are illegible due to the use of miniscule font. The text of the book has a good font but half or more of the pages of the book are UML diagrams.



5. The single most useful book on modeling I've ever read. This is not a java design pattern book, there really isn't any java in it at all. This is less a cookbook than a book on the theory of cooking.
   
   The central idea in this book is the 'Domain Neutral' design pattern. Read until you understand that, and then read again while you apply the idea a couple times in real life. Then you will be in awe. If you are looking for the answer to 'how do I model a shopping cart step by step' this is not the book for you. If you are a working designer who faces new domains every few days and needs a sharp utility knife in your toolkit this is it.
   
   8 years later I'm still referring to this book occasionally and practice it's ideas constantly. I can't say that about any other technical book I own besides richie/kernighan's classic.

5 comments about Design Patterns Java(TM) Workbook (Software Patterns Series).

1. I would recommend buying Joshua Blochs' "Effective Java..." and you will notice that there are many concepts that Bloch advises against and such concepts are recommended in this book.

   I think it is a total waste of money.




2. The idea behind this book is a very good one: teaching patterns avoiding excessive formalisms and with a hands on approach. I had great expectations from this title which were only partially met.
   The book content is sound and some of the patterns are explained in a decent way, but the workbook approach fails as most of the questions are unclear or just too trivial. I find the choice of using a firework factory to work out all of the patterns weird at best.. it makes for a very boring sequence .. fireworks might be fun to see but who cares to learn about star presses, fuses and chemical batches? Besides squeezing all of the patterns in a single context makes for a very forced result. And how about all the swing code thrown in without a real reason? It is just distracting. The author is certainly competent, and a sharp programmer, but he could not resist the typipcal geeky tendency of making things more complicated than they really are by throwing into the discussion basically everything he likes or knows about... parsers, state machines, swing, recursion, object models etc etc.. not to mention the damn fireworks.. ! ;)
   I am still looking forward to a book that offers a clear , no frills explanation of design patterns and presents for each pattern a series of ( a lot of ) examples from different context. That is what is n eeeded to absorb good object oriented design and patterns.. simple, clear explanations and practice, practice, practice. Meanwhile, before you go for "the book" (Design Patterns by Erich Gamma, et al ) I would recommend reading
   Design Patterns Explained by Alan Shalloway.



3. There is no point to buy this book if you already have the book of Gang of Four. Good help to understand all the patterns is using simpler examples than what Gang of Four used. Unfortunately, this book was unable to take the advantage of Java language to use simple examples to illustrate the point and concept of each design patten.
   
   One star might be too mean. However, if we are saying what someone already did, it would be better to use simple examples and make it easy to understand. Otherwise, what's the point?



4. I needed this book for a class. It was one of the worst books I have read. The first big problem is that every example is about fireworks. I found myself often struggling with firework concepts to understand the book. The second problem is that the book continually has questions/problems with the answer in the book. Before the concept seems to be fully explained, it is asking you to complete a diagram. I want the book to show me example, explain it and then test me, not test me beforehand.



5. The intent of the author is good, i.e., providing a workshop for people who are learning GoF design patterns. But result is disappointing.
   
   First of all, design pattern would lose most of its values (or at least it is hard to appreciate its value) if there is no design context and forces that constrain or influence the solution proposed by the pattern. The context and resolution of these forces will let the reader/designer the see the value of how a design pattern fits in and balances the forces and maintains a level of flexibility. However, each chapter of the book provides little context for the design challenges.
   
   Secondly, I don't understand why the author picks fireworks industry as the background for all the examples in the book, it is an area that most people are not familiar with. I know design patterns are not domain specific and can be applied broadly, but knowing the background of the industry in the examples is definitely helpful for readers. And all those examples are very boring, and sometime ridiculous.
   
   Thirdly, the author tries to provide some pattern refactoring examples, but does a lousy job compared with Joshua Kerievsky, the author of "Refactor to Patterns", who provides clear steps to refactor from an existing causal (bad) design to a pattern. Particularly, what are the problems of the existing design and how a design pattern will solve those problems.
   
   Overall, I am sorry to say that the author's mission failed terribly for such a good will.