Wednesday, 17 of September of 2014

Tag » Windows

Windows and The Internet of Things !

Having just read an interesting article by Paul Thurott, about Microsofts Internet of Things SDK built upon 32 bit x86 Windows and using Intels Galileo device (an x86 device the size of the Raspberry PI device) which uses Intels tiny system on a chip CPU (Quark), I found very interesting one of the core development methods which will be required. The WIN32 (or at least a subset of it) will be making a comeback. So why does this interest me ?

A decade and a half of WIN32 development

Because I have spent the last decade and a half not only learning the WIN32 API, but also learning how to build tiny sized software which require minimal hardware. How many programmers today can write software which not only runs on the latest computers, but also can run on something with only the power of what we would call a legacy PC ?  If Windows 8 could run on a PC with only a 500 mhz CPU or less and with only 256 megabytes of RAM and only minimal disk space available for applications, say 50 megabytes or less, could your software run on that ?

Well designed WIN32 software can !

No, really ! Why do I say that ?

The proof is in the pudding!

You have to be a WIN32 programmer to appreciate this. You also have to know how to design software without all the object oriented fluff most software has today. The core WIN32 is actually very procedural in nature. It is basically a flat API and the most efficient WIN32 software is that which is written using the flat API directly, without something like MFC (Microsoft Foundation Classes). Just plain pure WIN32. Now there is no reason that well designed GUI libraries could be written to make things easier, but such would best be written using the WIN32 as a flat API. No OOP stuff to get in the way.

As a long time developer of programming tools and GUI libraries based on the WIN32, I know how “lean” WIN32 applications can be. Maybe because of my going back to the old DOS days, I can appreciate the importance of writing software which requires minimal hardware (Once wrote a complete point of sale system for a video rental store, which ran on a CPM computer with only a 2.5 mhz CPU,  64 KB memory and two floppy disk drives). Old time programmers knew how to squeeze every byte and CPU cycle out of a computer in those days.

Would you like to see what can be done using the pure WIN32 API ?

Download this application I wrote for testing WIN32 backward compatibility on Windows 8: Win8 Test app

The app uses a GUI library which is 100% pure WIN32 based. The real test of any WIN32 app is how well it runs on minimal hardware. First try the app on your current PC and see what it does. It demonstrates WIN32 features like Forms (windows) and standard controls and the common controls, complex window regions, ownerdraw, customdraw, custom controls (written in pure WIN32),  WYSIWYG similar to what Visual Designers do (based on low level GDI), MCI multimedia, GDI drawing, DIB based drawing, OpenGL 3D.

Now feel free to try the app on the slowest Windows PC you have. Try it even with legacy PC’s such as Windows XP (ie. with only 256 meg RAM or less), Windows ME, even Windows 95/98.  Try to imagine how little hardware an Internet of Things device may have. Try it with a PC with less than a 500 mhz CPU and less than 256 meg ram.

Back when Windows XP was the current operating system, I purposely developed WIN32 software on a Windows 95 PC which I boosted to 256 meg RAM. The purpose was to see how well the software ran on minimum hardware. WIN32 software can be designed to run on very minimal hardware and you may be surprised how little you really need.

Native coding for Windows can produce high performance software. Learning how to leverage the low level WIN32 API using a native code compiler like C++ or others can produce even smaller, faster software. Is there is a need for this today ? Yes there is. Watch Herb Sutters talk “Why C++?” and see why and how. Native coding produces smaller, faster, software. The WIN32 coding produces even smaller, faster software. Just what we need for the coming “Internet of Things”.

Now if Microsoft can just learn how to squeeze a complete embeded GUI version of Windows 8 (no Metro or needed) into a small enough size to run on Intels Galileo device, then we would have something worth coding for. WIN32 programmers may then be in high demand. Whether you code in C, C++ or other languages (I code in Powerbasic, which is a BASIC compiler on par with many C compilers) doesn’t matter. They key will be learning how to leverage the WIN32 API so you can write tiny, tiny, tiny software which can perform even on the most minimal hardware. Combined with embeded Windows 8 designed for such small devices, then the internet of things just could become a reality.


Comments Off

Smaller, Faster and more reliable, but you won’t like it !

With all the interest in the “Internet of Things”, currently being discussed in the programming world, it is worth reexamining our approaches to developing software. One thing is for sure, building fast executing software for tinier and tinier devices requires some real rethinking. But wait a minute ! Haven’t we already been here before ? Actually we have, but it is not what you may think.

Our age and experience is our advantage

It seems the programming world is more and more dominated by the young. But in a strange way, the “old timers” among programmers now have an advantage few new programmers can even come close to. What is that ? We have more experience with working with less powerful devices.  You see, with everything going mobile today, devices must get smaller, but the problem is that the smaller the device, the less power it also must have. You just can’t pack as much power into a smaller device as you can in a full sized computer. The concept of the “Internet of Things” also means even smaller devices than we currently have, so the trend will continue. So what is a programmer to do ?

Programmers with a little gray hair, may already have an idea of where I am going in this article. But for you young people, I will give you a little background.

When less was all we had !

My own experience may provide some of the background needed here.  In the 1980′s I started digging deeply into computer programming. The home computer was popular back then, but it was nothing like it is today.  Most so called home computers of the 1980′s would be totally unusable for the average consumer today. They really could not do much and anyone interested in writing software for them really had to work hard to be able to write decent software.  Let’s consider one of the most popular among them, the Commodore 64 computer. It cost as much as two cheap laptops you can buy today (at about $600), but it only had a 1 megahertz CPU and 64 kilobytes of RAM.  True it was not a small device, but it is the minimal amount of hardware power that I am talking about here. By todays standard, a computer with nearly 1000 times more CPU power and over 8000 times more RAM memory than the Commdore 64 is considered minimal hardware. Even if devices designed for the “Internet of Things” had only 1/4 of that power (256 mhz CPU and 128 meg ram), they would still have a CPU 256 times more powerful and 2000 times more RAM than a Commodore 64 computer.

For more info about the Commodore 64

Yet, design software for the Commodore 64 I did. I was using an real native code compiler back then (Abacus BASIC compiler), not interpreted BASIC. I even used the compiler to write my own BASIC subset compiler for nearly close to assembly language speed. I had to understand the hardware I was working with much more so than the average programmer today does. Things like switching out ROM for RAM, building custom character tables, direct access to hardware sprites, etc. Programmers had to learn every “trick in the book” to be able to make a decent application.

When I started writing software for businesses later on, things were a little better, but old CPM computers I was working with were not much better than the Commodore 64. Yet amazingly programmers back then were able to write some very powerful, consumer and business software.

The lessons we learned

Programming is not only a skill, but it is an art of sorts. Like trademens of old (ie. wood workers) , programmers back then developed all sorts of “tricks” to get more out of a computer. They learned what worked and what didn’t. They found ways to squeeze more out of a computer than the manufacturers of the computer every envisioned. One good example was how some amazing programmers developed an actual GUI based operating system for the Commodore 64, called GEOS . True by todays standards it was rudimentary, but it was similar to the early Apple Macintosh interface and for back then it was an amazing feat for the Commodore 64.

Now programmers of today like to refer to old coding styles from back then with terms like “spagetti code” and they tout how much better coding styles of today are. Actually, programmers back then better understood the value of modular code than most may think. You see, when you are working with a tiny amount of RAM memory or even ROM memory for burned in code) you have a lot less to work with, so the amount of space used by code was critical. The only way to maximize ones code, was to write modular or reusable code in the form of flat API’s. The API’s had to be designed to do as much as possible with the minimal amount of code. So if you think old time programmers don’t appreciate modular code design, you are wrong. They understood its importance more than you may think. Code rusability (or modular design) was one of the keys of effective programming back then. But there was one major difference between modular design back then and modular design today. And what was that ?

Flat API’s versus Objected Oriented API’s

Programmers back then worked with what we today would refer to as a Flat API. Flat API’s are more procedural in nature than Object Oriented ones. But Flat API’s have a few advantages over object oriented ones. But aren’t Object Oriented approaches superior to old style Flat API’s ? Actually, you may be surprised (I told you that you may not like this) that Flat API’s not only still exist and are used by a number of programmers, but that the such API’s allow programmers to write the smaller, faster and more reliable software we all desire, especially for the coming “Internet of Things”. Let’s consider this.

Advantages of the Flat API model

- Smaller

Flat API’s by their nature tend to be significantly smaller in size than their Object Oriented counterparts. I am convinced of this. Building classes (and objects) for everything adds a significant amount of overhead to an API. It is just the nature of it. The generated machine code from such compiled libraries also has extra overhead in them as well, so the end result is software which is larger in size and more complex. Now one may thing it does not matter with the powerful computers of today, but what happens when devices get smaller and smaller and that power is lost ? The end result is sluggish software. With the powerful computers we have today, we should have lightning fast software, but sadly we don’t. Why ? Because of the extra overhead we add to software. Flat API’s can greatly reduce this overhead, which means smaller and faster software.

- Faster

Flat API’s use less code, which means less generated machine code, which means less machine code for the CPU to execute, which means FASTER code ! This I am also convinced of. True, the goal of many libraries today is suppose to be easier programming, so isn’t the extra overhead worth it ? The reality is that what many consider easy, may not be so easy after all. For some, coding today has become simply a matter of selecting objects, classes, methods and properties from a drop down list via an intellisense based code editor. But have you ever wondered who wrote all those objects and classes you use ? Likely a C++ programmer, not only adept at writing object oriented code, but quite possibly knowledgable with the use of more procedural style coding styles and Flat APIs. And some of those Flat API’s likely were written by some pure C programmers, rather than C++ programmers. Every programmer should watch this video of Herb Sutter’s talk entitled “Why C++ ?” .

- More Reliable

Now this one, you may not like to hear, but please have an open mind on this one. Can Flat API’s be more reliable than Object Oriented ones ? Now of course, reliablity has a lot to do with the quality of the code no matter how it is written. Bad code, no matter the methodology used, is still bad code. But with that out of the way, how could Flat API design be more reliable than Object Oriented design. Two reasons I will discuss here. First is the simple reasoning of when there is less code, there is less that can go wrong with it. The less code being executed, the less things that can go wrong. Flat API’s lend themselves to a less code approach, so there is less code to debug, less code to go wrong, so a better chance of more reliable software.  But the second reason is far more important. No programmer can write perfect code the first time. Human nature as it is, we all sooner or later mess up and we introduce bugs into our code. Some bugs are from typing errors. Some are from logic errors. Some are from design errors (the concept is simply flawed). At some point we have to go back and trudge through our code looking for what went wrong. In the old DOS days, this was not too much of a problem because following code flow was pretty straight forward. But today, with multi-threading, event based execution and especially with object oriented coding, tracking code flow can become a nightmare to say the least. To quote an interesting article I found in Intel’s web site, “Now it is almost impossible to follow the execution flow”  and with this I agree. Flat API’s by their nature are inherently easier to track code flow. Especially if the Flat API was designed well, modular and does not go too deep in its inner levels (ie. an API calls another API, which calls another API and so on).

Does anybody use a Flat API anymore ?

Actually, the answer is yes ! One of the most powerful, popular and with a long history is the Windows WIN32 API . While later versions of Windows has a good bit of COM in it, most of the WIN32 API is a flat API, which accessable even from the most rudimentary of languages like Assembler, pure C and so on. An entire application can still be written today using a purely procedural style of coding using a Flat API (WIN32). Why would anyone want to do that, seeing we have such more powerful programming languages today ? Back to the Internet of Things. Devices are getting smaller and smaller and less powerful because of this and we need to be able to build smaller, faster and more reliable software for these devices. Windows Embedded can be shrunk down to a pretty small size today and by using the WIN32 API developers can produce amazingly small, fast and reliable software, well suited to the smaller devices.

I have been programming using the WIN32 API for the last decade and half now and I am convinced at how powerful the WIN32 API is and how it allows one to build smaller, faster and more reliable software. As one example, why not check out this very powerful graphic library written using the WIN32 API. It is called GDImage . GDImage was written using the WIN32 API (and OpenGL 1.0/2.0 which is also a Flat API). The developer even uses GDI+ (GDI Plus), but instead of the window classes version, he uses the GDI+ Flat API version in the WIN32 API.  The graphic library was originally written in PowerBasic and then recently ported to C++ (but he avoided using an OOP in it).  The library is not only very sound (reliable), but what is most amazing is the performance (fast) and the size (only 315 Kilobytes) .

Now while I don’t expect many to code in assembler today, here is an excellent example of combining coding in assembler and using the WIN32 Flat API. It is a nice utility program called ToolBar Paint. It demonstrates how tiny a WIN32 application can be (and fast) and still be very useful and productive. Maybe there is something to learn from developers like these, especially if you want to develop software for the “Internet of Things”.

As a long time WIN32 programmer myself, I can attest to how fast and how small WIN32 applications (and libraries) can be. Also well written WIN32 applications can be very reliable too.





Comments Off

The $99 Windows Tablet ! Is it possible ?

Maybe this is only possible in my imagination, but I really do think it could be possible and if so it could bring Windows to a totally different use than ever imagined before.

Let’s start with the Desktop !

What does this have to do with the ultimate Windows tablet ? A lot, but be patient and I will get to the point. While some may think the desktop PC is obsolete, I for one really doubt that. The PC is for getting real work done. For some this may mean a laptop running Windows, but for many it means a real desktop PC, with a large monitor, a quality keyboard and a real mouse. Laptops are great for those on the go, but some just need a large display and once you start making the display large enough, it really does not make sense to make it mobile anymore. Both my wife and I use desktop PC’s, with primary 22 inch monitors (1920 x 1080 pixels)  plus a second monitor along side (which can be a bit smaller in size). She uses hers for working with graphics and animation software and I for programming. Dual monitors just make sense for many applications. The point is, no laptop and definitely no tablet will can replace the desktop PC for many tasks. But tablets need not be PC replacements either. They only need to  be useful within their own context (light weight and mobile).

Now add to this the keyboard. If anyone thinks that a touch keyboard or even a light weight external tablet keyboard can replace a quality desktop keyboard, then I really wonder how much typing they really do. I am so picky about my desktop keyboard, that I am still using an over 20 year old IBM model M keyboard with real mechanical keys. The speed at which I can type on this keyboard is so fast compared to any laptop keyboard, that it irreplaceable to me. A tablet could never even comes close in usability for typing in comparison. Real work requires a computer designed for the task at hand and desktop PC’s likely will always have a place, especially in business. It is important to use the right device for the right task.

Laptops are middle of the road devices

The laptop is very valuable as well. Laptops give you a more middle of the road solution. They have the power of a desktop PC, but they have the benefit of being mobile. For me the biggest weakness of a laptop is the keyboard and the touch pad. True, some get very good at using a laptop, but for some a laptop keyboard keyboard just can’t replace a quality desktop keyboard and a touchpad just can’t come close to the good old mouse. That said, many make do and they find the laptop still very useful. For example, my latest laptop I purchased, I opted for a Lenovo brand because of the reviews about their keyboards (they make very good laptop keyboards) and I purchased an external Microsoft Arc Touch mouse which I am very pleased with. Between the Lenovo quality keyboard and the Microsoft Arc Touch mouse, my laptop comes close to being nearly as useful to me as my desktop PC. Still, a 15 inch screen laptop at over 5 lbs, the extra mouse and the laptop messenger bag are not what I would call a total light weight package.

So now we come to tablets

So now we come to tablets. Tablets serve a purpose and are great mobile devices. True, most tablets are likely used by consumers, but my concerns are about using tablets for business purposes. Despite being a computer programmer, I don’t have a fancy smart phone and I am not wasting my time playing hours and hours of the latest mobile game. While I do have both a Windows tablet and two Android tablets, I didn’t get them for the typical consumer consumption tasks most people may use them for. When I browse the web (usually for research for work or for reading the latest news) I typically have my PC browser open with 5, 10 or even 15 tabs open, each with a different web page on them. I will browse one page (to see if the information is useful to my research) while another is downloading. I may watch a podcast once in awhile about something dealing with programming or other tech subjects on my second monitor, while browsing the web on the other. It is all a matter of speed and efficiency. This is all done on my desktop PC and not the tablets. My tablets, while I do have some personal uses for them, are primarily so I can experience how a mobile device works and for testing any software I may create for tablets. I haven’t done much with Android yet, so that is more of a hobby right now, but the Windows tablet was purchased specifically for testing Windows applications I may develop for tablets. But the more I use my tablets, the more I realize the limitations they have and also the key differences between software written for the desktop and software written for tablets (and there is a difference). The idea of a tablet being used as if it were the same thing as a desktop PC is not realistic. Software for tablets need to be written specifically for a tablet in mind.

Now I am coming from the perspective of using tablets for business use, not for the typical consumer use. For years I wrote custom software for a variety of local businesses (from CPM, DOS and then Windows). I know what it means to get work done using technology. Back in the DOS days a typical PC cost $2000 to $3000 each. That was a lot of money back then, so I had to learn how to help my clients make the most out of the technology they purchased.  One of the important lessons I learned was to use the right equipment for the right task, but also to keep the costs to an absolute minimum. I never encouraged a customer to upgrade to the latest computer, simple because it was fashionable. Some of my customers used their computers and software far beyond the typical lifespans most businesses allocate for them. I wrote some DOS applications which amazingly are still in use today. For a business, technology is great, but only if it pays for itself and it does valuable work. So why is this important and what does it have to do with Windows tablets ?

Use the right device for the right job

If a business mistakenly views a tablet as if it is was a full blown PC, then they may end up paying too much money up front for the devices, get less work done with them and may end up wasting a lot of money. Why ? Some software, simply put was meant to be run on a desktop PC with the hardware to support it and not on a tablet.  For the price of a high end Windows tablet a business could buy two inexpensive, but decent laptops or even desktop computers. So, if a high end tablet is going to be used by a business, they surely need to evaluate whether it really is up to the job and worth the investment. Maybe a laptop would be better suited to the task. Maybe the task is well suited to the tablet, but will the benefits outweight the costs. There is a use for high end tablets, but only when the returns make the cost worth it.

But tablets have limitations. By time you start adding things like a fancy case (or cover) for the tablet, accessories like digitizer pens and external keyboards, the costs can get pretty high and the low weight factor may be lost and what makes the tablet any better than a comparable laptop now ? Maybe a business could have purchased two decent laptops for the price of the one tablet and all its accessories. So does this mean that tablets have no value to a business ? No, but one needs to weigh the costs versus benefits. But imagine if very low cost Windows tablets were available, so one could afford to buy a laptop or desktop for the heavy work loads and then add an inexpensive Windows tablet to the mix for when a very light weight, limited mobile device would suffice or even better better suited !

A lesson from Android

I am not an expert on tablets by any means, but I do follow the news about what is happening in the mobile world very carefully. As a programmer I need to know what people are doing with mobile devices. One thing for sure is that tablets seem to be more popular among consumers, more apps in app stores seem to be for consumers (ie. games) and the current model for much of the tablet world for software is free software where developers find alternate ways  to monetize the software, such as in app purchases. The free model for software may work for consumers, but for businesses software costs money and the right software for tablets may even cost more. The software is what makes the device useful to a business, not the hardware. A fancy retina capable display (high resolution) may sound great, but it doesn’t usually make a tablet any more productive for a business.  Only two things matter for a business when it comes to using mobile devices. One is the cost of the device and the other is software which makes the device a useful tool. One lesson we can learn from Android is that lower cost tablets make a difference. Likely the popularity of Android has as much to do with the many different choices of hardware it runs on. Some may opt for the $300 tablet (or more), but more and more people are looking for the under $100 tablet. True the experience with a $100 tablet may not be as good as the higher quality tablet, but for many it suffices and they are happier because they did not waste money which could be better spent on more important things. The low cost tablet is here to stay and it plays an important role. So what about Windows tablets ?

Bay Trail and smaller form factor breaks some barriers

Not only has the performance of Windows tablets gotten better with Intels Bay Trail systems (Atom system on a chip), but this has brought the price levels down significantly. The new minimum system requirements for Windows 8 has also brought us the smaller 8 inch form factor, which gives us smaller, lighter and less expensive Windows tablets. Just this week Best Buy was selling the Lenovo Miix 2 , 8 inch, tablet for only $199. The Microsoft Store was selling the similar Dell Venue 8 Pro for only $229. The price is getting more and more reasonable now and this makes Windows tablets worth considering for a business.

But as a programmer, I think we could go further. How ?

Rethink how tablets are used in business

Maybe I am too thrifty by nature, but I find it makes sense to spend money on technology in a way where you get the most out of your investment. For example, unlike many who just have to have the latest smart phone with the most expensive data plan possible, I only have a cheap TracFone which only costs me about $7 a month with just enough minutes so I have a mobile phone when I really need it, like calling home to see what my wife wants me to pick up at the store when I am out or being able to call for help in an emergency when maybe my car breaks down. Just enough technology for the task at hand and at a price that does not break the bank.

For a business, mobile devices, such as tablets, are the same. Maybe a business wants to hand out a tablet to hundreds of employees. The cost can get very high in this case. But will the tablet accomplish enough work to make the investment worthwhile ? This will only be the case if the tablet is affordable enough and if the tablet is used correctly. Having written custom software for many years for businesses, I realize that the cost versus benefits factor must be carefully weighted out. From my experience, often the software is more important than the hardware. A $500 tablet with only minimal software (meaning it only accomplishes so much work) is far less valuable to a business than a $100 tablet with well written software which does some real work. The real investment should be in the software.  The freemium model of selling software for consumers in some app stores may give a false sense of security to some business owners making them think that if they just buy the really expensive tablet, then the software will be there waiting for them and it won’t cost much. Quality software, which does valuable work, simply put costs money. Now if the tablets cost too much money and the right software costs a lot more, then the total long term expense may make the investment a poor one.

Don’t be fooled by the bring your own device model

The current idea of bring your own device sounds like a great idea doesn’t it. Let the employees bring their own devices and the company saves money, right ? Maybe. But this creates the problem with cross platform development. How many different devices will the company have to support ? Can the software be written so it works just as well on all the devices ? What if you want the software available for desktop PC’s as well as the tablets ? In the long run the expense for writing custom software for so many different devices can far outweigh the savings of the bring your own device policy. Remember, it is not how many different devices you support which matters, but how much work those devices accomplish. The software is what mattters and quality software is not easy to develop, no matter what platform you support. Cross platform development, no matter how much it is promoted by tech companies, comes with compromises. Programmers, if they are honest will admit this. How many times will one platform support a feature while another may not have the exact same thing ? If you think the difference between different web browsers is a problem (ie. web site shows well on one browser but not on another), then consider multiple operating systems along with dozens of different form factors. What works well on a laptop may not work well on a 10 inch tablet. What works well on Windows may not work well on IOS or Android. Cross platform means compromise. Now at times cross platform makes sense and it is worth the cost. But is it possible that developing software for only one major platform and even one specific device format could produce better results if the software is written properly ? I think this is so.

It takes years for a programmer to learn how to get the most out of a specific platform

As a WIN32 programmer, I can honestly admit that it can take years for a programmer to learn how to get the most out of a single platform. I have spent nearly a decade and a half in learning the Windows API (WIN32) and how to get the most out of it and I still have only tapped into a small portion of it. Changing technologies every few years only slows down software development, rather than improve it. Just when a programmer feels they are getting really productive with a technology, all of sudden there comes a new one which the IT world now embraces and it is back to the drawing board again for many programmers. What a waste of experience this is !  Since software is the important thing for mobile devices for business use, then core technologies which change little over time have a far longer lifespan and may produce better and more productive software over time. As programmers learn how to tap into the deeper features of a technology, they can do more with it and accomplish more with less changes in the hardware. This has been true ever since the beginning of the home computer. Back in the days of the Commodore 64, a group of programmers created an operating system called GEOS, which accomplished more than the creators of the computer ever imagined possible. They turned a home computer with only a 1 mhz CPU and 64 KB RAM into a minature Macintosh, just by pushing the hardware limits through well written software.

If there is a platform today which has this same potential, I would say it is Windows and not the new WINRT Windows, but the good old fashioned real Windows. There probably aren’t many programmers left today with the experience with the core WIN32 API’s to know how to accomplish the same kind of thing the developers of GEOS did for the Commodore 64, but there are some and the technology is so well documented that it would not be difficult to train new programmers.. What many businesses may not realize is that good old fashioned native coding for Windows is capable of producing software which can not only perform well on todays Windows tablets, but it is capable of performing well even on a tablet with one quarter the power of todays tablets (maybe even less). I know, because I am a native Windows coder and I know it is possible. I also realize that there are programmers are capable of writing software for Windows which can run on far less powerful hardware and that if if efforts were made to develop more software this way, then manufacturers could build Windows tablets which can run such software which cost half the price of what they cost today. By matching the right software which less expensive hardware, the $99 Windows tablet could be possible. Rather than keeping Windows tablets high priced and making then more and more powerful, it is within reason to build even lighter Windows tablets, which are thinner with even longer battery lives, but which have less powerful hardware so they would be far less expensive. Software developers could concentrate on learning how to push the hardware to its maximum limit, so the tablet can do real work effectively, but with a low overhead for expenses for the hardware. Software needs to be designed for a specific platform and even a specific device format. Imagine a large corporation buying thousands of low cost Windows tablets for as low as $99, equipped with software that does an important job and effectively. One would not need any more hardware than the task requires. Some tasks could require a little as 1 ghz or less CPU, 1 gigabyte or less of RAM and an SSD no larger than 16 gigabytes. The displays need not be super high resolution either, but just enough to make the device effective.

Windows is actually far more capable for such devices than you may imagine. Companies who have used embedded versions of Windows in their equipment know that the minimum requirements of the hardware can be brought down to a pretty low level as long as the software they write can work with it. Imagine if the concepts of embedded Windows were applied to tablet development. The $99 Windows tablet could be a reality. Also imagine Windows tablet like devices which are so light and thin that they could be used for so called “wearable” devices. As costs drop, even flexible displays could be used for wearable devices. Imagine Windows devices so small and thin and inexpensive that they could be used for all sorts of embedded purposes, so they could be used almost anywhere. It is possible. But it all comes back to the software. I have been programming long enough to know they we don’t need more and more powerful hardware. We passed the point of “powerful enough” many years ago. Windows already has the core technologies so that high performance software can be written for it and require minimal hardware. The core WIN32 API’s , native coders use, are just as viable today as they were over a decade (or two) ago. If manufacturers were to concentrate on building less expensive, thinner and lighter Windows tablets, programmers will find ways to push them to their limits. It may require programmers to work a little harder, but as I said before the software is what matters now, not the hardware. If businesses could buy Windows tablets which are so thin and light (which is possible if they don’t need to be as powerful) that they are as easy to carry around as a cell phone and for a price as low or cheaper than many Android tablets, but still get a lot of work out of them, would that not make a lot of business sense ?

The ultimate $99 Windows tablet

The ultimate Windows tablet for me (and I expect others might be interested) is not the next generation tablet with twice the power or with the latest retina display. It would be a tablet which is inexpensive ($99 is possible), half the thickness of todays 8 inch tablets, but only requiring a decent resolution display, half the memory, half the CPU power and half the disk space of the typical Windows tablet today. Now imagine that because it needs less memory, a smaller SSD, less screen resolution and a much less powerful CPU it can be built not only more cheaply, but is can be half as thick, half the weight and have twice the battery life of todays tablets and be running real Windows ! Businesses would find more ways to use them. Probably buy more of them. And by putting the expense into the right software, still get a lot of useful work done with them. This is one native coder, already capable of writing such software today ! Yes, I mean today. The software is already possible.

Do you doubt this is possible ? Can native coding really produce high performance software capable of running on such a limited Windows tablet ?

Even though I am not a C++ programmer, I greatly appreciated Microsoft’s C++ expert , Herb Sutter, in his talk “Why C++ ?” where he discusses writing software with performance in mind. Watch this video (on Microsofts Channel 9) and see why native coding for a specific platform makes a difference.

As a native coder, I don’t currently write many full applications because I am a developer of tools for programmers and my main work has been in developing tools (ie. a GUI framework), but I do have some examples of what native coding can do which you can download. As a test to appreciate what native coding can do, why not download the following example applications and try them on as many different Windows PC’s as you can. I would recommend at least a resolution of 1024 x 768 for testing (at the default 96 DPI). Some of the apps are scalable based on the DPI, so I can’t guarantee that on some devices they may not scale beyond your devices screen resolution, but they should fit on most Windows PC’s and tablets. I have not optimized any of the apps for Touch yet, but they should still be useable even on a tablet.

What I would like you to try, is to see little hardware is required to run the applications. Run them not only on a modern Windows 8 PC, but also on Windows 7, Windows XP or even an earlier version of Windows. For example try them on any legacy PC with as little memory as possible and see if they still run reasonably well. Native coding can produce applications which are tiny in size and yet have very good performance.

App #1:   Windows 8 compatiblity Test

This app I created for testing my GUI framework and its features to make sure it worked on Windows 8 and that the WIN32 still supported the features. Make sure your PC has the proper OpenGL drivers for the 3D part (only requires OpenGL 2.0 or less).

App #2:  3D Model viewer

This app I wrote to test my GUI frameworks 3D engine. The app is for working with the STL file format (used in 3D printing). It can handle huge 3D models with as much as a million or more polygons in them. Now there is a quirk in some STL binary model files, where the header of the file is encoded as if it were an ascii (text) file, which may confuse the model viewer. If that occurs in a file you use and the model does not display, simply change the file extension from .STL to .STLB so the viewer forces it to be viewed as a binary STL model file. (I fixed this in a later version).

App #3:  3D Sandbox demo app for Intel 2013 App Innovation contest

This app was written for the Intel contest and it still has much work left to finish it, but it does demonstrate some nice features already such as scalability, better design for touch on tablets, etc. I should point out that the actual app (EXE file) may seem a little larger in size than the other apps above, but the actual code in it is minimal and most of the size is because of embedded bitmaps for texture maps.

All of the above apps are written using native coding (the GUI framework they use is 100% native coded) and they are designed to work on minimal hardware. So why not try to see how minimal machine you can get them to run on effectively. About the only feature in the apps which may have a limit  as far as hardware capability is the 3D stuff which requires OpenGL. For example with the 3D model viewer, maybe use models with a lot less polygons in them on a very limited Windows device. Now on my Windows Vista desktop PC, with a simple Pentium D (dual core) CPU , 2 gig of memory and a minimal graphic card, the 3D model viewer does a pretty good job with even 3D models with over a million polygons in them. So if you try the app with say a Windows XP computer with only 256 meg RAM and minimal OpenGL support, why not try much smaller models like with only a few thousand polygons.

The above demos should at least demonstrate the native coded applications can work on very minimal hardware, so a low cost Windows tablet would still be viable to run some very powerful software.




Comments Off