Home > Articles > Programming > Visual Basic

Software Issues 1: Programming Is Really a Language Art

  • Print
  • + Share This
Do you think of programmers as scientists in white lab coats? Maybe you should think in terms of painters in smocks and berets instead, suggests software development expert Tyson Gill.
The content in this article is a mix of original material and material adapted from Visual Basic 6: Error Coding and Layering (Prentice Hall, 2000, ISBN 0-13-017227-8) and the upcoming book Planning Smarter: Creating Blueprint-Quality Software Specifications (Prentice Hall, 2001).
From the author of

If you were planning the curriculum for a college, you would probably offer programming courses through the computer science department. It seems logical. But while the developers of nitty-gritty drivers need to be closely involved with the hardware guys, most high-level developers really don't. Application developers frankly have no more justification for being part of the computer science department than would a major in comparative religions who writes his dissertation on a computer.

Programming simply doesn't qualify as a science. For that matter, neither do most fields with the word science in their title, except maybe environmental science. Even though a good programmer must be logical and use technology, those are also requirements for many nonscientific fields. A scientist is one who uses the very well-defined scientific method to discover, investigate, and validate theories. Clearly software programming doesn't meet this strict definition.

Perhaps the engineering department would be a more appropriate place to offer programming courses. After all, we do call it software engineering. But engineering is the practical application of scientific principles. Since software engineering doesn't really apply any scientific principles, it probably doesn't technically qualify as engineering, either.

So where does a software course fit in?

Because programmers work almost exclusively with things called languages, perhaps software courses could be offered through the language arts department. Software development is essentially language and communications. While engineering doesn't require any use of language, programming is nothing but language. All of the activities of a programmer, from interviewing and planning to coding and documentation, are communications activities. Software developers essentially translate requirements from English to Basic or C++. Their work is most analogous to that of a journalist or novelist who researches a topic, organizes it, and translates it into a logical, detailed written work.

The task of converting requirements and processes from English to a computer language holds it own unique challenges every bit as daunting as observing a sunset and translating that moment into poetry. The poet has a rich vocabulary to draw upon, but the programmer's vocabulary is extremely limited. The poet can rely on inferences made by and the imagination of the reader. The programmer can't. When conversing in English, for example, people are forgiving; they extrapolate, interpolate, assimilate nonverbal cues, interpret context, and make mental corrections where necessary. Computers languages offer none of those luxuries.

Preparing a legal document is perhaps the closest thing to writing software. Legal contracts must defend against antagonistic interpretation and be perfectly unambiguous in their exactitude. They must exhaustively specify every obvious contingency in painstaking detail. But software development makes legal writing seem as loose as poetry. The software linguist must be 100% accurate and unambiguous as he translates loose human communication to rigid machine code. It takes a specialized literary skill to prepare a tight legal document—or a solid program.

Of course, no university would really offer Visual Basic classes alongside Journalism 101, but viewing programming as a language art stimulates us to shift our view of software developers in subtle but profound ways. They're not merely science geeks who understand technology. The good ones are far more than that. They're authors with both the technical knowledge and the communications skill to author programs that must flow and fit together as solidly as a novel by Edgar Allen Poe.

An emphasis on language skills for a programmer suggests that employers should look for exceptional communications skills in their candidates. This is arguably more important than technical skills. Communications skills are a talent and therefore virtually impossible to teach. Communications skills are a relatively permanent asset, while technical skills depend on transient technologies. Technical knowledge without a talent for communicating is a recipe for a programmer who knows his stuff, but can't develop or document a coherent, maintainable program to save his life.

But there are also flavors of communications skills to consider. There's a difference between verbal or English-language talent and computer-language talent. They don't necessarily translate, in the same way that short-story skills don't necessarily translate into screenwriting skills. Many programmers are hired based on the fact that they can talk a good program, but they may have virtually have no ability to actually write one.

This makes it very important to assess and match the right kind of communications skill with the appropriate job. The technical guy without writing skills might be a great technical resource and debugger. The tech-talker may indeed be a great project lead and salesperson. Great application programmers aren't necessarily the best verbally or technically, but they can craft code that sings like Sinatra. The key for each type of role is to realize the particular communications flavor that's critical to success and respect the boundaries.

Programmers rely on various communication flavors in every phase of the job. During the requirements analysis, they must make observations and inquiries, interview, organize, communicate, and translate requirements into coherent written documents. During development, they must be able to translate those documents into the precise language of computers in a way that's clear, accurate, and efficient. They must write code that communicates not only to the computer, but also to other programmers who will need to understand and modify that code later. Many programmers simply can't communicate in the right way to provide insightful comments in their code, let alone structure the code in a way that intrinsically communicates its operation to other developers. In the delivery phase, the programmer must translate his work back into technical or user documents, or at the least communicate clearly with a documentation professional who can produce meaningful documentation.

Another subtle distinction becomes apparent when you think of software development as a language art. Too many projects suffer because their clients and/or managers view software development as a purely technical process. They think of programming as a formulaic process, akin to accounting. We expect that if you give any accountant a copy of "the books," he or she will get the correct numbers out (assuming an understanding of basic accounting principles and the ability to do math). In the same way, some managers think that if you hire a programmer who knows how to construct an if-then-else statement, and then give him or her clear requirements, the programmer should be able to simply crank out the product.

It doesn't work that way.

These managers fail to give sufficient weight to the artistic aspect of programming. While programming isn't an art like painting, it's closer to painting than to accounting. Give two artists the same exacting specifications, and they're likely to produce two very different paintings. The same is true for programming. The range of variation is endless and no amount of specifications can totally eliminate it. Oh, you may be able to get exactly the screens you specified, but that's just an illusion of control. You have little ability to specify the part of the iceberg, all the underlying code, that lies beneath the surface of the user interface.

Further, if you could specify your desired code structure so completely as to eliminate the programmer's influence, it would totally waste the talent and craftsmanship of the programmer. It would be analogous to giving a great painter a photograph and saying that you want his painting to look exactly the same in every detail.

Programming is a modern craft in every way. The craftsman has (or should have) great personal influence over the final product. The programmer's communications skills, language skills, creativity, and talent should not only be allowed to express itself, but should be relied upon—in the same way that a movie director's talents are relied upon to turn a screenplay into a work of great craftsmanship and art.

Note that allowing, or even relying upon, the craftsmanship of the developer does not suggest that you're opening the door to nonstandard, unmaintainable code. A good programming standard provides a standardized, maintainable structure, while at the same time not inhibiting craftsmanship and creativity. It is possible to develop standards that combine both very well.

Seek out talented craftsmen with superlative communications skills for their role. Put them within the framework of a good coding standard. You may find that software development can be a modern craft worthy of the same recognition as that of the finest craftsmen who worked on great cathedrals, epic novels, or classic movies.

Seek out drones who can type if-then-else all day long in an overly restrictive environment, and you end up with uninspired, mediocre sweatshops of code. Fail to recognize subtle variations in communications skills, and you end up with people doing jobs for which they have little talent.

About the Author

Tyson Gill is the director of information technology at Alitum, Inc., in San Diego, California. He also teaches Visual Basic and Microsoft.Net programming at the University of California, San Diego. He is well known for his influential presentations on design, architecture, planning, and coding. Tyson is the author of Visual Basic 6: Error Coding and Layering (Prentice Hall, 2000, ISBN 0-13-017227-8) and the upcoming title Planning Smarter: Creating Blueprint-Quality Software Specifications (Prentice Hall, 2001).

  • + Share This
  • 🔖 Save To Your Account