5 comments about CDO & MAPI Programming with Visual Basic:: Developing Mail and Messaging Applications.

1. This book is written in a warm, conversational tone. The set up is easy to read with important points highlighted. It is apparent the author really knows a lot about computer programming.



2. This book is written in a warm, conversational tone. The set up is easy to read with important points highlighted. It is apparent the author really knows a lot about computer programming.



3. For the size of this book, it does a good job of covering the MAPI/CDO (both Win32 API and ActiveX) objects at an intermediate-programmer level - presenting the objects and object models with enough information that you can begin to use them right away, but not getting so technical that you lose interest or begin to only understand the minority of what you are reading.

   The author does include sample code for most of the objects that are covered, although many of those sample codes are spread out over a page or more and separated by paragraphs of explanatory text which can cause a little delay for readers that skim, or jump directly to topics, as back-tracking is often needed to find the start of the desired code. The publisher's web site does provide a download for some of the sample code - but the download only includes the full projects the book goes into, and not most of the smaller projects or snippets used in the bulk of the book.

   I did find that the author had included many unnecessary screenshots for a book aimed at intermediate to advanced programmers; it was also frustrating that many of the screenshots the author choose were of related topics but only used to explain how to `point-and-click' through making settings changes, rather than how to perform the task programmatically. One such example is the Mail control panel applet, where the author showed how to add an information provider to the selected user's profile (in the book's case the Personal Address Book service was added) but did not cover how to do it through programming. In fact, it was never mentioned if the task could even be performed programmatically.

   Overall, the book is a great reference for MAPI/CDO objects and will come in very handy for anyone needing to generically access the common e-mail functions and folders (inbox, calendar, contacts, etc.) quickly.




4. Excellent Book. All the code works. The only gripe I have is it doesn't tell you where to find the dlls.



5. This book is very thin, but don't let that throw you. The examples are easy to follow, and very concise. I just wish that there was a .NET version available.

5 comments about PowerBuilder 9: Internet and Distributed Application Development.

1. The best resourse for PB programmers who want migrate to web platform. The only resourse available to discover concepts in the steps of PB (User Objects) deploy to EAServer for web use.

   Great distributed application concepts and evolution of infrastructures.

   Good J2EE reference concerning to EAServer components.

   If you're working with EAServer 4 you must have this book




2. PowerBuilder 9: Internet and Distributed Application Development is the collaborative effort of computer expters William Green and John D. Olson and comprehensively presents the new capabilities of PowerBuilder 9 along with the architecture and patterns required to create distributed systems in PowerBuilder. Recommended for intermediate to advanced users, PowerBuilder 9: Internet and Distributed Application Development deftly addresses development Web and Intranet-based systems, including Web Services, Portals, Application-Servers, XML, and Mobile Access.



3. I have worked with PB since its inception about 12 years ago. During that time I have purchased everything written about it. This is the worst effort put into print. It is simply a rehash of articles on xml, soap, and internet theory. There is no relationship between PB 9 and this text other than the mention of it by the authors. Save yourself some money and wait or something that actually shows you how to develop internet and distributed applications -- this one does not!!!



4. For newbiew like me, this is the bible for entering the n-tier world with EAServer. Gives me a very good comparison with other options too.

   After having bought this book for my work, I have found my colleagues who take this book for reference often appreciating it's contents, especially for the tips & tricks and well laid out examples.

   I recommend all the PowerBuilder/Internet developers to invest in this book. Very affordable with good quality.




5. Save your money. This book, and its companion, are both written in editorial style, each chapter by a (potentially) different author who each feel that they must fill in the space with more history than substance.
   
   Get the online documentation from Sybase for free and learn something without wasting your time. That is unless you like history.

5 comments about openSUSE Linux Unleashed.

1. OpenSuse Linux Unleashed isn't for the casual computer library, but for the college-level collection strong in openSuse installation, configuration and website management. Programmers receive an excellent overview on the program's applications, administration tools, functions in web programming and networking environments, and more, and come from a technical writer well versed in explaining the program to novices. An accompanying DVD includes openSuSe10.3, making it an excellent blend of tutorial and program.
   
   Diane C. Donovan
   California Bookwatch



2. This is a great book and it comes with a DVD with the installation of SuSE Linux 10.3, the latest version on it. The installation went well and the book is a good read. If you want to install SuSE Linux this book will help you do it.



3. This book is very nice, about every question that I had about Open SUSE is answered in this book, from configuring bluetooth to programing in C. I recomend this book to anyone interested in learning open SUSE



4. As a user of SUSE Linux 10.0, I was hoping that this book would be a good addition to the information available online, and also allow convenient upgrade (on one PC) and a new install (on another PC). Sadly fails in both regards. I have already went through two books with corrupted/scratched DVD media. Let's see if the third time is the charm. At least Amazon is good about defective returns. On the print side, the book is all over the place. For installing openSUSE, it offers no useful information over what I already knew. The first three-quarters of the book is written at a very basic level (example: chosing a web brower, advising that difficulty in reaching the internet may be from using a "winmodem"). The last quarter of the book gets into advanced topics like kernal hacking and script programming without doing much more that just stating what those things are.



5. I purchased this book to help me get a feel for Linux, which I recently decided to install on my PC to dual-boot with Windows. Although reviews online seemed to suggest this book is for intermediate to advanced users, its actually a fairly good beginner's guide to SUSE Linux. If you already use Linux, you'll probably find this book useless. If you consider yourself an intermediate to advanced **Windows** user, and are thinking about migrating from Windows to SUSE Linux, you will probably find this book helpful in explaining the differences between Windows and Linux and how to overcome them.
   
   That being said, there isn't much in this book that isn't already available for free online (including the Linux install DVD in the book, which can be downloaded from opensuse if you have a decent internet connection.)

5 comments about Microsoft Windows User Experience (Microsoft Professional Editions).

1. C'est un excellent ouvrage pour tout ce qui concerne l'interface graphique Windows. Il est relativement bien illustré. Il comporte de très nombreuses expériences d'utilisateurs pour permettre de développer des logiciels conviviaux et parfaitement adapté à l'environnement Windows.



2. I haven't finished this book yet, but so far I'm very pleased. It's very comprehensive, and contains many screenshots. It also contains information about integration w/ Internet Explorer, which is important to me. The only downside is that it's written by Microsoft, so some of Windows' shortcomings aren't really discussed.



3. Great book on how to design a graphical user interface correctly. Very useful if you want to follow Microsoft's user standards (and why wouldn't you).



4. While the MS Windows User Experience will be a necessary reference book for MS UI developers, it fails as a general guide for creating a "great user experience." Scaning the first chapter, for example, I just had to laugh: I had been just reading a text on the new Macintosh OS X interface then switched to the Windows book. The Mac OS X UI guide was simplistic and bland, while the first chapter of the Windows guide was verbose and unnecessarily complex. How stereotypical is it possible to get? Also, in chapter one of the MS book there are less than 2 introductory pages of positive text, then 16 pages on what NOT to do.

   If you are looking for a book which lists MS Windows UI elements, and contains the official MS explanation of what to do with them, this book would be handy to keep around. However, if you are looking for an excellent book on user interface and "user experience", I highly recommend going to the Macintosh web site and downloading, for free, the "ancient" (by computer standards) 1995 Macintosh Human Interface Guidelines (which differs greatly from the Mac OS X book mentioned above).




5. This book is a frame by frame, widget by widget, menu item by menu item prescription for "proper" Windows application etiquette. By following this book's advice, your applications will look and feel just like a member of Microsoft Office. You'll learn everything from how many units to space a button from the border of a box to how to select multiple discontinuous pieces of text and then copy and paste them across applications. There's even instructions on editing the registry so that your documents can be printed from the explorer.

   It's essentially a style guide for Windows GUIs the way the Chicago Manual of Style is a style guide for writing English. It won't make you a good writer, but no one will correct your punctuation.

   I actually found this book useful from a Windows user perspective. It tells you how all the controls are supposed to work. If you use MS apps a lot, you've probably intuited a lot of this, but it's interesting to see it all laid out.

   This book does not explain how to use the Windows APIs to create GUIs. Get a book on Visual C++ or VB for that. This book does not explain how to design a usable application. Read Jeff Johnson's GUI Bloopers or Alan Cooper's About Face. This book does not teach you to be a visual designer.

   This book is about as interesting to read as a typical user's manual. It's one unforgiving piece of advice and description after the next without a single case study in the entire 500+ pages.

   Even so, if you want to understand how Windows apps are "supposed" to behave or you have to write such applications yourself, this book is a must-have.

3 comments about Software Assessments, Benchmarks, and Best Practices (Addison-Wesley Information Technology Series).

1. This author is a very good writer and technical expositor. I find him easy to read and the book hard to put down, which is not something one can say about every technical text. I particularly liked the author's frequent lists of pros and cons. He is well aware that every design process is a series of tradeoffs. Knowing what they are is a big help. This book is the culmination of a technology development scenario. It mentions competitive and ancillary software metric methodologies and closes each chapter with an extensive bibliography. The best previous books on this subject were written by this author. This book is the 1999/2000 upgrade.



2. The success or failures of software projects are dependent on various parameters. Software assessments & benchmarks provide qualitative methods and quantitative data on factors that lead to project success and failure. Assessing organizational standards and comparing them with industry standards helps to identify weaknesses and strengths in the software project development process. The book provides a valuable insight into the best practices in the industry and also lays down a clear framework for process improvement and software project excellence. For a Industry that is driven by metrics, the book is a `must read' for any professional in the field.



3. Jones is a master at data collection, distilling it, and drawing supportable conclusions. Like his other books (especially Estimating Software Costs, ISBN 0079130941), this one is wide in scope and deep with data and techniques.

   He begins with background material on software process assessments, comparing his company's technique to SEI's, and correlating the two. Note that Jones' approach predates the one developed by SEI and was first published in his 1986 book "Programming Productivity", ISBN 0070328110. This book is a natural extension of that earlier work.

   The next part of this book is an exhaustive survey of benchmarks and baselines, including pitfalls and an interesting discussion on activity-based software benchmark data. This material is a lead-in to 36 key factors that Jones identifies, including software classification, project-specific, technology, sociological, ergonomic, and international factors.

   Subsequent chapters address best and worst practices, process improvement, and benchmarks and best practices for various software classes and development approaches, including internal IS, outsourced development, systems, commercial, military and end-user software development and delivery. Each class is treated in a comprehensive manner and the findings are well supported.

   This book is an ideal resource for any organization wishing to establish a baseline before implementing initiatives such as CMMI, SPICE, etc. More importantly, much of this book is as applicable to the SEI assessment approach as it is to Jones's SPR methodology. I also recommend using Software Program Managers Network (ASIN B0001M00RA)in conjunction with this book (paste the ASIN number in the search box at the top of this page to reach it).

4 comments about Beginning Visual Web Programming in VB .NET: From Novice to Professional.

1. The title says "beginning" but the authors actually take you to very important topics that are at the forefront of much Internet activity. Namely XML and Web Services.
   
   The book goes through a lot of necessary but mundane stuff concerning user interfaces, server control and ADO.NET. Yeah, to know VB.NET, you need this material. But more significant is the long exposition on XML. It is now a de facto standard for markup of structured data. Within the entire .NET portfolio, it is pervasive. And also in the J2EE world. The book shows how Microsoft has integrated web development and VB.NET tightly into using XML. Well worth understanding.
   
   The other big buzz is about Web Services. Here the discussion is not as indepth. The basics are covered. But Web Services Description Language is only tangentially invoked. And what is seeming to be a more powerful language, Business Process Execution Language, doesn't even rate a mention. Perhaps this is why the title says "beginning"? There could well be a sequel in the works, to cover these.



2. I'm really impressed by the thoughtfulness of the organization and writing in this book. Where the reader has questions that require deeper explanation the exposition is there. The content is well researched and the author has obviously spent the time to do some complex information distillation for us. An ideal book for anyone looking to start with VB.NET programming. And well worth the look for those already using the platform who want to broaden their understanding.



3. Book was very well written. Author effectively communicates with novice users in a 'For Dummies' style without being patronizing or condescending. By 'For Dummies' style, I mean that he literally defines which menu option to click, etc. in a similar manner to the popular series.
   
   Intermediate to Advanced users will probably find this book to be a bit unwieldy, not because of the material presented but because of all of the detail given for the benefit of the novice user.
   
   I would absolutely recommend it for someone just getting their feet wet in the VB.Net web development arena.



4. Beginning Visual Web Programming in VB.Net is well worth a read. The book is very straight forward and the examples are such that they guide you through quite easily so that the reader can follow along without much trouble. Chapters 7 and 8 are really nice with their XML information and examples. XML is great if you need a pages that load fast and are efficient.The descriptions that come in these chapters increase your understanding of why it is such an important part of the overall structure. MSDE I personally find can be a bit of a pain when setting it up but with this particular book things seemed to go ok. Overall the book is definately worth reading and will only help in your knowledge of .NET programming.

5 comments about Generative Programming: Methods, Tools, and Applications.

1. The more experience you have designing and implementing complex software with C++, the harder it is to find well-written and thought-provoking books on the subject, especially with regard to architecture.
   
   The various tomes on design using "Patterns" are useful in a charming, lightweight way, but for making architectural decisions that can impact your designs in a revolutionary manner, look no farther than this book, which I consider to be crucial reading for software architects using C++.
   
   Highly recommended.



2. As it is said in another review, this is a solid (and rather academic) book on the theory behind code generation. Unfortunately, I find it somewhat dated and too focused on C++ templates.
   
   The first part of the book includes a nice introduction to domain engineering (a must for anyone interested in the development of product lines). Here, feature diagrams are introduced to represent variation points without implying a particular variation mechanism (such as inheritance or parametrization in OO languages).
   
   The core of this book deals with different implementation technologies. You will find interesting discussions on generic programming, polymorphism, C++ templates, and aspect-oriented programming. In my opinion, the chapter on AOP is probably the best, since it provides a good survey of different approaches (subject-oriented programming, composition filters, and adaptive [structure-shy] programming) and shows some examples in AspectJ Cool (a precursor of the current version of AspectJ [the Java aspect-oriented extension]) and Dynamic Cool (for Smalltalk).
   
   The chapters on generators elaborate on the transformational model of software development, where software development is seen as series of transformations performed on various representations of a system (i.e. creating and evolving specifications of systems and implementing them). Unfortunately, the authors focus too much on C++ template metaprogramming, which is not too practical (at least for me, mainly a Java/.Net developer). The application examples in the final part of the book also follow this approach despite its limitations regarding debugging and code readability. This limitations are not present in intentional programming, which is also covered in its own chapter. Ideally, IP would enable software source code to reflect the intention that programmers had in mind when developing it, thus simplifying maintenance and allowing programmers to keep a good high-level picture of their programs as a whole. Vapor-ware? Fantasy-ware? Maybe
   
   If you are looking for practical ideas on code generation, this book is probably not for you. It is worth its price, however, if you just want to broaden your perspective on computer programming and are not afraid of hefty academic volumes.



3. One very important lesson in problem solving is that there is no one method that always works. No matter how good you are at one technique, there will be problems for which it is entirely unsuitable. When applied to programming this implies that anyone who wants to be good at problem analysis and program design should always be on the lookout for new methods.
   Generative Programming provides an introduction to a collection of methods that are not commonly known. These methods are not the only possible way to produce high quality programs in a reasonable amount of time, but they are very useful for certain types of problems. Most exciting for me are the feature and aspect based decompositions of a problem.
   Aspects and features are not always easily represented in more common analysis tools, as is explain in the book, but a proper understanding of the features and aspects in your program can greatly improve design.
   Also useful is an extended discussion of techniques that can simplify code generation for programs that are compositions of features and aspects. This involves selecting the features needed and allowing the preprocessor and compiler to generate code on the fly. In lare software systems, this technique greatly reduces program complexity and improves readability.
   While I recommend this book, it is with a few qualifications.
   First, just as no other techniques are right for every problem, these are not either. Always check to see if the tools are right for the job before applying them. In this case, the tools in this book are rarely a good choice for small projects or for functions that will only be used one way. They are better suited to creating code that can be reused in a variety of different circumstances, or large libraries of code to support a broad user base.
   Second, though the book has a ton of useful information, it is not always the most readable way to present the information. The writing is fairly dense, and spends more time surveying the historical development of some of the tools than I would prefer.
   Finally, though the tools presented can be used in a wide variety of languages, the presentation is mainly done in C++. Comfort with the language will be essential for anyone wishing to understand the techniques presented.



4. This book does cover lots of techniques that fall under the rubric of generative programming, but be warned that there is a strong emphasis on C++ template metaprogramming. If you don't know C++, or are a bit fuzzy on template syntax, you'll be missing a lot. Consider this a C++ template metaprogramming book, with some bonus chapters to put it all in context.
   
   The opening chapters are a bit dull, containing a plethora of acronyms and jargon about various design methodologies, none of which seem to have made any particular impact in the last few years. I tentatively diagnose a mixture of thesis-itis and maybe translation-itis. If it's the former, I wouldn't be surprised to find that this made up part of the introduction or literature review chapter. However, the concept of feature diagrams is quite interesting, as it allows a graphical representation of a design specifying features and other properties (such as whether they're optional), without requiring any implementation (e.g. inheritance or parametric polymorphism), which is not possible with UML. How revelatory this is may depend on how seriously you take UML as a modelling tool, versus a convenient set of boxes and lines for representing class design.
   
   There are also chapters on Aspect Oriented Programming, which is a pretty good survey of the field, and which provides useful motivation beyond logging. Additionally, there's a chapter on generators, which provide a convenient Domain Specific Language for specifying behaviour and performance of software components (list containers is the example in the book).
   
   There's also a rather vacuous chapter on intentional programming, the brainchild of Charles Simonyi. It's an interesting enough idea, sitting somewhere between MDA, the Smalltalk class browser, and a souped-up IDE, but there's been absolutely no progress on it since the book was published, because Microsoft didn't release it, and Simonyi wasn't allowed to take any of the code with him when he left to set up Intentional Software. This chapter is ok on the big idea, albeit a bit breathless given it's not been shown to produce any useful software, but the worked example has all the allure of an Eclipse plugin tutorial.
   
   The above material is sporadically interesting, but often a little pedestrian. However, the real action of the book takes place in the chapters on template metaprogramming in C++, which demonstrates how to generate related families of classes at compile time, using template instantiation and careful use of inlining to avoid inefficient virtual calls and indirection. It's very impressive. There are several examples, including a class hierarchy for a banking domain, and an in depth treatment of a matrix library, which successfully unifies all the types (sparse, full, banded etc.) under one library, while maintaining performance competitive with Fortran.
   
   These C++ chapters demonstrate the ideas of the book in practice most clearly, although it also underlines the need for new tools and language features, given the outrageous ugliness of the compiler/template-abuse that is metaprogramming. On the other other hand, it is kind of cool to see colons, angle brackets and other bits of C++ coalesce into a strange new dialect using the compiler as an interpreter. If you're going to get anything at all out of these chapters, you do need to be comfortable with C++ templates. It would probably also help to have read something like Barton and Nackman's book, 'Scientific and Engineering C++', their unorthodox template designs providing a good warm up for what's in this book.
   
   If you don't program in C++, or don't care for template metaprogramming, you may not find huge value for money in the other chapters. And admittedly, the writing style hardly sets the pulse racing. But if you're looking to do some intellectual stretching before taking on Andrei Alexandrescu's Modern C++ Design (and that's probably a very good idea), step right up!



5. This book has some cool stuff and I was quite impressed by the part on functional programming using C++ template. Do you know C++ template has the same computing power as a Tuning machine.

No comments about Head First Programming.

5 comments about Eclipse: Step by Step (Step-by-Step series).

1. As part of my preparation for an Eclipse presentation later this month, I reviewed Eclipse Step-By-Step by Joe Pluta (MC Press). For someone with absolutely no exposure to the package, this will help you get started.
   
   Chapter list: Welcome to Eclipse!; Installing Eclipse; Introducing the Workbench; The Resource Perspective; The Java Perspective; The Debug Perspective; A Simple Program; Running and Debugging; The User Interface; Adding the Database; Install a Java Runtime; Install Winzip; Download Eclipse; On Things GUI; Start Your SQL Engines; Index
   
   I think to understand this book's style, you have to know the target audience of the author. He wants to show working code and examples that are well commented, and he wants to walk you through the steps involved in a task. He also wanted to show how Eclipse works from a Java perspective, even if the reader doesn't know Java. That's why you can type in the code he provides, or you can import it from the CD. The steps are very detailed with tons of screen shots to show you what each step should look like. Things are taken in bite-size chunks, so that really *anyone* could understand and use Eclipse by the time you get done with this book. If you have any experience with Eclipse already, you probably won't get much out of this book that you don't already know. But the beginner will be able to work through this material with no problem.
   
   The argument could be made that there is too much handholding and screen shots of things that people have seen millions of times already. In addition, the screen shots are large. They take up a lot of space and make the book larger than it probably deserves to be. For a $60 book, I think I would have tried for smaller images and more content to make up the 362 pages. Experienced IT professionals might think it's too much step-by-step detail, but then again the hard-core IT person probably isn't the target audience. Finally, once you work through this material, you'll want to get a more detailed book on Eclipse to learn how to use the tool with all the whistles and bells. But at least you'll have the basics down before you get there.
   
   So do I recommend it? If you want a no-threat introduction to Eclipse that assumes very little, yes. If you're looking for a single reference volume that will give you all the finely detailed minutiae of the platform, no. It all depends on where you're at and what you want.



2. Good job at hand-holding, but not enough for your $60.
   
   As an experienced programmer who has never used Java or Eclipse, this was a nice introduction into the technology. It took about four hours to get through the 350 pages, and while I now feel comfortable with the basic mechanics of Eclipse I find myself looking for a book with more meat to it.
   
   Definitely not worth $60. The content was more reminicent of a $19.95 Dummies book.



3. If you just want to try out Eclipse but don't know where to start and what to do, this is a perfect book for you. Don't expect to see much information on the Eclipse platform, plug-in concept, and architecture overview as the typical topics found in other Eclipse reference books. Instead, it leads you through a truly crispy clear "Step-By-Step" approach to experience Eclipse. All hands-on materials make you to try out Eclispe, taste it and feel it. From installation, workbrench elements, creating projects, to debugging a simple SWT (Standard Widget Toolkit) program, you will enjoy the easy-to-follow instructions. Although the book avoids the Eclipse architecture and plug-in concepts, it's indeed a very good introduction for any users including business and technical readers.

   (Reviewed by Otto Yuen, 15-Dec-2004)




4. I have been a Java developer, teacher, and mentor for over 5 years now. I not at all impressed with this book. I review books for clients and for internal use. If you want a good book on Java please say away from this. I have a strong suspicion that this guy came from RPG or COBOL. He demonstrates a lack of understanding of OO technologies (maybe this was done on purpose to get more procedural programmers to buy). There are many other books on the market that are better suited for learning Eclipse and Java.



5. I liked the simple approach that is easy to follow and understand. Sometimes it even goes down to elemtary school level and you will run through the pages. However, I was really disappointed because it didn't cover any web application elements. The sample used in the book just displays the results in the IDE window.

5 comments about Pro Java ME MMAPI: Mobile Media API for Java Micro Edition (Pro).

1. This is an excellent book for those with an interest in creating Multimedia Applications for J2Me Mobile devices.
   
   I would say that the book is split into three sections:
   
   Section 1 (chapters 1 to 3): This section gives detailed information about the architecture of the MMAPI and how it fits within the J2Me platform. There is also has a good "getting started" guide to be found here.
   
   Section 2 (chapters 4 to 8): Deal with how one uses the Player object in all its forms from playing simple tones, to playing back captured and streamed video.
   
   This section was the most useful to me. It provides excellent
   background information about each of the subject areas. An example of this is that it gives a full history of the MIDI standard, and an overview of the protocol itself, before it starts talking about how you write the code to play a midi file in J2Me.
   
   Section 3: (the last chapter) is a case study, providing yet more code examples, and a companion blog site.
   
   The only criticism that I have, is that the book, could have delved into the realms of streaming media a little deeper. The company that I work for, weComm is actively involved in the mobile TV space and I was pivotal in the creation of our application for streaming TV, and therefore I was hoping that this topic would be covered in more detail. That aside, I was very impressed, the subject matter was covered very thoroughly, and I felt guided through the MMAPI as I was reading it.



2. This is a well written book. It's not for beginners but then again you don't have be a J2ME (Java ME) guru to understand it. The writing style is technically clear and straight forward without a lot of personal fluff.
   
   Since MMAPI is a subset of Java ME, the scope of the subject is fairly limited but the author covers it well. The only area I might like more explanation is with respect to DataSource and SourceStream. This is covered briefly at the beginning of the book, but it would be nice to know how to implement a custom protocol.
   
   The biggest problem I have had with the MMAPI is it's inconsistent implementation and the author is quick to acknowledge this. One could probably write a whole chapter about the quirks of various mobile devices.
   
   In conclusion, I doubt you will find another book specifically on MMAPI that has the depth that this one does. I highly recommend this book if you are looking to get your feet wet with the MMAPI.
   
   BTW, I really appreciate the time the editors spent to proof read the text as there are very few errors, if any. It's always frustrating to me when I read a book with a lot of code and spelling errors. That's not the case here. Well done!



3. Pro Java ME MMAPI: Mobile Media API for Java Micro Edition has amazed me. The book is unique as it covers and desmyifies one of the most fragmented and confuse Optional Packages for JME.
   
   I've read more than a dozen books about JME but this is the first book that has really cleared some doubts I had regarding Mobile Media in JME.
   
   I strongly recommend this book if you are developing Multimedia Applications using JME.
   
   Vikram Goyal has done an outstanding job by clarifying and detailing every aspect of MMAPI, discussing the way it has been specified, emphasizing the differences that may occur from one implementation to another and also providing clear, detailed and error free examples that illustrate the aspects being discussed.
   
   Also, the text is very well-written and I've found only 3 typos. Very impressive! Apress is also doing a wonderful job.
   
   Chapter 1 introduces MMAPI and presents its features and requirements as defined by the JCP - Java Community Process, compares MMAPI and the MIDP 2.0 Media subset, where it fits regarding the JME Software stack and at last it lists the manufactures and market players supporting MMAPI.
   Nice introduction!
   
   Chapter 2 explains the MMAPI Architecture, the main high-level interfaces, delivers an introduction to the supported protocols and content types, presents the relevant feature sets and the security issues one must take into consideration. It also details the MIDP 2.0 Media subset so that one can understand what's left out on devices implementing it.
   
   Chapter 3 introduces the reader to MMAPI hands-on programming by explaining two simple MIDlets. It also builds the foundation regarding the overall development process and environment.
   
   Chapter 4 is unique, it details the Media Player lifecycle, its possible states and transitions. It explains each state very thoroughly as well as Player events and how to work with them, even the limitations and issues regarding custom events. I've never read a book covering MMAPI with such a detailed explanation.
   
   Chapter 5 covers all the issues regarding the access of media over networks. It starts with a very clear explanation of Threads in JME as well as the security permissions for media acess over networks. Then it puts it all together in a very clear and easy to follow example.
   
   Chapters 6 and 7 are the best ones in my opinion. Those two chapters do pay the book, definitely.Vikram has been brilliant and desmystified Synthetic Tones and the MIDI protocol. He has remembered me of my of childhood, when I've had musical theory classes as it explains everything music and shows you how that all fits into programming with MMAPI. Those chapters are so complete that they have a lot of tips on how to convert from RTTTL to MMAPI format, the MIDI specification and message format and how to work with MIDI in MMAPI, how to create JTS files and other niceties. Thanks Vikram :)
   
   Chapter 8 explains how to work with Audio and Video, playback, capturing, storing, controlling, mixing, it's everything there. It also describes the details of Media Encodings and Sampled Audio as well as the GUI options for dealing with Video.
   
   Chapter 9 has a very cool Device Blogging application that builds upon all the subjects presented so far and also gives a good example of MVC pattern in JME.
   
   Well, the only criticism I have is regarding the section about Streaming Media and also the Appendix C about the JSR 234 - Advanced Multimedia Supplements. Considering that Vikram has proved he's really a subject matter expert He could have provided better sections about them.
   
   In fact, He has already written an article about Streaming in JME and it's available on his web site (so I forgive him) but AMMS is still to be covered. What about on the second edition of his book? Let's wait and see!
   
   A must have book, absolutely!



4. When I got this book I jumped straight to Chapter 9 viz. "Case Study: Device Blogging". This chapter nicely explains how to write a blogging Midlet for a phone device which includes writing a Blog post, capturing/uploading images to a blog, and capturing/posting audio to a blog. The author explains the MMAPI concepts using the MVC paradigm along with complete source code for client and server side processing of application and interaction logic.
   
   The rest of the book goes deep into the MMAPI architecture and concepts with the help of source code of working applications. The functional Multimedia player example in the 3rd chapter explains the role of various components of MMAPI architecture. A dedicated chapter on Media player lifecycle and events is very helpful in understanding the basic concepts of event handling. The book also covers some of the fundamental concepts behind controlling pitch, tempo, audio mixing with the help of examples.
   
   Chapter 7 is dedicated to the MIDI specification which is very comprehensive and well explained within the context of JavaME framework. Writing a book like this requires a thorough knowledge of both JavaME and the various subtleties of tone, pitch, sequencing, octaves, frequency, audio conversion and their treatment on the device and at the network level. In my opinion the author has done a great job.
   
   All in all this book is a great resource if you are planning to develop the next Mobile video sharing, photo sharing application or your next multi-media player for a Mobile phone.



5. I have a litte doubt and try to solve my problems talking with the writer email showed in the book, but I never received a anwser...