Does Windows 8 programming lack creativity?

Windows 8 brings a totally new user interface model with its Metro environment, which is receiving mixed response from developers and end-user customers. The tile-like UI certainly is different from the classic desktop.

Does Metro mean that software will be even more creative than in previous Windows generations? Is there an inherent flaw in software design that prevents us from getting better software and will it still exist with Windows 8?

One Size Fits All Doesn't Always Work

I learned an interesting lesson when switching from developing end-user software to designing tools for programmers. I quickly realized that one size (or model) doesn't fit all. I had to make a choice. Do I build software tools so they work exactly like everyone elses' or do I design tools with the ability to be different things to different people?

A common rule you will often see touted in the software industry is that user interfaces should always follow certain fixed rules so all software is consistant. For years, Microsoft encouraged Windows software developers to maintain a certain look and feel. Now with Windows 8, Metro once again forces a certain look and feel (no windows, full screen and flat-looking UI elements). In the early years of the personal computer, there were no such rules so programmers were, in my opinion, more likely to be creative, to come up with new and exciting ways for users to interact with their software.

True, they may have copied some things they liked that others did, but in general programmers tried to find ways to do things better than they did with previous software. An outstanding example was GEOS for the Commodore 64. The C64 was not designed for a GUI, but some exceptionally creative programmers made it possible nonetheless. A term that best describes this mindset would be "thinking outside the box". I don't feel that same freedom today, but more and more I feel the pressure to conform to so-called UI standards, even if they may not be well suited to a specific task at hand. Windows 8 and its Metro interface continues to promote this less than creative mindset, despite its intended goal to do otherwise.

How Can a Programmer Be Creative When Developing Software?

So how does a creative programmer view software development? It's like the difference between Lego blocks and a block of wood. Lego blocks are fun and initially more creative because you can create all sorts of stuff quickly that may excite yourself and others. Today's programming styles are more like using Lego blocks. But a block of wood offers more creativity. Really? Yes. While a block of wood initially is much more difficult to turn into a work of art, in the long run it offers more choices. Lego blocks will always be block shaped and the only way to get something that isn't a block is for the manufacturer to design a specific Lego object that is not a block; that is fine for a toy, but not for software. A block of wood inspires the imagination, and an experienced woodworker will allow his/her imagination to run wild and with the right skills; it is amazing what the block of wood can become -- from a work of art to a practical tool or device.

Software development should be more like working with that block of wood. Provide a skilled craftsman with the tools to turn it into anything. Will Metro encourage such creativity? Or will it encourage conformity to the point of making software development less creative? These are valid questions.

One Size Should Not Fit All

A lesson can be learned from something in nature. Water is a perfect example of something where one size can't fit all. In general when something gets colder, it also increases in density (gets heavier per cubic inch). Metal, concrete and really almost everything we can think of follows this rule. Water, though, is unique in nature. It also follows this rule, until the point of freezing where something amazing happens. It actually gets less dense (lighter). It breaks the rule. Why is this important? Because when a body of water like a lake freezes, if ice were heavier than water it would sink and in time a lake could freeze solid. Ice would sink to the bottom, then the top layer of water would begin to freeze and this would continue until all the water was frozen.

But water is different. Because ice does not sink and is lighter than water, it floats; as it gets thicker, it shields the water below from the cold and acts like an insulator. I am sure the fish in the lake appreciate this very much. Water demonstrates intelligent design, but does our software?

Can you see the point? Sometimes it is good to do things a little differently, especially when doing so improves things significantly. Similiarly, with software development, there are times to "think outside the box" so to speak, to be creative, especially when it improves the user experience and increases productivity.

Change Only Works When It Really Makes a Difference

Not all tasks are the same, so neither should all software be the same.  Sometimes an old standard need not be changed simply because it works so well, while at other times something totally new may be required.

I had a customer for whom I designed some custom software. Originally it was a DOS application, but eventually I created a Windows version, too. What was interesting: The company preferred the DOS version. You don't do things exactly the same in Windows as you would in a DOS. They were so productive with the DOS version of the application, I chose to do something totally different. I wrote a Windows version which in the key areas (data entry) emulated the DOS application. It still had some Windows UI features, but where it counted acted more like its DOS cousin. It was a hybrid, not quite DOS, but not quite all Windows. Why? Productivity to the end user was more important than consistancy on a platform or having the latest UI.

Some outsiders might have thought my application looked ugly and failed to meet proper Windows standards. But this customer for years told me he has never found any software that was a good as the one I designed for him. The company still uses both versions of this software, DOS and Windows, together, to this day. In this case, I found that a hybrid approach (combining the old with the new) was better.

In some of my previous articles I proposed Windows 8 would improve with a better blend Metro and desktop motifs. It doesn't have to be one or the other (that actually lacks creativity). Rather than force software developers to pick one UI model or the other, why can't they be better blended. Windows 8 has the WinRT (Metro) and WIN32 (Desktop), so why not create a unique Blend API that merges the two together. It could follow the rules of the Windows 8 sandbox approach if necessary, but offer some more choices for long time WIN32 programmers. Why not be a little more creative!

Windows API (Desktop) is Under-Utilized

With terms like legacy, one might think that the long-time Windows API (WIN32), which is at the core of what in Windows 8 is called the desktop, is somehow obsolete, old fashioned and even flawed. Yet, to a creative programmer the Windows API is a rich environment with almost unlimited possibilities. The reality is that the Windows API and its features are under-utilized.

Let me give you some examples. In Windows there is a feature called OwnerDraw. What this means is that a number of UI elements (controls) in the operating system, such as a Listbox or Combobox can be customized so a programmer can change their appearance significantly. Another feature in the Windows API, called subclassing (also superclassing), allows a programmer to modify how a control works and responds to user input. For example, it's difficult for me to convert a normal Edit control (Text Box) to a Masked Edit control, where user input is more controlled.

Another very powerful feature in the Windows API is the DIB engine. DIB stands for Device Independent Bitmap. Basically it allows a programmer to define the format of a memory bitmap to what ever he or she prefers. It also allows a programmer direct access to the pixels of the bitmap so he or she can write extremely fast graphic routines. I learned how to leverage the Windows DIB API's and wrote my own proprietary 2D Sprite engine, which supported movement of non-rectangular objects, image flipping, frame animation and even alphablending and anti-aliasing.  Now do you realize that the Windows DIB engine has existed since Windows 95 and is just as viable today on Windows 8? This means I could do advanced animation on any Windows computer from Windows 95 to Windows 8 (and it works perfectly on Windows 8).

In designing the programming tools that my business sells, I find that the most powerful thing I can offer to other programmers is the ability to tap into all those unique features found in the Windows API, so they can build software any way they want to, without limits. It is not up to me how they design their user interfaces. I want them to feel free to do whatever they feel is best for their own software. Rather than force specific user interface rules, I find it is better to provide more ways to customize an application's user interface.

Is It Possible to Support the Entire Range of Windows Versions?

Some of my peers in the programming world criticize me still supporting legacy versions of Windows -- from Windows 95 to Millennium Edition (yes, you read that right). The common mindset in software development usually is "drop the old" and "build for the new", no matter the cost. Sadly, so much time is wasted because of this that programmers have to constantly keep upgrading their skills and end up throwing away tons of good code. But isn't it more creative to find ways to keep what still works while merging it with the new?

Do you realize that since Windows 95,  the Windows operating system was designed so one could easily do this ? The designers of Windows put some very smart technology into the OS from day one. No not COM. No not DirectX. But a very simple approach called DLL, or Dynamic Link Library. But what some programmers may not appreciate is that this dynamic library model has the ability to allow an application to poll the library to see whether certain APIs exist in it or not.

By using this simple technique one programmers can build applications and even their own libraries that are intelligent. This way one can build hybrid applications which can run on all versions of Windows and when it is run on a newer version, to access newer features of the operating system. This is not just theory. I have done it and I have customers who are currently developing commercial software using this technology. Sometimes the simplest solutions are better.

Microsofts GEM -- the Windows API 

Does Microsoft really appreciate the true GEM they have in the Windows API (WIN32)?

The Windows development world has moved from framework to framework over the years, starting with MFC to todays .NET. Yet software doesn't get better and better, but it is getting more bloated and resource hungry and actually slower. Yet I deal with a community of programmers who are constantly digging deeper and deeper into the Windows API, producing new and exciting products and tools that push the limits of the OS, while keeping the software so small that it can fit on a floppy disk and all using the pure Windows API.

Some may want to see proof of this, so here is a good example. The developer creates programming tools that just amaze me. I would consider this programmer to be an expert when it comes to the Windows API. He is also creative and his software shows it. He has two products in particular that demonstrate this, GDImage and WinLift. GDImage is a graphic engine that is amazing, and WinLift is a skin engine. Yet these libraries are absolutely tiny by today's standards and they are "fast and fluid", too, and they both demonstrate the power of the Windows API as well as true creativity.

Software Should Emulate the Real World

Rather than be confined to a fixed set of user interface rules, software should be designed to better emulate the real world tasks they copy. A simple, yet so obvious example, is how in an application that has a video player, it is common to have button controls that emulate the buttons on a VCR player. The consistancy here is not based on platform requirements, but on real-world tasks instead.

Especially software used in a business environment, we should design software that emulates the real world tasks they copy. For example, programmers may be encouraged to only use the style of button controls that the operating system provides by default. The buttons all look the same. The only way to have buttons with different colors is to draw them yourself using ownerdraw, so programmers may simply opt for the standard looking buttons, all the same color and style.

Yet in the real world physical buttons are rarely the same, nor are they always the same color. Color is often used to make physical buttons stand out -- for a reason! It is common with machines to have one button a specific green color while another has specific red color. Color has meaning. So why don't programmers use color with button controls more often?  Could it be they are fixed on UI standards and the desire to make software which looks like everyone elses?

The Power Has Been With Us All Along, But Do We Use It?

Isn't it a bit funny when you consider that many computer manufacturers tout the 3D capabilities of the video cards/chips in their computers today and that when you look at Windows 8 and its Metro-style applications that they look awfully flat by design? True, you can have 3D in Metro games, but where are all the 3D UI elements for normal applications? The real world is 3D, so why can't we use 3D more in everyday applications? That was my feeling, when my business produced it latest generation of programming tools.

Fortunately for me, the Windows API has long allowed third-party additions to the operating system, particularly OpenGL. Now OpenGL is considered obsolete when it comes to Metro. Fortunately for now, Windows 8 (with the right drivers) still supports OpenGL on the so-called legacy desktop. Because OpenGL has the ability to be used in multiple child windows (controls) at the same time in the same application, it is quite natural for me to want to design a custom control that uses OpenGL for 3D. I am not talking about a full-size single window OpenGL application. I am talking about a real custom control that provides OpenGL. I can create a form and then add multiple 3D controls where ever I need them. I even wrote my own proprietary 3D OpenGL based scripting language for the control and all using the Windows API and OpenGL API's.

But that isn't all! Once again, I used the hybrid approach. DirectX is all or nothing, but not so with OpenGL (which is why I used it). The custom control I designed is a hybrid. It combines the GDI (and even my 2D proprietary sprite engine) with OpenGL 3D. Now that is not the common approach to 3D, but yet it works great, so why not? Why not a real 3D control which you can plug into a normal Desktop application?

So whether it is 3D, animation or simply good business graphics, the power has been with us all along. Yes, the so called legacy desktop (WIN32) has always had the ability to amaze us. Don't believe it? Just for fun I installed a software OpenGL driver for the original Windows 95 and guess what? Yes, my little old custom 3D OpenGL control works perfectly on an ancient Windows 95 computer (albeit a little slowly). It also works very well on the Windows 8 consumer preview too.

All Is Not Lost!

Despite all the negativity, Metro is not the failure many would have us believe. It is something new and different, which in time will open up more possibilities, especially on tablet PC's. Also Microsoft was smart to leave us the desktop side of Windows, too, since it still is very important.

In reality, the problem is that Metro and the desktop are more like an "odd couple", with little in common. But like any good long-time marriage, the partners over time need to better blend together. The more separate they become, then the more likely they will divorce and we all know which one will suffer the most -- the desktop!

Maybe there is still hope for this unlikely marriage. Maybe the two can better appreciate the other and by the time Windows 8 is released, the two will become one. Thats my hope. Call me an optimist.

Photo Credits: StudioSmart/Shutterstock (top); Microsoft (others)

Chris Boss is an advanced Windows API programmer and developer of 10 year-old EZGUI, which is now version 5. He owns The Computer Workshop, which opened for businesses in the late 1980s. He originally developed custom software for local businesses. Now he develops programming tools for use with the PowerBasic compiler.