4 comments about J2ME Games With MIDP2.

1. Recently, on buses and trains, I've noticed people using cellphones to play games. On these dinky little screens, with a keypad instead of a keyboard, and with tinny audio. But even having all these constraints, such games have their attraction.

   This should be the draw to you, to program one of these mobile devices. If the hardware runs Java, then, as Hamer explains, J2ME is used. She describes how Sun stripped out a lot of Java classes, to arrive at a minimal subset that is aware of the severe constraints you face. Limited power. Small screen. Small memory. Intermittant and low bandwidth. No mouse. No keyboard. Get the picture?

   Yet even under all these limitations, Hamer shows how you can use J2ME and version 2 of MIDP to construct cool games. In many ways, it is harder than writing for a desktop or laptop or game console. But the best attitude is to regard this as a challenge of your ingenuity. Perhaps using this book, you will be the author of the next Tetris.

   I'm only half joking when I say this. Because there is something about this field that I don't think Hamer explicitly points out. If you go through the book, you should come to the conclusion that you can code an entire game by yourself. Realistically, this is no longer true for games on the other platforms. These are now storyboarded and written by a team of programmers, with often a million dollar budget. With J2ME and this book, you can still do it all.




2. I really enjoyed this book. The author does a solid job of explaining everything you need to know to write games for MIDP devices. If you are familiar with Jonathan Knudsen's book on J2ME (probably the best book on the subject), this book expands the single games chapter into a fun and interesting book.
   
   The book starts with a quick sample showing us how to use the Sun IDE and how to run our games on the emulator and how to download our games to a phone. The author shows a couple of example games, a maze and a jumping game, that give a good overview of the basic techniques games use on MIDP devices. She then expands those examples by showing proper use of threads and shows how to play tones and music during a game. Storing information (such as high scores or user preferences) is demonstrated. Downloading game enhancements such as new levels for a dungeon game are also demonstrated. The book is full of well-commented code samples (worth stealing) that show the techniques being discussed.
   
   The author of this book has a nice, easy to read style of writing. Her enthusiasm for the topic comes through and makes you want to try the many sample games. If you have been spending too much time on enterprise programming then playing around with some MIDP games might be just the antidote and this book will get you started on the fun.



3. This the the right title for this book. It is basically a review of the code of a few simple games (like a cowboy jumping tumbleweeds, or a simple 2d maze) with very little space devoted to theory and explanations.. both of the APIs and of the internal logic and algorithms. Not that this book isn't useful.. it is but you have to wade through a lot of code, and I think the author could have done a much better job if for example she had taken the time to EXPLAIN the maze generation algorithms instead of just saying "look at the code". In short, more time and effort on the author's side, less on the reader.. and I think this book was written in very little time and with very little effort.



4. I really wanted to like this book, but it turned out to be just a collection of very long code fragments with no annotation and little explanation. There is a great topic here, and there are some good ideas, but the knowledge is locked in the code.
   
   If you are the type of person that learns by reading code then you will already have learned the APIs by looking at the sample code. The reason we buy technical books is to teach us how to use the APIs through a combination of well annotated example code, well organized reference material for the APIs, and illustrations that demonstrate best practice code flow. This book only has the code and a little explanation, the reference material, and effective illustrations are missing.
   
   I recommend this book only if you can't find any other material on MIDP2.

5 comments about AspectJ Cookbook.

1. This is an excellent practical guide to incorporating Aspects, in particular AspectJ, into your object-oriented software skillset.
   
   This book is not a theoretical study of AOP; rather, it is a guide book for the software engineer who has already decided that using Aspects will benefit his or her software and is now looking for a 'How-To'. As a handbook, it begins with how to install AspectJ; how to build projects with Eclipse and Ant; and also looks at how to deploy AO applications, web applications and web services. It then goes on to look at basic and advanced AspectJ features and usage. As a side note, the Eclipse IDE provides great visual AspectJ support and is worth having a look at if you are planning on using AspectJ ;)
   
   This is a book that a software developer can dip into when programming using Aspects - to find out how to do something; or using the design pattern chapters - how to do it better.



2. Because of AspectJ's complex syntax it really benefits from a cookbook-style approach. I find the abstract concepts of AOP are somtimes a lot easier to understand than the AspectJ syntax (involving aspects, pointcuts and advice) needed to implement them.
   
   Russell Miles has done a great job of structuring the book in a logical way. The book begins with recipes for compilation and deployment of Aspectj code using all the usual tools. The second section explains how to capture join-points on all the event types supported by AspectJ, ie. method-calls, exception catch blocks, object initialization etc. These first two sections form a good starting point reference for AspectJ syntax.
   
   The bulk of the rest of the book contains recipes for practical use of aspects. I'm no expert on the topic but these chapters struck me as quite a good selection of the 'cross-cutting' concerns that people usually bring up in AOP discussions. eg. language extensions, object persistence, logging and tracing, virtual mock objects, RMI, lazy loading, transaction handling, security policies etc. The author also includes recipes for using Aspects to implement each of the GoF patterns. I found some of these recipes more interesting than practical - the benefits of using aspects seemed tenous in some cases (do all of them really involve cross-cutting concerns?) although they widened my view of the potential applications of AOP.
   
   I generally found the recipes very well written and clear. The book also includes many UML sequence diagrams that are great for showing how aspects get woven in. I think AspectJ really needed a book like this - all in all a great contibution to the O'Reilly series.



3. The largest part of the book covers AspectJ language elements. The chapters have titles such as "Capturing Join Points on ", "Defining Advice", and "Enhancing Classes and the Compiler". Yet this is something that one very rarely wants to do. All these tasks are just means in the service of an end. To use the title's metaphor, these tasks are not recipes in themselves, they are only intermediate steps on the way to a meal. And at that they're not well captured by the format -- for my taste Laddad's "AspectJ in Action" does a much better job. The three chapters on implementing the GOF patterns using AOP could have been interesting had the author just once strayed from the boring routine of presenting nothing but the mechanics of the respective pattern. Does he ever touch the question why anyone would want to use AOP to implement these patterns? If he does, it must have been well-hidden. Also, there are a lot of similarities which are more than superficial in the AOP implementations. As it stands, the original work by Jan Hannemann, on which these chapters are based, is a much more relishable read. Then, at the end of the book, there are three chapters on applying AOP/AspectJ at the component, application, and enterprise level as well as one on AO design patterns. These chapters are the model for what the whole book should have been like, in my opinion. They finally deal with real-world problems and how AOP/AspectJ helps in solving them better than earlier approaches do.



4. You need to already know the ideas behind aspect orient programming [AOP}, before opening this book. Plus a fluency in Java, by the way. While I have the latter fluency, I'd only met AOP briefly in a few papers.
   
   Under the familiar O'Reilly cookbook format, the book has guidelines on various difficulties you might be having, when running AspectJ. It's a superset of Java. The new syntax is not so difficult to learn. True, it's more involved than writing a new class, that conforms to existing Java syntax. But a good Java programmer should quickly grasp how to implement crosscuts or advice.
   
   As to the broader issue of whether you should use AOP at all, the book is silent. It tells you well how to use AOP in the form of AspectJ. But you need to decide, based on externalities, whether to take it up at all.



5. I would say that this is a survival guide more than a cookbook for the people who interested to try the AOP. This is book with a well structure to express its contents by problem-solution-discussion fomat. Reader can find what he need quickly from the book.
   
   For the people who would try AOP the first thing they may concern is the scope of the Aspect J and how weaving the Aspect J into their current application like JSP, Servlet, Java application and also the compatibility with the IDE like Eclipse. The book first introduce these things to give a outlook of the ability of the Aspect J and then it introduce the main concern about capturing join points for the weaving the Aspect J to the application. However, it may be not easy to understand how the capturing join points can be used to solve the programming problem before you read the chapter 17 - 23 which about the application of the Aspect J. In 17 to 19 chapter it show how to use Aspect J to implement the common design pattern. In the final chapter it introduce the Aspect oriented design pattern and you may get the concept about AOP in this chapter
   
   I suggest that the reader may skimming the chapter 17 - 23 first to get the outlook about the concept of AOP and solving problems by AOP.

5 comments about Java 2 Certification Training Guide.

1. In preparation for the Java 2 Programmer exam, I worked through this, and two other texts; "A Programmer's Guide to Java Certification" by Mughal and Rasmussen, and "Java 2 Exam Prep" by Bill Brogen. This book, in my opinion, was the weakest of the three. I would only recommend it as a supplemental source of practice questions once you have worked through another certification guide (or two).

   Although this book does cover all of the major areas of the exam (test# 310-025), it is missing quite a bit of the syntactical minutia that the exam is so notorious for containing. It is also my opinion that this book does not contain enough "debugging" type review questions - where you a presented with a block of code and asked what (if anything) is syntactically incorrect. This type of question wass very common on the version of the exam that I recently took.

   If you are preparing for the exam, I think your best bet is "A Programmer's Guide to Java Certification" by Mughal and Rasmussen. If you reach a point at which you can answer all of the review and practice questions in this book, you are probably more than prepared to take a shot at certification.

   I'd also like to recommend the three Marcus Green practice tests (available from javaranch.com). They are an excellent last-minute study tool and an accurate indicator of how well you will do on the actual exam. My actual score turned out to be a few points higher than my average score on these practice tests.

   Good Luck!!!




2. This book is adequate as a supplement as you prepare for the exam , but it is not exceptional. There were a couple questionable topics, in particular, be cautious of the explanation it gives of polymorphism. The coverage of the Developer exam is very brief, but if you are buying the book only to pass the programmer exam, you should probably do fine. Personally, I found The Complete Java 2 Certificaion Study Guide to be clearer and more effective.



3. Used this book exclusively to study for the J2CP test. The example questions were outdated and nowhere near the level of complexity found on the actual test. I passed, but not because of this book (5+ yrs experience w/ Java).

   The developer certification section was short on content. Now that Sun has beefed up the Architect exam, I wouldn't trust the Architect section in this book.

   The book is good at giving you a solid understanding of the Java language basics. However, the purpose of buying a book like this is to prepare for and pass the certification tests, and there is no hope for someone with little experience to pass any of the exams using this book.




4. So far I have read 6 chapters of Part I. There is a typo or an outright mistake on nearly every page. Semantics of the language are described either incorrectly or in terms too vague to even be wrong. Whoever typeset the thing put "fi" and "fl" ligatures in the monospaced code typeface, and after about 100 pages forgot to indicate syntactic metavariables with italics. When I read others' reviews saying that the real exam questions are much harder than those in this book, and then I find that the ones in the book actually have incorrect answers given in some cases, I lose all faith in the rest. I guess you get what you pay for.



5. This book is atrocious. It is very expensive and is completely valueless for passing the exam. It provides no real information, rather it is an endless checklist of things that you need to know to pass the exam. Sun provides this for free in their test objectives list. The mock exam is exactly that, a mockery of an exam. The test engine barely works (I had to modify several files to get it to work) and the questions are poorly phrased and confusing. I would strongly advice anyone who wants to pass the test to save their money and purchase another book instead....

5 comments about Inside Java(TM) 2 Platform Security: Architecture, API Design, and Implementation (2nd Edition) (Java Series).

1. If you are a Java developer, please read this book. It is complete in terms of the security hooks and accurate. It is a great book, deserving of five stars.



2. The second edition is the most up-to-date Java security book for j2se v 1.4.x. A must-required reading for Java security platform written by Sun's Java security team. It describes the nuts and bolts in a readable language. Highly recommended.



3. If you are new to Java, then you shouldn't buy this book.
   If you are new to security, then you shouldn't buy this book.
   If you prefer loads of examples instead of dense and precise explanations, then you shouldn't buy this book.
   If you are looking for a pictorial guide on Java security, then you would probably have to go somewhere else as well.

   However...

   If you know your Java basics,
   If you like completeness,
   If you like preciseness,
   If you want to know why the APIs look the way they do,
   If you take nothing for granted,
   If you want an update on latest changes,
   If you like things to be drawn in a historical perspective,
   If you want a book that you can pick up and read a chapter without having to go through it in a linear way,
   If you are serious about security,
   In that case you should now pick up your coat, and run to the nearest bookstore to buy this book.

   The only thing I found odd in this book is the introduction into security, covering a discussion in general, and an overview of different types of security and access control models. The weird thing is that it introduces a lot of concepts, without actually refering to any of them in the chapters later on.




4. This book is certainly gives good introduction to the fundamentals of Java security. For those new to Java security, there is also brief intro to security of the Java language and platform. The coverage on Java Security APIs are bit narrow and needs lot of update on JCE, JAAS, JSSE etc.
   Frankly speaking this book is a bit obsolete and now it's for the authors to come out with a new edition including Java 5 and Java 6 !



5. In fact this book is a complete coverage of the java security.
   It is true, that the subject is quite complex and needs concentration
   to be understood perfectly. However I believe this books lacks suitable examples.
   In my personal point of view, providing sufficient clear examples in a book,
   will help the reader to understand better the subject.
   I didn't find this important quality in this book.
   If somebody wants to buy a book about Java security, this
   means that he/she didn't understand completely the whole subject, just
   by reading the API on Sun web site and therefore he/she is looking for
   a better source of information that illustrates the subject in a more
   convenient and clear way. Unfortunately this book, although complete
   in the coverage of the topics, is too far a way to be considered as a clear
   and easy understanding book, particularly, for those who are not already
   seniors in Java security.

5 comments about Graphic Java 1.1: Mastering the AWT.

1. There are very many sorry Java books on the market these days. Therefore, I was very glad to discover "Graphic Java", 2nd edition. I found it to be a thorough guide to the AWT. In addition, it is accurate throughout, whereas many books fail to properly explain and use the new event model or other features of JDK 1.1.

   The book covers every aspect of the AWT, including events, containers vs components, layout managers, lightweight components, etc. Each discussion is peppered with effective examples that clarify the topic at hand. And, along the way, the authors point out good coding tips, such as the effective use of inner classes for event handling, proper object-oriented design, etc.

   As if that all wasn't enough, the second half of the book presents a very useful library of custom components that extend the AWT. The source code for this library is on the CD, and the book explains much of the source in detail. This section is also very valuable in learning to understand the AWT.

   In a world full of mediocre, inaccurate Java books, this one is a JOY to read




2. I concur with the review listed above, but must add that anyone out there trying to use Layout managers must read the 100 pages dedicated to that topic in this book...absolutely the best coverage of GridBagLayout that I have ever seen, including a very demonstrative applet that goes a long way towards helping a person learn how to use this very complex layout manager. The only reason I couldn't rate this book a 10 is that I found several coding errors when examining and running the many, comprehensive examples contained on the CD that accompanies this book. Definitely a must read.



3. It helped quite a bit, but the book will get deep quick with not a lot of explanation of how it got there. Yes I have it, read it and like it.



4. Graphic Java 1.1: Mastering the AWT is the best book that I've come accross, so far, for AWT programming. The book is a little advanced, new Java programmers may find this to be a little difficult. However, at the same time, the book also clearly teaches the new 1.1 event handling model. This is an excellent book for anyone who needs to do Windows programming with Java.



5. Having read the reviews, I expected a lot of deep information. I was mistaken. It is not a bad book, but if it stands out, it is mostly because the majority of Java authors figure that publishing a poorly documented API is adequate. I'd call this an intermediate level book.

   It lacks a permuted index, which is a must for a book like this. A lot of the nitty-gritty information is presented as an aside to demonstrating the examples instead of a well thoughout discussion. Some of these are in the index and some are not.

   If you're looking for thorough discussions of the AWT architecture, keep looking. If you're looking for a good discussion of how to use layouts, this might be the book for you.

5 comments about The Java(TM) Tutorial Continued: The Rest of the JDK(TM) (Java Series).

1. This volume largely contains topics newer to Java. The topics includes Collection, Internationalization, 2D, JavaBeans, IDL, JDBC, RMI, Security, JNI, Reflection, JARs, Extensions, and Servlets.

   This new volume follows the tradition of good writing from the original volume.The book is extremely readable and a great source to learn from. Unlike the first volume, which I recommend only to beginner, even experienced Java developers will find tutorials in this volume that will make it worth the purchase price. It is an excellent book for programmers of all levels of experience.




2. I bypassed AWT knowing that SWING was on it's way. This book made it simple for me to create great looking GUI's for my apps. Follows the same style of "The Java Tutorial" Second Edition.



3. Excellent book - detailed, comprehensive and yet easy to read and understand. I highly recommend this book for learning and implementing Java.



4. Looks like a good tutorial book - however, it's now several generations out of date, which is a problem. Sun keeps updated copies of the books on line, but the limits of printing mean that the bound volumes don't get updated. This covers Java JDK 1.2 - NOT JAVA JDK 5 (the current release). Since there are significant changes between the revisions, this is of limited utility these days.



5. An excellent book - very informative but should be seen as a book to build on the foundation of the Java tutorial - edition 3 or something similar as the content assumes a good foundation of java basics.

3 comments about Foundations of Algorithms Using Java Pseudocode.

1. The authors take a more informal approach to describing algorithms, than other texts, by Knuth, Sedgewick and Aho. This may appeal to some of you, who might have been put off by the level of mathematical background required by the other books. Or by the rate of exposition of ideas within those books.
   
   The presence of problems with each chapter helps your learning. And there certainly seems to be plenty of examples. To me, it seemed like they were belabouring the point, in places. But to you, it might feel like a comfortable dialog.
   
   The usage of Java pseudocode is neither here nor there. If you are sufficiently skilled in a programming language, and it need not be Java, then you should have no problem writing out actual code to test the algorithms. In other words, don't worry if you do not know Java. Just imagine it as generic pseudocode.



2. I found the material and explanations in this book to be generally followable. I would definitely recommend it for learning the various concepts.
   
   The problem is, as a reference for how to implement certain algorithms, it falls completely flat. Simply because they wrote all their algorithms with the idea that arrays start at '1'. This is icomprehensible inasmuch as no programming language has arrays starting at 1, no budding programmer would think of an array as starting at 1, the authors would have had to test all these algorithms in languages with arrays starting at 0 and then spent way too long converting them since a good many of the algorithms in the book are completely broken when rewritten under the assumption that arrays start at 0 (the 'norm').
   
   In summary, it seems like they went out their way to create extra work for both themselves and their readers. This one little thing is honestly a huge pain.



3. The book was purchased as a classroom text. The subject matter is incredibly difficult, but the authors do their best to make it comprehensible.

5 comments about The Visual Basic Programmer's Guide to Java.

1. Of the many Java books I have purchased, this has been the most helpful. I recommend this to anyone learning Java, especially Visual Basic users. Can't wait for an update to cover JDK 1.1.x and Beans.



2. Recommendation
   VB pros - Strong Buy.
   Delphi pros - Buy.
   C++ pros - Don't Buy.

   Pros
   Author makes language approachable by writing VB code next to Java code. Learning by example snippets makes Java seem easier than it is. This teaching method gives the reader the bonus of a boatload of code samples to play with, all on a CD. These CDs are nice, but I remain unconvinced that a CD justifies the skyscraper prices computer publishers demand.

   Cons
   Biggest letdown was absence of database material. JDBC came on the scene about the time the book did so perhaps that explains the omission. JDBC or not, the author should have said something about databases. Also, the Internet received too little attention. I was surprised since the Internet was touted by Sun as the language's primary justification (read cross-platform compatibility) after marketing the benefits of a language for toasters and refrigerators warmed programmers hearts like watching a flawless sprinkler system hose your workstation during a supposed fire drill.

   Review Abstract
   The chapters are organized well and short (<20 pages each). This isn't Moby Dick so biting off small bites and taking time to digest is part of good geek mores. You actually learn to think of VB in an abstract manner - more mores.

   Chapter Review Details
   1. "What is Java?" A quick and dirty overview of Java. Could have used a fun in the Sun anecdote or three.
   2. "Installing & Using Java" Missing any mention of Visual Cafe or Microsoft J++. Perhaps I'm a bit tough here, but author burst out of the gate without even checking on Symantec and Microsoft.
   3. "Syntax of the Java Language" Didn't hurt much.
   4. "Object-Oriented Programming" Best lesson for Vbers who like pick-it-up-during-lunch training methods.
   5. "Using Classes in Java Programming" Whoever gave them the name "class" must enjoy the bewildering look on people. It makes more sense to stick ! with the term "object." It confuses me. I think schedule every time I see "class" instead of methods to accomplish something like returning the number of characters in a string using int len = abc.length();.
   6. "Inheritance" Actually a good moniker. Properties and methods are passed on to your version when you base it on a previous object. It's the same as placing a textbox on a form. You have access to the height property even though you didn't write the code for it. Java folk say you inherited the height property.
   7. "Java Visual Controls" Just what the chapter title means. About the only chapter that needed more material and examples.
   8. "Writing a Simple Visual Application in Java" This is where the book would start to change if the author does another version. This chapter simply needs to include a real tool like Visual Cafe or Microsoft J++.
   9. "Layout Managers" Too much said here. VB does it better and, amazingly, Microsoft marketing machine doesn't even demand credit for it.
   10. "Using Graphics Methods" I don't know how to draw on paper much less on screen so no opinion here.
   11. "Writing a Program With Two Windows" Excellent chapter with a misleading title. Should have gone with Communication between Windows.
   12. "Files & Exceptions" Another strong chapter that would have been a good transition into databases.
   13. "Using Threads in Java" Best theoretical chapter in the book. I didn't get it all so I'll have to reread it a few times.
   14. "Images in Java Applets & Applications" Necessary evil for artistically challenged like myself.
   15. "Menus & Dialogs" Nuff said.
   16. "Classes & Binary Files in Java" Should have come after chapter 12.
   17. "Keyboard Input in Java" Makes me appreciate VB.
   18. "Using the Mouse in Java" Makes me like VB even more.
   19. "Building Custom Contro! ls" Somewhat tough. I would usually surf far and wide for one someone else's hack before taking the time to do anything complicated.
   20. "Using Packages" A way of grouping classes. I never heard of it before.
   21. "Building Web Pages" No Java, just plain HTML.
   22. "Applets & Web Pages" Late, but finally!
   23. "Interacting With Web Page Forms" Really fun section.
   24. "What is JavaScript?" Author gets points for due diligence.
   25. "Using Sockets in Java" Most powerful chapter. You can get dangerous here.
   26. "Math Classes & Matrices" A small chapter that was still appreciated. It would have been easy to add some statistic examples on CD like standard deviation and average of arrays.
   




3. This book is unlike any other Java book on the market. For a VB programmer, the comparisons really clear even the most abstracts aspects of Java programming. I highly recommend this book.



4. As a proficient VB/COM developer, I thought this might be a good book to begin learning Java with. Be warned: It is not! It was written over 4 years ago and it completely out of date. The text makes constant references to the accompanying CD, which does not exist. The book honestly looks like a poor quality photocopy. It is clear that this was writen in 1996 and republished in January 1999 with nary a change in content. The book only goes to VB4, which is long gone. Want to learn Java? Buy Beginning Java 2 by Ivor Horton. I am sending this book back.



5. As a long time VB and ASP programmer, retraining for Java or C# is a mind-boggler. After taking a class on OO Analysis and Design, I can now make sense out of the paradigm of OO, and appreciate it's benefits. But the paradigm shift is so great, that one probably needs more than the syntax training and introductory level OO concepts presented in this book to be successfull with OO. However this is not the author's fault. If you already grasp OO concepts, this book provides superb examples of how to move from procedural syntax and program structures to use inheritance,polymorphism, and encapsulation as provided by Java.

No comments about Java SE 5/6 Deltas.

No comments about Sun Certifier Java programmer Video Training Course for Java 5 and 6.