Thinking of All the Possibilities in Software Design

A number of books on my shelf, some of which I’ve written, broach the topic of divergent thinking. Unfortunately, many developers (and many more managers) don’t really grasp the ideas behind divergent thinking. Simply put, divergent thinking starts with a single premise and views as many permutations of that premise as possible. Most developers don’t take the time to use divergent thinking as part of the development process because they don’t see a use for it. In fact, most books fall short of even discussing the potential for divergent thinking, much less naming it as a specific element of application design. I’ve explored the topic before and a reader recently reminded me of an article I wrote on the topic entitled, Divergent Versus Convergent Thinking: Which Is Better for Software Design?.

The process that most developers rely upon is convergent thinking, which is where you convert general goals and needs into specific solutions that appear within a single application. The difference between the two modes of thinking is that divergent thinking begins with a single specific premise, while convergent thinking begins with a number of general premises. More specifically, divergent thinking is the process you use to consider all of the possibilities before you use convergent thinking to create specific solutions to those possibilities.

There is an actual cycle between divergent and convergent thinking. You use divergent thinking when you start a project to ensure you discover as many possibly ways to address user requirements as possible. Once you have a number of possibilities, you use convergent thinking to consider the solutions for those possibilities in the form of a design. The process will point out those possibilities that will work and those that don’t. Maintaining a middle ground between extremes of divergent and convergent thinking will help create unique solutions, yet keep the project on track and maintain project team integrity. Managing the cycle is the job of the person in charge of the project, who is often the CIO, but could be some other management position. So, the manager has to be knowledgeable about software design in order for the process to work as anticipated.

One of the reasons that many applications fail today is the lack of divergent thinking as part of the software design process. We’re all too busy thinking about solutions, rather than possibilities. Yet, the creative mind and the creative process is based on divergent thinking. The reason we’re getting the same solutions rehashed in a million different ways (resulting in a lack of interest in new solutions) is the lack of divergent thinking in the development process.

In fact, I’d go so far as to say that most developers have never even heard of divergent thinking (and never heard convergent thinking called by that name). With this in mind, I’ve decided to provide some resources you can use to learn more about divergent thinking and possibly add it to your application design process.

 

These are just four of several hundred articles I located on divergent thinking online. I chose these particular four articles because they represent a range of ideas that most developers will find helpful, especially the idea of not applying stereotypical processes when trying to use divergent thinking. Stereotypes tend to block creative flow, which is partly what divergent thinking is all about.

The bottom line is that until divergent thinking is made part of the software design process, we’ll continue to suffer through rehashed versions of the current solutions. What is your view of divergent thinking? Do you see it as a useful tool or something best avoided? Let me know your thoughts at John@JohnMuellerBooks.com.

 

Extending the Horizons of Computer Technology

OK, I’ll admit it—at one time I was a hardware guy. I still enjoy working with hardware from time-to-time and it’s my love of hardware that helps me see the almost infinite possibilities for extending computer technology to do all sorts of things that we can’t even envision right now. The fact that computers are simply devices for performing calculations really, really fast doesn’t actually matter. The sources of data input do matter, however. As computer technology has progressed, the number of sensor sources available to perform data input have soared. It’s the reason I recently wrote an article entitled, Tools to Help You Write Apps That Use Sensors.

The sensors you can connect to a computer today can do just about any task imaginable. You can detect everything from solar flares to microscopic animals. Sensors can hear specific sounds (such as breaking glass) and detect ranges of light that humans can’t even see. You can rely on sensors to monitor temperature extremes or the amount of liquid flowing in a pipe. In short, if you need to determine when a particular real world event has occurred, there is probably a sensor to do the job for you.

Unfortunately, working with sensors can also be difficult. You don’t just simply plug a sensor into your computer and see it work. The computer needs drivers and other software to interact with the sensor and interpret the data they provide. Given that most developer have better things to do with their time than write arcane driver code, obtaining the right tool for the job is absolutely essential. My article points out some tricks of the trade for making sensors a lot easier to deal with so that you can focus on writing applications that dazzle users, rather than write drivers they’ll never see.

As computer technology advances, the inputs and outputs that computers can handle will continue to increase. Sensors provide inputs, but the outputs will become quite interesting in the future as well. For example, sensors in your smartphone could detect that you’re having a heart attack and automatically call for help. For that matter, the smartphone might even be programmed to help in some significant way. It’s hard to know precisely how technology will change in the future because it has changed so much in just the last few years.

What sorts of sensors have you seen at work in today’s world? Do you commonly write applications that use uncommon sensor capabilities? Let me know about your user of sensors at John@JohnMuellerBooks.com. I’d really be interested to know how many people are interested in these sorts of technologies so that I know whether you’d like to see future blog posts on the topic.

 

Keeping Your CSS Clean

It happens to everyone. Even with the best intentions, your code can become messy and unmanageable. When that code is compiled into an executable, the compiler can perform some level of cleanup and optimization for you. However, when you’re working with a text-based technology, such as Cascading Style Sheets (CSS), the accumulated grime ends up slowing your application measurably, which serves to frustrate users. Frustrated users click the next link in line, rather than deal with an application that doesn’t work as they think it should. It doesn’t take long to figure out that you really must keep your CSS clean if you plan to keep your users happy (and using your application).

Manually cleaning your code is a possibility, as is keeping your code clean in the first place. Both solutions can work when you’re a lone developer or possibly working as part of a small team. The problem begins when you’re part of a larger team and there are any number of people working on the code at the same time. As the size of the team increases, so does the potential for gunky code that affects application speed, reliability, and security negatively. In order to clean code in a team environment, you really do need some level of automation, which is why I wrote Five Free Tools to Clean Up Your CSS. This article provides good advice on which tools will help you get the most out of your application.

The cleaner you keep your code, the faster the application will run and the less likely it is to have reliability and security problems. Of course, there are many other quality issues you must consider as part of browser-based application development. Messy CSS does cause woe for a lot of developers, but it isn’t the only source of problems. I’ll cover some of these other issues in future posts. What I’d like to hear now is what you consider the worst offenders when it comes to application speed, reliability, and security problems. Let me know about your main source of worry at John@JohnMuellerBooks.com.

 

Avoiding Graphical Pokes in the Eye

There are times when you can truly say that something isn’t better than a poke in the eye. Using too many of the wrong sort of graphics on a website is one of those times. Some sites use graphics in such a way that it really does feel like a poke in the eye after a while. You end up with sore, tired eyes after viewing the site for only a few minutes. Sites like this is of the reasons I wrote Zapping Graphics that Dazzle Too Much. The article helps you avoid the sorts of graphics that actually make your site a place not to visit. More importantly, the article provides you with specific techniques for creating truly amazing graphics that dazzle in the right way.

Graphical pokes in the eye are bad for the user, but they’re also bad for you because they give users a good reason to avoid your site. Users get to the point of wanting to receive a service or buy products at any other site they can find online. After a while, your site just sits there being viewed by the few people who stumble upon it after clicking a link in a search engine. If things get bad enough, even search engines will place your site so far down the list that no one will find it.

The fact is that there isn’t really a good reason to have unacceptable graphics on any site. There are resources online (see my article for details) to help you create better graphics, even if you can’t rely on a graphic designer. However, if you’re betting the business on the viability and acceptability of your site, then the cost of a graphic designer is probably a lot cheaper than the cost of failure. An essential truth for anyone creating a website today, especially one that sells a product or service, is that the next site is only a click away. Business owners have always had to keep track of the competition, but doing so is even more critical now because a competitor can easily outclass you with just the right presentation.

Don’t get the idea that great graphics are only useful to businesses either. Creating applications today usually means working within a Web-based environment now. In order to create an application that employees or other users will actually enjoy means developing and using engaging graphics in the right way. Applications, even great applications, can fail miserably when users refuse to employ them to perform useful work. When that happens, you could find yourself out of a job.

Most developers really don’t have a lot of graphic design experience. The few who do are in high demand. Building some graphic design skills will make it easier to find employment in today’s competitive environment. Your applications and websites will be successful because they attract the right kind of attention. Let me know your thoughts about the role of graphics in the business environment today at John@JohnMuellerBooks.com.

 

Finding Math Libraries for Your Next JavaScript Project

Finding precisely the JavaScript math library you need can be difficult. In both HTML5 Programming with JavaScript for Dummies and CSS3 for Dummies I define a need to perform math tasks accurately. Both books provide some workarounds for the inaccuracies inherent in performing floating point math. It’s important to remember that some numbers can’t be represented properly in the decimal system used by humans, that there are other numbers the computer can’t represent accurately in decimal, and that there are also error present in converting decimal numbers to binary and vice versa. In short, there are a number of levels at which math errors can occur. Yes, it’s true that the math errors are small, but they become a concern when performing large calculations, some of which can’t suffer any level of error (such as plotting a course to Mars).

The problem is so significant in some cases, that trying to work around the issues becomes an application development task in its own right. It’s for that reason that I started looking for math libraries to perform certain tasks. After all, it’s a lot easier to let someone else do the heavy lifting when it comes to a complex calculation. You can read about the results of some of this research in my article entitled, “Four Serious Math Libraries for JavaScript.” The article not only details the source of many of these errors in great detail, but reviews four libraries you can use to solve them.

The important takeaway I got from the research is that, like many programming tasks, there is no one library that does it all. Each library had something to recommend it. However, each library was sufficiently robust that you shouldn’t need to combine them to create your application. The point is to choose the one library that best meets your needs.

I’m actually looking into a number of library types for use in JavaScript programming. The advantage of JavaScript is that it does provide incredibly strong community support in the form of libraries that you simply use as needed. What sorts of issues do you encounter when writing applications using JavaScript. Let me know what kinds of libraries that you’re having a hard time finding at John@JohnMuellerBooks.com. I’d be more than happy to perform the research for library types that receive enough reader support and report my findings to you.

 

Obtaining an Editor for Your Web-based Application

One of the things I like most about writing code for Web-based applications is that there are so many libraries out there to make the task simple. You can stitch together libraries to create an application in only a small amount of the time required to create the same application in desktop form and the resulting application is going to be a lot more flexible. (Admittedly, the desktop application is usually prettier and can be faster.) Some time intensive tasks for desktop developers, such as creating an editor, require little or no work when creating a Web-based application. In fact, you can get a number of editors for free as described in my article, “5 Free JavaScript Libraries to Add Text Editing to Your Web Application.”

In this case, I wanted to see what was available in the way of editors. There are quite a large number of editors out there, some paid, some not. After discovering that the scope of my original article idea was too large (just editors in general), I decided to narrow the scope to just those editors that are free. After all, why pay for something you can get free unless you actually need the special features of the paid product?

Unfortunately, I still ended up with too many editors (somewhere in the neighborhood of 20). So, I decided to categorize the editors by complexity and presentation. I ended up with five major categories that span the range from simple to complex. The article contains what I think are the five best editors. Of course, your opinion may vary from mine. The point is, that you have a significant number of editors to choose from, so there is absolutely no reason to ever write code to create your own editor unless you need something truly specialized.

I’m thinking about other sorts of classes of application module for future articles. For example, it might be necessary to create an application where the user can make a simple drawing to show how something is put together or how something has failed. I actually needed such a module when trying to describe the glass panes used in the front of my wood stove not long ago and finally resorted to using paper and faxing it. The graphics module would have been easier, faster, and simpler.

What sorts of modules do you need for your Web-based applications? I’m always looking for good ideas from the people who read my material. Send me your thoughts at John@JohnMuellerBooks.com.

 

Browser-based Applications and APIs

Both HTML5 Programming with JavaScript for Dummies and CSS3 for Dummies place an emphasis on the developer who needs to create a unique site in the shortest time possible, and yet achieve this feat with low support costs. The task might seem impossible. Both books achieve their goals by focusing on free or low cost tools, development aids, and Application Programming Interfaces (APIs). However, the API is the lynchpin that holds everything else together and makes everything work. The idea is to obtain a functional application that does everything it needs to do in an incredibly short time using resources that have been created, tested, and maintained by someone else.

My books discuss a few of the most popular APIs and provide pointers to other APIs that you might want to try. In addition, both books provide some best practices for working with APIs. However, I wanted to explore the concept of what makes a great API further, so I wrote “Avoiding Problematic API Choices.” The goal of this article is to help you weed out the great APIs from those that could actually damage data or leave your organization exposed to unwanted risk. The time saved developing an application is quickly used up when the APIs used to create that application cause support issues, so it’s best to use reliable APIs.

Using tools, development aids (such as free art), and APIs is a no brainer.  Creating browser-based applications makes it possible for your application to run anywhere and on any device. These free (or sometimes low cost) aids add extra incentive to develop browser-based applications because now you also avoid a large amount of the cost and upkeep of an application. Organizations that don’t avail themselves of these technologies will eventually be left behind, especially as the Bring Your Own Device (BYOD) phenomena becomes even more prevalent.

There are many tools, development aids, and APIs out there and I have yet to explore even a modicum of them. I can say that I’ve worked with a considerable number of the most popular offerings online, plus a few private (paid) offerings. Still, I’m looking forward to my continued exploration of this particular area of development. I find it incredibly interesting because I started out at a time when assembler was considered the state of the art (and a time saving approach to development when compared to other methods available at the time). Computers have come a long way since I began and every new day brings something exciting my way. It’s the reason I continue to pursue this technology with such diligence.

Of course, I’m always interested in hearing what you have to say. Do you see APIs as being safe and helpful, or as a source for problems in your organization? Which tools, development aids, and APIs do you use most often? Let me know your thoughts at John@JohnMuellerBooks.com.

 

Making Smart Computer Language Choices

Many readers have asked over the years why I spent time learning the computer languages that I have. Some languages were learned as part of the requirement for getting my computer science degree and a few were learned as part of getting a job. However, most languages were learned as a means to communicate better with the computer. A computer speaks only one language—machine code, which is nearly impossible for humans to learn. My first coding experiences started with machine code and then progressed to languages such as Macro Assembler (MASM). As technology has improved and my needs have changed, I’ve learned other languages, which is why I wrote “6 Ways to Determine a New Programming Language is a Turkey.”

Some of the languages I’ve learned over the years really were turkeys. The language is probably acceptable, but I didn’t get anything for my efforts. The language wasn’t right for me—it didn’t help me to communicate better with the computer. You’ll likely find that you experience the same problem if you spend enough time writing code. The more time you spend writing applications, the more languages you eventually learn.

I rarely get into arguments with other people who feel the language they like best is superior to all others. I realized a long time ago that the language really is superior from their perspective. If I were in their precise situation and writing exactly the same kinds of application they’re writing, I’d probably come to the same conclusion. That’s why the choice of language is both personal and imprecise. My article helps you make an informed choice based on the criteria that I use most often to select a new language. An informed choice will reduce the mistakes you make when selecting a language.

The point at which some developers make a mistake is in thinking that the computer pays any attention at all to the language they choose. The computer couldn’t care less. All the computer knows is machine code. The language you choose is for your benefit, not the computer’s benefit. The moment you start thinking that a language does anything at all for the computer, the chances of choosing a turkey increase greatly.

There are some mechanics of computer languages that you do need to consider. For example, you need to know that the language you choose will translate into machine code your computer understands. You also need to know that the more comfortable you make things for yourself, the less efficient the code becomes. That’s not really a problem in today’s environment of high-powered computers, but that reality did affect my decisions early in my career. At the time, MASM provided the most efficient means possible to communicate with a computer without resorting to machine code. Even so, MASM was difficult to work with and I welcomed the introduction of C as a means of making things easier on myself.

Of course, this all leads into the question of which language you feel works best for your needs today. Some developers know just one language well—others, like myself, have an entire toolbox full of languages to use to meet specific needs. Where do you fall into the list? As I continue to write books, I’d like to hear about languages and techniques for using those languages that interest you most. Let me know your thoughts on computer languages at John@JohnMuellerBooks.com.

 

The Place of Automation in the User Interface

There was a time that a developer could rely on users to possess a certain level of technical acumen. That’s no longer the case. Most of the people using a device containing a CPU today (I’m including PCs, laptops, tablets, and smartphones here) don’t know anything about how it works and they don’t care to know either. All these people know is that they really must have access to their app. (Some don’t even realize the role data plays in making the app work.) The app can perform myriad tasks—everything from keeping track of the calories they’ve eaten to maintaining the scheduled events for the day. Devices that contain CPUs have become the irreplaceable partner for many people and these devices must work without much concern on the part of the user. In short, the device must provide a superior level of automation or the user simply won’t know how to interact with it.

I was recently watching television and saw a commercial for a Weight Watchers app for mobile devices. In the commercial, a woman exclaims wonder about the new programs that Weight Watchers provides, which include this app for her mobile devices. To track her calories, she simply points her phone at the box containing whatever food she plans to eat and the app tracks the calories for her. The interesting part is that there is no data entry required. As technology continues to progress, you can expect to see more apps of this type. People really don’t want to know anything about your app, how it works, or the cool code you put into it. They want to use the app without thinking about it at all.

Of all the parts of a device that must be automated, the user interface is most important and also the most difficult to create. Users really don’t want to have to think about the interface. Their focus is on the task that the app performs for them. In fact, some e-mails I’ve received recently about my Windows 8 book have driven home the idea that the app must simply work without any thought at all. It’s because of these e-mails (and those for other books I’ve written) that I wrote the article entitled, “Designing Apps with Automation in Mind.” This article points out the essential behaviors that applications must exhibit today to be successful.

On the other side of the fence, I continue to encounter an “old world” philosophy on the part of developers that applications should pack as much as possible into a small space—users will eventually figure out the complexity of the interface provided. Unfortunately, as users become more vocal in requiring IT to meet their demands, these approaches to the user interface will lose out. The next app is a click away and if it does the job of automating the interface better, your app will lose out. Even if there isn’t another app to use, the user will simply ignore the app you’ve provided. The user will rely on an older version or simply not interact with the app if there is no older version. Many organizations have found out the hard way that attempting to force users to interact with an app is bound to fail.

The fact is, to be successful today, a developer must be part psychologist, part graphics artist, and part programming genius. Creating an acceptable interface is no longer good enough, especially when people want to access the same app from more than one device. The interface must be simple, must work well, and must automate as much of the input as possible for the user or it simply won’t succeed. Let me know your thoughts about user interface automation at John@JohnMuellerBooks.com.

 

ViStart Updates

In Part 2 (page 62) of Windows 8 for Dummies Quick Reference I discuss a Start menu replacement application named ViStart. The basic reason that ViStart attracted my attention is that it provides the means for getting the Start menu back. Getting rid of the Start menu causes productivity issues for most users, especially users who have worked with older versions of Windows for a long time. ViStart is only one of several such offerings. I chose it for the book because you can download it and try it out on your system. It also provides one of the best experiences in getting the Start menu back.

Since the release of the book, LeeSoft has made some useful update to ViStart. The quick list of changes is:

 

  • Control Panel Added
  • Ability to disable and enable these Windows 8 desktop features:
    • Disable hot corners
    • Disable charms bar
  • Skip Metro automatically when booting the system
  • Change skins at runtime using the Control Panel
  • Change Start button at runtime using the Control Panel
  • More context menus when you right click files in Start menu
    • Jumplist
    • File popup menu
  • Fixed the problem that prevented pinning folders to the Start menu
  • It’s now possible to drag and drop frequent programs to and from ViStart
  • Pin to ViStart added to Windows file context menu
  • More control over what the ViStart start orb does
    • Show the ViStart menu
    • Show the original Metro menu
  • More control over what both Windows keys do with ViStart open
    • Show the ViStart menu
    • Show the original Metro menu
  • Context menu for navigation pane items
    • Rename navigation pane items
    • Rename documents
    • Hide/show items (to show a hidden item, go to control panel)
    • Properties
    • Toggle navigation pane option to show as a file menu or to show up in an explorer window, like “Recent” in the normal Windows Start menu
  • More stable, ViStart doesn’t crash as much as it did before
  • ViStart has optional offset y and x properties for Start menu skins. When ViStart doesn’t appear in the correct position, you can offset the Start menu using this feature
  • Install new skins with ease, ViStart no longer needs to be restarted to identify new skins
  • Drag a pinned folder from the frequent programs to the navigation pane and ViStart will add it as a new navigation pane item
  • More control over how the Start menu appears
    • Toggle show program menu first instead of frequently used programs
    • Toggle user picture
  • Added Show Metro to the pinned program list
  • Added Show Metro Apps to the pinned program list
  • Added default program listing for fresh installs (such as Notepad and Command Prompt)


That’s a substantial number of changes. All of these new features should greatly improve your experience with Windows 8. You can see a video that explains the updates further on YouTube.

While nothing can make the Windows 8 experience precisely the same as using Windows 7, working with add-on products does help considerably. In fact, I discuss add-ons as part of my article entitled, “8 Ways to Reduce User Training Costs for Windows 8.” Let me know about your add-on experience at John@JohnMuellerBooks.com.