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.

 

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.

 

How the Internet Affects the Information You Receive

For many years now (centuries, in fact) professional authors, editors, and production staff have worked hard to provide you, the reader, with high-quality material. It isn’t always error free (see Errors in Writing), but these paid professionals do their best to assure the material you get is of the best possible quality. The Internet has changed all that. Today, anyone can write anything and publish it online. Search engines ensure that people can find the information, and you now have the option of reading information that has never been verified, edited, or checked in any way for accuracy or fitness of purpose. We have traded quality for quantity.

I’ve realized that there was a problem for a long time now. Sales of articles, white papers, books, and other forms of writing have declined for all authors for quite some time because people feel they shouldn’t have to pay for something they can obtain free. It’s true, a bargain is always appealing no matter what that bargain might be. However, there is a hidden price for this free material and I’m also pleased to find that some media sources are trying to open a forum for discussing the costs of free writing. The latest article I’ve read on the topic, “Today’s Internet: All the fake news that’s fit to publish,” discusses the topic in clear terms. I strongly encourage everyone to read it because the article does accurately describe the cost to you, as a reader, of the free information available online.

Before the e-mails start popping up in my inbox, yes, I do have a vested interest in convincing you that buying a book is superior to obtaining the information online. After all, I’ve written 90 books to date and I’m currently engaged in writing book 91. It would be remiss of me not to mention that your purchase does help me pay my mortgage and electrical bill. However, my goal in writing this piece is not to line my pockets—I’m truly interested in helping you obtain the best information possible because you need good information to make good decisions. In fact, look at my past blog posts and you’ll find that the quality of your reading experience has always been my prime consideration. I write books because I enjoy writing and knowing that my writing helps people. There are other ways I could earn a living (such as consulting) that would put far more money in my pocket than writing does.

There is always going to be a certain amount of angst over buying something that you can possibly get free. People often make house and auto repairs themselves or ask Jane down the street to do it for them to avoid paying a professional to perform the task. Likewise, you have the option of using the free online sources of information to avoid paying professional authors to obtain, verify, and write that information for you. The quality of the material you receive will generally reflect the source that you obtain it from. Of course, there are people who do write quality material online and provide it to you free (in many cases, through the support of a vendor or organization). The point is that you need to find an information source you can trust in order to use that information to make decisions or learn new skills.

One additional benefit of relying on a professional author that you don’t obtain with an Internet source is support. Most professional authors will post addenda, answer questions, and provide value-added materials, much as I do in this blog, as part of publisher-supported sites, and through e-mail. When working with an Internet author, questions are often ignored and remain unanswered years after they’re asked. The price you pay for a book or other professionally written material includes support that you probably won’t get from other sources. As with anything in life, you must consider the tradeoffs of the decisions you make.

How do you feel about the quality of information you receive from the Internet? Do you see any benefit at all from buying books written by a professional? As I seek better ways to serve your needs, the answers to these questions are becoming increasingly important to me. Let me know your thoughts on the topic at John@JohnMuellerBooks.com.

 

The Subtle Art of Communication

Communication is part science, part social experiment, and part art. The science comes from psychologists who have come up with ways to quantify and qualify various kinds of communication. The social experiment is the process we all go through learning to communicate because communication is not a skill any of us is born with. The art comes into play with the human mind that can master the intricacies of communication in its many forms. When taken together these views of communication create a picture of a complex issue that many people only partially grasp. It’s not any wonder that developers, like any other person, encounters problems communicating at times. Yet, developers must have superior communication skills in order to translate the real world requirements defined by users who don’t know how to write code, into the abstract environment that comprises an application.

The issue of communication becomes even more complex with each person involved with the communication. We’re talking a geometric progression here. When you have a two people, there are only two lines of communication to consider. Add another person and now you’re dealing with six lines. Add another and you’re dealing with 24 lines. Now imagine that you’re trying to get every element of a huge organization to communicate and you begin to appreciate the difficulty of the Application Performance Manager’s job. Application Performance Monitoring (APM) has become a critical technology for enterprises today because people can’t communicate well enough to define the precise nature of application performance issues and errors. APM seeks to aid communication by providing tools that help locate the sources of an application issue before the user even notices it.

It was with this whole issue of communication in mind that I wrote, “Breaking Down the Walls of the Siloed Application.” This article answers two important questions about enterprise communication. First, what happens when a group of perfectly reasonable people become entangled in a enterprise level conversation about a problem application? Second, how does anyone resolve the issues that such communication creates. You’ll have to read the article to get the details.

This article could apply equally well to developers, manager, and users. In fact, it’s actually a view of what happens in any social setting where large numbers of humans are trying to communicate without much success. The artistic mind of the Application Performance Manager provides the creative solutions to the problem in this case. Of course, there are many other situations that this article doesn’t address (even though the advice I provide may very well work in these situations too). What sorts of communication issues have you encountered recently? Have you found a successful solution? Let me know at John@JohnMuellerBooks.com.

 

Debugging As an Educational Tool

One of the questions I get asked quite often is how I learn new programming techniques. After all, I work with a broad range of languages and IDEs in my pursuit of new programming environments. Let’s face it—I like to play with code. For me, it’s not really a job to write application code. I like to see how different things work and what’s possible with a given language. In order to accomplish my goals, however, I need to learn techniques quickly. The debugger is my secret to learning how to code quickly and easily. In fact, I’ve written an article on the topic, “Improve Your Coding Skill by Listening to the Debugger.” You also see this technique emphasized in a number of my books, especially LINQ for Dummies and Start Here! Learn Microsoft Visual C# 2010 Programming.

The main reason that I use the debugger as an educational tool is that I can see the code in action. It’s possible to see how the code actually works, rather than envision what the code is supposed to do. The difference is important. For me, seeing the code actually work demonstrates that the theory behind the code is sound. Many theories sound good until you actually try to use them—using the debugger proves the theory as you work through the code.

From a personal perspective, the biggest hindrance that I face in using the debugger as an educational tool is the lack of good comments. In fact, comments are such a problem that I write about them in Creating Useful Comments. When the code lacks comments, I need to look up the calls myself and then determine how the developer is using them. It’s time consuming and a somewhat painful way to learn at times because I can see the code work, but I don’t know how it works or why the developer chose a particular approach. Even worse is when the code contains misleading comments. Worse still are comments that are outright incorrect because they reflect a previous state of the code or the developer didn’t actually understand why a technique works (the sheer dumb luck approach to coding).

Make sure you check out my article on the topic and get back to me about it. I’d like to hear your views on using the debugger as an educational aid. For that matter, I’d like to hear your viewpoint on debuggers as a class of application. Do you feel they need work or are debuggers as useful as they need to be? You may even feel that debuggers have become encumbered by way too many features. Whatever your viewpoint, let me know at John@JohnMuellerBooks.com.

 

Software Quality Connection is Moving

A lot of you know that I write articles for Software Quality Connection (SQC) from time-to-time. In fact, you can find the newer articles listed in the Articles category of this blog. All of the existing articles and any new articles I write will still be available for your viewing pleasure. However, they’ll be moving to a new location, SmartBear blog. You can read about this update in the Software Quality Connection – Now Part of the SmartBear blog post. Make sure you subscribe to either the RSS feed or e-mail messages so that you get all of the amazing posts from this organization.

Of course, I’m concerned that you’re able to continue to read my articles. If you experience any problems, whatsoever, accessing one of my articles, please let me know. I’ll do my best to clear things up. For example, my most recent SQC article, “How to Inherit Somebody Else’s Code” now appears at http://blog.smartbear.com/software-quality/bid/167035/.

My future articles will appear on the new site. I’ll let you know as they get published so you can take a look and provide your usual feedback to me. Let me know if you have any questions about the new setup at John@JohnMuellerBooks.com.

 

Inheriting Someone Else’s Code

In my book, “C# Design and Development,” I propose a lot of management techniques that could apply to any language. In fact, I’ve used the techniques in this book successfully for years with Visual Basic, C#, IronPython, C++, and PHP, among many others. The idea behind the concepts in this book is to create code that performs well from the outset and is easy to maintain when changes are required. In today’s environment, you can count on changes at some point. There are many reasons to expect changes:

 

  • The business is bought by someone else and the code must be integrated into a new system.
  • A change in some other component necessitates a change in the application (such as the changes in Vista and Windows 7 security).
  • The business has grown and now needs new features to support its customers.
  • Modifications in the law mean changes to the way the application interacts with data.
  • Technology changes in such a way that the application no longer works properly.

In fact, the reasons for change are endless. I could probably continue writing reasons for change for hours and not cover even a small number of them. The point is that applications will change at some pointit’s simply a matter of time.

If you’ve written code for any time at all, you know that feeling in the pit of your stomach when you discover the perfectly lucid comments you wrote at the time you created the application are no long lucid now. Worse still, the documentation you put together doesn’t tell you what you did and why. Still, after a few hours of looking at your comments and documentation, you can usually begin to fit the pieces together of an application you created because you can recreate the thought patterns you had when you designed and wrote it in the first place.

However, what happens when you’re part of a team or you’re working on an application that someone else designed? Now there isn’t any way to “get back into the groove” of what you did in the past. The thought processes are foreign, so the comments and documentation have to be as comprehensive as possible. Even with great comments and documentation, it’s going to take a while to get up and running with the code.

The longer it takes you to recreate the ideas that went into creating the code, the longer the project update languishes and the more extreme management’s position becomes. The only thing that management knows is that your application (the one you inherited from someone else) is costing the business money. Not only is there a cost associated with the update, but the delay costs the organization money too. Users who have to fight with an outdated application are always unhappy and aren’t productive. So, what techniques can you use to become productive as quickly as possible? That’s what I’d like to know as well. Obviously, reading the documentation and comments are two pieces to the puzzle, but what other techniques do you use?

I’m currently putting an article together that discusses this topic in detail and I’d like to hear about your techniques. If you’ve ever been frustrated by someone else’s code, write me at John@JohnMuellerBooks.com. I’ll let you know when the article is published on Software Quality Connection

 

Working with Low Level Code

Working with low level code is becoming less necessary as Microsoft continues to improve the .NET Framework, but you sometimes still need to resort to direct Win32 API access using P/Invoke.  My book, “.NET Framework Solutions: In Search of the Lost Win32 API,” is a great place to learn about P/Invoke and the significant number of ways you can use it to access Windows features that Microsoft hasn’t made available in the .NET Framework yet.  For example, you’ll find a thorough discussion of the Windows messaging system in Chapter 4.  However, the discussion is a bit lengthy because there is so much you can do with the Windows messaging system.

One of the questions I get asked quite often is whether there is a quick start sort of guide I can recommend for working with the Windows messaging system.  With that in mind, I wrote a series of four DevSource articles some time ago.  Here’s the complete article list:


These four articles provide quite a bit of information about Windows messages that you might not know from a .NET perspective.  Using these techniques can save you considerable time, especially when you need to interact with other applications.  In fact, the final article reveals secrets you can use to interact with applications when you don’t have the source code; a significant problem for most developers.  So, how do you use P/Invoke?  Have you had to resort to P/Invoke to work with Windows 7 features that haven’t been added to the .NET Framework yet?  Let me know at John@JohnMuellerBooks.com.