2 comments about Kicking Butt with MIDP and MSA: Creating Great Mobile Applications (Java Series).

1. This book has many topics very well writen, i really recomend it.
   And it have new technology for J2ME



2. I really hate Netbeans, but in spite of that fact, and the fact that this book makes heavy use of the technology, I dug into the book. I have a real interest in learning about the development of Java programs on cell phones past the writing of small local applications and games, and this book seemed to fit the bill. I'm the happy owner of many of the author's past books, and this one didn't disappoint me either. At first glance parts of the book look rather sparse. That is because, for one, Knudsen doesn't see the point in just regurgitating the standard. The second reason is that much of the source code is on the book's accompanying website. If you are interested in writing mobile applications with Java, I highly recommend this book. I discuss the book's contents chapter by chapter as follows:
   
   Section: I Getting Started
   Chapter 1. Overview - explains why MIDP is such a good fit for mobile devices and describes how MIDP and the rest of the band fit together to form a powerful platform for mobile applications.
   Chapter 2. Tools - Building MIDP applications is surprisingly easy. This chapter describes several development alternatives and explains some of the magic that these tools provide. Also justifies Netbeans, which I dislike, but it's a fair trade-off to play with such cool stuff.
   Chapter 3. Quick Start -Describes a few simple parts of MIDP so that you can get something running right away. You'll also have a basic scaffolding upon which to build your later knowledge.
   Chapter 4. Core APIs - Don't assume that you know all this stuff, even if you're experienced with Java technology on the desktop or in a server environment. The constraints of small devices dictate that these APIs are more compact and less rich than their desktop counterparts.
   
   Section: II The Lives of MIDlets
   Chapter 5. The MIDlet Habitat - learn the details of how MIDlets live and die and how devices prevent bad MIDlets from performing bad deeds.
   Chapter 6. Starting MIDlets Automatically - Incoming network connections can start a MIDlet. For example, a Short Message Service (SMS) message arriving on a certain port or an incoming socket connection could launch a MIDlet. MIDlets can request to be started at a specific time. MIDlets can respond to specific types of content. For example, an audio player MIDlet can be set to handle one or more audio file types. Other applications can ask the device to launch a MIDlet to handle a certain type of content.
   
   Section: III User Interface
   Chapter 7. Basic User Interface - This chapter and Chapter 8 discuss the screens that LCDUI, the user interface, supplies and their supporting baggage.
   Chapter 8. More User Interface
   
   Section: IV Graphics
   Chapter 9. Creating Custom Screens - If the plain old LCDUI screens are not sufficiently jazzy or flexible for your application, you can create your own screen using a canvas. It's more work, but it's more fun. You can control almost all of the drawing on the display and you get fine-grained event information as well.
   Chapter 10. Custom Items - A middle ground lies between the easy path of canned LCDUI screens and the raw bravado of using Canvas. Custom items are your own items that can be placed into standard forms. A custom item is very similar to a canvas, but it has some additional equipment to allow it to be part of a form.
   Chapter 11. Using the Game API - One popular category of Java ME applications is games. Even when faster data networks make other types of applications more popular, games will always be an important part of the Java ME ecosystem. MIDP has a Game API designed to help you create 2D action or board games. It has a souped-up canvas and supports building a screen using multiple layers. The entire API consists of five classes that are discussed in this chapter.
   Chapter 12. Scalable Vector Graphics - The shortcomings of images on small devices are addressed by JSR 226, the Scalable 2D Vector Graphics API for J2ME. Scalable Vector Graphics (SVG) is a kind of XML for describing pictures. Because it is essentially a programming language, SVG can also describe animations and user interactions. JSR 226 is a standard API for displaying and manipulating SVG documents.
   Chapter 13. 3D Graphics - The Mobile 3D Graphics (M3G) API, gives MIDlets the ability to show 3D content. It is a scaled-down version of the desktop Java platform 3D API. The M3G API is a scene graph API, which means it knows how to render scenes that are described as a hierarchy of groups and objects. How to use the API is discussed here.
   
   Section: V Storage and Resources
   Chapter 14. Record Stores - MSA devices provide three ways to work with persistent storage. The first way is with record stores, which are tiny databases that contain records. The official name for this API is the Record Management System (RMS), which is covered in this chapter.
   Chapter 15. Reading and Writing Files - MIDP devices often have some kind of hierarchical file system. The PDA Optional Packages define a FileConnection API that provides access to a device's file system. It is a mandatory part of MSA and MSA subset. The FileConnection API is the subject of this chapter.
   Chapter 16. Contacts and Calendars - The Personal Information Management (PIM) API provides access to contact lists, calendars, and to-do lists on mobile devices. The API is the subject of this chapter.
   Chapter 17. Mobile Internationalization - A fancy phrase that means making your application run in different languages. Internationalization is handled by Mobile Internationalization API, the subject of this chapter.
   
   Section: VI Networking
   Chapter 18. The Generic Connection Framework - All network access in MIDP devices works through the Generic Connection Framework (GCF). The fundamental idea of GCF is very simple. Your application supplies a connection string, and GCF hands back the corresponding input and output streams.
   Chapter 19. Text and Multimedia Messaging - This chapter covers the Wireless Messaging API (WMA) which extends this capability of transmitting and receiving text messages to MIDlets.
   Chapter 20. Bluetooth and OBEX - teaches you the fundamentals of Bluetooth communication but does not attempt to cover the Bluetooth and OBEX (Object Exchange) APIs in meticulous detail.
   Chapter 21. XML and Web Services - describes how to use the XML parsing API, how to call Web services using the JAX-RPC API, and how to work with RESTful Web services. Examples will show how to parse a Rich Site Summary (RSS) feed and how to write a RESTful client for the Flickr photo-sharing service.
   Chapter 22. Session Initiation Protocol - Session Initiation Protocol (SIP) is a standard way to set up a call, videoconference, or other session between two network endpoints. This chapter is a broad overview.
   
   Section: VII Multimedia
   Chapter 23. Playing and Recording Sound and Video - Discusses the Mobile Media API (MMAPI) for working with images, audio, and video. There are some good detailed examples here.
   Chapter 24. Advanced Multimedia - expands on the promise of MMAPI with 3D audio, image processing and encoding, camera and radio control. The basics are in the book, the online software has more detailed examples.
   
   Section: VIII Security and Transactions
   Chapter 25. Smart Cards and Cryptography - an introduction to the Security and Trust Services APIs (SATSA). SATSA actually contains four separate APIs. Two of these are for communicating with smart cards, while the other two relate to cryptography. Only the basics are covered.
   Chapter 26. Mobile Payments - discusses The Payment API, which provides MIDlets with a simple API for making payments.
   Chapter 27. Know Where You Are - discusses the Location API for using GPS to determine where you are or where you want to go.
   Chapter 28. Application Architecture - a good capstone chapter presents ideas to help you with your application design. This chapter gets you in the right frame of mind to design your own application effectively and imaginatively.

5 comments about Beginning EJB 3 Application Development: From Novice to Professional (Beginning: from Novice to Professional).

1. Over the course of a couple weeks I read the entire book. I found that the book provides the most value by doing this. I had some limited experience working on existing EJB 1/2.x apps and have developed some prototype apps using EJB 3 also. The book really filled in some gaps in my knowledge including the history of the specs. I don't know that I would use the book for a reference though. I will probably refer to the spec to get the details.
   
   Although I didn't follow the directions provided to get the code samples running in the Glassfish server I appreciate the detail the authors went through to help the reader. The directions seemed to be complete. I didn't feel like I had to go through this step because I already have code up and running deployed to Glassfish using Netbeans.
   
   Sometimes I felt like the book didn't provide enough detail using nontrivial examples in certain areas such as the lifecycle and interceptor methods. Other times it provided too much detail such as the examples using JSF. I'm about to start a project using EJB3 and JSF so I found the discussion of integrating JSF into an EJB3 app interesting but the average reader would probably be better of referring to a book specifically on JSF.
   
   The sections on performance testing were some of the best in the book. They explained how to set up the tests and the important statistics to look for. I was looking for some information on unit testing EJB3 outside of the container and was disappointed not to find any.
   
   Overall I thought the book was excellent and would recommend it to both developers new to EJB3 and more experienced ones that either want a good overview of the subject or are looking to migrate apps using the older specs. The book didn't blow me away but I still found it hard to find even minor points to be critical of. The book has definitely given me the confidence to apply the new technology appropriately.



2. EJB 3 took its time to get mass acceptance, primarily because many Java developers did not have great memories of earlier versions of EJB. EJB 3 is however now gaining momentum and a number of EJB 3 books have hit the market. Beginning EJB 3 is a Beginner - Intermediate level book from Apress.
   
   In their letter to readers, the authors say that "With EJB3, the EJB spec developers had at last settled upon a model that really made sense. Coming from EJB 2.x world, it was like a breath of fresh air.." So EJB 3, is widely believed to be a significant step forward in simplifying enterprise Java development.
   
   The book uses several examples to demonstrate the new found simplicity of EJB 3. The free, open source application server GlassFish, which is the reference implementation for all specifications in Java EE 5 is used in the book.
   One of the important changes in EJB 3 was the introduction of annotations. However XML descriptors are still very much around. Java development has a tradition of always taking the most complex approach and if there isn't one, it works at complicating the simple approach. So after the initial excitement about annotations, there's again uncertainty. It's now (Annotations) vs (XML) vs (Annotations & XML mix). On this, the authors say "A simple rule we follow is this - If we need to decouple our entity and bean classes from their EJB 3 metadata, as when we want to use the same entity classes with two different inheritance strategies, we put our metadata in XML. Otherwise, we stick with annotations" "And don't forget...whenever metadata is specified for an element using both XML and annotations, the XML always wins"
   
   Chapter 1 introduces EJB 3 and gives us a quick overview of all that's changed in EJB 3.0. Chapter 2 looks at session beans and dives into using dependency injection in session beans, interceptors, callbacks, local vs remote access even before a session bean example is deployed. So the book kind of works with the assumption that you have tried your hand or as some would say "burnt your fingers" with an earlier version of EJB. The book runs the risk of being too fast for someone who might be trying EJB for the first time.
   
   Chapters 3 and 4 look at entity beans and persistence and Chapter 5 looks at message driven beans. Chapter 6 begins with the basics of Web Services and then moves on to the various web services specs and how you can use the @WebService nd @WebMethod annotations to quickly get your app web services ready.
   
   Chapter 6 to 11 deal with web services, integration, transaction, performance and migration from version 2.1. The good thing about these chapters is that the authors first introduce the concept, the need and the basics and then delve into the actual development. Problems while deploying EJB across applications servers were commonly reported with earlier EJB versions, so it's good that the authors have dedicated a chapter to EJB 3 deployment and planning.
   
   JSF has become more or less the standard for new Java web development. So Chapter 12 is a useful one as it shows EJB client development using a simple JSF + EJB 3 application.
   
   Overall, for a beginner-level book I think it would have been good if there was more content and hand-holding in the initial chapters, as Apress has a book "Pro EJB 3" which could look at the advanced EJB topics in detail. But if you have been on the enterprise Java scene for some time and have tried out EJB earlier, this book will get you going with EJB 3 in no time.



3. I thoroughly enjoyed reading the "Beginning EJB 3 Application Development" book. (I'm a senior programmer, have been using Java since 1995 and am co-founder and co-leader of the Austin Java Users Group.) The book started off with a nice executive overview of EJB 3 and the usability problems with EJB 2 that it solved.
   
   On a side note, I have been impressed by the EJB 3 working group for making such a bold move forward while remaining backward compatible with the old specification. Typically as a given software technology matures and becomes well established, the software infrastructure and APIs develop a lot of inertia that leads to significant resistance to large improvements. The EJB 3 working group overcame this pressure and produced a bold new elegant design that should be a pleasure to work with. It always takes time and a lot of work to create a clean simple design and I think the team has done that finally with EJB 3.0. The authors captured the advantages of the new specification and leveraged the new capabilities and simplified approaches.
   
   I appreciated the section on setting up the environment and the mechanics of compiling and deploying the EJBs using the free GlassFish application server. Just enough detail of the incantations to work with the server was given in order to get started without getting bogged down in lengthy setup descriptions. The authors provide examples up front to get you quickly up to speed with the new paradigms. They continuously mix clear examples with explanations to ensure that you gain an incremental understanding quickly.
   
   Stateful and stateless session beans are covered. Comparisons are made between annotations and the XML descriptor files and the rules to override are clearly defined. I enjoyed the section on interceptors and was impressed how easy it is with annotations to intervene with preinvoke or postinvoke operations. I liked that the authors are succinct with their explanations. The authors get to the point quickly, which I appreciate given the volumes of material one needs to absorb to keep current in this industry. The examples start off simply and gain complexity as more features of the spec are added to the application. Useful process flow and database schema diagrams typically accompany the examples to clarify the problem.
   
   Early on I found a couple of small bugs in the sample code (mostly caused by a moving specification), but the authors have been very proactive about posting erratas on the website.
   
   JMS and message driven beans are discussed as well. A quick overview of JMS and MDB is given with a succinct, but very relevant status-notification example. The mechanics of setting up a JMS topic and a JavaMail resource is described, as well compiling and deploying the MDB.
   
   There is a nice brief overview of web services and the associated standards. A useful credit card verification example is provided complete with the mechanics of compiling and running the code.
   
   I thought the sections on the Java persistence API were well done. I felt the authors covered most of the typical issues that you run into when mapping Java objects to a relational database schema. Advanced sections covers hierarchical modeling and the advantages of user-defined primary keys for instance. Concrete table definitions and their associated Java mappings are illustrated.
   
   The authors demonstrated that they have solid design experience since they intermingle practical sage advice and admonishments througout the book.
   
   I thought that there should be more advice on forward versus reverse engineering of the database schema since there are a lot of lousy database schemas out there that have been generated directly from the Java object model.
   
   The authors provide a good overview of container versus bean managed transactions. The mechanics of using each approach and the associated trade offs are illustrated. I like that the authors included some of the basic information on transactions such as the definition of ACID for instance. (I need to refresh my memory every so often.)
   
   The performance benchmarking section was very well done. A clearly thought out methodical approach to performance testing is given with what I thought were surprising results between the two mapping approaches (single table inheritance and inheritance through joins). An overview of a very useful load testing tool is given as well. Salient performance comparisons between EJB 2 and 3 are also presented.
   
   For the seasoned EJB 2 folks, there is a chapter on migrating the EJB 2 applications to EJB 3. This chapter may help in understanding what EJB 3 does for you compared to EJB 2 as well.
   
   In summary, the book was definitely worth my time to read. Beginner and advanced programmers will learn from this book. I'd definitely recommend getting the book and I look forward to working with EJB 3 in practice.



4. The book is a good summary of the specs and gives a nice introduction to the new things in the world of EJB 3. The section on converting your v2 apps to v3 was particularly useful. Appropriately marked "From Novice to Professional" the book touches on many aspects of the J2EE world in a manner that treats the novice with care and the professional with grace and insight/direction.
   
   On the negative side... The book has a lot of repetition. Many pages are nearly identical (especially the sample building) and could have been condensed and made more useful by sticking to use of Ant and examination of the scripts. The same can be said for the "copy-and-paste nature" of some of the writing. However, one can tack that up to "consistency in writing style."
   
   The book is not what I would call an "easy read," but was informative none-the-less. It serves as a starting point and base reference.
   
   The authors have provided a generally well-rounded book and I would definitely recommend this to others.



5. Seems like a good book when you skim it in the book store. After you buy it and start reading, you realize that (a) there are many errors, and (b) APress (publisher) has "disappeared" the errata from their web site. Nice. I'll be contacting APress about a refund (unfortunately, I write in my tech books :-)

5 comments about Ruby by Example: Concepts and Code.

1. Superb introduction to Ruby and important programming idioms that every Rubyist should know. Shows you a small chunk of code, with significant lines numbered, and follows the code with descriptive paragraphs that show you what the code is doing. In effect, you learn how to read the code as you go through the book, starting with basic material and getting more advanced as you go along. VERY nicely done.



2. 'Ruby by Example: Concepts and Code' is the perfect reference for anyone that wants to learn how to use Ruby, one of the hottest programming languages to come around in some time. With over around 300 pages of content spread across 45 examples, this book will give you all the basis you need to go from a non-Ruby user to someone writing good code immediately!! I think that the No Starch line has some of the most unique layouts you will find from any publishing line. Chapters are usually broken up into small manageable chunks that make it easier for the reader to actually learn and dissect the information they are taking in, fonts are clear and concise, and it's just an enjoyable easy read all around. While this may seem low in importance I don't think that's the case at all. Especially for a book where the user base is someone new to a language, environment or tool, I want a book that is easy to learn from, fun to read and makes me actually want to LEARN and look forward to the next chapter(s). If you want to learn Ruby and build on your development skillset, pick up this book and move to the fast lane!!
   
   ***** HIGHLY RECOMMENDED



3. Ruby By Example seeks to teach Ruby by introducing a series of small scripts, explaining how they work, often by showing some examples in irb, Ruby's interactive shell, and reinforcing the explanations with some suggested modifications to the script to highlight the principles just expounded. The closest examples in other languages I'm aware of are Dive Into Python and (to a lesser extent) Wicked Cool Perl Scripts.
   
   This is a very nice idea, and there are some examples that are a cut above the usual fare: chapter 9 includes a Bible Code generator, and an implementation of the 'methinks it is like a weasel' sentence natural selection program from Richard Dawkins' The Blind Watchmaker. There's also mention of memoization, profiling and benchmarking, the Schwartzian transform for sorting, and even Symbol#to_proc. There's also quite a gentle introduction to Rails, which is probably sufficient for someone new to Ruby and Rails to move onto Ruby for Rails.
   
   However, the execution isn't always perfect. Probably the biggest downside to this pedagogical approach is that there's not really one obvious place to describe how a particular feature works in depth, or the focus moves away from its practical use in a script. As a result, many of the explanations are compressed. Chapter 1 provides a 'crash' description of object orientation in 9 lines. Chapter 3 first mentions hashes, but compares them to functions, and not to arrays. Tail recursion is defined in a 4 line footnote in chapter 7. If you already understand these concepts, you'll be fine, but they won't teach you anything. If you don't, they aren't very helpful. At a couple of points the book also insists that everything in Ruby is an object, but code blocks (among other things) aren't until they're wrapped in Procs. For the more functional-esque techniques advocated in the book, this is a subtle point which could trip up a beginner.
   
   Also, some of the examples are weak. Chapter 4 rushes through regular expressions, using them to compress whitespace, but why not also mention String#squeeze? Chapter 5 uses regexes to deal with XML and it gets the job done, but advice on using a real XML parser might have been more useful in the long term. Chapter 6 contains a truly contrived Buffy the Vampire Slayer-related example.
   
   This isn't a bad introduction to Ruby, and it's a very admirable attempt to do something different, but I wanted to like it more than I did. If you already know some object oriented programming, this could make a good companion to a more tutorial-style book, like The Pickaxe.



4. If you want to learn Ruby quickly and you can only afford to buy one book to do it with, this is the one I would buy! It has interesting little projects with well documented code which introduces you gradually to more advanced topics in the language. It is not a cookbook, but rather, a very well picked selection of programmes where new concepts are thoroughly explained and older concepts are reinforced. There are "hacks" to just about every script and I was able to learn more from this than I did from grinding through the Pick Axe. Amazingly, now when I pick up the Pick Axe it seems accessible!
   
   Well worth the investment!



5. The book came very fast in the mail. It was new in quality. I am able to teach myself Ruby from the book.

5 comments about Foundations of Security: What Every Programmer Needs to Know (Expert's Voice).

1. Our collective security against threats such as phishing, denial of service and online fraud in general depends not only on our own actions, but also on those of others. While other users may affect your security by their actions (or lack thereof), the most important person in terms of your security is the software developer. This is a book written to help software developers identify common problems and create security-conscious designs.
   
   This easily accessible book describes common problems in an instructive manner. It explains what will and what will not work, reviews good design principles, and offers an overview of commonly used cryptographic techniques. If every developer lived by the guidelines of this book, we would be in a much better shape than we currently are.



2. While some of the good security books for software developers need to be updated, this is, in my opinion, a much needed new security book for programmers. It is clear yet not too formal with good examples. Even if you have done a bit of security programming, chapters 7 and on are definitely worth the read.
   
   Although this book doesn't have all the answers (e.g. no comparison of web programming languages), web programmers will not be disappointed and my guess is that most web programmers need to read this book.
   
   The authors work at Google and are dealing with some of the nastiest problems the Internet has to offer. They are very good communicators, have written some of the best recent papers and I'm glad to see Neil Daswani just started a blog on blogspot.



3. An excellent book for new programmers. The first part of the book provides a very good overview of security concepts. Chapters 5-10 detail different attacks and their defense. At 290 pages, the authors don't waste the reader's time. Information is well covered with enough detail for most readers.
   
   Throughout the book the authors present code examples on exploits and their defense. Even through the examples are written in different languages, the authors explain the code clearly. The reader doesn't' have to be familiar with the particular language. I haven't written anything in Java in over six years, but had no problem understand the Java examples.
   
   If you are a new programmer or haven't read a book on security recently, this would be the book.



4. Having an English major as one of the authors makes a big difference. The expertise from the other two reknown authors is communicated in simple, easy-to-understand language.



5. I found this book as a collection of google-able basic material. The book provides zero guidance to a programmer on the basics for how-to implement security in code not just alphabet soup because "the devil is in the details". I wrongly picked this book and now it just fills an odd spot of our IT library as this book has no relevance to a Microsoft or Java programmer or Web 2.0 (J*Script) programmer. With Security taking mainstream in every aspect of programming and every component of IT stack - this book did not provide any confidence to an average developer aspiring to securing SOA or J2EE/.NET application. As a whole, the book reflects poorly on the technical content maybe I am not the intended audience of this book.

4 comments about Scripting Recipes for Second Life.

1. This book provides a very basic introduction to LSL scripting. Everyone of the scripts in the book can be obtained as freebies within SL and much more can be learned about LSL in the SL Wiki and various other online tutorials and references. Speaking of references, this book had none. One of the few reasons I keep programming books around is that its nice to be able to flip open a book and get a quick answer to a programming question. Well, forget it. This book has no reference section and a marginally useful index.



2. I liked this book a lot. This book is useful for both a beginner who wants to get started in the basics of LSL and also very handy for someone with scripting experience who wants a nice inventory of ready to use scripts that can be easily dropped onto an object.
   For the beginner, the book starts out with an overview of the Linden Scripting Language (LSL) and descriptions of the most commonly used functions in LSL. The explanations are clear and contain examples for each newly presented concept.
   The real value of this book though is in the wide array of useful scripts provided. When I started in SL, I bought various in world items which did things using scripts. I realize now that if I had had this book then, I could have made these objects myself, which at least for me is more fun than just spending Linden dollars for someone else's not modifiable way of doing something.
   
   Here is a list of some of the scripts included in this book.
   Buildings: Splashing water, Open door, Owner locked door, Mult-User lockable door, Teleport pad, Elevator
   Particle Effects: Basic particle emitter, Chimney, Leaf generator, Jewelry, Explosion
   Vehicles: Car, Boat, Helicopter, Super car
   Scanners: Avatar radar, Notecard giver, Automatic door, Traffic scanner
   Miscellaneous recipes: Avatar cannon, Analog clock, Weather station, Slide show, Notecard controller slide show, Announcer script, Online indicator
   Commerce: Camping pad, Simple tip jar, Club tip jar, Vendor script
   Rental Property: Rental script
   Weapons: Basic gun, Multi-bullet gun, Bullets for the guns
   Wearable Objects: Parachute, HUD parachute, Jet pack, Anti push bracelet
   
   The cool thing I found from the book is that all of the example scripts have been implemented on objects and are freely available for copy/modify at the authors island in SL.
   
   I would highly recommend this book for anyone interested in writing scripts in SL (except perhaps a seasoned scripter who might find this book a little too intermediate).



3. When I first got this book, I was frustrated with it because it jumps deep into LSL and makes an assumption that you have a basic understanding -- it is not an introductory book. And to be fair to the book, it doesn't hold itself out to be an introductory book. If you are looking for a beginner book in LSL, get something else!
   
   BUT, after I spent some time learning LSL through other sources (online Wiki!) I found that the book actually has become really useful to me as a way to understand LSL. In other words, don't make this your first book on LSL, but maybe make it your second.



4. Exactly what I looked for. Simple examples that allow me to quickly get what I want and learn the language.

5 comments about Business Process Management with JBoss jBPM.

1. A couple of interesting things happened to me recently. I have been designing a system with a workflow side to it and the thinking was that the JBoss jBPM workflow engine might be a good fit. So I was wading into the documentation to see if I could make some sense of the thing. Like a lot of large software products, jBPM comes complete a circus full of acrobat files, documentation that is detailed, in depth and kind of, well, incomprehensible. At least for the beginner. I'm sure once I get out of this initial spin up phase, I'll soon have all of my business processes humming along, but I have to admit that so far it has been rough going.
   
   Which brings us to the second interesting event: out of the blue I got an email from the PackIt publishing company asking if I would like to review one of their books, Business Process Management With JBoss jBPM by Matt Cumberlidge. They would even send me a free copy. It is dangerous to ignore luck like that and so here we are.
   
   Cumberlidge's book opens with an outline of what can only be described as the business process management philosophy: understand your business process, automate it (or a part of it) with a workflow engine and then iterate to improve. The book then launches into its single case study, the heart wrenching adventures of Bland Records in its quest to turn musical talent into profit. Thank goodness - if I have to sit through one more online pet store implementation I was going to get violent. After taking us through an analysis of the Bland workflow (aren't they all bland?) Mr. Cumberlidge, talks briefly about the architecture of jPBM and then jumps right into is main topic: the details of getting jPBM set up and flowing that work.
   
   And I do mean the details - this book starts by explaining how to install Java and moves on to using the jPBM Eclipse plugin to build the workflow definition. From there we segway into creating jBPM based user interfaces and deploying the whole thing (in JBoss, naturally). We finish up by discussing such real world issues as monitoring your workflow, sending email alerts when your process starts to smell a bit fishy, and deciding if the whole effort was worthwhile.
   
   There is a lot of detail in this book - many, many screenshots, lots of handholding through menus and dialogs. Perhaps a little too much for me, but I'll make allowances since Cumberlidge's focus is so squarely on helping the reader become productive with jBPM rapidly. The details are all very Windows oriented, but this Linux/Mac user had no trouble translating them into my OS as needed.
   
   Aside from the technical content, there are a couple of things I really like about the book. The text is clearly written (if just a tiny bit wordy). Best of all, Mr. Cumberlidge writes in an easy, informal style. There is none of the "consider this" and "therefore it may be concluded that" nonsense that makes so many technical books read like 700 pages of stereo instructions. Be aware that this is a very focused book: it is less like "jPBM The Missing Manual" and more like "jPBM The Missing Quickstart Guide". Still, Business Process Management With JBoss jBPM is a competent book that fills a real gap.



2. This book is described as A Practical Guide for Business Analysts and is intended for Business Analysts who are not familiar with, or who are new to the JBoss jBPM system.
   
   The book takes an iterative approach to Business Process Management (BPM) and starts by describing why we might need BPM and what its benefits to an organization might be. The first chapter of the book continues to describe some scenarios where BPM is expected to be beneficial to a company (for example "Processes are carried out in disparate teams" and where BPM would not be used (for example where it would impose a disproportionate burden on a small business). Chapter 1 ends by introducing a suggested six-phase project lifecycle, which is described within the remaining chapters in the book.
   
   The first stage of implementing BPM describes how to set up a BPM project and includes details on Project Initiation Documents, scoping the process, process analysis and scoping out the process workflow. Sample activity diagrams and project documentation (e.g. RACI matrices) are provided as examples.
   
   After describing the business process, the book details how to model the process using JBoss jBPM including details of how to install the jBPM engine, the JBoss application Server and the jBPM designer. The jBPM designer is an Eclipse plugin, so some readers of the book may already be familiar with this application. It should be stated however that the target audience for this book is not software developers, but Business Analysts (although there are sections within the book on how to customise jBPM processes using Java code). This section on implementing a process using JBoss jBPM is one of the larger chapters in the book and covers details of jPDL (Process Definition Language). As with the rest of the book, this is described in a clear and easy to understand tutorial approach that should provide the readers with sufficient information to build their own processes after completing the book.
   
   In order to deploy and test the business process on JBoss jBPM, a user interface is required which is the subject of the next chapter in the book. This chapter described how web based user interfaces can be automatically generated from within the process editor and then customised by a business analyst. The web based user interfaces are defined using Java Server Faces (JSF) with the Facelets view technology. The book does not go into great depth about either of these technologies, rather it assumes the Business Analyst will be making minor modifications to these pages.
   
   The sample process within the book is developed and deployed onto a standalone JBoss workstation. Details are provided however on how to deploy the project onto a production server using a production ready database.
   
   Sometimes within a business process it is necessary to invoke custom actions that can be developed using Java code. A brief description is provided showing how to develop a custom action to extract data from a process and insert it into a separate database. This is provided as an overview of how custom actions can be developed, however the focus of the book is on developing and deploying business processes in an iterative manner rather than on in depth analysis of the Java code required to develop custom actions.
   
   Finally the book concludes with details of how process monitoring can be achieved using the SeeWhy business intelligence platform.
   
   This book follows a tutorial style approach describing an iterative procedure for developing BPM applications deployed to the JBoss jBPM engine. The book takes the reader through the whole project lifecycle, from identifying target processes, building prototypes and finally getting project sign-off. The style of the book is easy to read whilst still remaining informative. This book is recommended for Business Analysts using or looking to use the JBoss jBPM suite of tools



3. This book really helped me understand more about jBPM. However, I tried to implement the example and it only worked partially. After some time with help from folks on the jBPM user forum I was able to login using the accounts from the demo sql scripts, but have not been able to get the tasks forms to come up for that user.
   
   The jbpm console is very different from the book even though the publication date is less than one year back. I've posted alot of questions to the publisher but have received no responses.
   
   I think I will continue to try and get this to work but wish the author would publish some notes to the publisher web site to help people.



4. This book is a easy-to-read, nice, brief introduction to BPM and BPMS using jBPM tool.



5. The book provides a very good overview of what business process management is, its benefits and how it can be done with jBPM. This relatively complex subject is helped alot by a clear and to the point writing style. A single case study is worked through the book which also assists the reader in understanding the context behind BPM. Unfortunately this book suffers by trying to be too general and not focusing in on the process management or programming aspects of jBPM. As a result if you are a programmer you will probably feel the code examples given are not deep enough, whilst in contrast those not used to JBoss/Java will probably feel overwhelmed when code samples are given. This is certainly not a bad read, but at the end of it you are left feeling there is a lot more to jBPM than what was briefly touched on...

4 comments about OpenGL ES Game Development (Game Development Series).

1. I was pleasantly surprised to see a book on OpenGL ES already in commerce after such a short time from the birth of the specification and first implementation. Indeed this book, as said in its preface, came out in "cell-phone time", (that is, very quick) but unfortunately also in "cell-phone-quality" (that is, very poor). It is an incoherent puzzle containing disparate info about EGL, some basic considerations about OpenGL ES functionality, audio for mobile devices, fixed point math and advertising for a few commercial game engines. If you think that looking hard enough you will find at least some info on how to choose and configure your development environment, to see working code for some basic functionality and maybe a little game.. well you are sadly mistaken. Another "book" hastily put together to make a few extra bucks at the expense of the unsuspecting reader. Buy only if love rough toilet paper.



2. I have finally finished reading this book. I found most of the information in this book very helpful. I've been developing 2D Java games on cell phones for a while. I found a lot of great infomation on OpenGL ES and EGL. There is enough here to really get started and some great insight on how to do fixed-point math. I found the sample code lacking at little and there isn't an actual 3D game from cover to cover, but the chapter on writing an OpenGL ES game was pretty good insight from a real 3D professional game developer. The audio chapter could be left out and the book still would have been good. If your looking at learning OpenGL ES gaming for cell phones you should at least consider this book as a good starter.



3. I've been reading up on OpenGL ES and just finished my first commerical game project that will be using OpenGL ES for a phone that will be out soon. I really enjoyed this book and it was a great help for our team to get the right info and tools. Lacking a full game, but not needed to get all the info you need - and every game developer already knows how to write a game mate :-)



4. The book does not talk much about OpenGL ES, but lots of the difference between OpenGL and OpenGL ES. It is good for the people that are experienced in PC 3D graphics.

5 comments about Professional Visual Studio 2005.

1. Yes this book is riddled with typos and coding errors, but it's still a very well written and informative introduction to VB 2005.
   The chapters are really easy to read (not like normal textbooks), with solid examples and small end-of-chapter exercises to reinforce ideas.
   If it had been properly proofed, it would easily get 5 stars.



2. Try as hard as I can, I cannot find a purpose in this book other than for the authors to make some money. It barely touches on the options in VS2005 without any concrete direction or in-depth description of why to use the features. I have found that the VB2005 book I purchased at the same time as this ("Visual Basic 2005 : The Language") provided much better coverage than this book
   I would NOT reccommend this book to anyone. You would find a much more effective use of your money by buying the above book or a book on the targer language in VS2005 you are using



3. Too much of this book has no depth and is repeating what is written on the screen.



4. I received this book within a few days and the book was in great shape. Nice job.



5. I was expecting a more detailed book on VS 2005, but it wasn't. However some people might find this book useful.

5 comments about Beginning Web Programming with HTML, XHTML, and CSS (Wrox Programmer to Programmer).

1. This will absolutely be the last Wrox book I bought. The annoying, condescending author's photo on the cover aside, this book is extremely verbose, to the point of distracting the reader from really learning anything. For example, it seems on every other page the author feels compelled to tell you that XHTML is just the successor of HTML (he must of thought of the typical reader as totally dumb) and he has a God-given talent of saying so in far more words than necessary each time. Another example: when he gives you some sample code, he would do it step-by-step, and each step would repeat teh same code that was already printed before! What's more, in teh "how it works" recap section, he would then re-print the entire code segment! This book weighs in at over 600 pages, but the contents could easily have fit on half that. Talking about killing trees.
   
   The content quality itself is also quite lacking. The book is neither a tutorial nor a reference, but seems stuck trying to be both. For example, when a HTML element is introduced, say , the author gives you a little overview and then just lists the attributes one-by-one. Some examples are given, but these are often on a diffrent page from the definitions so you have to turn the page back and forth. Extremely annoying. The chapter on CSS is very confusing, and the two chapters on Javascript won't teach you anything. I don't know how anyone could have rated this five stars; maybe they are the author's friends and family.
   
   In short, I totally regret my purchase. I should have gone with a O'Reilly book. I blame it on Amazon: when I wanted an HTML book Amazon didn't have any O'Reilly HTML books in stock!



2. I had an interest in web development years ago when I invested some time going through free html tutorials online. I also spent some money on a couple of books on html as well as JavaScript, but never finished what I started. About a month ago I purchased this book to get my feet wet again, and I have to say that this book served its purpose.
   
   The title does say "Beginning Web Programming..." and the material definitely fit the title. Having finished reading the XHTML and the CSS portion of this book I feel very comfortable in writing XHTML documents. It also served as a handy, although heavy, reference during my practice coding sessions.
   
   The CSS portion of this book took up two chapters. It served as a great introduction to CSS and it left me with enough know how to write simple stylesheets. As I tried to write more complicated stylesheet like defining rules for layouts using
   , I found myself struggling and decided to purchase a more advanced book on CSS.
   
   There are two chapters devoted to JavaScript on this book. From reading the titles of those two chapters I am under the impression that it will give you enough knowledge to download pre-written JavaScripts online and be able to effectively implement it on a webpage. I complete skipped these chapters as I had purchased a separate book on this subject.
   
   All in all, this is a good book for beginners who want to gain the fundamental knowledge about building a website. If you want to become a professional this book serves as a good starting point, as it will equip you with the fundamentals and lead you to your next step in your studies to become a professional Web Developer.



3. I have only dabbled in programming before, mainly in C#. I am well-pleased with this book.
   
   PRO: 1. This book was a solid introduction to HTML and XHTML. What impressed me most is that the author gives you the fundamentals of the HTML language, and also teaches you modern Web methods using CSS.
   2. Follows a logical order, putting you into practice from the first chapter.
   3. Good primer for [...]and general web development for the new programmer. In fact, if you are interested in XML, I would study this book first, and then move on to XML. By the end of the book, you will have mastered many concepts of XML, and will have learned HTML in the process.
   
   CON: It could have used a better scheme of highlighting points, bulleting, etc. But the dedicated reader will overcome this small failure.



4. I have gone from being frustrated with this title to disliking it intensely. I would suggest alternate materials such as the O'Reilly publication, "HTML & XHTML: The Definitive Guide."
   
   First, "BWP w/HTML, XHTML, and CSS" is dated. Its publication date is 2004. This text often complains that features "are not supported by browsers" that have since been updated. There are more current materials published within the last year. (And on the subject of browsers, I have not found a single mention of Mozilla, Safari, or Opera in this book).
   
   Second, the author's presentation is often difficult to follow. Concedely it is a difficult subject to organize when there are "live" tags, "deprecated" tags, the ongoing effort to separate stylistic elements into CSS, and different browswers' idiosyncracies with which to deal. Duckett, however, is next to hopeless in separating these subjects.
   
   Most critical is the fact that this book is a very unhappy blend between an introductory tutorial and a reference "bible." Duckett will introduce a basic concept -- say, "tables" and will then load up on all of the attributes that the element might take. Learning the key ideas gets lost in the process. The book often leads off into asides and references to more advanced topics that will easily lose the initiate. It is no coincidence that several of the reviews here use the word "intermediate" in connection with this text.
   
   The author does not seem to understand the principle that individuals learn by working from the "known" step-by-step to the "unknown." Instead, he seems to rely upon the idea that "if I throw everything at them in a random fashion, they'll figure out a good amount of it."
   
   As an example of its "random walk" approach, Chapter 4 first provides a sound introduction into the use of colors and making references to images. The closing section of the chapter, however, branches off into a discussion of the