Design of Distributed Apps
Best preparation for the Visual C++ Distributed Apps exam: Get experience. Beyond that, here's how to get ready and what to expect.
As I began preparing for this beta exam, I wasn’t sure
what to expect. For one thing, the exam requirements for
the Visual C++ Desktop exam [70-016. See
review in this issue.—Ed.] differ only slightly
from the requirements for the Visual C++ Distributed exam.
From the requirements, it looked like the Distributed
exam would cover many of the basic Visual C++/Microsoft
Foundation Classes (MFC) techniques commonly used by Visual
C++ developers. Questions on implementation of various
user interface elements (dialog boxes, toolbars, and the
good old Document/View architecture) were probably a given.
I also assumed there would be significant coverage of
the “Distributed” piece of the Visual C++ application
In addition, I certainly expected to
see questions on Microsoft Transaction Server (MTS), ActiveX
Data Object (ADO), and various database topics that are
some of the major contributing technologies to distributed
C++ 6.0 Distributed Applications (70-015)
Rating: “As with most of Microsoft’s
certification exams, the more real-world
experience you have, the better off you’ll
be. Consider using some small, well-conceived
sample distributed applications to gain
the skills needed to pass this exam.”
Designing and Implementing Distributed
Applications with Microsoft Visual C++
Number of questions
in reviewed version of exam: 113
on beta; fewer on actual exam.
2 hours and 45 minutes for beta; expect
around 90 minutes for the live exam.
Live as of October 1999.
Who should take
it? One “distributed applications
development” exam is required for the
MCSD; this exam is one of the three
What classes prepare
- No. 1011: Mastering MFC Fundamentals
Using Microsoft Visual C++
- No. 1012: Mastering COM Development
Using Microsoft Visual C++
- No. 1015: Mastering MFC Development
Using Microsoft Visual C++ 6
My exam preparation process was further
complicated by some of the recent changes in Microsoft’s
certification exam policies and procedures. Would this
exam be adaptive? Would the exam have questions of the
new “case-study” type?
In the end, I was right about what
I expected, but there was coverage of additional material
as well. In this article, I hope to provide some insight
into what you’ll need to pass this exam. I’m a Visual
C++ developer working on my MCSD certification, and I’m
sure there are plenty of others out there doing the same.
The Simple Facts
Here’s one fact that was at least true
for the beta exam (and I believe isn’t likely to change
on the live exam): There were no “case-study” questions.
Although the length of some of the questions made them
border on case studies, you had to answer only one question
relating to each problem statement. Although the beta
exam I took wasn’t adaptive, be aware that this doesn’t
necessarily mean that the live exam won’t be. (Though
I doubt it, at least initially. After all, the intent
of the beta exam is to test the questions, not the sequencing
of questions or the pass/fail criteria.)
I can’t imagine a Visual C++ exam without
any questions about MFC. For the longest time, developing
an application with Visual C++ meant using MFC exclusively.
Based on what I saw on the beta exam, Microsoft still
considers this an important skill when developing distributed
So, be familiar with common MFC programming practices.
The exam preparation checklist is a good place to find
areas you should brush up on. Most programming practices
listed are fairly common and should be very familiar to
anyone using MFC on a regular basis. I’d recommend, however,
that you look at the nitty-gritty details of some of your
MFC applications. Knowing the general approach to accomplishing
something in MFC and relying on the on-line help system
to get you the rest of the way is OK when you’re working
in your office, but no matter how many times you press
the F1 key during an exam, you won’t get the MFC on-line
documentation you’ve come to rely on. So brush up!
Tip: A word of caution about
reviewing your MFC coding techniques. Don’t assume that
knowing how to use the Wizards to generate skeleton code
is enough to ace this part of the exam.
It’s no big secret that Microsoft is
banking on the Component Object Model (COM) for the foreseeable
future. One of the biggest features in Windows 2000 will
be the introduction of the COM+ programming model. This
strategy, combined with Microsoft’s positioning of Visual
C++ as the most powerful and flexible development tool
for creating Microsoft-centric software solutions, should
be an indication that COM is an important topic to understand.
Again, working with these technologies on a regular basis
is the best preparation. Below are some important details
on creating and using components with Visual C++ that
you should understand well before taking the exam.
For starters, make sure that you’re
familiar with the latest compiler support for COM. Microsoft
is constantly making it easier to use COM components from
within Visual C++; the native COM support found in Visual
C++ 6.0 can make your life a lot easier. Experience with
the #import pre-compiler directive is a must. You should
be comfortable using this technique to generate the smart
pointers used to easily create instances of COM objects.
It’s probably a good idea to review some of the #import
specifics, since there may be some hidden gems worth learning.
A great place to get your “legs” using #import is by using
it to program with the ActiveX Data Objects (ADO) data
In addition to the technique for using
ADO components within a Visual C++ application, it’s worth
taking a closer look at the components themselves. Distributed
applications will need to access a variety of data from
various data sources. ADO is the set of components that
makes this easier for software developers. Thus, a deep
understanding of ADO will well serve any developer creating
a distributed application (or taking a distributed application
The silver bullet here is that ADO is Microsoft’s latest
attempt at encapsulating and abstracting data access;
it’s done quite well, making it fairly easy to learn the
basic concepts. Gaining some real-world experience using
ADO will not only benefit your exam-taking experience,
but just may make your life a bit easier the next time
you need to access data from various data sources. Imagine
learning a few relatively simple data access techniques
with ADO and being able to use them to access virtually
any data source out there.
Tip: There’s an ADO tutorial
that includes examples of using the ADO components from
Visual C++—check it out by searching for “ado tutorial”
Know the ATL
Not only is it important to know how
to use components in your Visual C++ applications, you
should also know how to create them. Remember when I said
it would be hard to imagine a Visual C++ exam without
any MFC questions? It’s quickly becoming the same for
the ActiveX Template Library (ATL). This is the relatively
new framework for developing COM components with Visual
C++ and it is not likely to go away in the near future.
Once again, real-world experience using ATL is your best
bet to prepare for this exam. In preparing, details are
very important. Dual interfaces, ActiveX controls, and
various macros used by ATL are especially important when
digging into ATL. Unlike the type of components created
with MFC, ATL is designed to make very lightweight components.
A variety of issues surround the relationship between
ATL and MFC, and any good Visual C++ developer should
MTS Will Rule
Last, but definitely not least, writing distributed applications
brings into consideration things like scalability, transaction
processing, and load balancing. Microsoft’s answer to
these issues is Microsoft Transaction Server. MTS allows
you to focus on your component’s base functionality without
worrying about how it will scale, or about rolling back
transactions. MTS is so important to the future of distributed
applications that it will be integrated into Windows 2000.
Tip: At the risk of sounding
like a broken record, I suggest getting some real-world
experience with MTS before attempting this exam.
Dig into Databases
At the core of most distributed applications,
you’ll find some sort of database management system. More
often than not, the database will be a relational database
management system (RDBMS) based around Structured Query
Language, like Microsoft’s SQL Server. When you’re developing
a distributed application, you need to know how to interface
with the RDBMS. There are many options available to software
developers for doing this. One that’s very popular and
puts a lot of the processing requirements on the server
is the use of stored procedures. Basically, these are
functions written on the database side to perform some
sort of processing on the data. Knowledge of SQL is required
to author stored procedures. The ADO objects mentioned
earlier provide a mechanism for calling stored procedures.
Make sure that you don’t forget to look at this topic
when you’re investigating ADO.
Typically, one might expect this sort of knowledge to
be the responsibility of “the database admin,” rather
than the actual developer. Well, based on what I saw on
some exam questions, Microsoft apparently thinks that
Visual C++ developers creating distributed applications
should be somewhat savvy about databases. I would definitely
get some experience in stored procedures before attempting
Tip: As with a lot of the
exam questions, don’t forget that syntax details make
all the difference when trying to choose the correct answer.
A couple of areas aren’t necessarily
a part of traditional distributed applications, but are
mentioned in the exam preparation guidelines. Those are
Active Documents and ISAPI. Before attempting this exam,
you should at least have minimal exposure to these technologies.
There’s a nice overview of ISAPI on Microsoft’s Seminar
Online area that may be useful if you haven’t been involved
with any ISAPI development.
Some issues that impact any software
development effort and can be especially interesting for
distributed applications include source code version control
and installation and setup. You should be familiar with
the general techniques and procedures surrounding these
sorts of things.
Visual C++ 6.0 does contain changes in the integrated
development environment (IDE) that you should familiarize
yourself with. If you’re using version 6.0 on a regular
basis, you should be fine; but I know plenty of developers
who are still using previous versions.
Tip: Use the new IDE for
a while just to make sure you experience some of the new
productivity features in version 6.0, like edit and continue
As with most of Microsoft’s certification
exams, the more real-world experience you have, the better
off you’ll be. This is as it should be. However, I don’t
think this means you need to have written an entire distributed
Internet C++ application supporting 10,000 simultaneous
users in 35 different countries implemented with all the
latest and greatest Microsoft technologies.
If you’re like most of us, you may
want to consider using a slightly smaller-scale application
to gain the skills needed to pass. There’s a lot to be
said for learning the nuts and bolts of C++ using small,
well-conceived sample applications. Consider solving a
nagging problem at your company by writing a small distributed
application with Visual C++. The experience will not only
be helpful for the exam, but might be useful to your employer—and
thus to your career.
Since I took the beta exam, I’ve been doing some research
on Windows Distributed InterNet Applications (DNA), Microsoft’s
latest application development architecture. It’s clear
that Visual C++ plays a key role in the development of
Windows DNA applications, and that familiarity with this
architecture is becoming a crucial skill in writing distributed
applications. A final word, then: Using Visual C++ to
develop a DNA application will improve your chances to
pass this exam.