Microsoft Certified Professional Magazine Online | Newsletters: Developer Central 1.6: Peopleware: Your Father's Software Development?

In this issue :
1) Editorial Chatter
2) Weblinks
3) It's Survey Time!
4) Improving Software Development: Peopleware: Your Father's Software Development?
5) .NET Explorer
6) Project 2002 Conquers New Worlds
7) Review: Kutchka Templating
8) Review: Total Visual Code Tools 2002
9) Review: IP*Works! V5 .NET Edition
10) Review: AQTime
11) Review: DataPipe
12) Review: abcDB Pro
13) New and Notable
14) Book Notices
15) Reader mail
16) Web Resources for Developers

First, let me just say ARGH and apologize for leaving out the URL of DataMystic, whose excellent TextPipe Pro I reviewed in the last issue of Developer Central. You'll find them at http://www.datamystic.com/ -- and be sure to check out the review of DataPipe later in this issue.

So, that out of the way, the big news for this issue, at least from the certified developer point of view, is that Microsoft is revamping their developer certifications. You might have missed the announcements in amongst all the other fuss at the .NET launch event, so let me start by just summarizing the requirements for the new certifications. Before digging in, though, it's important to note that the old MCSD is *not* going away, at least not any time soon. Apparently Microsoft learned its lesson from the abortive attempt to sink the NT4 MCSE credential.

That said, you now have your choice of two developer certifications: MCAD and MCSD. MCAD is the new Microsoft Certified Application Developer, aimed at those who build application but who don't necessarily need the enterprise design and analysis skills included in the MCSD exams. With proper planning you can (and, I think, should) earn the MCAD on the way to the MCSD. Here's the MCAD requirements:

One core exam from the following list:
- Web applications with VB .NET
- Web applications with C#
- Windows applications with VB.NET
- Windows applications with C#

A second core exam from the following list:
- Web Services and server components with VB.NET
- Web Services and server components with C#

One elective from the following list:
- Web applications with VB .NET
- Web applications with C#
- Windows applications with VB.NET
- Windows applications with C#
- Designing SQL Server 2000 databases
- Designing BizTalk solutions
- Designing Commerce Server solutions

Note that you can only have one "web applications" and one "windows applications" exam counted. For example, if you use Web Applications with VB .NET to satisfy the core requirement, you can NOT use Web Applications with C# as an elective. But you can use either of the Windows applications exams as an elective in that case.

So, that's the MCAD. How about the new MCSD? Microsoft calls it the MCSD for Microsoft .NET Certification, but you know that everyone else in the known universe will refer to it as MCSD .NET. Here's the deal:

Required core exam:
- Analyzing Requirements and Defining .NET Solution Architectures

A second core exam from the following list:
- Web applications with VB .NET
- Web applications with C#

A third core exam from the following list:
- Windows applications with VB.NET
- Windows applications with C#

A fourth core exam from the following list:
- Web Services and server components with VB.NET
- Web Services and server components with C#

And one elective from the following list:
- Designing SQL Server 2000 databases
- Designing BizTalk solutions
- Designing Commerce Server solutions

Note that many of the new exams are not yet available. Apparently it will be June or later before you can actually earn the MCAD, and 2003 before the .NET Solution Architecture exam goes live. (We asked Microsoft about this, and they said "The timing for the release of exam 70-300 relies on the need to conduct a job-task analysis among developers who create architecture solutions based on the recently released final version of Microsoft Visual Studio .NET. The job-task analysis will validate all tasks of a lead developer including design and architectural skills. Exam 70-300 is very important as it will be a key differentiator between the MCAD and MCSD. We intend, as we do with all of our exams, to take the necessary steps to ensure the highest quality." Which may mean that they, like the rest of us, are still working out the details of .NET architecture best practices.) But unless you need the MCSD *right now* for some reason, I'd recommend waiting and taking the .NET-related exams. Those skills should keep you busy for a few years, and the credentials won't retire any time soon.

So, what's the deal here? I think it's fairly simple: the Microsoft merry-go-round has taken another turn, and certification is going the .NET route along with everything else about the company. Yes, you can get off the merry-go-round if you like. But think for a moment: what happened to the developers who said "DOS is good enough, I don't need to know Windows!"? Or "DDE is fine, who needs COM!"? Sure, there will be work using the older generation of development tools for quite a while. But inevitably those opportunities will begin to contract. If you believe the MCSD is a valuable credential today, then the MCAD or MCSD .NET should be equally valuable next year.

OK, enough certification. I'm sure I'll revisit this topic in future issues, preferably with your feedback. But for now, there are a lot more reviews, notes, and URLs below. Hope you find some of them useful! If you have feedback on these resources, MCSD .NET, or anything else, feel free to drop me a line at mike.gunderloy@mcpmag.com .

(And the perennial note: watch out for URLs that wrap later in this newsletter, especially ones that point to MSDN. HEY MICROSOFT, how about some shortcuts to MSDN pages?)

One of the biggest problems with writing an e-mail newsletter is that it's hard to get to know your audience. So, I'd like to ask you to take a few minutes to visit http://www.larkware.com/MCPSurvey/survey1.aspx . What you'll find there is the first (and probably not the last) Developer Central Reader Survey. For this first one, I've got some questions about what you think the hot areas will be for development in the next few years, both in the industry as a whole and in your own career. Is there something I should be writing more about? Or something I should just shut up about? Now's your chance to tell me! We'll also take a look at the survey results as we plan topics for future issues of MCP Magazine.

You're welcome to be anonymous, but there's also a spot on the survey for your e-mail address. I won't share this with anyone, but I will draw one random winner from all the respondents and send that person a copy of my own SQL SERVER DEVELOPER'S GUIDE TO OLAP WITH ANALYSIS SERVICES. So: a chance to give me a piece of your mind, a chance to win a book, and a chance to influence future coverage. What more could you want? C'mon, click that link now and let me know what you think.

Tom DeMarco and Timothy Lister wrote Peopleware in 1987. The second edition, featuring 8 new chapters, came out in 1999 from Dorset House Publishing. The book is based on research that started in the early seventies, making some of the stuff here more than a quarter-century old. That's a long time in programmer years. I seem to recall we were programming with pointy sticks and clay tablets back then, but the memories are pretty hazy.

Anyhow, is there anything for the hot-shot latte-drinking dot-com developer generation to learn from this book? Amazingly enough, the answer is a resounding yes! This book is a classic of the field of software management, and at just over 200 pages it should be required reading for any team leader or manager.

Note that this is not a programming book. The subtitle here is "Productive Projects and Teams." What DeMarco and Lister are concerned with is the fact that the ratio in productivity, by almost any measure, between different teams is ten to one in the software industry. Put another way, the best teams can build in a year what the worst teams take a decade to do. And this doesn't seem to be just a matter of the best teams having the best programmers (though the best programmers do tend to gravitate to the companies that have an environment that encourages good teams). So what's the difference?

DeMarco and Lister argue that the difference is that the good teams have a good working environment, aren't subject to ridiculous nonsense that doesn't contribute to developing software, and have managers who stay out of the way (and if necessary run interference to keep other people out of the team's way). Along the way, they talk about the stultifying effects of Big Methodologies, the necessity of offices with doors and windows rather than those odious cubicles, having fun at work, the necessity of some chaos, and why some organizations can learn and others can't, among other things.

Many of the problems that the authors identify boil down to management treating developers as if they were cattle rather than people using their brains for a living. For example, they devote several sections to skewering the Furniture Police, who are (sad to say) found in any major corporation. If you've ever worked in a cubicle farm, this might ring a bell:

"Basement space is really preferable from the point of view of the Furniture Police, because it lends itself more readily to uniform layouts. But people work better in natural light. They feel better in windowed space and that feeling translates directly into higher quality of work. People don't want to work in a perfectly uniform space either. They want to shape their space to their own convenience and taste....The very person who could work like a beaver in a quiet little cubbyhole with two large folding tables and a door that shuts is given instead an EZ-Whammo Modular Cubicle with seventy-three plastic appurtenances. Nobody shows much interest in whether it helps or hurts effectiveness."

Fortunately, this is one area where things have changed for the better, at least in some organizations. Microsoft, for example, is notorious for "wasting money" on things like offices with doors and windows for developers, free drinks, lounging areas, and other such nonsense. The result? Microsoft people actually like being in the office, for the most part, and are free to concentrate on writing good quality code. In fact, Joel Spolsky [http://www.joelonsoftware.com/navLinks/fog0000000262.html] has argued that one of the reasons for Microsoft's success is that Bill Gates built an entire company full of managers who've read Peopleware. Joel recommends that software managers re-read the book once a year -- not a bad idea, at that.

Of course, the Furniture Police are just a symptom of a larger problem that turns up in many guises. The problem is that a misplaced sense of efficiency leads to cost-cutting measures that actually cost money in the long run because they impede team building and software development. A few other examples:

- Those odious "motivational accessories" (you know, the ones with some full-color photo and a phrase like "Giving Your Soul to the Company is the Highest Good") that are substituted for real motivators (like higher pay or offices with doors) by penny-pinching middle management.

- Institutional adherences to process improvement programs (most notably the Capability Maturity Model) that concentrate on making your process efficient while removing all consideration of whether you're efficiently producing anything the market wants to buy. If the CMM were reflected in the real world, perfect mud pies would sell for more than flawed coconut cream pies.

- Teams that get scattered all over the corporate campus because it's too much trouble for the facilities people to find them a single set of offices in one contiguous block.

You get the idea. The problems are legion, and DeMarco and Lister fearlessly catalog many of them.

Rock-climbers enter a state called "flow" while they're concentrating, in which moving up the rock seems effortless and timeless, the entire body is involved in the climb, and everything comes together perfectly. Of course, much as we'd like to pretend otherwise, software development isn't really like rock-climbing. For one thing, when our code falls down it doesn't tend to cause compound fractures. But we do share one thing: the flow state. Many words have been written trying to describe this state. Fortunately, I don't have to add to them. If you've ever done serious software development, uninterrupted by petty nonsense, you know what flow feels like. It not only feels good, it leads to good code.

"Flow" is the thing that management tends not to understand, the reason that the Furniture Police are allowed to dictate your working environment. As DeMarco and Lister point out, this is completely understandable, because most management is naturally interrupt-driven. Management is the very art of responding to endless interruptions. Unfortunately, software development isn't. After a five-minute phone call it takes most developers fifteen minutes or more to get back into a flow state. If the five-minute phone calls come once every twelve minutes, you're doomed.

As an aside, I'd love to see some serious research on whether outstanding programmers get into a flow state more quickly than others. My hunch is that they do. I also suspect that they can maintain a deeper stack of interruptions without losing track of what's at the bottom of the stack. Of course hunches are much easier to come by than proof.

Bear in mind, though, that it's not just the mysterious and oppressive Them that keep developers out of a flow state. We also do it to ourselves. If you have trouble getting there, try shutting down your e-mail client for a few hours. The world won't come to an end, and you won't have that niggling interruption hitting you every thirty seconds.

If you've gotten the impression that Peopleware is based on experiences with software teams at large corporations, you're right. Of course in these "new economy" days, there are an awful lot of us writing software in corporations where the staff can be counted on your fingers, even if you include the cats and dogs. Despite that, I think this book still has a few things to offer the independent developer.

First off, if you're having one of those days where you think corporate wage-slavery might be preferable to yet another round of phone calls to shake money out of dilatory customers, reading about the bad management nonsense here may give you renewed energy for being out on your own. More importantly, though, independents are their own managers. We're not immune from setting up our own offices in such a way that it helps us fail. Is your toddler underfoot for hours during the working day? Do you have a ballgame on the television for "background noise"? Just how much time did you spend on web-surfing today, hmmm? Recognizing -- and removing -- the homegrown impediments to flow can help you deliver more value to your clients, and ultimately raise your billable rate.

Finally, it's the rare independent developer who never spends time in a corporate setting. Understanding the principles set out in this book can help you make better use of your time out in the field. For one example, if you're writing a boilerplate contract, you should specify that you'll be given a working area with a desk, chair, and door. If the client balks at that, the warning bells should go off in your head. Find another job, or at the very least raise your rate.

If you've already read Peopleware, now what? Two suggestions. First, it's worth dropping by the web site for the Atlantic Systems Guild [http://www.atlsysguild.com/], a company which the authors helped found. Second, read it again! Face it, this book is just plain fun, and I was happy for the excuse to dip back in when writing this column. Really, how often do you get to read gems like this:

"When bosses are particularly needy, the burden of ceremonial status meetings can grow almost without bound. We know of one organization, for example, where daily two-hour status meetings are the norm. When participants are off-site during a meeting, they are expected to call in and participate by speakerphone for the whole duration. Nonattendance is regarded as a threat and is subject to serious penalties."

You won't find a single line of code in this book. But if you're managing a team, you'll probably find that listening to DeMarco and Lister will help get a lot more lines of working code into the final product more quickly than ignoring them will.

Does your boss get it? Or are you thinking of leaving an anonymous gift of Peopleware on his desk? Write me at mike.gunderloy@mcpmag.com to let me know! Comments may be used in a future issue of Developer Central, unless you ask me to keep them confidential.

One sign that .NET is really real now: tools are starting to appear. Let's start with a pair of SOAP tools. Maybe not everything in the universe is a Web Service yet, but you'd never know it from all of the activity in the vendor space.

The first of these tools is the latest release of the XML Spy Suite, 4.3 ($399 from http://www.xmlspy.com/default.asp). Along with about a bazillion other features, this version includes a SOAP debugger. You can watch both requests and responses and edit them using all of the tools that XML Spy puts at your disposal. This is a good way to get right down inside a SOAP session without having to parse the XML yourself.

The other tool is a little deal called NetTool, from the CapeClear folks (free download from http://capescience.capeclear.com/articles/using_nettool/). This one lets you set up a little proxy to intercept and forward SOAP requests and responses. It also lets you just put together your own SOAP messages and send them off, though you do need to know something about XML to do this.

Of the two, I found XMLSpy to be easier to get working as a SOAP proxy; NetTool requires having a Java VM installed, and its cross-platform UI us a bit less intuitive for me (because, of course, I'm not used to that look and feel). But the price is certainly right on NetTool. If you're working with Web Services, you'll probably eventually need one of these tools.

Also on the tools front, FMS, a long-time vendor of Microsoft Access and Visual Basic tools, is turning their attention to .NET. Their first .NET product is Total .NET XRef, which is designed to ease the problem of working with objects and variables in your .NET code. Sooner or later you'll be faced with a question such as "where did I use that class?" or "where is the definition of this class?" That's the sort of question that Total .NET XRef can answer. Just right-click on a variable, property, class, method, namespace, or most anything else and choose XRef. You'll get a dockable ToolWindow containing the essential information on the use of that item in your project: file, namespace, class, member, and line of use.

You can download a limited-time preview version that will function until the end of March now. Although this is still beta code, in my early testing it seems to work pretty well already. This is the first bit of a new toolset that's worth keeping an eye on. Grab it from http://www.fmsinc.com/dotnet/XRef/confprvw.asp .

On the other end of the spectrum, there are some very high-end tools for .NET shipping now. Two of these are Rational XDE, which integrates UML design tools with pattern support directly into the Visual Studio .NET IDE (http://www.rational.com/news/press/pr_view.jsp?ID=8240) and Codagen Gen-it 2.5 Architect, which features model-driven code generation for enterprise applications (http://www.codagen.com/news/pressreleases/2002/20020213_e.shtml). I'll try to work in test drives of these products in a future issue of Developer Central.

At least, that's the plan. Microsoft Project 2002 is due out some time around mid-year, but I've had a chance to play with a beta version and it's looking pretty good. Rather than introduce major changes to the interface, Microsoft is using this release to put more enterprise and collaboration functionality into Project.

One major change in this version is the introduction of multiple editions of Project. There's still a standalone version called Project Standard. But there's also a Microsoft Project Server, which layers functionality on top of SharePoint Portal Server and other collaborative technologies to allow rolling up multiple projects into a single enterprise-level view of resources and tasks. Then there's Project Professional, for the folks who need to manage the information in Project Server, and a Project Web Access client as well. Project Standard can also share the information in Project Server but lacks some of the notification and management features of Project Professional.

Of course, it wouldn't be a Microsoft release without new features. One of the nicest things about this version is the Project Guide, which functions as a sort of interactive tutorial to help you set your first project up. There's also better Office integration, automated e-mail notifications, better security, more "what-if" analysis, and lots of other goodies.

Developers will find improvements in Project's OLE DB driver, integration hooks for the info stored in Project Server, XML data interchange, Digital Dashboard technology, and lots of additions to the object and event model.

Project often doesn't spring to mind as the basis for a custom solution. But if you find youself with a problem that involves collaboration, scheduling, and resource allocation, it looks like the combination of Project, Project Server, and SharePoint is going to be mighty powerful. The new version is worth a second look as a potential solution platform. You can get more information, and order a copy of the beta marketing kit, at http://www.microsoft.com/office/project/evaluation/beta/default.asp.

Kutchka Templating is an add-in for MindManager (which I looked at in Developer Central #3, http://www.mcpmag.com/newsletter/article.asp?EditorialsID=67). Perhaps the best way to explain Kutchka Templating is to say that it enables you to easily produce recombinant Mind Maps. You can load two or three (or a dozen, for that matter) Mind Maps, and then use Kutchka to pick and choose the branches that you'd like to combine into a new map. The branches come over complete with all their information, notes, icons, and so on.

Kutchka also allows you to assign simple predecessor/successor relationships as you add branches. This lets you turn a Mind Map into sort of a rough-and-ready dependency chart. Automatic hyperlinking lets you proceed through a list of tasks in the order that they're linked.

The basic Mind Map is an excellent tool for brainstorming. What Kutchka Templating brings to the table is a way to take chunks of past brainstorms and re-use them, and a way to adapt Mind Mapping to process-oriented projects by adding the notion of flow. After spending a few minutes with the tutorial, I didn't have any problem using its capabilities, which are well-integrated into the MindManager shell. All in all, a nice little addition to the native capabilities of MindManager.

If you write VB or VBA code for a living, you know there are a lot of annoying repetitive tasks in the job. (Of course, the same is true for almost any language). Total Visual Code Tools is designed to dispose of some of these annoyances, and to help enforce coding standards on multi-developer projects as well. It provides a set of builders and clean-up tools that work in Office 2000, Office XP, and VB 6.0.

After telling TVCT about your coding standards (the prefixes you use for variables, the commenting style you prefer, the way you like your error handlers structured and so on), you're ready to start using the Builders. These dialog boxes can create common code structures for you: procedures, properties, recordset code, SELECT CASE statements, and so on. Launch a builder, fill in some options (like the procedure name), click a button and watch the finished code get injected directly into your project (or, if you prefer, to the clipboard, a file, or a text editor).

TVCT also offers tools to clean up and standardize existing code, to obfuscate code that you're ready to ship, and to manage a few other little tasks such as block-commenting code or clearing the immediate window.

All of the standards you set up are stored in a single external file, which makes it easy to make sure everyone on a project is using the same standards. Another bonus for the busy shop is a help file section that details a bunch of VBA best practices.

One of the differences between good developers and those who just hack at the code is the tools that they use. Adding Total Visual Code Tools to your own toolset will help you to write more consistent code -- which will pay off in the long run as you discover that consistent code is easier to maintain.

IP*Works! V5 .NET Edition, $495
/n Software
Research Triangle Park, North Carolina
(919) 544-7770
http://www.nsoftware.com/

I reviewed the VB6 edition of this package in the last issue of Developer Central. The new .NET edition has the same features: it's still designed to provide you with implementations of all the major Internet protocols that you're likely to need. This includes old favorites like finger, ping, and whois; more complex protocols including IMAP, SNMP, and LDAP; and even generic TCP/IP and UDP clients and servers. This version even includes a SAX2-compliant XML parser and a SOAP client, so you can build applications that play with new stuff. In all, there are 34 components here, covering the full range of protocols.

Of interest is the way that /n got this edition together: they wrote a Java to C# translation tool and moved over their existing Java codebase. The resulting controls work quite well and integrate smoothly into Visual Studio .NET, right down to (optionally) occupying their own tab in the Toolbox.

Could you do the same work without these controls? Sure; the .NET Framework includes TCPListener, TCPClient, and UDPClient classes that you can hook up to pretty much any Internet protocol. Do you want to do it that way? Not unless you really enjoy writing a bunch of extra code. Personally, I'll be happy to let the /n folks do all that work for me. This is a solid set of controls that hits its intended target well.

Do you know which ten functions in your application account for the most time during an average run? What percentage of your code is actually visited by your test suite? Are you freeing all the memory that you allocate?

If you don't know the answer to these questions, then your toolbox is probably lacking a profiler. One excellent choice for filling that gap is AQTime, from AutomatedQA (makers of AQTest, which I reviewed in the last issue of Developer Central). If you're using Microsoft Visual C+ or Visual Basic, Borland Delphi or C++ Builder, or the gnu gcc compiler, AQTime can give you a detailed look at what's going on when you run your application.

AQTime is simple to use. Open it, load your executable application, choose a type of profiling to do (for example, a line-by-line coverage profile, or a function time profile), and hit the run button. Then use your application as you normally would, while AQTime collects the data. When you exit your application, the results are right there, with a variety of views from functional diagrams to bar charts of relative times to numeric results.

Of course AQTime also integrates with AQTest, giving you an ideal way to see whether your test suite covers all the code in your application, and integrating performance data with bug hunting. There's even an integrated source code editor so you can see just what code is contained in the problem functions.

Some applications can get away without optimization. If yours is one of those, great. If not, the cost of AQTime can easily be saved in helping you focus just on the pieces of code that need the most work in pursuit of efficiency.