Variants Books

This book is similar to another one on the same subject - Introduction To Computer Science Using Java, Student Edition. However, the current book seems to cover the matter at a slightly more advanced level.

It does help that, for instance, when dealing with widgets for programs using graphics, that the widgets lend themselves to an inherently object oriented mindset. Thus the pedagogy of teaching graphical programming in java is self reinforcing.

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.

As Java has gotten built out, the default SDK has a huge number of packages. Can be overwhelming. Typically you don't need to know all or even most of these. But which should you know? Durney supplies one such choice of packages in his book. It does not cover those packages or classes involving elementary syntax. You should already have these down.

Instead, he offers certain packages of high utility. Take the NumberFormat class as an example. It lets you control the number of digits in an output. Then there are the far more complex Date and Calendar classes. These deal with various different conventions for showing the date, as well as a host of language dependent issues. For example, in most of the world, a date is written in the format day-month-year. But the US uses month-day-year. So you might need to customise your displays accordingly. These classes are also deal with the non-metric nature of the many time divisions. As a programmer, you can use the classes instead of having to re-invent a lot of functionality.

But the book's chapter on Applet usage may be less useful to many readers. As Java has developed, Applets have gotten steadily downplayed. Little serious programming appears to be done with these. Before some of you get irate and berate me, take a look at the latest Sun documentation. Sun has pushed Java steadily into server-side applications, where it is doing quite well.

This book has some of the flavour of how many scientists and engineers learnt to program Fortran in earlier years. Then, Fortran was the main language for numerically intensive applications. (Go back far enough and it was the only language.) So Fortran was taught from that perspective.

Likewise with this book. The emphasis is from the point of view of a user who is NOT a computer scientist. Rather, she hails from some other subject, and needs to know enough of Java to apply it to her problems. A very utilitarian approach. Java purists might bewail this, but remember, not everyone can be, or desires to be, a full time programmer.

If you are a physical science major (especially in physics), or an engineering student, then you should have the ideal background for this book.

This is a concise reference, and a good primer. Has lots of good re-usable example code for starting out, and covers many considerations when learning to build effective applications with JavaBeans. Highly readable. I left with a good perspective and I consult it regularly. Looks good on the tech bookshelf, too. :)

Good for beginners, It helped me with my HTML. Also gave me a good foundation to start my Java Applet development. This is one juicy text!

This is a good book for practicing basic java programming concepts but the problem with book is that you need a lot of already written java classes from authors site. Sometimes problem of classpath arises. Secondly, some advance computer science concepts like seraching, recursion are introduced very earlier which makes it difficult to use this book for first java course. I am myself a teacher. I think labortary manual should be self sufficient not dependent on the code or material not available in manual itself. It reduces the interest of student in the subject and experiments. However, it is an execellent effort by the author. There is no such book available. It can be improved more if it is made not dependent on some code not written in the manual.

Hill provides a nice quick course in the data structures you are likely to meet in computer science. He illustrates these with example code in Java. A choice of language. Standard Java comes with classes like HashSet, Hashtable, Vector, List etc that implement these structures. It saves the reader from having to write those from scratch.

From the book, you should get an appreciation of how to use the structures in your code. Plus maybe a bias towards using Java, since it comes with these very convenient classes. Unlike lower level languages like C or Basic.

Foundations of AOP is an introductory book about the new programming paradigm "Aspect Oriented Programming" that takes care of crosscutting functionalities and code scattering to help you create better structured and clearer programs.

The book starts defining the new concepts related to AOP (joinpoints, poincuts, aspects, etc) using some examples in pseudo code and then describes 4 of the most popular tools that exist today: AspectJ, JAC (Java Aspect Components), JBoss AOP and Spring AOP. These descriptions are very complete, showing complete syntax, configuration and compilation instructions for each case. Basically, it implements the same example with the different tools so you can compare them.

There is a chapter dedicated only to compare the 4 tools mentioned above. This comparison includes the weaver implementation, syntax for pointcut definition, aspects, jointpoint types, jointpoint instrospection, introduction mechanism, advice code type and some advanced features like aspect instantiation, ordering and reuse.

The book also covers some design patterns using AOP. It shows implementation of well known patterns like singleton, observer, command, etc, using some of the tools described before and then evaluates these implementations to see if they are optimal for real world solutions.

Another topic covered is quality of service and AOP. Here the authors show us how to use AOP to verify that an application's definition and execution correspond to its identified requirements. They achieve this by implementing what is called design by contract using AOP. They also show two testing techniques (coverage analysis and nonregression test), and the use of AOP to integrate JMX with a java application.

The last three chapters are dedicated to show the full potential of AOP in a sample J2EE application. It shows how to use AOP in the business, presentation and client tiers.

Finally, I could say the book is very good introducing the concepts of AOP and describing several tools that implement them. If you have none o little knowledge of AOP, this could give you a good start. Even if you already know some of the tools described here, this book can be used as a reference. The only thing to consider is that the book doesn't cover the latest releases of some of the tools.

Since this book came out, there have been at least 2 major revisions of Java. But, you know what, don't worry. At the level of treatment in the text, it is not closely connected to the latest in Java. Beside, as Java gets upgraded, it tends to be a superset of older versions.

What Hughes does is use Java as a good language in which to imbue the precepts of computing. If you have never programmed before, you should probably start with an object oriented language. Skip Fortran, Pascal and C. Well, given Java's popularity, it's a natural choice.

Some of the early chapters deal with material that is not restricted to OO languages. Like the if-else construct. Or for loops. You should not have any problems with these. Later in the text, it actually goes into how you can think in OO terms, and how to map these into actual source code.