Rating: 
Summary: Designing usable MIDlets starts here...
Review: As a MIDP 1.0 developer and member of the MIDP 2.0 Expert Group I was very concerned about how many of the complex aspects of MIDP 2.0 would be communicated to developers new to the platform. I was delighted to find that the MIDP 2.0 Style Guide does a fantastic job of covering both the technical (implementation) aspects of MIDP 2.0 as well as the super important usability aspects of small devices.This is not a book for learning how to use the MIDP API's from Java, for that I suggest looking at "Programming Wireless Devices with the Java2 Platform, Riggs et al" or similar. This is a brilliant companion book on how to design your applications and as a result should be viewed in that light, rather than as an alternative to a technical book. The book has a well structured layout, both at a high level and at an individual chapter level. The book starts with an introduction to the MIDP specification, the changes from MIDP 1.0 and a general guide to designing applications for the sorts of devices that MIDP operates on. The book then covers each of the major user interface components (from High-level API to the new Games API) as well as the likely interfaces that users will work with for installing and removing applications. However, where this book really excels is the fantastic linking of the application developer concepts with the MIDP implementors concepts. The success of MIDP 2.0 will be how "standard" the implementations are, and how well application developers can leverage the commonality and standardisation of the platform. Each section has paragraphs grouped for "Application Developers" and "MIDP Implementors" which provides advice such as "Recommended: Use the SENSITIVE modifier for text boxes and text fields....." and "Strongly Recommended: Never store the contents of the text box....". This additional clarification covers areas that specifications cannot easily cover, the intentions behind the specifications and how the MIDP API implementation can impact on the application developer. This can provide great value to a developer when identifying potential risky implementation options and areas where different MIDP implementations may cause problems. A great reference for all MIDP developers; hopefully MIDP implementors will do everybody a favour and take on the recommendations provided in this book as this would be of value to the entire MIDP community.
Rating:
Summary: Designing usable MIDlets starts here...
Review: As a MIDP 1.0 developer and member of the MIDP 2.0 Expert Group I was very concerned about how many of the complex aspects of MIDP 2.0 would be communicated to developers new to the platform. I was delighted to find that the MIDP 2.0 Style Guide does a fantastic job of covering both the technical (implementation) aspects of MIDP 2.0 as well as the super important usability aspects of small devices. This is not a book for learning how to use the MIDP API's from Java, for that I suggest looking at "Programming Wireless Devices with the Java2 Platform, Riggs et al" or similar. This is a brilliant companion book on how to design your applications and as a result should be viewed in that light, rather than as an alternative to a technical book. The book has a well structured layout, both at a high level and at an individual chapter level. The book starts with an introduction to the MIDP specification, the changes from MIDP 1.0 and a general guide to designing applications for the sorts of devices that MIDP operates on. The book then covers each of the major user interface components (from High-level API to the new Games API) as well as the likely interfaces that users will work with for installing and removing applications. However, where this book really excels is the fantastic linking of the application developer concepts with the MIDP implementors concepts. The success of MIDP 2.0 will be how "standard" the implementations are, and how well application developers can leverage the commonality and standardisation of the platform. Each section has paragraphs grouped for "Application Developers" and "MIDP Implementors" which provides advice such as "Recommended: Use the SENSITIVE modifier for text boxes and text fields....." and "Strongly Recommended: Never store the contents of the text box....". This additional clarification covers areas that specifications cannot easily cover, the intentions behind the specifications and how the MIDP API implementation can impact on the application developer. This can provide great value to a developer when identifying potential risky implementation options and areas where different MIDP implementations may cause problems. A great reference for all MIDP developers; hopefully MIDP implementors will do everybody a favour and take on the recommendations provided in this book as this would be of value to the entire MIDP community.
Rating:
Summary: A gentle introduction to MIDP 2.0 GUI elements and more
Review: First, a very important note: *this is not a technical book*. If you are already familiar with older versions of MIDP, this book is an overkill and might be a bit boring from time to time. Having said that, the book really does a good job introducing the MIDP GUI concepts and much more. It's a very readable book and contains plenty of clear examples. In the first four introductory chapters (Introduction, MIDP Characteristics, Designing Applications for MIDP and Screen Layout) the authors briefly go over the most important features of MIDP. A special emphasis is given to the new fearures introduced by the latest MIDP 2.0. Then they move to the most important MIDP GUI elements. Each element is introduced and its usage is suggested and the next six chapters explain design patterns and rules to be used with the most common GUI elements (Lists, Text, Forms & Form Items, Alerts and Canvas Screens). The 11th chapter was the most interesting chapter for me - it explains the recommended usage of GUI elements related to game programming. The game package is brand new and introduced in MIDP 2.0. Here the elements such as offscreen buffer, layers and sprites are described. There is even a small subchapter about game performance and resource usage and, at the very end of the chapter, the authors give some general advices related to game creation and programming concluding with a crucial remark: "Always test your games on actual devices". Chapter 12 explains Abstract Commands and the next three chapters introduce the features that really distinguish MIDP development from other Java applications. These features are, of course, strongly related to mobile devices properties and include Application Discovery, Installation and Mangement, Push Functionality and (many times neglected) Security. The last chapter (16) goes briefly into some of more advanced topics of MIDP 2.0 (touch input, overall application preformance and multithreading). This chapter is very basic and contains some obvious hints, but, as I said, this is not a technical book and the chapter does a good job presenting the features that might help GUI designers. The book is intended for beginners in the MIDP application development and, as the name of the book says, is mostly *a style guide* providing plenty of hints and advices. These advices are nicely separated in two classes: "For Developers" and "For MIDP Implementators". Authors use "Recommend", "Strongly Recommend" and "Consider" to mark the importance of these hints. The book is coming from Sun and takes its place in the fameous "from the source" series which implies a certain level of quality. I can recommend this book for all beginners in MIDP area and, especially, to GUI designers and product managers wanting to became more familiar with the MIDP application look & feel.
Rating:
Summary: A gentle introduction to MIDP 2.0 GUI elements and more
Review: First, a very important note: *this is not a technical book*. If you are already familiar with older versions of MIDP, this book is an overkill and might be a bit boring from time to time. Having said that, the book really does a good job introducing the MIDP GUI concepts and much more. It's a very readable book and contains plenty of clear examples. In the first four introductory chapters (Introduction, MIDP Characteristics, Designing Applications for MIDP and Screen Layout) the authors briefly go over the most important features of MIDP. A special emphasis is given to the new fearures introduced by the latest MIDP 2.0. Then they move to the most important MIDP GUI elements. Each element is introduced and its usage is suggested and the next six chapters explain design patterns and rules to be used with the most common GUI elements (Lists, Text, Forms & Form Items, Alerts and Canvas Screens). The 11th chapter was the most interesting chapter for me - it explains the recommended usage of GUI elements related to game programming. The game package is brand new and introduced in MIDP 2.0. Here the elements such as offscreen buffer, layers and sprites are described. There is even a small subchapter about game performance and resource usage and, at the very end of the chapter, the authors give some general advices related to game creation and programming concluding with a crucial remark: "Always test your games on actual devices". Chapter 12 explains Abstract Commands and the next three chapters introduce the features that really distinguish MIDP development from other Java applications. These features are, of course, strongly related to mobile devices properties and include Application Discovery, Installation and Mangement, Push Functionality and (many times neglected) Security. The last chapter (16) goes briefly into some of more advanced topics of MIDP 2.0 (touch input, overall application preformance and multithreading). This chapter is very basic and contains some obvious hints, but, as I said, this is not a technical book and the chapter does a good job presenting the features that might help GUI designers. The book is intended for beginners in the MIDP application development and, as the name of the book says, is mostly *a style guide* providing plenty of hints and advices. These advices are nicely separated in two classes: "For Developers" and "For MIDP Implementators". Authors use "Recommend", "Strongly Recommend" and "Consider" to mark the importance of these hints. The book is coming from Sun and takes its place in the fameous "from the source" series which implies a certain level of quality. I can recommend this book for all beginners in MIDP area and, especially, to GUI designers and product managers wanting to became more familiar with the MIDP application look & feel.
Rating:
Summary: Well thought out and concise intro into MIDP 2.0
Review: Good book, good book. Targeted at experienced Java developers. The book follows traditional Sun style for '... from the source' line. Starts with overview of technology, then loads you with a good number of examples. Given the fact that the MIDP 2 is new, this book is a good resource to own. A lot you can find from the Net but if you are serious about doing real MIDP 2, then you should have this book in your arsenal. There is only so much you can do with MIDP. Pretty basic stuff. I liked the previous review comments: code like you did in 80s. So, true. So as long as you understand that MIDP 2 is for cell phones (not PDA), have basic knowledge of AWT, and own a Java enabled phone, you should be all set to go after reading this book.
Rating: 
Summary: The standard for designing MIDlets
Review: If you are designing Java programs to run on cell phones or PDAs then you will want to keep this style guide nearby. This will not teach you how to code but it will teach you how to design your MIDlets so that they will be usable. The book will show you what works and what doesn't work on small devices. You won't find a single line of code in this book because that is not what this book is about. What you will find are lots of samples of good design and bad design plus plenty of recommendations to help you to write usable MIDlets. The target audience for the book is made up of two groups, those who are porting the Java environment to a new device (implementors) and those who are writing MIDlets to run on those devices (application developers). The book is well structured to show what is the responsibility of each group. For example, the style guide tells the application developer not to worry about text that is too long to fit in a field because it is the responsibility of the implementor to determine if text should be clipped or wrapped. The book starts with some basic guidelines (make your code simple, predictable, and efficient) and a description of the minimum MIDP hardware (tiny screen, limited input, two colors, and little memory). The authors then get into the main focus of the book, designing MIDlets. Starting with screen layouts, they take us through the different items you can place on a screen such as lists, text fields, forms, commands, etc. The focus is not on how to code but on how to make these items usable. The book also covers issues such as push, security, and touch input from the usability point of view. There is no doubt that this book will be the standard for designing programs for MIDP devices. This book can help you avoid a lot of simple (and not so simple) mistakes that you may not notice until you get to usability testing. You could write your MIDlets without this book but why not save yourself some headaches.
Rating:
Summary: The standard for designing MIDlets
Review: If you are designing Java programs to run on cell phones or PDAs then you will want to keep this style guide nearby. This will not teach you how to code but it will teach you how to design your MIDlets so that they will be usable. The book will show you what works and what doesn't work on small devices. You won't find a single line of code in this book because that is not what this book is about. What you will find are lots of samples of good design and bad design plus plenty of recommendations to help you to write usable MIDlets. The target audience for the book is made up of two groups, those who are porting the Java environment to a new device (implementors) and those who are writing MIDlets to run on those devices (application developers). The book is well structured to show what is the responsibility of each group. For example, the style guide tells the application developer not to worry about text that is too long to fit in a field because it is the responsibility of the implementor to determine if text should be clipped or wrapped. The book starts with some basic guidelines (make your code simple, predictable, and efficient) and a description of the minimum MIDP hardware (tiny screen, limited input, two colors, and little memory). The authors then get into the main focus of the book, designing MIDlets. Starting with screen layouts, they take us through the different items you can place on a screen such as lists, text fields, forms, commands, etc. The focus is not on how to code but on how to make these items usable. The book also covers issues such as push, security, and touch input from the usability point of view. There is no doubt that this book will be the standard for designing programs for MIDP devices. This book can help you avoid a lot of simple (and not so simple) mistakes that you may not notice until you get to usability testing. You could write your MIDlets without this book but why not save yourself some headaches.
Rating:
Summary: Program like it is 1985!
Review: Sun and Microsoft have been duking it out for several years for control of the desktop and servers. Microsoft dominates the desktop, but on the server side, Sun holds greater sway. When Sun introduced Java in 1995, it was in an attempt to prise open the desktop. Though java has gained massive uptake on servers, Sun has been unsuccessful on the desktop. But on cellphones, Sun has used java and the phone manufacturers' fear of Microsoft to great success. About 100 million cellphones in the world use Java. Sun says the number of such phones sold this year will be greater than the number of PCs sold; though of course the unit cost of PCs is greater. Which brings us to this book. Written for those who wish to develop using Java on cellphones, PDAs or other small mobile devices. Very topical in the context of the above struggle. In the struggle for mindshare amongst developers, Sun and Addison-Wesley have put forth with this style guide. Very straightforward. The biggest difference, if you are a Java programmer on a server or desktop, is that the resources are now much more limited. The screen might be 1 bit deep and only 96 x 54 pixels, and you might have less than 1Mb of RAM. In a way, if you have been programming since the 80s, some of the constraints are a blast from the past. Back then, on standalone, non-mobile platforms, you probably have no more and maybe much less than 1Mb. You certainly didn't have a 24 bit deep 1600 x 1200 colour display like today's desktops. We have all become pampered with the flush resources on the latter. Now, with the AWT gone, replaced by much skimpier graphics, you can relive the fun you had in the 80s!
Rating:
Summary: Solid giudelines for development for the really small screen
Review: The move from the full screen of the desktop to the significantly reduced screen of a handheld is similar to the re-formatting of a movie made to be viewed in a theater to one presented on a television. However, beyond the problems of reducing the size, there are vast differences. Movie and television screens engage in one way interaction with the viewer, and the effective use of handheld devices necessitates that the viewer be able to discern every detail and interact with the screen.
The problems of compressing a fourteen inch square image into one two inches square are extensive, what is minor on the large screen often becomes significant on the smaller one. This book lists a series of style guides for the small screen presentation, placing them in three categories: strongly recommend, recommend and consider. A guideline is listed as strongly recommend if not following it could render the application unusable. If it is placed in the recommend category, then not following it will lead to an application of reduced usability, although it will still perform as expected, but nowhere near optimal. Being placed in the consider group means that following it will lead to a somewhat improved application.
The guidelines listed in the book can be placed into two general categories, those that apply to all screens and those that are specific to the very small screen. Examples of those that apply to all would be the rules that all error messages should describe the problem and the selected item should always be clearly highlighted. Organizational rules for forms, lists and other structured presentations of data are quite different when the available screen real estate is so limited. It is of course these rules that should receive the bulk of your attention, because for most of us, they are new.
When developing for the handheld, it is necessary to adopt a different mindset, and this book is an excellent primer pushing you into that mode. It shows you a very large number of the critical rights and wrongs, and it should be read by everyone who is shifting to that type of development. There are many things acceptable in the desktop that are unacceptable in the handheld and it is necessary that you learn them before you begin.
The improving combination of better batteries, more electronic power in a smaller space, higher quality wireless signals and improved content means that developing for the handheld is an expanding market. From this book, you can learn the fundamentals of presentation, a necessary first step in creating the applications that will continue to feed the expansion.
Rating:
Summary: MIDP 2.0 Style Guide for J2ME
Review: This is one of a class of books that every application developer should
read, and that not enough do. It provides cheap access to knowledge that is
expensive to obtain. The title is almost a misnomer; Call it a Usability
Guide and give a better idea of it's usefulness. MIDP 2.0 is the latest version of the most common J2ME Profile. It's a
fairly new specification. Nokia, for example, have only announced support for
this on their Series 60 devices in the last couple of months and I'm not aware
of software or firmware upgrades for legacy devices yet. A lot of the content
in this book can be usefully applied to MIDP 1.0 devices though. The MIDP 2.0 Style Guide for the Java 2 Platform Micro Edition is a widget
by widget guide to best practice programming with the MIDP 2.0 API. The
information contained within comes from established design principles, J2ME
programming and implementation experience, and usability studies. The latter
particularly doesn't come cheap, and is out of the reach of most individual
programmers and small companies. So there is real value for money here. The layout is very browseable, with most chapters being a set of
recommendations for a specific for specific widget such as a text box or a
gauge. For the most part each chapter follows a standard format, that is
defined in the introduction. There are two target audiences here; J2ME developers and MIPDP 2.0
implementors. For the former it's an excellent resource. For the latter I
would say it was pretty much required reading. This is because it ends up
defining what amounts to a contract between MIDP implementors and application
developers. For instance, from two successive recommendations on text boxes, Application Developers<
"Use [The NON_PREDICTIVE] modifier in a textbox that has a URL, EMAIL,
NUMERIC, or DECIMAL constraint. Email addresses and domain names are not
typical words, so turning off predictive text input ..." And in the next paragraph, MIDP Implementors
"If the application specifies the NON_PREDICTIVE modifier, allow users to
enter one character at a time without any predictive input facilities." Clearly the first recommendation is only meaningful if the second has been
followed already. There are lot of these sort of co-dependent recommendations. There is still a lot of slop in the MIDP 2.0 specification. Large chunks of
it are optional, or can be implemented in more than one way. This is only to
be expected in such a young technology, but it means that books such as this
may help to define the standard if people use what they give.
I would expect many of the recommendations in here to become part of future
versions of the MIDP specification.
| 
