5 comments about Beginning J2ME: From Novice to Professional, Third Edition (Novice to Professional).

1. If you need a no-nonsense, down-to-earth, non-philosophical guide for how to write Java applications for mobile/cellular phones, this is the best book you can buy today. It's very concrete, with lots of working examples etc, and leaves out the fluffy stuff that's so typical for computer books nowadays. The book is an especially good starting point if you are into applications (communicating or non-communicating), but the APIs for writing games are also covered. I hadn't programmed in Java before (yet C and Visual Basic for many years), but I had no problems developing mobile applications after reading this book. Being such a concentrated book means it also works as a reference for when you need to look things up. All in all, this book is for real developers and strongly recommended.



2. this book is very easy to read..good technical explanations.,
   easy to understand JME model concept..
   
   reallity from beginner to professional..
   very sugested..



3. I was still fairly new to Java, but noticed that there was a J2ME study group near me.The bokk helped me both with Java knowledge in general as as well as J2ME in particular
   Jana
   Leader, San Gabriel Valley Java Users Group



4. I have always been under the impression that when buying a book of technical nature, one is supposed to purchase a piece of an author's hard-earned, over-the-years experience, otherwise it's just paying for a documentation reprint. Such an experience can be conveyed to a reader in at least two major ways: (1.) a very well-organized, thought-through and consistent presentation of fundamental - yet often complex - concepts (e.g., "Head First Java" by Sierra), or (2.) an in-depth, unique perspective on advanced topics not to be found anywhere else (e.g., "Effective Java" by Bloch). Unfortunately, as far as I can tell, this book delivers neither. As an example of the lack of the former: the discussion of J2ME Configurations and Profiles is almost as muddy and inconsequential as the specification site itself. As an example of the lack of the later: the entire Performance Tuning chapter, a subject I would expect to be critical for success with a mobile platform is about 10 pages, entire page -sized screenshots included. Topics such as real-world compatibility of J2ME across different vendors' implementations is almost not mentioned at all. So, what's left? Basically, a few hundred pages of short, introductory chapters on J2ME APIs, reading pretty much just like Sun Developer Network Reference technical articles or implementation-oriented CodeProject pages. Don't get me wrong, the book authors' hard effort is clearly visible, but you can as well google for "J2ME Record Store tutorial", a "J2ME Bluetooth API tutorial" and so on.



5. Never programmed in java beyond the Hello World type application and bought this book. This along with one that covers learning the syntax of java and I have written two useful apps that I have on my phone.
   
   I have something pretty complex as my ultimate goal (although text based - not a game) and feel confident this gives me enough to accomplish that goal.

5 comments about The Rational Unified Process: An Introduction (3rd Edition) (The Addison-Wesley Object Technology Series).

1. Target Audience
   IT professionals who need to learn about the Rational Unified Process (RUP)

   Contents
   This book is a relatively high-level overview of the entire RUP process.

   The book is divided into the following chapters: Software Development Best Practices; The Rational Unified Process; Static Structure: Process Description; Dynamic Structure: Iterative Development; An Architecture-Centric Process; A Use-Case-Driven Process; The Project Management Discipline; The Business Modeling Discipline; The Requirements Discipline; The Analysis and Design Discipline; The Implementation Discipline; The Test Discipline; The Configuration and Change Management Discipline; The Environment Discipline; The Deployment Discipline; Typical Iteration Plans; Implementing the Rational Unified Process; Summary of Roles; Summary of Artifacts; Acronyms; Glossary; Bibliography; Index

   Review
   The Rational Unified Process, or RUP, is a software engineering methodology that attempts to map out and document all parts of a software development project. It's extremely comprehensive, but it's also adaptable to whatever level of effort is appropriate for your situation. This book, The Rational Unified Process - An Introduction, is a good start to begin your understanding of RUP.

   First off, let me say this is not an easy read. It's a good book with all the information you need to know to start using RUP, but the information is dense and highly detail oriented. Like most developers, I'm more oriented towards coding and testing. But realistically, you need to know what the system should do before you get to the coding piece. RUP helps to put all that into a formal framework so that the necessary things will get done in the proper order.

   While the entire RUP framework might feel overwhelming, the author makes sure to let you know that you can adapt the RUP to meet your situation. If you are adding a function to an existing system, you will be more focused on use cases, development, and deployment processes. The author does a good job in segmenting the information so that you can more easily focus on your needs.

   You should also not consider this the end-all volume on RUP that you will ever need. Kruchten doesn't try to detail specific techniques like use cases or UML. You will learn where they fit in to RUP, but you will need additional information on how to implement use cases or UML diagrams. Consider this the volume that allows you to place everything in a mental framework so that you can figure out what you will need to know going forward.

   Conclusion
   If you are considering or in the process of implementing RUP, this is a book you should be studying. It's not an easy read, but it will give you the overview you need to understand the process and concepts.




2. This book introduces the logic behind Rational Unified Process (RUP). RUP is a novel idea. It puts several good practices in a consolidated package. What makes RUP useful is the fact that Rational provides all the necessary software tools to support this. This book does an average job in explaining the RUP. It over stresses obvious and well accepted concepts like "iterative development"; which makes the first half (6 chapters) of this book a bit boring. For a professional with software development and management experience, I found the first sixe chapters are best read at a cursory glance. The second half of the book introduces the workflows - and it is this half that I found more interesting. I finished this book as bed time readoing over the weekend - so this book is an easy reading. However this book is not about teaching how to use Rational Products. This book only gives an overview of the basis of origination of RUP. You would need another book to become an expert in using RUP.



3. It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.
   
   I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.
   
   Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.



4. "The Rational Unified Process, An Introduction" offers readers a concise and strong introduction to the topic of the Rational Unified Process (RUP). Stressing the role of RUP in unifying the entire software development process, this book underscores the importance of efficient and effective software development.
   
   The book is structured in a logical and easy-to-follow manner and makes good use of descriptive graphics. For those with an interest in optimizing their software development processes, this is a good addition to your library.



5. After starting a few books in this series, this is the one I ended up finishing because of its readability. As an introduction to RUP, this book did its job. My only reservation is that it might be a bit too formal for those unfamiliar with the RUP jargon.

3 comments about Practical JRuby on Rails Web 2.0 Projects: Bringing Ruby on Rails to Java (Expert's Voice in Java).

1. Over the past several months I have spent a lot of time searching the internet for information on JRuby, specifically looking for ways to have Ruby on Rails host Ruby powered applets. I thought I been fairly successful at gathering information until I read this book, and realized how much information I had missed. If you are working on building a production quality application or just want to learn what you can do with the current state of JRuby on Rails, try this book. It will help get you on track right away while avoiding many of the 'gotchas' that come with using Rails on JRuby.
   
   You will need to have a good understanding of Ruby, and prior experience with Rails would be very good too. I did encounter a few issues where a few commands listed in the book did not work, but JRuby and Rails being actively under development make problems like that unavoidable.
   
   This book would make a good companion for the Pragmatic Programmer's Pickaxe book as well as their Agile Development with Rails book. The projects in this book are definitely more fun than the store in the Agile Rails book.
   Agile Web Development with Rails, 2nd Edition
   Programming Ruby: The Pragmatic Programmers' Guide, Second Edition
   
   Finally, remember that one of the best ways to support open source projects like JRuby is to buy the book (written by a core developer of the project).



2. I am not in this book's target audience. Whereas the book is aimed at experienced java developers who are just getting started with rails and want to take advantage of JRuby, I've rarely touched Java but have lots of ruby and rails experience and am interested in JRuby mainly to see where I might be able to take advantage of java libraries, or ship my ruby apps into new contexts. In that respect, the book was helpful but there's probably space for a companion volume for people like me.
   
   The book takes a measured pace, introducing Rails early on and then building in different components from the Java world as it works through four different projects. Use of JDBC within a rails app, calling ruby code from Java, deployment strategies, packaging a Rails app as a .jar that can be dropped into an application server, and making use of java for interfacing with SOAP web services are all covered.
   
   Readers will probably need to spend some time experimenting with each feature to really get comfortable with them, but the book works well to get you started and point in the right direction. The introduction to Ruby and Rails is a case in point, as Ola dives right in to his examples after a brief lead-in. That may work well for experienced developers who will enjoy exploring the accompanying code, but it is worth being aware of.
   
   It did feel like there were some missed opportunities later in the book, particularly in the final project, to introduce more of Rails' "RESTful" features since that example really invited that style of design, and it would have been interesting to have some discussion of the pros and cons of treating the libraries built to interface with external services as models within a rails app, making the interface more transparent.
   
   I'm also not quite sure where the "Web 2.0 Projects" line in the title comes from. The final project interfaces with amazon web services, which I suppose might get thrown onto the "web 2.0" bandwagon, but don't go into the book expecting a series of stereotypical "web 2.0" projects. It's an introduction to JRuby on Rails for Java developers, whatever approach to the web they may be taking.
   
   JRuby is a really exciting technology that promises to help developers take another step towards picking technology based on their projects, not just the platforms their organisations may have standardised on over the past decades. If you're a java developer wanting to learn how to make use of JRuby and looking for some help to get up and running, this book is likely to give you just that.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



3. Have you had any experience with Ruby or Rails? If you have, then this book is definitely for you. Author Ola Bini, has done an outstanding job of writing a book about four technologies: Ruby, Rails, JRuby and Java.
   
   Bini, begins by giving you information about the technologies covered, why they should interest you, and an overview of the book. Then, the author shows you how to install everything you need for the rest of the book, including all RubyGems you'll be using. Next, he describes what parts it contains and things that are good to know when doing Rails development. The author also introduces many of the more practical details of Rails in the process. He continues by looking at the databases that JRuby on Rails supports. Then, the author focuses exclusively on the syntax and usage of JRuby's Java integration features. Next, he shows you how create most of the Rails code needed for the CMS application, but stubs out all rendering functionality. The author continues by showing you how to complete the CMS application by adding all the rendering functionality and also taking a look at a few alternative approaches. Then, he shows you how to use JRuby from inside a J2EE Enterprise Bean, implementing the functionality of this bean in Ruby. Next, the author also details deployment options for a JRuby on Rails application, how regular Rails deployment usually works, and how to make the situation much better with JRuby. The author also looks at the options available to consume web services with JRuby, and implements a library to search for books at [...]. He continues by showing you how to create two different libraries for JMS interaction. Finally, the author shows you how to contribute to JRuby or its surrounding projects.
   
   This most excellent book can offer you many possibilities if you use JRuby on Rails. It will help you create your first application with JRuby on Rails, and get it into production.

1 comments about An Object-Oriented Approach to Programming Logic and Design.

1. This author is imprecise in her use of terminology. She switches between similar terms for the same thing without signaling. She uses the same term for different things without signaling. She even uses incorrect terms.
   
   The author tends to use a concept in a discussion and then, later, she introduces the concept formally to the reader. Sometimes she never introduces the concept, and youstruggle with the text before you realize that a new concept is involved and you must set about untangling the spaghetti on your own.
   
   On a positive note, the author makes good use of analogies to illustrate abstract programming concepts. Overall, however, this text is a monument to mediocrity.

5 comments about Beginning J2EE 1.4: From Novice to Professional (Apress Beginner Series).

1. I was taking a college course using Wrox press pro to pro series book on J2EE and it was kicking my butt. I purchased this book and it was invaluable in breaking down concepts in an easy to understand manner. The book is well written and a great introductory text to J2EE, I highly recommend it for anyone trying to learn this technology.



2. Overall a very good book except for the errors. ;-) I would've given this book a higher rating if it were not for the editing.
   
   I read the book from cover to cover. The explanations are good but there are problems with the examples. It really is difficult to find a programming book that is not rife with poor instructions and/or examples that will not compile. This book is better than most but I am a rather unforgiving sort when it comes to code examples in a book. There is nothing more frustrating than spending hours on a problem that could've been solved at the outset with just a little more attention to detail by the editors.
   
   My setup is a Windows XP Pro notebook, jdk1.5.0_06 installed on C:\ (the root directory) and J2EE 1.4 also stored on the root. I am using Eclipse 3.1 for an IDE (Integrated Devlopment Environment). If you can avoid it, do not put any of your Java software in directories that have spaces in their directory/folder names. This will prevent problems you will encounter when entering commands on the command-line that involve using environment variables in path names (there may be other problems avoided as well).
   
   Here is a summary of some of the trouble I ran into. I would like to say at the outset that I DO recommend this book. Unfortunately there is no such thing as an error-less computer book especially when you are dealing with a technology that has not yet matured.
   
   The problems begin in Chapter 3 on page 54, #5. Compiling the FaqCategories.java resulted in the following message...
   Note: FaqCategories.java uses unchecked or unsafe operations.
   Note: Recompile with -Xlint:unchecked for details.
   To solve this problem I changed the following line of code...
   private Vector categories = new Vector();
   to...
   private Vector categories = new Vector();
   
   This problem occurred because JDK 1.5 uses generics. I guess I can't blame this one on the publishers because I am probably using a later JDK than they were. This problem comes up again in Chapter 4, page 108, Questions.java. You will need to compensate for the use of generics in JDK 1.5. So here is the source you should use for that example...
   import java.util.Map;
   import java.util.HashMap;
   
   public class Questions {
   private String topic;
   private int numTopics;
   private Map questions = new HashMap();
   
   public String getTopic() { return topic; }
   public void setTopic(String t) { topic = t; }
   
   public int getNumTopics() { return numTopics; }
   public void setNumTopics(int n) { numTopics = n; }
   
   public Map getQuestions() { return questions; }
   public void setQuestions(Map m) { questions = m; }
   
   public Questions() {
   questions.put("1", "How do I use implicit objects?");
   questions.put("2", "How do I use the JSTL?");
   questions.put("3", "How do I use the 'empty' operator?");
   setNumTopics(questions.size());
   }
   }
   
   
   I remember having trouble with the JSTL (Java Standard Tag Library) examples in Chapter 4 but unfortunately I did not make any notes for those problems.
   
   In Chapter 5, page 161, #3 I had a problem with the login.html page. I changed the following line...
   
   
   to...
   
   You may not have the same problem depending on your setup.
   
   I had the same problem with the code on page 192 near the bottom of the page. I removed '/Ch05/' from the path. The explanation on page 194, #5 is not good at all. It would've helped tremendously if they had included a better explanation and a screen shot.
   
   Want to get confused? Read the first paragraph under "How It Works" on page 204. The whole Filter topic needs to redone.
   
   In Chapter 6, page 243, the connection string they use is just plain wrong. Look at how they refer to the same snippet of code in the middle of page 245, that is the correct connection string. I have no idea how they came up with the one on page 243.
   
   In Chapter 7, page 263 in the middle of the page the variable declaration should be "String sql" not "String sdl". On page 274 I had problems with the command-line entries. I had to resort to using the App Server Admin Console. On page 275 the conn, stmt and rset variables are declared just before the try block and within the try block itself. I removed the words Connection, Statement and Resultset from within the try block. In the smae example I had to remove the semi-colon from <%= e.getMessage(); %>, it should read, <%= e.getMessage() %>. In page 289 replace "192.168.1.103" with "localhost". (Someone was asleep at the wheel in Chapter 7!)
   
   In Chapter 8, page 325 the Deploytool shows a "JNDI Name" tab. My version of the Deploytool does not have a "JNDI Name" tab but the same functionality can be found through a click on the "Sun-specific Settings" button. On page 328, the command line entry shown in #2 did not work unless I rebooted my computer first. It could be that if it doesn't work for you try stopping and restarting the app server. That may be all
   
   it needs. On page 337, #11, the second bullet, change 'Stateless' to 'Stateful' - then you will be in agreement with the session-type tag in the ejb-jar.xml file shown on page 341.
   
   In Chapter 9, page 359 - remember, if you do not have a "JNDI Name" tab click on the "Sun-specific Settings" button. On page 389 the "Try It Out" example does not point out changes that must be made in the source code from a previous example to make this example work. I had to
   
   download the examples from the APress web site to see that there were differences (normally I hand-poke all the source code examples to get used to the "feel" of the code - in this case that practice presented a problem).
   
   Chapter 10 became a problem for me because as with other places in the book this chapter uses source code developed in previous examples and builds upon them. Well, if everything went well for you with the previous example then this practice is fine but if you had problems that you could not solve then you are pretty much out of business in subsequent examples. This is where the authors started leaving out detailed steps because, supposedly, you already did those in the previous example. Well, what if you were just hopping around in the book? I don't
   like their practice of leaving out the detailed steps - put them back in, afterall its only a page or two here or there.
   
   In Chapter 11, the top of page 475, the command-line entries are wrong. Each option needs to be double-hyphenated and the option 'resourcetype' needs to be changed to 'restype'. Here is what the first command-line entry should look like...
   asadmin create-jms-resource --user admin --restype javax.jms.QueueConnectionFactory --property imqAddressList=localhost jms/QueueConnectionFactory
   
   In Chapter 12 there is a very long and involved set of steps to go through to implement a web service and then invoke a client application to use that web service. I got all the way up to the next to the last step and wouldn't you know it, the client app will not compile. It looks like a seemingly easy-to-fix problem but the solution is not readily apparent. The error is "Package javax.xml.rpc does not exist" but that class is in the application's project. Strange problem but I have not found a solution to date. So that problem mows down two whole chapters because chapter 13 depends on this example too.



3. The book is a very well-balanced introduction to many J2EE topics such as JSP, Servlets, JDBC, and EJB. Examples are "as simple as possible, but no simpler", and are quite useful for understanding the various topics.
   Obviously this book is now out in the newer edition that covers the much-changed and simplified (yey!) Java EE 5, but for anyone who would need to work with legacy J2EE 1.4 applications this book certainly provides good value.



4. I've had this book for a week now and I would love to be able to give a knowledgeable review but I can't get past the second chapter.
   
   Why? The second chapter details setting up the SDK but after many hours of searching I can't find anyplace to download it. It uses the first (November 2003) release of the J2EE SDK and there have been 3 updates since then. The current release uses an entirely different database with an extensively updated web server.
   
   I'm looking to familiarize myself with J2EE 1.4 and this appears to be a very good book for that, but it's going to be a major pain when I'm forced to use different software.



5. Being a beginner I was frustrated by other books before I happened upon
   Beginning J2EE 1.4. I'm only 1/4 way through the book but all the examples
   work and I feel I've already got my money's worth. I think after studying
   this book I will be able to go back to other beginning books and fix the
   reasons why their examples did not work for me.

5 comments about Pro Active Record: Databases with Ruby and Rails (Pro).

1. No fear of the legacy database!
   
   Excellent book overall, but Chapter 7 is what takes the cake for me.
   It's generally considered a pain to use ROR with legacy databases, but
   K.Marshall et al, show that it is not only doable, but not bad at all.
   
   Excellent examples and explanations, showing code in a step by step approach - starting at the very beginning (what active record is, configuring/installing it, etc...).
   
   At the same time, the style is extremely laid back (at times the authors poke a bit of fun at each other), which is always welcomed when learning something new.
   
   Great book and great choice to include information on getting active record working with legacy databases.



2. Right at the start of Pro Active Record the authors address a possible problem some may have with it: that there's not enough in Active Record to warrant a full book. They point out that the basics are well covered as sections elsewhere but that this is the first book to really dig into working with legacy schema and other `advanced' uses. That's fair enough, but after reading the book I am still left with the question of why, then, they dedicate the first half to covering ActiveRecord's most basic concepts?
   
   Judging from postings on the rails email list, there's certainly a lot of confusion about ActiveRecord, associations, observers, how to work with legacy table names and primary keys, and so on. But in a book with a title prefix of "Pro" I was expecting to jump straight into the nitty gritty of topics like compound/composite primary keys and performance tuning, probably with some real world examples, and maybe with a serious exploration of AR's internals. As it is, such topics only get a quick treatment in the final chapter (the compound/composite primary keys section is a paragraph referring users to a plugin).
   
   It's almost always instructive reading other developers' code and it would be unfair to claim that I didn't spot a couple of tips that may prove useful, but they were passing things. And sometimes I found myself wondering what happened to the tech review process, particularly in the coverage of the has_one association, where not only is the variable naming confusing, but they seem to be calling the each method on a single ActiveRecord instance.
   
   I'm left wondering what the audience is for this book. The title and blurbs suggest it's pitched at people who want to go deeper into ActiveRecord than they have before, but the content is better suited for someone with some database experience who wants to pick up ActiveRecord to write some scripts. As it is, if you've worked with ActiveRecord before your time will be better spent writing plugins and exploring the internals for yourself, and if you've not you'll get most of the same material from a decent Rails book and some time exploring.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



3. Visuals:
   Font size and layout are good. Easy on the eyes. Large and frequent sub-headings make it easier to locate information.
   
   Audience:
   The book lists it's intended "User level" at "Intermediate-Advanced".
   
   Practicality:
   It really depends on what you are expecting. I've been using Rails and ActiveRecord for about 2 years, so I should fit into the target audience. After reading the book I still think it will be a great reference book to have within arm's reach while working with ActiveRecord. To me it will serve as an API to AR. So it will be practical in that sense.
   
   On the other hand, while reading it I never experienced any "aha!" moments where I felt like I learned something new or exciting, which I had hoped for from a "Pro" book.
   
   If you are a beginner (never having used AR) it will definitely save you time (and eye strain) hunting down tutorials on blogs.
   
   Overall:
   It's a good Active Record reference & usage tutorial(s). I would have appreciated this book even more when I was first starting to use the Ruby on Rails framework. So if you are a beginner, don't let the "Intermediate - Advanced" user level scare you off. If you are using Rails, even as a beginner, you will probably be using Active Record too. In fact I think this book would probably be better named "Beginning Active Record" instead of "Pro Active Record".
   
   I was kind of surprised when I read the Introduction to the book that it starts off with:
   
   "Is there really enough to talk about in Active Record to fill a whole book?"
   
   "Our answer, then and now, is, "Yes and no""
   
   As an "Intermediate - Advanced" user, that's kind of how I felt at the end of this "Pro" book.
   
   I give the book 4 stars, with the assumption that you go into it with the expectation of "Beginning Active Record".



4. I was ecstatic when I heard a book dedicated strictly to Active Record was being written and signed up for a copy right away. As a Java developer with just a little bit of Hibernate experience, Active Record has been my biggest challenge learning ROR (in addition to some of the Ruby language idioms). I've read a lot of the other Rails books (e.g. Prag Programmer series) which also cover Active Record, but not in as much detail as this book. In particular, I found the numerous code examples very useful and easy to understand. The authors provide a lot of "here's the SQL generated by Active Record" which help me better understand the "man behind the curtain".
   
   As some of the other reviews have already stated, the introductory and overview sections of this book are excellent. After that, there is a chapter dedicated to explaining the core features of "Active Record". That helps lay the foundation for the rest of the book which covers more advanced topics. Depending on whether you're working with a new schema or legacy schema, there are a lot of tips to help you successfully use Active Record in your real world application.
   
   Hibernate is Java's ORM equivalent to Rails Active Record. The book "Java Persistence with Hibernate" is a whopping 841 pages. "Pro Active Record" is 280 pages, so it's only fitting that the ROR persistence framework can be explained in 1/3 the number of pages. Don't be discouraged by the size of this book as it packs a lot punch. I currently own almost all the good Ruby / ROR books, but this book is one that I always keep by my side.



5. Honestly, you may want to pass on this one! The pragmatic book's coverage on this as well as the online resources should be enough to get you by. There were no aha moments with this one, it is a bit of a dry read, with some repetition. I was hoping to dig deeper into the magic that allows ActiveRecord to learn your table names by introspection with some specific gotchas relating to feature support across the different DBMS. I feel like I have a reasonable resource book to allow me to search for ActiveRecord information in one spot. However it is nowhere near as good as Obie Fernandez's The Rails Way as far as references go. There are sections in there which are too repetitive and which may have been aided by the use of the occasional table (pun not intended!) or two.
   
   There may just not be enough material in here to warrant the expense. However, the idea was good and there may still be hope for a second edition with a bit less repetition and more in-depth discussions.

No comments about ASP.NET 3.5 AJAX Pocket Guide.

5 comments about Expert .NET Delivery Using NAnt and CruiseControl.NET (Expert's Voice in .Net).

1. I picked up this book last week and within a few pages already had major ideas for my build system. I had been struggling by with a very basic, very weak continuous integration system using CruiseControl.Net and NAnt, but I had no idea the kind of power these tools give you, nor did I have a real understanding of what a good enterprise build system should do.
   
   Well, that problem has been rectified. After reading most of this book I was armed with the knowledge I needed to go out and put together a build system I can be proud of, one that presents real value to my development rather than just being there so I can say "ya...I use continuous integration" - a situation that I suspect is not uncommon.
   
   So if you are doing any signigicant development work with .Net you definitely should read this and learn how to make a build system that works for you and provides real and significant value.



2. I picked up "Expert .NET Delivery Using NAnt and CruiseControl.NET" as a developer familiar with the original open source projects, Ant and CruiseControl, from the world of Java development. I have been long interested in how "the .NET people" do things even though my personal experience with .NET technologies has been limited to doing a day of training every now and then. From this perspective, I have to say I find a lot of good stuff in this book but it's still missing that something. The author, Marc Holmes, clearly states in the introduction that the book's goal is not to be a comprehensive guide for the tools being used. Instead, his focus has been to show the reader a practical approach to tackling problems involved in "delivering software." I had some difficulty seeing that focus while reading.
   
   The first chapter titled "A Context for Delivery" is actually an excellent albeit short overview of the variety of aspects involved when discussing how to manage software configuration, the build process, and the deployment process. The next couple of chapters
   introduce the NAnt build tool and its essential built-in tasks. As a tutorial to NAnt, these chapters felt a bit too lightweight. Chapter 2 is an excellent tutorial for getting started with NAnt and chapter 3 briefly enumerates the most important built-in tasks available. These first three chapters were definitely the ones I liked the most.
   
   Chapter 4 presents a simple case study, getting a GUI application for performing XSLT transformations to build with a NAnt script. The author follows through creating the script from scratch, all the way from the classic "clean" target to checking out the project from Visual SourceSafe, incrementing a version counter on assemblies, running automated tests, static analysis, and packaging the build output into a .zip file for deployment. There's some discussion of NAnt features that weren't illustrated in the previous chapters but not much more than that.
   
   Chapter 5, titled "Process Standards", talks about the case study team refactoring their build scripts towards a structure that supports a "standard" build script to be used throughout the company's .NET projects. Very little meat in there. Most of this chapter seemed to present a topic of interest only to move on right away, without giving solutions beyond tiny snippets of NAnt tasks. As someone not familiar with most .NET concepts, I found it very difficult to follow.
   
   Chapter 6 brings continuous integration into the picture. After a brief explanation of why one would want to implement a continuous integration process, Holmes proceeds to describe CruiseControl.NET and how to configure it to build your .NET project. Again, only superficial coverage of the configuration options available which is consistent with the stated goal of the book not being about the tools themselves. Yet, at this point I realized that the good stuff had all been about the tools -- NAnt and (to a smaller degree) CruiseControl.NET. This pattern continued through chapter 7 which talks about extending NAnt with your own custom tasks. In fact, this chapter does a good job in showing the ropes through developing a FxCop task.
   
   Chapter 8 is a good one. It talks about techniques for dealing with the database schema in the context of continuous integration and incremental development. The example scripts do leave a sense of "magic" happening that I would've liked to know more about, but even as such this chapter can be useful for getting started with automated integration of the database alongside the application.
   
   Chapter 9 talks about code generation (with XSLT and CodeSmith) and how to incorporate it into the build process. The examples were a bit difficult to follow and there wasn't much background on the tools (CodeSmith and XSLT) themselves.
   
   To finish off, chapter 10 presents some closing thoughts as a summary for all the things discussed in the body of the book. Good stuff, makes a lot of sense. I find it interesting, though, that beyond the first and last chapters I found very little content that I could associate directly with practical delivery other than from the tool perspective.
   
   As a summary, I consider "Expert .NET Delivery Using NAnt and CruiseControl.NET" to be a nice tutorial for NAnt and CruiseControl.NET. Having said that, a large part of the book seemed to be somewhat disconnected from the stated goal of showing a practical approach to problems in delivering software.



3. Holmes gives you a very motivated guide to using NAnt and CruiseControl.NET. I'm from the linux/Java world, and am familiar with Ant. So the NAnt discussion was very relevant to my experience. Holmes explicitly says that this book is not a comprehensive guide to the abilities of either package. But in some ways, while not comprehensive, it may well be better than a text devoted to either [or both]. You can see in Holmes' text, very plausible ways for why and how you can use those packages. Going through the chapters, he delves into a detailed practical application. Helps you build a context in which you might use the tools for yourself.
   
   I was unfamiliar with CruiseControl.NET. But ended up being impressed with how it lets you do this agile, continual integration. On the broader issue of explicating issues in code delivery, I tend to agree with a previous reviewer, Koskela. Who stated that the book doesn't give a bigger view than that of the tools. Though it certainly does that well.



4. This book is simply arduous to read. I kept looking to the "About the Author" section for a hint that perhaps this was a translation from the Russian original, or something. Vague sentences, paragraphs, and overall structure haunt this book, and make it a task to read. Did this book even have an editor?



5. This serves as a good introduction to NAnt and NAnt contrib. Working through the excercises was helpful. The introduction for CC.NET is also good.
   
   I recommend this for anyone new to NAnt and CruiseControl. I caution the use of Continuous Integration. It is an excellent way to immediately identify build and integration issues; however, you have to beware of "false positives". For example, an auto-build everytime something is checked in will determine if that checkin causes a build failure with everything else that is checked in.... however, you need to do some soul-searching to determine if this is what you really want. Do you want to trap failures and correct them, or determine a development strategy ahead of time that will prevent these surprises? The continuous build isn't a bad idea, but it becomes troublesome if you are substituting that for a good development and integration plan.

5 comments about Massively Multiplayer Game Development 2 (Game Development).

1. there is very little detailed technical content in this book -- i mean, if you are a software developer, then a lot of this feels like fluff. i wanted a leg up on coding, and this isn't that book. it does provide a certain high-level overview, but it's not sufficient for "game development." for example, the discussions of server architect are interesting, but largely represent a kind of "we did this and were successful" summaries. if you wanted to move into this field, this book isn't an "open sesame." if you haven't thought much about the field and just want to get a feel for what the issues are, then the text is interesting but expensive.



2. To the game developer, the theory behind MMOGs can be a mystery. Often it is hit-and-miss and many developers can and do get it wrong. Great games can turn to dust because designers made critical mistakes.
   This book does NOT have all the answers!
   But it does pose a lot of questions and provides learned and thoughtful chapters written by some of the best game people in the business.
   
   Part one covers design techniques with eleven chapters in game theory.
   Part two explores engineering techniques including automated testing, data collection and analysis and anti cheat mechanisms.
   Part three gets into production techniques with eight chapters covering subjects from project management to providing online support.
   
   Its become my Bible of MMOG dev.



3. PLEASE NOTE THAT THIS IS THE SAME REVIEW AS THE SEQUELS BOOK, THAT IS BECAUSE I CONSIDER THEM TO BE EQUALLY AS GOOD AS EACH OTHER.
   DON'T BUY ONE BOOK, GET THEM BOTH.
   
   As a games programmer I wanted to branch out into a MMG and this book was one of 4 that taught me everything I wanted to know.
   
   This book is split into 3 main sections; each section has several chapters about differant aspects of the MMP's. If you have any interest in MMP games you cannot help but to find most chapters helpful.
   I will admit that some chapters bored me and I skipped them, but the amount of helpful chapters there were more than made up for it.
   
   Each chapter has been written by a differant person and quick searches on google makes you realise that these people really do know their particular areas of expertise.
   
   James



4. The book is unlike typical computer graphics books that focus mainly at the source code level. Alexander has compiled an impressive set of essays, drawn from game programmers at several companies. It is an industry-wide summation of publicly available ideas for state of the art coding, circa 2005.
   
   Look, if you are hoping for tips on solving a specific coding problem, this may not be the best choice of books. Instead, the articles are more useful at the architectural design level, for a new multiplayer game. Some topics seem quite novel. Like applying graph theory to study and design a game. Including at the large ["macro"] level where you might be building a community, with economic facets. Graph theory also permits a way to classify different MM games, providing a unified and consistent view. Not the sort of thing you might expect to run into in a gaming text. But the complexities of building a MM world can be staggering.
   
   There are many more essays, touching on numerous aspects. You need to be an experienced game developer to fully appreciate this book. Which is not to say that the ideas here cannot ultimately find expression at the source code level. Just that you need to take a high level view.



5. As an experienced online game producer with one reasonably successful title under my belt I really felt that this book offered less in terms of game development knowledge than what can be freely and easily found on the internet.
   
   The book itself is a collection of essay-length chapters written by different authors regarding various aspects of online game design. I found that the length of these chapters is generally too long for simpler subjects and too short for more complicated topics.
   
   The authors aren't heavy-hitters from Microsoft, Sony, Blizzard, etc. Not that there aren't some great minds behind some of the articles, but I really felt that the majority of the articles were written by authors that didn't have nearly the amount of knowledge regarding these topics that I would expect. In particular there are a few articles from authors (some whose companies have a less than stellar reputation with their users) that contain some patently bad advice.
   
   Overall, I'd say the book is hit-and-miss, with more misses than hits. There are a few worthwhile articles, but not enough to justify the cost of this book. You'll get almost as much from reading the chapter list and spending some time thinking about the topics covered as you will from actually reading the chapters.
   
   I wouldn't recommend this book to a person of any level of experience in online game development. There are far better books on this subject out there.

3 comments about Mobile Web Development.

1. I am doing mostly Java, PHP, RoR development. Has never done any mobile web development before. To cater my curiocity of furture mobile we, I ordered this book using 2 day shipping. I was woundering why this book didn't have a cent of discount. Now I know why, it is a great book which worths all the money.
   
   I read it from beginning to end in 6 hours. I simply could not stop. It covers most important aspect of mobile web development. Now I am very anxious to try build a mobile version of my website.
   
   Examples in the book are deep enough and very easy to understand.
   
   I highly recommend this book



2. Mehta instructs about coding for cellphones, covering topics ranging from GUI development to accessing a database server.
   
   If you already have experience writing GUIs for desktop or web applications, then the GUI part of the text should be dead simple. Of necessity, there is a severely constrained graphic environment on the cellphone. It is good, in the sense that you don't have much to learn, and almost certainly, the complexity of your GUI should be low. Of course, the tradeoff is this very constraint. You are very limited in the images and widgets you can display. Back to basics, one might say.
   
   Hopefully, you'd have dealt with database schema and designs in other contexts. The text's coverage of this is somewhat abbreviated. Enough is given for the book's main example to be nontrivial. But this is not a database book; just keep it in mind.
   
   Payment is a no-doubt germane issue for some developers. The text describes how eBay's Paypal can be used for billing purposes.
   
   The other interesting topic in the book is a brief explanation of Interactive Voice Response systems. Since after all, the user can talk into her cellphone. Just as for databases, IVRs have their own complexity, hinted at here.



3. This is a quick and effective introduction to developing websites specifically targeted at mobile device users. I say "users" for a reason -- one of the strongest advantages to the book is a strong focus on considering your user and their needs as a key element of mobile web development.
   
   My overall reaction to this book was positive. It covers a wide variety of key issues for mobile web programming in an easily understood manner. The book is targeted primarily at developers who already have some experience at web development and design, so it doesn't delve into any serious detail when it comes to server-side programming or HTML coding, but instead makes a point of emphasizing places where the mobile web is different from internet interaction on a desktop device.
   
   Mehta goes out of his way on many occasions to emphasize the serious importance of considering who (and what!) will be using your mobile web application.
   
   "Any website accessed from a mobile device is mobile web -- whether it's been tailored to work on a mobile or not!" (Mobile Web Development, Nirav Mehta, page 10)
   
   The book covers a wide range of issues -- from developing for mobile devices using a "lowest common denominator" plan to implementing highly dynamic mobile applications which adapt automatically to the device currently in use. The text is easy to understand and follows a logical progression, starting with the mobile web development practices which are most similar to the development of standard web applications before moving into the areas which are very specifically targeted towards mobile devices.