Exam Reviews

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.

• By Tom Steele
• 08/01/1999

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 development puzzle.

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 applications.

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.)

MFC Forever

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 applications.

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.

Components Galore

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 access components.

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 exam).

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” at msdn.microsoft.com.

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 understand them.

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 the exam.

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.

Miscellany

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 debugging.

Final Thoughts

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.