Software development has changed a lot since the days when I started programming. In those very early days, programs written in bare machine language were toggled into a rather large machine one by one and then executed by pushing a button. Debugging was agony.

Help came soon with the introduction of punched paper tape and optical readers. Although progress in this area has been striking, it lags behind the advances on the software side. Machine language is invisible. Its replacement by assembler language, high-level languages, and the introduction of development environments has been nothing short of astonishing. This book is an exposition of a very contemporary environment, C# and Extensible Application Markup Language (XAML), and Microsoft Visual Studio.

Examining this triumvirate reveals the strengths and weaknesses of this approach. All three of the elements are powerful in their own right, and yet they’re limited in their scope. This environment produces apps that run only on Microsoft’s own platforms.

The first word in the book’s title is “Universal,” an exaggeration considering that the universe is actually a “MicroUniverse,” basically Microsoft’s universe. The author shows how to write programs that will work under Windows and Windows Phone, but not on an iOS or Android device. There are good reasons for this, of course, but it’s useful to remember that we’re talking here about Microsoft’s universe.

The use of C# and XAML mixed together in the same program modules is encouraged in those circumstances that are beneficial. It’s not always clear what these are, and the case is not made that the added complexity and extra knowledge involved are worth the trouble.

The author’s goals are:

• “to provide a solid grounding in the underlying concepts in a practical and approachable fashion”;
• “to answer the questions most people have when learning how to write universal apps and to show how commonly desired tasks are accomplished”;
• “to be an authoritative source”;
• “to be clear where the technology falls short”;
• “to optimize for concise, easy-to-understand code”; and
• “to be an easily navigated reference that you can constantly come back to.”

There are 24 chapters organized into six parts.

Chapter 1, “Hello, Real World,” is what you’d expect. The example is first written as English only and then in other languages, exploring the concepts of globalization and localization, and ends by discussing how this app might be submitted to the Microsoft vetting service. Chapter 2, “Mastering XAML,” focuses on the mechanisms of XAML, property and object elements, and keywords. This concludes Part 1.

Part 2 has three chapters dealing with the mechanics of actually building an app. It discusses sizing, positioning, and transforming elements; object layout; and the process of handling inputs from touch pad, mouse, pen, and keyboard. The emphasis is on the correct (or reasonable) behavior for a variety of screen sizes, orientations, and types.

Part 3 talks about the app life cycle from initial call to final kill and what they must do in their life cycle. There is a chapter on threading and the interaction with the operating system. Finally, there is a chapter on how to make money with the app (Good luck with this!).

XAML comes into its own in Part 4. Here, we discover the controls that are embedded in XAML. There are a fair number of these, and six families of them are each treated in their own chapters. These are content controls, items controls, text, images, media controls, and everything else. All but the last of these are straightforward. Chapter 14 deals with controls that do not easily fit into the categories of the other chapters.

Part 5 continues the use of XAML by examining its place in vector graphics. There is a full-length chapter on animation. Chapter 17 explains three main components of control restyling, that is, styles, templates, and visual states, permitting the developer to change the look of XAML controls. This feature alone empowers the developer with a powerful degree of creativity.

Chapter 19 begins Part 6 and shows how an app can work with data of different kinds. The kinds discussed are app data, user data, and networking data. Chapter 20 shows how apps can use certain commands found in the Windows environment, commands such as search or print. This is followed by chapters entitled “Leveraging Contracts,” “Reading from Sensors,” “Controlling Devices,” and “Thinking Outside the App.”

The last pages of the book contain a very thorough index.

The book is well proofread, and very colorful, with specially colored inserts and sidebars for frequently asked questions, tips, and warnings. The code examples can be downloaded from a website. Examples assume the use of Windows 8.1, Windows Phone 8.1, and the corresponding developer tools (freely downloadable). A thorough knowledge of C# and XAML is a prerequisite for understanding what’s going on. The prose is of high quality.

The book is recommended for developers who feel comfortable using Microsoft Visual Studio who want to create apps for Microsoft products.

More reviews about this item: Amazon