Tony Davis

Simple-Talk Editor
News, views and good brews

The Horse's Mouth

Published Thursday, July 23, 2009 4:12 PM

It was one of those wonderful moments when a task that was, a moment ago, frustrating and nigh-impossible, suddenly became less daunting.

I'd been wrestling with Powershell. We were checking and editing a Powershell article for Simple Talk and I'd started the ritual of testing out the code and making sure that all the instructions worked. It is often difficult for the authors of articles to think themselves into the role of educated beginner in a technology, so someone usually has to check that instructions are graded and complete. As usual, I was voted by the editorial committee into the role.

My epiphany happened when I typed in
Get-Help Get-Command -examples
...and
Get-Help Get-Command -full
... and wondrous stuff spilled forth down the screen. Suddenly, I could make progress. Obviously, I had to type in the name of the particular cmdlet for which I wanted examples of use but, hey, I can cope with that.

It was beautifully written help, brief but to the point. With that, and a few simple examples of full Powershell scripts, I was airborne. It made me think how unnecessary so much of the training and publication industry around Microsoft actually is. There is a huge industry that interprets the information that Microsoft provides and re-interprets it for mere mortals without otherwise adding much extra value. Even Microsoft itself has joined in the game. It gives us the information from the developers distorted by 'chinese whispers', rather than from the source. SQL Server Books-on-Line has always provided a rich harvest for the trainers. Everything is there, if you can find it, but has, in the past, been painfully structured, short on practical examples and often written in a style that refuses to compromise with the less brain-bound reader in any way. Inevitably, an industry has developed to interpret the occasionally strangulated text of some of the MSDN information into reasonable, simple English.

There are, within Microsoft, people who really understand their products and can communicate them well. Whoever provided the terse but valuable help text for Powershell was, surely, a developer talking direct to other developers. It has always been a difficult struggle for any software provider such as Microsoft to pitch it right: to make sure that the key people have the time to trasmit their knowledge and understanding to others. This is a difficult balancing act to perform, since few of the creative developers are natural communicators. But when they are, then we all gain.

With any software product of any complexity, the job isn't finished until its use is made crystal-clear to the end-user. It is not a peripheral task. The people who developed the system are always best placed to write about it. This is why books such as Brian Kernighan and Dennis Ritchie's "The C Programming Language" (Dennis Ritchie wrote C), and Brian Kernighan and P. J. Plauger, "The Elements of Programming Style" (Kernighan wrote AWK and a lot else besides) remain classics of the art of explaining complex technology in a simple approachable way.

What do you think? Is it better for developers to stick to coding and leave the wider aspects of communicating with the users of their applications entirely to others; or is it better to encourage them to participate more in explaining how their applications work?

Cheers,

Tony

Comments

 

aleonard763 said:

Hi Tony,

  As usual, excellent points. I'd like to bring up two things: First (and you covered this in your statement "There are, within Microsoft, people who really understand their products and can communicate them well."), writing is this whole other skill from programming. It is excruciatingly easy to underestimate the effort involved in writing at all; easier still to underestimate writing well. (See how poorly-worded that was? And I'm published!)
  Second, sometimes developers just aren't given enough time to do the documentation (and sometimes the testing).

  I agree great documentation comes from the developers who build the software. I just think the stars have to align for this great documentation to come to be.

:{> Andy
July 26, 2009 10:20 PM
 

BillNicolich said:

On the question of who should do the communicating - the programmers or other technical writer-type specialists - I'd say both in a friendly competition for who can do it the best, empirically determined by a group of reviewers. Or, let them cooperate.

Here's a sketch of how this "friendly competition/cooperation" idea could work. There's a pool of communication specialists and there's the programmers. They have two options. They can either work alone and submit their material to be reviewed separately, or they can get together and collaborate. There's a bonus to be had for whoever produces the material most accepted by the reviewers. If the two teams cooperate, each will get half the bonus. If they compete, one or the other will get the bonus.

A programmer who finds it difficult to produce acceptable material will seek to cooperate while a programmer with that unique gift to both code and communicate well might seek to compete. Maybe the talented programmer knows that she doesn't have the time to do it alone and seeks to cooperate on that basis. The point is, the options are there and the review process helps ensure that the best material goes out the door.

Of course, the reviewed material doesn't have to be accepted on a "one or the other" basis. The material can be blended with the bonus going to the contributor with the most material accepted. If a programmer gets some of their material accepted in a blend situation, they get their attribution as co-author.

In short, let the same forces that shaped the ant and the hawk - competition and cooperation - shape the documentation.
July 27, 2009 8:07 AM
 

jmoldoverx said:

Unfortunately, in too many organizations, communication of technical information in an understandable fashion is not seen as a priority.  In addition, there is a widely-held perception that spending one's time being a "technical writer" instead of developing code is demeaning and a waste of time.  While I like the approach suggested by Bill Nicolich of creating a review process and pushing for competition and collaboration with rewards in the documentation creation process, for any company much smaller than a Microsoft, it's not as practical, and for a smaller IT shop within a company, it's not even possible - the costs involved are more than management is willing to bear.  Until there is a change in attitudes (starting with the hiring process), where an ability to speak and write clearly (and explain a process) is seen as just as important as an ability to write quality code, this will continue to be a problem, both for those of us who need to use poorly documented commercial software, as well as those of us who need to use custom, in-house created packages.
July 27, 2009 8:24 AM
 

gbrayut said:

I think you might have missed a crucial point demonstrated by the Powershell help system: Make the information more accessible by marking it up with meta-data. Like everything in Powershell, the information returned by the get-help cmdlet is an object (in this case a MamlCommandHelpInfo object), which has methods and properties that can be used to dive in directly to the section you are interested in or to consume the information in code and convert it to something else. You can get a better understanding of how this works using the following code:

$results = get-Help get-Command
get-Member -InputObject $results
$results.syntax
$results.syntax.syntaxItem[0]

The above code will create the output displayed here: http://picasaweb.google.com/lh/photo/0W6qSW8wRcyouMpR92ZSmQ?feat=directlink
                           
The main power of this rich help data is that other applications can consume it and inject the information where it is most useful. PowerShell Analyzer, for instance, uses the data returned by get-help to display call tips and "pretty print" versions of the help information:

http://picasaweb.google.com/lh/photo/1_I_afmv_OpTrv9CiRWjQQ?feat=directlink
http://picasaweb.google.com/lh/photo/ie5CnPd6m0Pxl6FcKnGdEA?feat=directlink

This should be the ultimate goal, where by you provide access to the information when it is needed most. XML Comments in C# and VB.NET work in much the same way, where the developer embeds the documentation in the code, Visual Studio uses this information for property and method call tips, and the compiler creates an XML document that can be transformed into HTML using XSLT or reused by other code such as NDOC for creating MSDN style CHM help files. In my mind that is how you do documentation right.

July 27, 2009 11:24 AM
 

rachelp said:

Some interesting thoughts here. I think gbrayut makes a good point - "writing" documentation isn't just about writing ... it's also about making it accessible, and findable, and putting it exactly where it's needed ...and also working out what *not* to write.

Other interesting points made in these comments have been about the lack of time for programmers to write documentation well. When you add not just writing, but also designing the navigation, look-and-feel, and also ongoing maintenance of documentation, on top of a full time programming job, the chances are the end result isn't going to be pleasant or pretty.

I think it's not impossible - or uncommon - for a programmer to also be good at all of the skills involved in writing documentation. I also think the same about programmers designing user interfaces. But add these 2 (or 3!) roles together, and you're asking a lot from someone - which is why I'd generally argue against this.

But then I would say that: I'm in the business of technical communications...
July 28, 2009 8:12 AM
You need to sign in to comment on this blog


















<July 2009>
SuMoTuWeThFrSa
2829301234
567891011
12131415161718
19202122232425
2627282930311
2345678
Finding Stuff in SQL Server Database DDL
 You'd have thought that nothing would be easier than using SQL Server Management Studio (SSMS) for... Read more...

Mission Critical: SQL Server 2008 Performance Tuning Task List
 In which Buck Woody imagines how the US military would have tackled DBA checklists for... Read more...

Simple Query tuning with STATISTICS IO and Execution plans
 A great deal can be gleaned from the use of the STATISTICS IO and the execution plan, when you are... Read more...

Switching rows and columns in SQL
 When they use SQL Server, one the commoner questions that Ms Access programmers ask is 'Where's the... Read more...

Writing Efficient SQL: Set-Based Speed Phreakery
 Phil Factor's SQL Speed Phreak challenge is an event where coders battle to produce the fastest code to... Read more...