Book Review for "Microsoft Windows Intune 2.0: Quickstart Administration"

Are you a Windows administrator? If so, you may be curious about Intune, Microsoft's browser-enabled tool for managing groups of PCs. This book explains how you can use Intune to set up and manage groups of PCs, to include software installation, migration, and maintenance.

The first chapter explains basic cloud concepts. Most of today's current buzzwords are explained from a high-level view.

Chapter 2 covers PC management, including management via policies. This is a little closer to the core material for the book, but still not quite down to the hands-on level.

Chapter 3 starts with Intune capabilities. This chapter is really an overview of what will be covered in more detail later in the book. Roughly, these topics include the following: Installation of Intune, the Management console, Security management, Auditing, Reporting, and Alerts and Support.

Chapter 4 is a deep dive on the Installation process.

Chapter 5 is all about configuration. It includes sections on addition of administrators, configuring groups, alerts, and license management.

Chapter 6 covers policies and updates. Policies have a sophisticated hierarchy, so you can group PCs by different criteria. Firewalls and anti-malware are explained here.

Chapter 7 explains how you can prepare software to be pushed to your client PCs, and how you can also remove software from the client PCs via Intune.

Chapter 8 is about Reporting and Alerts. Intune ships with standard reports, or you are able to write you own if you wish. Reports can help you do things like figure out which of your managed PCs have older hardware, or are running particular versions of software. Alerts are notifications that something has gone wrong, like mal-ware being detected. Obviously, these are important.

Chapter 9 deals with responding to Alerts and ways you can provide support for the remove client PCs.

Chapter 10 explains Desktop and Recovery Toolset (Dart), which is the most capable support mechanism. This is the one you will end up using if a user has a blue screen of death or some other serious flaw that can't be resolved through simple software pushes. You can unlock passwords and un-install hot fixes that you think may have done more harm than good. One notable item: If you go into deep recovery mode, you're going to need an actual user at the keyboard of the affected PC. Microsoft hopes to make this completely remotable in future iterations.

Chapter 11 gives coverage of Windows 7, which is the current target O/S for Intune. It includes a nice section that tells you how you can backup user preferences and data from the current O/S (i.e. XP) and how to re-apply them when the machine has been upgraded to Windows 7.

Chapter 12 explains how Intune relates to other Microsoft products you may be working with. Most of these products will be completely compatible, some will be partially so, and some not at all. It also explains which other Microsoft products you may be using for PC management, and how they may relate to Intune.

Overall, the book is a very easy read with a generous allotment of screenshots.

Who should read this book? Anyone who manages groups of Microsoft PCs which will be using Windows 7. Given that scenario, Intune looks like it would make administration from any browser-enabled PC possible. If that's your toolset, you probably ought to look into Intune and this book.

The book can be found here.

Happy Cloud-based Administering!

Avoid this Fundamental Mistake, Simply Illustrated

An easy to make mistake in planning your Enterprise application can cost you big time. (Some folks even repeat this error after suffering through it once, because they don't understand why they failed the first time.) Here are two pictures that show you the right way to do it, and the wrong way as well.

One of the best things about my job as a SOA support engineer is that I get to see lots of application architectures, shared from smart people from all over the world. I probably learned more in the first year of this job than I did in my best 5 of any other, because I got to benefit not just from my own mistakes, but also from the mistakes of others. Nobody is right all the time, and anybody who steps out to design something complicated is putting themselves at risk of learning some good lessons. Here's one that's shown up time and again.

It's natural to read about layered architectures and think this means you can have different machines that serve different purposes. It seems natural to think of a bank of servers that act as 'business logic' machines, perhaps sending data over the wire to a different bunch of machines at the 'DAO layer'. This is wrong, don't do it! A variation of this theme is to envision a couple of machines that 'concentrate' on a task like being a messaging broker. Same idea-- let one server concentrate on one task-- this is not good!

A better way of doing it is to use your whole middleware stack on EACH server. (That's right-- let that server act as GUI, mid-tier, Data layer, JMS broker, etc.) Manage load by using a load balancer up front. This is much easier-- once you have the configuration put together, replicate it as many times as needed to scale up (assuming your middleware offers this capability. In JEE, it's pervasive.) If you have stateful clients, you'll want to use replication so you can failover. If your cluster goes beyond a couple of machines, you'll want to use 'Buddy Replication' schemes, where only 2 or 3 machines replicate state for each other, rather than every machine trying to carry state for the rest of the cluster.

Check the diagrams. This isn't a new idea-- I know I've heard this from Martin Fowler, read it in 'JBoss in Action', and seen it in print elsewhere too. But still, the idea is perhaps not the 'natural' decision to make, so people who haven't had it called out to them may make a big error in a very expensive place. Please think hard before adapting a "Distributed and Layered" architecture!

Happy Architecting!

Book Review: Hadoop In Practice MEAP update

Manning adds more content to the latest Hadoop book. Real-world users will benefit.

Manning offers books that are in "MEAP", which is a way for readers to peak at books as they are developed. As the book is written, Manning will periodically take what they have "so far" and make it available electronically. They're recently offered a few more chapters of "Hadoop in Practice", here's what they contain.

There are some minor changes to earlier content, but the biggest change is new content. Here are the new chapters:

Chapter 2, "Moving Data in and out of Hadoop"

Chapter 4, "Applying MapReduce Patterns to Big Data"

Chapter 7, "Utilizing Data Structures and Algorithms"

Chapter 2 deals with moving data into and out of Hadoop. It provides techniques for working with flat files, databases, and HBase. You're introduced to some tools that can help you with these tasks and ancillary needs like translating and aggregating the data. You're given ideas on how to push data from external sources to HDFS, and how to pull data from external sources directly into the MapReduce framework. You're also given an introduction to a scheduler that can help you repeat these tasks on a periodic basis, sure to be a production concern. All the examples contain instructions on how to obtain the helper components, how to build them if necessary, and how to configure and run them.

Chapter 4 provides suggestions to help optimize Big Data operations in MapReduce like joining, sorting, and partitioning.

"Joins" are familiar to most programmers, necessary to combine data from 2 different sources based on some specified criteria. You are given ideas on how to best handle Inner joins and Outer. You are given ideas on how you might do your joining on the Map side or the Reduce side, and when each idea is appropriate. You are also given some expert insights into how Secondary Sorting works, and how the MapReduce framework interacts with your Map and Reduce functions at this point in the life cycle.

Chapter 7 examines algorithms and presents some valuable patterns and algorithms you can apply to your big data problems. Graph theory is used to conceptualize problems like 'Shortest Distance', where you try to calculate the fastest way to traverse a graph of nodes. Other problems deal with things like determining which nodes is best associated with another, the famous PageRank algorithm, and use of Bloom filters.

In my opinion, these latest chapters add positive value to the book, I think it's shaping up nicely. The concepts presented reveal expert insight into real-world problems a Hadoop user would encounter. If you are a Hadoop user, you owe it to yourself to check this one out.

Happy Hadooping!

Book Review for "Do More with SOA Integration"

The first notable thing about this book is that it's big, nearly 700 pages. It is really a conglomeration of sections from several other books, so the scope of what is covered is wide. Like SOA itself, the book is not a cohesive whole that offers a shrink-wrapped solution to your problems. What this book does is offer concepts, considerations, and implementation advice for a variety of SOA needs.

The first few chapters are high level overviews. They provide a historical introduction to SOA, going back to the roots in EAI and before. Much of this will not be important for a contemporary architect or implementor, but it will help the reader to understand the past technologies used for Integration and how we got to where we are today.

The third chapter has some relevant material, and introduces some very important concepts. Among these are Transactions, OSGi,JCA, SCA and Process Modeling. These are all topics that are very much relevant to contemporary SOA, so the authors did well to include them. They also included some material that didn't quite pan out as well as it was envisioned (i.e. JBI), so it's a slightly mixed bag. Like with any book on a fast moving topic, you'll want to consult the contemporary workspace as you read the book, to understand which parts are going to be important to you.

Chapter 4 is about XML processing, and it has some really good content. (You can't touch SOA without getting XML all over you.) There are some expert recommendations on schema design, namespaces, message construction, etc. SOA architects should find some good ideas here.

The next chapter introduces BPEL, the standard way of hooking web service invocations together. As with the rest of the book, the material is presented using tools from the Oracle tool chest. Throughout the book, the reader should keep this in mind because users in Oracle shops will find some ideas directly applicable, where users of other technology stacks may have different mechanisms for accomplishing similar tasks. Fortunately, BPEL is fairly standard, so the terms we find in this chapter will be applicable to many users.

There are sections that are very much particular to certain products or vendor components. (For instance, there's a sizable piece on PeopleSoft CRM and Oracle Applications, integrated via BPEL.) This section can serve as a generic case study for users of other products, but some of the material is necessarily specific to the chosen products.

JBI and it's inner working are given good coverage in a couple of inside chapters. Once thought to be an emerging standard for ESBs, it now appears Integration products are growing in different directions, so these chapters may not be of interest to you depending on your chosen toolkit. Still, the material is well written and will be of use to some users.

Chapter 9 is about Web Services, a workhorse component of SOA. It includes a small catalog of "Runtime Patterns". I'm not quite sure what to think about the patterns yet-- we probably don't have enough well-agreed best practices documented in SOA, so this might be a step in the right direction. Some of it seemed a little too general to be useful for me, but perhaps in time I'll see better what was intended here.

Chapter 10 hits heavily on the Enterprise Service Bus (ESB). ESBs are solid winners in the marketplace, and have proven themselves to be an important component of SOA. This chapter is a big one, and the coverage is good. I found particular value in the sections on ESB operations, XSLT processing, distributed transactions, and WS-Standards.

Chapter 11 is about loosely coupling services and working to make services stateless. Some interesting ideas are presented, and implementation details about how to achieve the desired statelessness if you are using Oracle's tools.

Chapter 12 covers BPEL, as used with Oracle's suite.

The final chapters focus on 'legacy' integration, especially mainframe integration. The focus is especially sharp on IBM mainframes and the surrounding environment. If you are tasked with working in this space, there is material of value to you here.

So, what's the final verdict? I would recommend this book to:

- Anyone integrating with an IBM mainframe, using Oracle's tools

- Users of Oracle's SOA Suite

- General SOA readers who have a desire to round out basic knowledge. This book is not a good way to get off the ground, though.

The book can be found here.

Happy Integrating!