A lot can be said about Windows 8. Personally I like it, it’s 2013 and Windows 7 was still using practically the same Window management paradigm; Application Windows minimize to the Taskbar, which serves as a launching point- in conjunction with the desktop- for pretty much everything. A lot can be said in favour of this- and why it’s lasted so long. For one thing, it works, and it works well.

Design

Personally I believe that to be a very strong argument for why Windows should keep the same design strategy. But it’s also very true that the software and hardware ecosystem is changing. There are some proponents that say that the desktop PC as we know it will no longer exist. I agree with that sentiment, but not very far- It won’t change roles, but we are definitely going to see new input devices and innovative UI designs appear, such as touch interfaces. Imagine a touch-screen interface on your laptop or LCD Monitor- pretty powerful feature that you don’t miss until you’ve given it a try. Then you find yourself scratching at your older LCD and wondering how you ever got along without a touch-screen. It’s very much like most other UI additions; the Pointing Device is ubiquitous when it comes to desktop and laptop machines, and unless you happen to have some understanding of a lot of keyboard shortcuts that aren’t really spelled out anywhere (On windows, I mean things like Control-Esc, Alt-Hyphen (to show the control box of an MDI Child) Alt-Spacebar (to show the control box of a Window) Alt menu accelerators, window management using the mouse, Alt-Esc, and of course Tabbing about dialogs, there simply isn’t a lot to go on. I know most of those accelerators and can usually use most applications without a mouse (when I have to charge the batteries, as an example), but I still find myself constantly reaching for it anyway. It’s become a part of the computing experience. Personally, this is how I feel touch-screens will be regarded in the future. In many ways the way we regard touch-screens today have a lot in common with how we thought of mice before the Macintosh popularized Point & Click. It’s just waiting for it’s “Killer App”. For the Mouse, that was the Macintosh, which brought with it the GUI. What will be the Killer App for Touch on the desktop? Impossible to say. But I have no doubt none of the Operating Systems we have available- be they OSX, Linux, or Windows, come close. The way I see it, when this new Killer App/OS finally appears- the one that makes Touch a necessity as the Macintosh and Windows made the mouse a necessity- we will regard the systems we have today in the same way we currently think of DOS and pure CLI machines- that is, not really suited to your average user.

Moving forward

But, back to Windows 8. Taking what I said above, one can perhaps see why I think it’s at least a step in the right direction; we’ve gotten used to working in one way- like we got used to working with CLI interfaces before. What is going to happen will likely be some sort of fundamental shift. The issue of course is that- well, this is the tech industry, so a “fundamental shift” is not something that generally get’s you loud gasps. Part of the reason might be that the news, and of course application marketing- often conflates things so that it seems like there is a fundamental shift every week. But that doesn’t change that we’ve been using the same basic interfaces for nearly a decade. Nonetheless, Windows 8 is more a “transient” in-between thing. It’s not quite a touch OS, and it’s not quite a Mouse interface. It tries to deliver on both fronts, and I think it does a reasonable Job of it.

Developers,Developers,Developers!

My concerns lie primarily in the developer side of things. Switching from a Command-Line Application programming model to a Event-Driven User-Interface model has caused a fundamental shift in the development landscape. Developers that can’t keep up, give up. And, fundamentally, that’s what worries me. Will I be one to keep up, or will I give up? Either way, I don’t doubt that desktop applications on Windows will be with us for the foreseeable future, but one still has to consider the fact that time, as it moves inexhorably forward, will move past that temporal horizon we can currently see. But we don’t know what skills we’ll need. This is what drives many developers insane- trying to keep up with all the technologies today is pretty much impossible. But at the same time, it’s what attracts many of us to the field; while no doubt other industries are constantly making new discoveries, I’ve always found the discoveries and ‘ah ha’ epiphany moments totally worth it. For example, when I first started using C# a year or two ago, I struggled. I was moving from Visual Basic 6- an old frazzled language and platform that was put out to pasture years before. I distinctly remember the most frustrating part was having a understanding deep enough to know that the language was not giving me all it’s secrets, but not deep enough to fully understand them. It was the promise of knowing more that kept me going onwards. the C# Reference that came as part of the MSDN library with Visual Studio 2008 was a constant companion, as I referred to it for things like the syntax of declaring a lambda or anonymous delegate. At some point, the underlying concepts clicked; the last two neurons on the chain of learning suddenly touched dendrite to axon and it just clicked. Suddenly I found myself going back over my code and refactoring it using my sudden deeper knowledge. Naturally, it didn’t stop there, and I ended up having similar experiences with Delphi as well as (back to C#) LINQ. To some extent working with a bit of JSON suddenly made me understand what a prototype language was, and so on.

The Chase

Am I saying I’m at the end of the road? Of course not. What I’m saying is that I worry that perhaps the next hurdle will be too high. The mild euphoria that such epiphanies promise being beyond my grasp. For a time, I suspected that the Windows 8 Development model was simply beyond my grasp.

I received an E-mail through the Microsoft MVP Program that provided some very helpful information on creating a Windows 8 App based on a Open Source framework, Metropress. Metropress has been renamed since to ideapress. It w as very promising. After some effort I was able to create this:

Now that’s a sexy Windows 8 App.

And it was pretty awesome. I could read posts and started to consider putting images in more posts as a result. Unfortunately I wasn’t able to get it on the App store; even though I had a free Developer Account through MSDN, it required a Credit card number. Oh well! Perhaps I can plonk it up there in the future at some unspecified time. At least I was able to learn a bit about the Windows 8 development model.

My reaction to the Windows 8 development model is anger. There is nothing fundamentally bad about it, but from what I could tell (from looking at the default sample applications) there is a lot to it. That is- we’re talking the level of boilerplate required to extremely basic Windows Application in C. That’s what initially got me thinking of the historical precedent. But it is interesting because behind all these technologies and APIs, there really is a single goal. To make everybody else play catch-up. If people are spending time learning to develop a Windows 8 Application, for example, they won’t be innovating their own products. It’s not a 100% airtight theory, of course, but it rings true in a lot of cases. In this case I think software development is still trying to get a foothold on exactly how a touchscreen application should look and act. Just as windowing systems all acted brutally different in the early days, so too is a lot of touchscreen-oriented behaviour very much OS-specific.

For the next few iterations, OS and software vendors will be simply trying to find out how a touchscreen application should work. They will experiment. Some attempts will fail. Others will succeed. And we cannot predict how times river will flow, so it’s best ot just ride out the rapids and hope you have a fast enough reaction time to prevent yourself getting dashed against the rocks.