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:

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:

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.

---------------------------------------------------------------------

Improving Software Development

Peopleware: Your Father's Software Development?

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.

Beware the Furniture Police

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.

The Magical Flow State

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.

But What About Us Independents?

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.

A Fun Read

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.

---------------------------------------------------------------------

.NET Explorer

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
.

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.

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.

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.