Brian starts out by looking at the history of mobile and the mobile landscape as it is today. Long-term followers will not find much new stuff here, but it nevertheless makes for an interesting read.

He then moves on to “mobile strategy”. Topics include questions like “What is special about mobile”, the influence of “context” also is explained in some detail. Finally, various options for creating a mobile app are explained – some of them are somewhat obscure and definitely aren’t something you deal with every day.

The next part analyzes the design process for mobile applications. These chapters are what make the book really interesting – you are introduced to design, prototyping and user testing methods for touchscreen and non-touchscreen applications.

The second half of the book looks at the design and creation of mobile web sites: frameworks, compatibility et al get covered in extreme detail. Native application developers are largely left twiddling their thumbs…

As usual for O’Reilly, the book is well-written and readable even for non-native English speakers. Code examples are provided in various web languages; an ample amount of images is included for clarification where beneficial.

In the end, Mobile Design and Development is a great book if you want to create a mobile web app. Creators of native applications can’t use half of the book: if you are interested in the mobile design process, it is a good if somewhat paper-heavy tutorial. Web heads, on the other hand, should buy it straight away…the 23$ shouldn’t hurt…

William Rice starts out by looking at a few “common myths” of the trade. What is user training, what isn’t it? Who needs to be trained?

Afterward, the book takes a strictly wizard-like approach. A repeating template not dissimilar to the one found in use cases takes you step-to-step from nothing to running user demo, which can be deployed to third-party instructors.

Style-wise, PackT is different from other, more “established” publishers. Their visual presentation is more “to the bone”, and less playful – the whole book didn’t contain a single image. Nevertheless, it was well written and easy to understand.

In the end, I predict that PackT has a bright future ahead of it. This book fulfills its need – if you have just been enlisted to teach at an university or often write manuals and online help systems, you definitely can benefit from it. The price of 13$ for the paperback is ok…

Larry Roof and Dan Fergus start their text with a thorough look at the 2003-ish mobile device landscape, the .NET Compact Framework in general and also provide a few hints on UI design. Afterwards, topics like controls, files and XML get covered in painstaking detail.

Once this is done, the book goes on to provide a very thorough introduction to databases. If you ever wondered about how to keep databases in sync, use SQLCE or whatever – your answers should be in here.

Loose ends like help systems, P/Invoke, generating reports with third-party components and even networking are also treated in individual chapters. While this coverage can not be called complete in any way, it nevertheless provides interesting starting points for further study.

Finally, a few appendices cover “small stuff” which didn’t fit anywhere else…

The book’s presentation is somewhat atypical: it is divided into independent chapters, which provide you with a dense mix of code and explanations. It’s a bit strange at first, but understandable – being a non-native English speaker, I had no issues understanding the tome.

Even though the book is now hopelessly outdated in some aspects, I nevertheless consider it a must-have for every Visual Basic developer. If you are developing mobile apps, head over to Amazon and cough up the 21.5$…

As this book is not intended as a learning but rather a reference tool, reading it from start to end is not as easy as with other books. However, I tried and succeeded – if you already have a pretty good understanding of C/C++ and object-oriented programming, you should be able to grasp the concepts within a few minutes of thinking around.

O’Reilly has put a lot of work into the index. If you are looking for something, you will usually be able to find the relevant piece of text very quickly.

Please let me put this in writing once again: you are NOT able to learn C++ from this book. Novices, look elsewhere! People familiar with Java may have a chance, but are also advised to look elsewhere.

Text-wise, there is nothing to bicker about. The book is clear (for a reference), and contains enough tables and graphs to visualize stuff where needed:

Cutting a long story short: the 10$ this book costs are well invested, especially if you tend to program offline a lot (netbook) and have a nasty habit of forgetting rarely used syntax elements. The book covers all important things except for using C code in C++ programs – this is a purchase you will not regret IF you are already proficient in C and have at least basic knowledge of object-oriented programming.

The book starts out by looking at the basics of the .NET framework – what is CIL, why are things implemented the way they are and so on. The next two chapters look at variables and strings: this is not ideal for beginners, as it does not allow you to start coding immediately.

Afterwards, the book looks at exceptions and object-oriented programming. Generic data structures and delegates also get a chapter of their own. When this is done, chapters look at multithreading, data storage, databases and LINQ – every important piece of C# gets covered except for P/Invoke.

Christian Gross’s text structure is very “head-heavy”. Blocks start out with a bunch of code, which gets explained afterward: things like syntax samples are used rarely. This means that quite a bit of thinking is needed to get into some concepts, which means that casual reading is not as easy as it is with other books.

In the end, the Amazon price of 30$ voids further discussion – if you are interested in C#, you are unlikely to find a cheaper book which is not “just a reference”. Even though the text structure is not optimal for my taste, I nevertheless got everything I needed…

Nevertheless, the folks at the Boy Genius Report have uncovered very interesting screenshots from the inventory system of a Canadian carrier – the most interesting quote is below:

…
While nothing is confirmed, we have to think we’re looking at EV-DO Rev. A for both handsets along with dual-band GSM as the World Edition moniker implies
…

As of now, no further information is available – stay tuned!

First of all: this book covers dynamic campaigns implemented with Flash. This means that the included images alone don’t tell the full story – you have to read the book and look at the included DVD on a PC in order to fully grasp a campaign.

Advertising OnLine divides its campaigns by their subject matter: the chapters cover Food&Beverage, Media, Service&Retailer, Technology&Games, Transport and Miscellaneous ads. Each ad campaign is given one to three pages worth of photos and a badly-written description text (which comes in three languages:). While some campaigns are straightforward or boring, some of the ideas really made me think. For example, did you ever think about using an IM bot as advertising tool?

Mobile computing freaks will be happy to hear that the book covers various advertising campaigns for phones: Nokia, Motorola and the now-defunct Siemens Mobile are all in the mix.

The aforementioned chapters are divided by interviews with various creatives: as the book was written in 2005, these serve more as amusing reading than as insight.

Like with most photo books, the paper quality is insanely high. The entire book is printed on semi-glossy paper, which makes the pictures look lovely. Unfortunately, the text is very unclear and full of grammatical errors…I often read all three (English, German, French) versions of the text in order to grasp its meaning.

In the end, people expecting to learn about making the most of a small ad space will be gravely disappointed with the book. It instead looks at what future technologies like ShockWave and Flash can achieve (or will be able to achieve in the future) compared to classic GIF banners. If you ever wondered why banner designers use flash, like picture books and have 26$ and some time to spare, hit this Amazon link…

Programming Sudoku is divided into seven chapters. The first looks at the rules of the game and can serve as an excellent introduction to the game for beginners and people who never cared about Sudoku puzzles(e.g. yours truly).

The second chapter looks at Visual Basic.NET and at designing applications for Windows. A nice load of basics are transported in the process: people who can program in C or VB6 will be able to pick the ball with ease.

The next three chapters look at various algorithmic tricks that can be used to tackle Sudoku puzzles. Even though Sudoku itself is straightforward, solving “difficult” puzzles can require extremely sophisticated and interesting algorithms…

Chapter six is especially interesting: it looks at methods for generating puzzles. Toppling around solving algorithms generally is a very interesting approach: this tome takes it to the max.

Finally, an appendix looks at a soduku derivative called Kakuro…

Wei-Meng Lee did an excellent job clarifying key concepts. The sample code is easy to understand, images are deployed wherever they are useful:

In the end, Programming Sudoku is an excellent read for people who feel like reading up on methods for solving puzzles with a PC. The methods learned here probably can be applied to other games easily… However, the book has an additional positive effect: it serves as a quick introduction into Visual Basic.NET. If you currently develop Palm apps and plan to move over to .NET CF, getting this book will pay out. As for the price: at 17$@Amazon’s , it’s a total bargain!

The book starts out with a broad look at the enterprise device landscape, the development options and at the various flavors of Windows CE. It also gives an overview of what the .NET CF can do well and what it can’t – people who have not programmed for the .NET CF before will definitely benefit a lot from this.

The second part looks at an enterprise application’s “architecture” – that is, at data storage and synchronization. Multiple chapters are dedicated to each of the fields, each one of them presents every possible concept in considerable detail(with a nice bit of sample code). I especially enjoyed the chapters on data synchronization related to the SQL Server CE – knowing this has saved me literally hundreds of man hours on a project that I currently pursue.

Part 3 is a “smorgasboard” of various interesting items. Fox&Box introduce you to things like localization, application deployment and security – topics that are very important in everyday life, but are very hard to get a grip on without proper documentation.

The book is very well written and easily understandable for anyone with a bit of Visual Basic experience. Graphics and tables like the one below help you when it comes to understanding complex problems:

In the end, the ever-famous Fox&Box book IMHO is a tome that belongs into each and every .NET CF coder’s claws. While it does not contain hundreds of step-by-step recipes(or a thorough introduction into Windows Mobile); it gives you a quick overview of the development landscape. This will come in handy when looking for actual sample code – and helps you avoid unnecessary duplication of code already contained in the framework. The price of 40$ at Amazon’s is a bit steep(seeing that small parts of the book are outdated), but still justified…

Matthew MacDonald starts off by looking at the IDE itself – what changed, and more importantly, what’s in it for me. Many of the hints given herein can be significant time-savers(e.g. the automatic documentation generation). After that, the book goes on to look at various new aspects of the Visual Basic language. VB6 coders like me will find great value in these chapters; as they omit what you already know.

Two chapters on Windows and Web applications follow. These are written in a ‘cook book’ style – if you need what’s described, read it and party. If not, reading the code anyways shows you interesting facets of VB2005(for example, did you know about the IsNot operator?).

A chapter on all kinds of data-related tasks is included – its style follows the chapters before it. Last but not least, a chapter on the .NET framework looks at interesting ‘miscellanea’ like code performance timing and deployment – while I still miss a recipe on the insanely tedious process of creating an installer for a .NET CF application; it made a great read nevertheless.

O’Reilly books traditionally are well-written and easy to read; I am happy to say that this one makes no difference. The paper used is of good quality, too…the unusual page design helps a lot when making notes:

In the end, Matthew MacDonald’s book makes a great ‘hint book’ showing a lot of cool ‘gems’ that a developer could otherwise miss easily. While it cannot replace a structured introduction to VB; the hints contained can be worth their price in gold. If you have 22$ spare, add the book to your next Amazon order!