However, what remains in the proceeding chapters includes far too much coverage of basic Java programming techniques and practices along with innumerable source code listings of the Micro Edition classes. For example, the 23 page chapter on security includes a 11 page primer on network security, encryption, and the like, as well as the 11 pages source code of a third party MD5 digest and Https implementations. This leaves a single page for discussion of the topic as it relates to wireless device programming! Though money isn't everything, at over 13 cents a page, this is too much.
Sams 1 edition August pages. For those who want more details, you may read on. This book assumes no Thread knowledge. By the end of the book, you will understand the finer points of thread programming. The book is broken down into three parts. Part 1 shows you all of the ins and outs of threads.
There is a lot of sample code and many details. This section will give you all you need to know to program with threads. Part 2 shows several techniques for good thread design. It is a nice reference, but not particularly necessary. It is hard to find negatives about this book, but I did manage to find two. The primary negative is that the reading is a little dry. It wasn't so dry that the book was unreadable. The other negative is that there is no website to download sample code.
This didn't affect me much since I prefer to type in the code anyway, but others might find that to be a major drawback. Java Security by Scott Oaks. O'Reilly second edition May pages. The book provides a solid foundation of the classes that comprise the Java Security model. The book starts out with an overview of the Java 2 security model and quickly moves in to details of the 'Java Sandbox'.
The author explains the fine points of permissions and policy files as related to the java. That's it for the basics; this book is definitely for the advanced Java programmer. The book goes in to detail describing class loaders and byte code verifiers, explaining how they are implemented within the JVM. A brief introduction to cryptography, this is a topic that warrants it's own book.
Additionally there are examples of how to generate message digests and use them to create and verify digital signatures. The book also covers creating and verifying signed classes using the jarsigner tool. Advanced topics cover the use Cipher engines for encryption using JCE. And to round out the security features, there is a chapter on JAAS that gets in to both the administrative and programmatic sides. Overall, this is an excellent book on security and a welcome addition to the serious java developer's bookshelf. Java Event Handling by Grant Palmer. I'm looking at my O'Reilly Java books that cover a similar scope and notice they're all under pages.
They look and feel readable. Java Event Handling is pages. Most of it covers the "event API. There are almost no pictures, which is a real shame. The index also tells a story: I had trouble finding entries that weren't class or method names. The least interesting thing is knowing the names of classes and what their methods do; those things should be the by-product of discussion and illustration, not the centerpiece.
The book does seem like a complete reference on its subject. And there are code samples, more than a few, to illustrate key points. Someone who feels lost and wants a lot of examples for a guide may benefit from it. But the "deep questions" that follow learning by repetition don't get much support. Those who can take the precepts given on faith will find it serviceable; those who want proof the author knows what he's talking about will find it unsatisfying. Craig Cleaveland. A combination of Java and XML stated in the title sounded promising. So, maybe because of too high an expectation, this book was somewhat disappointing.
It is written in a simple, "dummies friendly" style which is just too simple for the subject matter. However if you are familiar with both, the examples don't provide too much insight besides common sense. The chapter that could be central to the book shows how you can develop your own template language. Instead of formal approach, the development process is shown "by example", and a reader can witness how a syntactical clone of JSP is designed. In my opinion, absence of any formal design guidelines, limits the chapter's value.
In short, it can be a gentle introduction in a rather complex field, and give you some ideas how to implement a simple Program Generator in your project. Then, if you want more, Krzysztof Czarnecki and Ulrich W. Eisenecker's "Generative Programming" is the classic in this field; which is more of a challenge to read, though. Bigus, Jennifer Bigus. Wiley unknown edition December pages. This book consists largely of annotated Java source code for a simple expert system shell or knowledgebase, with a few simplistic examples of embedding business rules in classes based on an "intelligent Agent Framework".
Unfortunately, the "agents" presented in this book are just classes which are dynamically loaded into a container, and offer not much new to anyone who has used servlets or EJBs. I read through this book, and was sufficiently dissapointed with the code that I wrote my own, considerably more flexible, knowledgebase using based on the same principles, so it was useful for that, but unless you are in a similar situation, you should probably avoid this book. Java Connector Architecture by Atul Apte.
While the back cover talks of "presenting JCA Specifications", you need to wait till the tenth chapter to get that taste. Personally, I don't understand why the author did not make these pre-requisites and concentrate on the actual subject matter - JCA. My interest in the book soon vanished as I had to wait till chapter 10 to see the first line of Java code. Not my kind of book. I wanted to learn the Connector architecture throughly, but this book din't help me to the extent that I expected. There are very few examples.
Just one huge application in the last chapter, although referece is made to parts of it in earlier chapters. This application is developed in the last five chapters. Seems to me that towards the end of the book, the author realized that we quickly need one example. Sams 1 edition July pages. The first part of the book gives a very brief introduction to AOP.
For a first book on the subject, it would have been legitimate to expect a little more substance in this introductory part. The second part is dedicated to AspectJ and creates a real-world web application from scratch. The author clearly explains how to modularize crosscutting concerns such as security, logging, tracing, profiling, buffering, pooling, caching, etc, si well-presented. The third part presents the syntactic and semantics details of the AspectJ language constructs aspects, pointcuts, etc whose use is illustrated by simple examples.
I would have expected the precision and completeness of the AspectJ Programming Guide coupled with those nice little examples. The little details and a substantial amount of typos put aside, I was basically satisfied and would recommend it to any serious developer willing to get in touch with AOP. The AspectJ Programming Guide available at aspectj. It includes comments on the differences between StarOffice and OpenOffice and pointers to other useful resources, such as websites with information on creating macros and additional templates that are available from the web.
The book uses the OpenOffice. The tone of the book comes across as being created by people who like the program rather than a creation of a faceless corporation. Here is an example of the text style from the section on macros from the last chapter of the book. The StarOffice suite has a huge amount of functionality and this book covers most of the functionality you are likely to use. The book is in paperback and has a 40 page alphabetical index. It doesn't try to do it in a visual style with a screen shot for every mouse click but via text instructions.
I learnt a huge amount of new features despite having worked extensively with StarOffice for over two years. I strongly recommend this book to anyone who intends to use StarOffice. Apress second edition February pages. First they invent electricity, now it's all done without wires. And it was an actual, production, working, business MIDLet, that we can use on our ranch. The section on game programming for J2ME is exceptional.
Especially for someone, like me, that has never understood how to write a game. It makes me really want to write one. The book is very easy to read, you won't find yourself re-reading a paragraph because you didn't understand. Jonathan has a very smooth elegant writing style that not only instructs you, but it keeps you reading on. I didn't want to put it down, well except for the strong urge to start programming. It has been a really long time that I have read any programming book that makes me want to code.
Sams 1 edition November pages. This book is a nice introduction for the developer who is unfamiliar with Ant and is looking to get started using it. If you are a developer who is experienced with Ant then this book will not be of much interest to you. The book starts with a nice introduction to Ant showing how to create and use a typical build script.
The first three chapters cover the basics of Ant and the authors do a nice job of making Ant simple to understand. The next two chapters cover all the built-in and optional tasks that are part of Ant. This section is of limited use to the new Ant user. Since the tasks are listed in alphabetical order and broken out into separate chapters for built-in and optional tasks, you have to know what you are looking for in order to find it.
It would have been nice to have a list of all the tasks with a brief description all in one or two pages which would have made it much easier to find a task. There is one brief chapter explaining how to write your own Ant tasks. Troubleshooting Ant scripts is followed by two chapters showing real world examples of using Ant. The book ends with a discussion of tool support. Conclusion: the authors have done a very nice job of explaining Ant for the novice Ant user. Manning Publications 1 edition November pages.
I found the coverage lucid and useful, but only one point at a time. I couldn't get a feel for the flow of this book, and found myself flipping around quite a bit to see if I'd accidentally skipped a page and missed some key point. None of them seem particularly energizing. This book, while helpful and strong on a lot of individual points, lacks whatever it takes to tie the points together so the reader can say "Now I get it.
Addison-Wesley Professional 1 edition March pages. The first half of the book explains what LDAP Directories are, how they differ from databases and how they are similar to databases. It contains information on where LDAP came from, why the protocol emerged and what has made it so successful. The second half of the book was just as intriguing as the first. Sections 2 talks about the advantages of each and the limitations of each and how they compare with one another.
The only thing I felt lacking from this book was a good explanation of how LDAP stores it's data on disk physically and how it achieves such good read and search performance. And I don't understand why there are 2 elephants on the cover. Apress 1 edition March pages. Ol Doc Martin called it a bad case of bluetooth. This book is not about some dental problems. It is about a new type of wireless networking that uses radio waves for two or more devices to communicate. The first four chapters explain Bluetooth.
Its Java APIs and how it all works. While I believe I learned how to discover available devices in the area, connect and discover their services, I feel that the writing of these chapters could have been clearer. I found it difficult and tedious to comprehend the concepts. In chapter 5 they give two very good examples of Bluetooth and Java in action.
The later chapters start to delve deeper into more specific types of Bluetooth environments and products in the market. Such as using a Bluetooth simulator, Bluetooth security, micro blue target, Ericsson Blipnet, and Bluetooth with Jini.
Overall, I was disappointed. I thought I would come away with great new knowledge. Instead I came away with a confused look on my face. I couldn't grasp the concepts. Maybe it was at a higher level than Intermediate, or maybe it was just me. Even if you know nothing about Bluetooth or wireless communications, this book will give you enough information to get started.
The book starts with an examination of Bluetooth and the terminology you need to understand Bluetooth enabled devices. Chapters cover creating a Bluetooth print server, passing objects between Bluetooth devices, and securing messages between devices. The authors discuss the PC software available to simulate Bluetooth devices so that you can develop an application without having two Bluetooth devices sitting on your desk. The final chapters covers topics such as Jini and Ericsson BlipNet. The book contains many well commented code samples demonstrating how to use the Bluetooth API.
The book is very clear and concise. It reads as if it was written by a couple of enthusiastic Bluetooth developers anxious to share the technology. And they do an excellent job of doing exactly that. I started the book knowing almost nothing about Bluetooth but now I feel confident that I can develop Bluetooth pplications. If you have any interest in Bluetooth then I can recommend this book as an excellent resource. Mastering AspectJ by Joseph D. Gradecki, Nicholas Lesiecki.
Wiley 1 edition March pages. This book does a great job of showing how aspect-oriented programming AOP nicely complements current object-oriented techniques. The authors first introduce important AOP concepts, and explain how AspectJ reifies these concepts into a concrete and powerful programming language that brings AOP capabilities into the Java language. Plenty of code examples demonstrate how to best use AspectJ in real-world projects, and how to integrate AspectJ with current software development tools and techniques.
It is worth noting that this book is really about aspect-oriented programming. As a designer, you won't see any serious techniques for modeling aspects, as research on the subject is still ongoing. However, there is a very interesting chapter on how to apply an aspect-oriented version of the Observer design pattern to existing code without modifying the original system. The book finally provides an impressive list of links to interesting AOP resources, and the whole code is made available on the companion web site.
On the downside, some chapters would have needed a little more proofreading and technical editing, but the overall tone is good. To date, this is the most complete and interesting resource about the AspectJ programming language. You get real insider information since the authors Gong and Ellison have been chief and lead security architect, respectively, for the Java 2 development team.
It is concise yet fairly detailed at times, and about as fun to read as the JLS, if you're into that sort of thing. It is not a how-to book so don't expect to find any detailed examples. It only covers the J2SE platform security. Even though I wouldn't really go buy the book, I hope Sun makes it available in some form on their website like they did with the JLS because it does have some useful information.
Addison-Wesley Professional second edition November pages. Two things make this new edition even better than the first edition. First, plug-in development in Eclipse is now easy and so well explained in this book that there is no reason not to try it. Have you ever worked with an IDE and thought, "why isn't this function available in the pop-up menu" or "why doesn't it have this feature"?
Developing a plug-in will allow you to customize Eclipse to provide the missing feature and this book will clearly explain exactly how to do that. Second, the section of the book that deals with developing with Eclipse has been improved with detailed chapters on team development including using CVS as well as an excellent example of integrating with Tomcat to develop an E-Commerce application.
The book is divided into two sections. The first pages deal with using Eclipse and cover everything from the basics to complex team development issues. The next pages cover everything you need to know about extending Eclipse. The book ends with pages of exercises that give detailed, step-by-step examples. Five exercises deal with using Eclipse while the rest show examples of extending Eclipse. It is a big book that covers a lot of material but it covers it clearly and with plenty of examples. If you buy one Eclipse book, this should be it. Addison-Wesley Professional 1 edition May pages.
The first part of this book deals with using Eclipse from a Java developers point of view. I found this was not any more helpful than the documentation available on the Eclipse web site. Eclipse works extensively with plugins that can be integrated into the Eclipse environment to provide new functionality. I would have liked to see something on some of the more popular plugins such as those used to run application servers. Even a list of where to go to get plugins would have been helpful.
Unfortunately, this part of the book only covers the basics of what comes with Eclipse and does not discuss any existing plugins. The second part of the book, about pages, covers writing your own plugins. This part of the book is excellent. It covers not just the basics, but virtually everything you need to know to write plugins. Whether you wish to code a new toolbar, editor, specialized view, or wizard, it is all covered in this section.
With this book you will be writing plugins in a fraction of the time you would have otherwise spent. The book also contains exercises which allow you to test your new knowledge. If your only goal is to use Eclipse then you don't need this book. If your desire is to write plugins then I wouldn't even try without it. Manning Publications 7th edition May pages. It's designed for versatility and it succeeds brilliantly. Of course, with increased versatility usually comes increased complexity. Eclipse In Action is written with Java developers in mind and leads you through the major functionality and extensibility of the IDE through in depth examples.
The examples are great and have a nice depth they don't feel as contrived as most examples in books like this. This has some definite benefits -- you feel like you're getting real-life experience by doing examples and it makes the book smoother to read front to back.
However, there is a drawback -- this book doesn't always make a handy reference to put on the shelf. To figure out how something works, sometimes I find myself looking back a chapter or two to see how the example works so that I can work forward. I found that this book lent itself to being read straight through rather than picking put chapters to read individually. I found the book easy and enjoyable to read, although you'll probably want to be sitting in front of your computer working along to get the most out of it.
The technical information is dead on and I found few mistakes -- the editing is done very well. I'd definitely recommend this book to anyone that wants to get the most out of Eclipse. Morgan Kaufmann 1 edition April pages. The first half of the book addresses basic techniques for unit testing. The author is a proponent of eXtreme Programming and test-driven design, and those concepts are explored as they relate to unit testing. This first part of the book is quite exhaustive and contains in great detail pretty much everything you would expect.
One pleasant surprise here was a nice chapter on inheritance and polymorphism as it relates to unit testing. Link offers some excellent advice on this rarely addressed topic. Once you've mastered the basic techniques, Link kicks it up a notch and addresses some more advanced topics relevant to our day-to-day lives as Java developers.
The book discusses unit testing persistent objects, web applications, and GUIs, as well as rarely examined topics such as concurrent programs and distributed applications. As if that weren't enough, Link throws in an outstanding chapter on the role of unit tests in the software process which is necessary reading if you are attempting to integrate the book's practices into your own organization. The tone is academic and some of the phrasing is awkward, although it should be kept in mind that it is a translation from German.
I like to think of "Unit Testing in Java" more as a text to be studied, rather than as a reference. However, there is so much that is good in here, that it is definitely worth the effort spent reading it. This is good stuff, but mostly also covered in other books. The section on Mock Objects is especially well done though, illuminating an often misunderstood topic area. The latter half is where this book shines. It tackles some of the really tough areas and does it very well. Singletons, database persistence, asynchronous services, concurrent and distributed systems, web applications and graphical user interfaces; all these are often skipped over as "too hard to test".
If you've ever found yourself thinking something like that, you need this book. This book is a translation from a German original. Although the translators have done a tremendous job with the technical content, sometimes a phrase or section title, especially in the initial introduction can seem very unusual. Don't be put off by the quirky language in the early chapters, the meat of the book is well worth reading and putting into practice.
This book is a masterly example of how to convert programming theory into solid, practical advice. MIDP 2. Addison-Wesley Professional 1 edition June pages. This will not teach you how to code but it will teach you how to design your MIDlets so that they will be usable. You will find lots of samples of good design and bad design plus plenty of recommendations to help you to write usable MIDlets.
The book starts with some basic guidelines make your code simple, predictable, and efficient and a description of the minimum MIDP hardware tiny screen, limited input, two colors, and little memory. The authors then get into the main focus of the book, designing MIDlets.
Starting with screen layouts, they take us through the different items you can place on a screen such as lists, text fields, forms, commands, etc. The focus is not on how to code but on how to make these items usable. The book also covers issues such as push, security, and touch input from the usability point of view. There is no doubt that this book will be the standard for designing programs for MIDP devices. This book can help you avoid a lot of simple and not so simple mistakes that you may not notice until you get to usability testing. You could write your MIDlets without this book but why not save yourself some headaches.
Right off the bat, one notices that there is very little difference between standard Java 1. This is NOT a Java teacher. Recommendation: If you have a Palm, get the book. If you have a PocketPC, see what you can dig up on the Internet first -- if you're stuck, get the book. This book covers both of these implementations and explains the differences in clear and concise language. The book is relatively short at about pages but it covers the material in sufficient depth to get you started in developing for both environments.
Automated Analysis of Java Message Service Providers | SpringerLink
The book starts by explaining the different configurations and points out which are available on which devices. After showing us how to create a test environment, the author discusses the coding issues involved with devices with limited memory and speed. The next few chapters discuss developing a user interface, storing data, networking, and accessing web services. The differences between MIDP and PersonalJava are pointed out in each section with plenty of code samples demonstrating these differences. The book is written assuming a basic knowledge of Java and J2ME.
The book serves mostly as a tutorial although it could be used as a reference as well. This book fills that slot nicely. Wiley 1 edition July pages. There are many ways to code an application but a few of those ways will cause problems in the long run both in debugging and maintenance.
This book looks at four of the most popular Jakarta applications, JUnit, Cactus, Struts, and Ant, and shows the most common problems that you encounter when using these applications. The book gives a chapter each to Ant and the two testing applications JUnit and Cactus but the majority of the book is dedicated to Struts.
Each chapter looks at several programming mistakes and then discusses ways to revise your code to fix these mistakes and make your code more robust. The problems with certain coding styles are well explained with clear reasoning as to why you don't want to code a particular way. Corrective solutions are well documented with plenty of code samples to show both before and after images.
Although the chapters on testing and Ant are good, the heart of the book is the chapters on Struts. The authors discuss potential problems using Actions, ActionForms, and the Struts tag library.
Java message service ebook
Some problems can just make your code more difficult to maintain while others can introduce intermittent bugs that are very difficult to diagnose. Anyone who is using Struts should absolutely read these chapters, as it will save you from making some simple mistakes that could cause a lot of long-term pain in your development. These problems are usually the result of a lack of experience but can also be caused by there not being enough time to refactor code.
The pitfalls are not farfetched and I did recognize a few in my current code! The layout of the pitfalls is quite useable: the situation giving rise to each pitfall is explained, followed by a concrete example demonstrating the pitfall -- this helps clarify how this sort of thing COULD actually happen and isn't just a hypothetical problem the authors concocted. Following that is a description of the solution as well as a step-by-step procedure to FIX existing code that's fallen prey to same this is nice.
Then, finally, the broken example introduced earlier is fixed. The code examples in this book are QUITE extensive and it is good that they are available online so one doesn't have to type them in! Some of the examples contain generic code that is immediately reusable by developers and so has practical rather than merely instructive use also. Unfortunately, there aren't too many texts currently available that take an in-depth look at the subject. The book first touches on some topics fundamental to TDD, such as refactoring, programming by intention, and of course the basic theory behind TDD.
Appendices further flesh out this material by addressing extreme programming and agile modeling. Although other members of the xUnit family are looked at, this book is squarely focused on JUnit and Java. As such, the text goes into detail about using JUnit, including the API, and how to go about the task of writing tests.
Where this book really shines is in its coverage of mock objects and techniques for testing GUIs. The meat of this book rests in a very detailed walkthrough of a project using TDD. Astels leads the reader through every test and every refactoring along the way, from inception to the finished product. This is probably the next best thing to sitting down for a pair-programming session with a TDD guru. Unfortunately, there are a couple of complaints I feel the need to point out. The project presented is a Swing application that persists its data in a flat file.
There is no coverage provided for testing web based enterprise applications. While mention is made of DatabaseChecker, a test utility suitable for simple database tests, Astels chose not to have the example project use a database for persistence. As a consequence of this decision, this common task is left unaddressed. Despite these omissions, there is still much to be gained from this book. I feel a reader may obtain the most benefit by downloading the sample code and working through the example project step-by-step along with the text.
If you are interested in a practical guide to TDD, this book is definitely worth a look. Eclipse: Step-by-Step by Joe Pluta. I wouldn't probably be as much lost if I were brought on another planet -- there I would at least know where is the left and where the right. Then some kind soul lent me a book written in more human style, so I could begin to orient myself along the four sides of the world I wish my early days I had a book like this!
If you are confident in your learning abilities, and prefer to find your own path, there are books about Eclipse that you will enjoy more.
Most Innovative Java Product: Tomcat 3.2, the Jakarta Project
But if you feel lost and looking for help, you will find it in this book. You will get your personal guide, who will never let you get lost, but will walk you through the foreign planet explaining what is this or that thing you are passing. Each example is provided with a program on CD, so you do not have to type your own if you do not want to, and you can learn how to use Eclipse even if you know no Java at all.
Each step you need to make is listed, explained, and for each step there are screenshots that illustrate what your screen should look like. If you installed Eclipse from CD, you will never have to wonder why your screen doesn't look like it is supposed to. In the following stage learners need one procedure that work, "they copy it, they learn it", and they need a very detailed description of this procedure.
In the next, detaching stage, people learn several ways to do the job along with advantages and shortcomings of each. In the third, fluent stage, they forget about procedures, as they do not need them. This book is determinately and rigorously written for the first group of learners, and it should be appreciated as such. Or maybe you haven't even figured out how to start it up. Don't worry. Just get a copy of this book and you will be using Eclipse like an old ranch hand in no time.
Many books for the novice claim that they will teach you something but they hit "magic happens here" moments that leave you lost. You won't find any of that in this book. The title of this book is "Step By Step" and that is exactly how this book teaches Eclipse. The book assumes that you know nothing about Eclipse. After showing how to download, install, and start up Eclipse, the book takes a tour of the basic features that every programmer will need to know in order to code, test, and debug their programs.
It starts by explaining what a "perspective" is in Eclipse terms and examining the most commonly used ones. The book then takes a look at a few simple Java programs, showing how to code and debug them. This book is geared for novice users and is not meant as a reference. If you are familiar with IDEs and don't feel lost when using them then this book is probably going to be too basic for you.
But if you are new to IDEs and like a lot of hand holding then this book will help you to work comfortably with the product. AspectJ in Action by Ramnivas Laddad. Manning Publications 1 edition July pages. AOP is a new programming approach that complements the traditional object-oriented approach by allowing developers to modularize crosscutting concerns of an application, such as security, logging, tracing, etc, into "aspects".
Such a mechanism provides for a better maintainability of the code and allows programmers to reuse aspectual modules in multiple applications. By adopting a hands-on approach, this book is committed to be a very practical reference for aspect-oriented programmers. The author did a wonderful job of introducing the new AOP trend. So far, no other book succeeded to present the challenges of AOP so well as the author of this book does. In the first part, the author presents the basic syntax of AspectJ and goes on with more advanced concepts of the language.
The second part is dedicated to presenting simple applications of AspectJ in monitoring logging, etc , policy enforcement and optimization pooling, and caching techniques. Finally, the author explains how to use Ant and the AspectJ compiler to build applications efficiently. In summary, this book provides a very good resource for both people starting to learn AOP and AspectJ and experienced AOP programmers who wish to deepen their knowledge in this new area.
I could use the tools after a little work, but most of the comments and insights surrounding Jess seemed expert-driven, and I backed off the idea of using Jess to teach for the lack of material helpful to a beginner. Jess in Action changes all that. It's a clean, well-written book. From my view anyone with some Java experience and some programming background could learn Jess and use it for complex projects by using this book. I found the principles of rules-based programming well laid-out, the examples engaging, and the flow very comfortable. I found some very minor flaws in the presentation -- some forward references, a style that slips into jargon now and then -- but on the whole the book is useful.
You'll read it more than once, if you grasp the power of the tool that's been put in your hands. This book is about Jess, a rule-based system written in Java. If you are interested in learning what kind of problems Jess can be used to solve and how to use Jess to solve these problems then this book will answer your questions.
The first section is a tutorial on Jess. This section covers the Jess syntax and demonstrates how to write rules for Jess. The tutorial is clearly written with some simple examples that do a good job of helping to make Jess understandable. The tutorial even shows how to do some optimizations for rules.
The rest of the book covers some fairly complicated applications written using Jess. The author refers to this section as a cookbook and the examples are complex enough and explained so well that it could easily serve this purpose. The best part of this section is that it will help someone who isn't familiar with rules engines develop ideas about how they might implement a rules engine to solve their own business requirements.
The examples themselves cover integrating Jess with Java both in typical client based applications and J2EE web based applications. If you are interested in using Jess as a possible solution to your business needs then this book is a virtual necessity. I couldn't imagine trying to use Jess without this book. Manning Publications 1 edition October pages. The main problem with unit testing is building tests that are easy to run and maintain. That is where JUnit enters the picture. JUnit simplifies the task of creating unit tests and this book simplifies the task of understanding and using JUnit.
The book starts with the basics of using JUnit but then moves on to explaining the intricacies of JUnit. UML diagrams clearly show the flow of control within JUnit and your unit tests. The book also shows how to do unit testing of Servlets and JSPs which can be much more complex to test. The author demonstrates both the use of Cactus as well as the use of mock objects for J2EE testing. In fact, the best part of the book is that the author helps you determine how to decide what type of testing strategy is right for your application.
I thoroughly enjoyed this book and found the author's comments clear and insightful. The author supplies plenty of code samples with explanations of not just how but why we do our testing a certain way. The author's own experience is passed on to us with his "best practices". Anyone who is writing Java code should read and understand this book. The quality of the code you produce will vastly improve. Leafing through any one of these titles while sipping an espresso in the bookstore's coffee bar, you'll quickly figure out that repeatable, automated unit tests are a good thing, and that JUnit is the unit testing framework most often used for Java unit testing.
A couple of mochachino grande's later, and you've read enough to convince you that your continued survival rests on writing these automated unit tests. Unfortunately, and before your caffeine buzz even wears off, you're struck with the realization that while you're motivated and ready to go, you're just not sure exactly how to go about writing tests for many of your J2EE components. This is not a book on test-driven development, and it's not a book trying desperately to convince you of the value of tests. The book's goal is to demonstrate exactly how to write comprehensive unit tests for the various components of your J2EE applications.
Writing tests for servlets, filters, JSPs, taglibs, database components, and EJBs are all covered in detail, as are testing strategies using mock objects and Cactus. Not only are you shown how to write the tests, but also how to write testable code. Along the way, the author points out useful best practices and how to use design patterns to improve your tests and the code you are testing. Code examples are thoroughly documented throughout the text in order to illustrate the techniques being discussed. Pick up one of the other books if you're looking for something more motivational, but when you're ready to sit down and bang out some code, you'll want this book at your side.
Manning Publications second edition July pages. It wasn't even that the second edition was bad. It's that my expectations were too high from the first edition. I think there were too many authors on the book. The different styles were apparent which is awkward in a book. The cover says the book covers JUnit 4. This one is probably marketing's fault, but it stands out extra on a book about quality.
I also think the scope of the book was too large. Many things are covered, but not enough things are covered well. While most things were mentioned, there were only 3 pages on Hamcrest matchers. I felt other core concepts were breezed through and not enough space was spent on the fundamentals. The first edition had more pages on core JUnit and there was less to cover then!
I was also surprised not to see Mockito mentioned in the mock testing section or Emma in the coverage section. Not featured, mind you. Just mentioned. And finally, I found one factual error that I consider significant because it is a fallacy. Nor have many people who posted since May or beyond. Why is there a forum if nobody reads it? Many things were done well - examples, best practices, available tools. I just had the bar so high from the previous edition that I was let down. If you already own the first edition or are familiar with what is out there, you don't need this book.
If you've never done anything in JUnit, it is still useful. Just remember that the order unit tests are run is not guaranteed! Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch. Addison-Wesley Professional 1 edition October pages. More importantly, as someone who is in the middle of their first major Eclipse plugin development project, I learned a lot -- even though I've previously read every other available book on the topic.
Gamma and Beck take you through the development of a fairly sophisticated plugin, step by step. Perhaps most welcome, the plugin they develop isn't a syntax-highlighting text editor an example that's already been done to death, but a set of tools for running JUnit tests on Java code! This is the only book I've seen that discusses testing and Test-Driven Development of plugins, a must for serious plugin developers. As you'd expect from the developers of JUnit, they use JUnit to test every piece of functionality they add.
Surprisingly, even though you'd expect some confusing in writing about using JUnit to test a JUnit plugin, there's none. Gamma and Beck are both excellent writers, and they know this subject matter inside out. A word of warning: this is neither an introduction to nor a reference for Eclipse plugin programming. But if you've gotten beyond the novice level with Eclipse, I guarantee you'll learn something by reading this book. A little experience of using Eclipse as an IDE, and a desire to extend the framework further are needed for this book.
Before you know it, you'll be developing your first plug-in. Of course, it's a 'Hello World', but it introduces the concepts you need to go on to bigger and better things. The 'bigger and better' thing the book provides is a JUnit plug-in that performs automatic unit tests during builds. The authors don't just teach you how to build a plug-in, but how to build a plug-in that 'plays well with others' and allows for your plug-in to be extended in the future.
Wrapping up the book are a collection of 'pattern stories' describing some of the design patterns used in Eclipse. The clear writing style and the flow of topics will help you get up to speed and writing plug-ins in no time. If you need further details on a topic ample references to the Eclipse documentation or other books that will help you on the subject are provided.
All-in-all this book is a great resource for anyone that wants to extend the functionality of Eclipse.
- Independent Software Architect, Author of Software Architecture Fundamentals?
- The Sacred and Profane Love Machine (Penguin Books)?
- Historical Materialism and the Economics of Karl Marx.
- Frictionless Markets: The 21st Century Supply Chain!
- Construction Documentation Standards and Best Practices for Landscape Architectural Design.
A lot of focus is given on available alternatives both general approaches and product offerings, open source and commercial for handling the problem of spotty and low-bandwidth connectivity, and on technologies for communicating between the mobile client and enterprise systems. Furthermore, plenty of sample code is available illustrating these techniques in the form of several full-blown sample applications downloadable from the companion website. The book has packed a lot of coverage into less than pages. This inevitably means that many subjects are bypassed rather quickly, referring to sample code for details.
Fortunately, Yuan has found a reasonable balance and managed to include sufficient detail in those subjects that interest me the most networking, on-device databases, XML and web services, and security. I would say that this book is best used as a reference for a mobile application architect wondering what her choices are. On the other hand, the focus on particular products -- proprietary APIs may render some sections of the book outdated once standardization becomes reality in those areas which Yuan explicitly and repeatedly predicts.
All in all, "Enterprise J2ME" is definitely the most comprehensive resource to date for enterprise Java developers having to deal with the new world of smart clients and packs a whole bunch of valuable information and tips for actual implementation. Kline, Timothy J. Morgan Kaufmann 1 edition September pages. Therefore, I hail the authors for making a brave move. The book is not just an introduction to the Bluetooth Java APIs but also an introduction to the whole Bluetooth architecture and terminology. The fact that a lot of space is used to explain the underlying protocols specified in the Bluetooth specification can be both a godsend and a sleeping pill.
For me, it was a godsend. The book starts with a brief overview to what Bluetooth is as a technology. This section of the book is a very pleasant read, giving out just the right amount of information. Next, the authors continue by tackling each main acronym one at a time using a recurring pattern: introduce technology, introduce API, illustrate with snippets of sample code. This section covers approximately half of the length of the book and can be labeled "the meat".
Some portions, such as the chapters about service records, are slightly too detailed for my liking as someone new to the whole Bluetooth scene , but mostly, the content is straightforward and easy to grasp. After having discussed all the big things in Bluetooth for Java, two sample applications are introduced. The full source code for examples throughout the middle chapters has been included as appendices for the reader's comfort.
Also, the Bluetooth APIs have been included as appendices, which I personally would've left out but also don't mind having it there. As a closing remark, I feel that this book is a wonderful piece of work and well worth reading for developers new to Bluetooth technology and the related Java APIs.
- Droid X2: The Missing Manual.
- A Companion to Persius and Juvenal.
- Read Java Message Service Oreilly Java Series ?
- Warriors: Power of Three #2: Dark River.
Its approach suited me perfectly. The section on the object lifecycle isn't clearly explained having too much concentration on lists and not enough on explanations. The following chapters do a decent job of explaining the pieces of JDO. The authors wrap up with some tips, take a look at what might be coming in the future, and show a case study.
The authors do not look at any JDO implementations, which leaves their explanations in essence, hanging in mid-air. Although they show how to code in JDO they don't show what a programmer needs to do to hook their code in to a database. This means that without further reading, you can't run any of the examples supplied. Although the book is not bad and might be worth a read, it is not as clear or as well written as one might like. Cambridge University Press 1 edition June pages.
Unfortunately, in its present state, it contains a wealth of redundant material. Nash begins by spending 55 pages defining frameworks and touting their benefits, and then moves on to another 50 page chapter entitled "Application Frameworks: What do they provide and what are the benefits? This book is badly in need of editing. Curiously, the chapters in the middle of the book are entirely unrelated to choosing application frameworks. There are long treatises about open source including over thirty pages of annotated software licenses, about development methodologies, about design patterns, and even about IDEs.
Why all this material appears in this book is a mystery to me; again, an editor could have helped. The last two chapters of the book, which concern best practices and case studies, are a bit better and certainly more on topic. Readers interested in the Struts, Cocoon, Expresso, or Turbine application frameworks will benefit from the comparative study in the final chapter.
I find it hard to imagine a typical Java programmer having much use for this dreary, heavy-handed tome. A manager new to software development might find it of more value. The overview is dense and would be scary for someone new to persistence. The API section is the largest. One chapter is devoted to each key JDO interface. These chapters read like heavily annotated Javadocs; the subheads roughly correspond to the interface methods.
Each chapter is accompanied by a UML diagram of a single class; a listing would be more useful. The case studies are the best part of the book. This material could save you countless hours of frustration. One thing this book lacks is code. When code does appear, it's an Ant build file, or a class showing how to use the "transient" keyword, or something else peripheral to the main topic.
There is essentially no real JDO code at all until the case studies at the end of the book. Also noticeably missing is an introductory tutorial. There's no "Hello, JDO" program here. Many programmers want to see a basic program like this; its absence is disappointing.
This would make a good second book on JDO -- a reference you could turn to for details after you already knew your way around. You may also want a book with more code and tutorial content, and the writing is rough, but the case studies are full of great advice. Java Regular Expressions: Taming the java. Apress 1 edition October pages. The author assumes that the reader has no experience with regular expressions so even if the subject is completely new to you, you will be able to follow along easily.
The book approaches the topic in a clever way that makes it both an excellent tutorial as well as an excellent reference to keep nearby. The first chapter covers regular expression syntax. The second chapter looks at the two main classes, Pattern and Matcher, and discusses each of the methods in these classes.
The way the information is presented makes it a perfect tutorial, as the methods are introduced in a sensible order that allows the detailed discussion to build. At the same time, since each method is discussed with excellent description and examples, it serves as a useful reference. Chapter three looks at some advanced topics such as groups, qualifiers, and lookaheads.
In chapter four the author gives us some advice and chapter five demonstrates some useful examples. The books ends with a reference, summarizing the topics discussed in the first two chapters. Other than a few minor misprints and one slightly confusing group example early on I could find nothing to complain about. Any Java programmer interested in learning regular expressions will find this book extremely useful. It is hard to imagine that there could be a better book on regular expressions than this one. Newbies often run away screaming when faced with this explosion of punctuation, never to return.
Help has arrived in this small, accessible book. Rather than starting out with the Big Scary Table, Habibi appeals to the reader's intuition, and demonstrates several regex applications before even mentioning punctuation marks. By the time that fragments of the Big Scary Table do arrive, the reader has already seen fully worked examples and learned techniques for developing a regular expression for a given problem.
Instead of the Big Scary Table, this book uses small tables that make understanding complex regular expressions easy. There are tables which break up regular expressions into pieces, each row pairing one chunk of the expression with a clear explanation. Other tables show the steps involved in developing a complex regex. The honest explanation of each step makes these tables valuable real-life case studies. After describing regular expressions themselves, the book presents a practical overview of the java. There's also a separate chapter on advanced features, and a final chapter showing fully-worked practical applications.
The only flaw in this book is a slight bias toward Java on Windows systems. A reader working the examples on Linux would have minor problems the author doesn't mention. Overall, I'd strongly recommend this book to anyone new to java. Yes, I've read the entire book. It is that good. In its simplest form, that's exactly what it is, but enterprise MQ servers enhance functionality by wrapping this linked-list management with a number of features:. The strengths of MQ derive from the inherent loose coupling provided by the asynchronous nature of message processing.
The processes of posting a message to a queue by one entity and removing the message and processing it by another entity are completely separate. The two entities don't have to be running at the same time, be located on the same system, or even know the other's identity; they each interact only with the queue, on their own schedule. They only have to agree on the forms of messages they will accept from each other; otherwise, they don't have to know anything about each other.
Loose coupling has many advantages. It provides a natural mechanism for dividing a unit of work into smaller, independent components, which implicitly creates abstractions between the stages of processing a request. This subdivisioning allows us to easily abstract the implementation of each component from one another, better measure and manage the resource utilization by each component, or replace one component with another that provides similar functionality without having to change the other components. The JMS specification requires that JMS providers also implement publish and subscribe features, which allow you to create distinct, application-defined channels called topics , and allow individual entities to subscribe to topics.
A message queued to a topic is automatically placed on the private queue of any entity who is subscribed to that topic. Topics perform a valuable sorting function in financial services or news delivery applications. For example, while more than stocks are traded on the major US exchanges, each investor may be interested in only So you could create a topic for each ticker symbol, let users subscribe to the symbols they are interested in, and then let the MQ engine do the work of displaying only the quotes each investor wants, avoiding the delivery of duplicate quotes.
This process is much harder to implement with an SQL database. There are a number of common usage patterns that are well-suited for using message queueing. When you see one of these in your application, you should consider using messaging. Highly event-oriented applications are very well suited to using MQ technology. These include financial services applications think about a trading station that displays stock price updates, initiates trades based on changes in prices or the execution of other orders, reports on the status of orders, and so on , news-wire service applications, and supply-chain applications.
In financial markets, events must be acted on quickly; you want to be notified when something important happens, as soon as it happens. Databases are excellent for storing data persistently, but storing transient data and notifying us when the data has changed is not their strength. Even though it is inefficient, polling databases is extremely common.
The display monitors in every airport are constantly polling the database to update the information they are displaying. A bank with many teller windows often uses electronic signs to indicate the location of the next free teller. An order processing system inside an e-commerce site may poll the database to see if any new orders need to be processed.
Or an insurance claims workflow system might poll to see if there are any new claims that can be assigned to available claims adjusters.
All of this polling makes for a lot of extra work. If there are many entities polling frequently and they would have to, if they want updates in the data to be reflected quickly , this could create a substantial load on the database server and the network. Most of the time, polling returns no data, or worse, data we've already seen and have to process again or identify as having already been processed. Databases are simply not designed for polling or for events.
If you must take action relatively quickly after an event occurs or data changes, asynchronous messaging is by far the easier and more efficient way to accomplish this. Whenever you find yourself polling a database for an update, consider using JMS instead. According to the workflow portal a cooperative effort by the Workflow Management Coalition and the Workflow And Reengineering International Association , workflow is " Workflow applications are characterized by having many agents agents can be humans, automated processing steps, or even physical equipment such as machinery or printers who each perform a small portion of the task and pass it on to the next agent as determined by business rules.
Consider the process of approving and paying an electronic expense report. The employee creates and submits the report, and then the report needs to be approved by the employee's manager and maybe by another level of management if the dollar amount exceeds some threshold. Then it goes to HR, where it will be checked for accuracy and scrutinized to ensure that the expenses are valid business expenses and comply with the company's policies. If approved, a payment request will be created and the check will be scheduled for printing. After that, it may go to accounting, where the individual charges will be applied to the appropriate accounts and cost centers.
At each of these stages, the expense report may be bounced back to the employee or the employee's manager. In building a workflow application, the primary design goals are to make sure work gets quickly from agent to agent, and to make sure that tasks don't fall through the cracks. MQ servers, working hand-in-hand with databases, make it easy to build flexible, scalable, and extensible workflow processing into your application. The process of accepting, approving, and filling an order in an e-commerce or supply chain application has a lot in common with workflow applications, although most of the steps involve electronic participants rather than human ones.