Big enough is big enough

Visual Studio has a macro capability, but you might never have used it. You might not even know that it exists.

You see, you cannot use it as Visual Studio comes "out of the box". The feature is disabled. You have to take action before you can use it.

First, there is a setting inside of Visual Studio to enable macros.

Second, there is a setting inside of Windows to allow Visual Studio macros. Only system administrators can enable it.

Yes, you read that right. There are two settings to enable macros in Visual Studio, and both must be enabled to run macros.

Why? I'm not sure, but my guess is that the Visual Studio setting was there all along, allowing macros if users wanted them. The second setting (inside Windows) was added later, as a security feature.

The second setting was needed because the macro language inside of Visual Studio is powerful. It can call Windows API functions, instantiate COM objects, and talk to .NET classes. All of this in addition to the expected "insert some text" and "move the insertion point" we expect of a text editor macro.

Visual Studio's macro language is the equivalent of an industrial-strength cleaning solvent: So powerful that it can be used only with great care. And one is always at risk of a malevolent macro, sent from a co-worker or stranger.

But macros don't have to be this way.

The Notepad++ program (the editor for Windows) is a text editor -- not an IDE -- and it has macro capabilities. Its macro capability is much simpler than that of Visual Studio: it records keystrokes and plays them back. It can do anything you, the user, can do in the program, and no more.

Which means, of course, that NotePad++'s macro capabilities are safe. They can do only the "normal" operations of a text editor.

And it also means that macros in Notepad++ are safe. It's not possible to create a malevolent macro -- or send or receive one. (I guess the most malicious macro could be a "select all, delete, save-file" macro. It would be a nuisance but little else.)

The lesson? Macros that are "powerful enough" are, well, powerful enough. Macros that are "powerful enough to do anything" are, um, powerful enough to do anything, including things that are dangerous.

Notepad++ has macros that are powerful enough to do meaningful work. Visual Studio has macros that can do all sorts of things, much more that Notepad++, and apparently so powerful that they must be locked away from the "normal" user.

So Notepad++, with its relatively small macro capabilities is usable, and Visual Studio, with its impressive and all-powerful capabilities (okay, that's a bit strong, but you get the idea) is *not* usable. Visual Studio's macros are too powerful for the average user, so you can't use them.

Something to think about when designing your next product.

Android PCs will clobber Linux, on the desktop

The big PC operating systems (Windows, MacOS, and Linux) leave a lot of administration work to the user. Over the years, all have made improvements. Windows has focussed on domain management, giving corporate support teams administrative control over PCs. MacOS has hidden a lot of configuration from the user and made the installation of applications easy with drag-and-drop operations. Linux has leveraged open source, package managers, and repositories of software to reduce the cost of installing software.

Android already has a firm beachhead in the phone and tablet market. Now it can expand onto the home PC.

A number of manufacturers have introduced "Android PCs", full-sized computers running Android. I think that they have a bright future, and may supplant Linux on the home desktop PC.

But isn't Android really Linux, configured for phones and tablets?

Linux is at the heart of Android, true. But Android is more than Linux with a smaller user interface. Android handles more device management and software management than Linux.

Android's model is closer to Apple's iOS/iTunes method of managing software. Android (and iOS) let the user purchase and download software quickly and easily from centrally-managed repositories. They are not exactly the same: Apple locks you into their repository; Android lets you add software from other repositories. Yet both have unified updating mechanisms, and both let you move to new devices and keep your apps (and data). Android (and iOS) manage the updates for all of your apps. Buy a new phone, and (once you register) you can quickly re-install your apps without incurring additional charges (Android and iOS remember that you have purchased the apps).

The traditional PC operating systems, in contrast, force you to upgrade your software and (possibly) acquire new licenses. In Windows, the Microsoft update service handles Microsoft products, but products from other vendors need their own systems. Buy a new Windows PC, and you have to install all of your applications, including the Microsoft ones. This arrangement works for the corporate environment, with a support team that assigns, licenses, and installs corporate-approved applications. It offers little for the individual PC owner.

Linux distros come close to Android's functionality, with an update service that handles all software. Yet Android's update system is easier to use and more convenient, especially for the individual user.

Windows will maintain its dominance in the corporate world, and Android will gain in the home market. It is the enthusiast, the computer geek, who wants to tinker with Linux and settings. The average person wants a computing appliance, one that needs as much attention as a toaster. Android delivers a better toaster than Linux (or Windows).

That's for user PCs. Servers will remain unaffected by the rise of Android. The people running servers (the sysadmins) are geeks, and they want (need) the ability to tune those servers.

Android (or some operating system that offers a toaster-like appliance level) for servers may happen in the future, as individuals (non-sysadmins) want servers. But that's some time away.