Can’t recruit experts in your area? Make your own.
Extensive testing has revealed that making a hole-in-one with a one iron is easier than hiring a client/server (C/S) expert. Yet our Little Rock, Arkansas, company now has over 60 C/S experts on staff. How have we managed such a feat? We hire bright college graduates and spend five months and $500,000 making them experts.
The thought of spending that much time and money on training shocks many people. Why do we do it? Because we have no choice! There is a tremendous demand for our services, but there aren’t enough qualified people to staff the opportunities. Our application suite has a complex three-tier architecture, is implemented in several languages and runs on multiple operating systems.
Originally, we tried to hire the experts we needed, but we found it impossible to recruit in the Little Rock area. We widened our search to include a larger talent pool by recruiting in Dallas and Atlanta. However, C/S experts in Dallas and Atlanta were generally not interested in moving to Little Rock. After much effort and few results, we decided that if we wanted top-quality C/S programmers, we were going to have to make them ourselves.
Trial and Error
The traditional approach is to hire programmers and assign mentors to give them on-the-job training. We tried mentoring and found it didn’t work for a number of reasons. First, there are few developers who have the people skills to be good mentors. Second, if a senior programmer with the ability to mentor exists, he is too busy pounding out designs and code to mentor anyone. Even if you do get good results from mentoring, it is a slow process. New programmers can’t grow quickly using mentoring techniques, and mentors can only work with one or two people at a time. In addition to the assigned mentors, we gave people books to read, videos to watch and computer-based training software to run. We also sent people to one-week classes, conferences and seminars. Eventually, we concluded that on-the-job training was just too slow, too expensive and too limited.
Our first shot at extended training was a six-week course in Visual Basic and software engineering. During those six weeks, we were able to teach syntax, effective usage, graphical user interface design, program design, and our programming standards and methods. The graduates of that class were able to immediately begin production work. Our success at creating VB programmers encouraged us to expand our efforts.
In January of 1997, we started a five-month client/server programming class. The goal was to produce C/S experts who could work on application architecture, object design, GUI design, database design, coding, testing and anything else that needed to be done. We met those goals. We are now teaching our fifth class and recruiting for the sixth and seventh.
The curriculum consists of the following:
• Client/Server Concepts. Students learn the principles of C/S application architecture, design and development. This includes using UNIX servers, NT servers and mainframes.
• GUI Design. Students learn to design attractive, easy-to-use user interfaces.
• Visual Basic Programming. Students learn to use VB to create GUIs, ActiveX components and controls.
• C++ Programming. Students learn to use C++ to create ActiveX components and server processes. This includes programs for Microsoft NT and UNIX.
• Relational Databases. Students learn to design and access SQL tables using ActiveX Data Objects (ADO) in Visual Basic and RogueWave’s C++ class library in C++.
• Software Engineering. Students learn to design and write high quality programs that follow our ALLTEL standards and practices. Daily code reviews are used to teach simplicity, maintainability, cohesion, coupling, encapsulation and so on.
• Object-oriented Design and Programming. Students learn to design and implement complex object-oriented programs in VB and C++. Use cases, CRC cards, the Unified Modeling Language and Rational Rose are used.
Our curriculum is ambitious. The first class lasted 100 days and cost about $400,000 dollars. Our current class has grown to 110 days and costs roughly $500,000 dollars. The obvious question is, "Has it been worth it?"
The answer is a resounding "Yes." The students have been successful beyond our wildest dreams. They have allowed us to expand our products rapidly and grow our business by leaps and bounds. They have become our technical leaders and our most valuable assets.
Keeping the Talent
So how do we do it? We put 10 students and two full-time instructors in a classroom. We have experimented with different sized classes and different combinations of instructors, but this is the one that works best for us.
The majority of the students are new graduates with computer science degrees. There are several reasons for hiring new graduates. First, it’s cheaper than hiring experienced developers. Second, we can assume a base level of knowledge because they have computer science degrees. Third, they are used to reading, studying, learning and homework. Finally, new graduates don’t have many bad habits to "unlearn."
On the flip side, it’s tough recruiting on campus; competition is fierce for new graduates. It’s also difficult to evaluate someone’s true ability on the basis of his performance in school. Unfortunately, there seems to be little correlation between grade point average and ability. Also, employers run the risk that new employees may leave the company soon after completing the training. To reduce this risk, our trainees sign a contract that requires them to repay us the cost of the training if they leave in less than a year. Of course, we hope they stay longer than that. To help ensure that they do, we give them promotions, challenging work and opportunities to lead. We have retained 55 of the 57 people we have trained.
We have had several mainframe COBOL programmers go through the class to be retrained in C/S techniques. Compared to new graduates, these employees are more loyal to the company, and they know the business. We can access more information about them to determine how they will perform. Best of all, they are easy to recruit.
The downside of retraining existing employees is that they may be expensive. It is difficult to reduce the salary of a highly paid mainframe programmer to that of an entry-level programmer, even though he is performing at an entry level. Also, experienced developers have trouble with the structure of the class. The daily schedule is from 8:00 a.m. to 5:00 p.m., with no flextime or long lunches. Everyone works at tables in a classroom; there are no private offices, cubicles or phones. Students aren’t allowed to take personal time or vacation time while in class. The students are expected to read and study at home just as they would in a college class. Another problem revolves around changing work habits. After working in structured COBOL for 10 years, some developers find it difficult to make the switch to object-oriented C++.
If the students are available, the next question is, "Who is going to teach the class?" We made one of our top developers and mentors the instructor. He had excellent technical skills, good oral communication skills and, most importantly, a desire to teach. Preparing lesson plans, making presentations and monitoring labs is difficult, demanding work. If an instructor is not excited about the class, he will not be a good teacher. Even if a company has an interested expert, he will still need help. No one is the master of all C/S skills. In the first two classes, we brought in independent trainers for two weeks and used a series of guest instructors to assist the full-time instructor. The guest instructors were senior developers who would come in and teach one to five days and then return to their regular development work.
While this approach worked, it was disruptive to development. All of the guest instructors were valued experts, and borrowing them interfered with development efforts. In our third class, we replaced the guest instructors with a second full-time instructor. The two instructors were carefully chosen so that they would not require the assistance of guest instructors. On the surface, losing the second instructor for five months would seem to be a greater loss than a day here and there from a series of people, but in practice it is much less disruptive. The class also improved because both instructors learned to teach. The guest instructors were chosen for their technical expertise, and sometimes had difficulty expressing themselves to the students.
It is also a good idea to have two instructors, so the class is not stopped for a couple of days if the primary instructor breaks a leg playing softball. However, the biggest reason to have two instructors is to train a second primary instructor. C/S programming is a constantly changing field. Having a technician teach more than two classes in a row runs the risk that he will lose his technical expertise. It also raises the possibility that he will catch "ivory towerism" and do a poor job keeping the class practical. Ideally, the instructors teach five months and work at least seven months before teaching again. In each class we identify one or more students who will come back as assistant instructors after getting some work experience. After working for several more months, they return as the primary instructor. This allows us to build up a pool of experienced instructors. We have also discovered that teaching improves a developer’s ability to build systems. To summarize, the rotation goes like this:
• Attend class for five months as a student.
• Work as a developer for seven months.
• Serve as the assistant instructor for five months.
• Work as a developer for seven months.
• Serve as the primary instructor for five months.
This rotation ensures that we develop teaching expertise, keep our instructors’ skills current and reduce our dependency on any one person. We also supplement our instructors with such world-class experts as Dan Saks, who has taught C++, and Richard Hale Shaw, who has taught COM/DCOM.
We have also changed the way classrooms are typically set up for computer instruction. A central lecture area includes tables and chairs, while computer tables are arranged around the perimeter of the room. This allows students to sit close together for lecture and spread out to work on labs. The tight-knit lecture arrangement encourages discussion, allows everyone to see the projector screen and whiteboard and focuses the students on the instructor instead of their PCs. A separate building ensures the class and the instructors are not disturbed by development issues.
The typical daily schedule for the class is a lab from 8:00 to 9:00, lecture from 9:00 to 11:30, lunch from 11:30 to 12:30, another lab from 12:30 to 3:30 and reviews from 3:30 to 5:00.
People learn by doing, so our schedule gives the students four hours a day to work on lab exercises. During the class, the students build a miniature version of our application suite that includes all of the technology that is in our product. We have a minimum of toy exercises that teach language features and a focus on labs that build on one another. We start with simple VB screens. Gradually, we add ActiveX objects written in VB and C++. These components grow in complexity throughout the course. The students learn everything from the lowest level before using higher-level tools. For example, the students develop ActiveX components in raw C++ before they are taught to use the Active Template Library (ATL), wizards and code generation tools. They develop components on the server and use them from the client. By working on an application that builds incrementally, students learn the iterative approach and face the issues that appear only in large systems.
While the students are encouraged to work together on design issues, each student codes his own modules. This ensures that every student knows the VB GUI code, C++ server code and so on. While each will be strong in different areas, all our graduates can do anything that needs to be done.
Feedback is a vital part of education. We provide it in several forms. The 110 days are divided into three major sections of about 38 days each. The first section is Visual Basic and software engineering. The second is C/C++ and ActiveX. The last section consists of the C/S issues specific to our company. Two weeks into each section, each student is given an informal oral evaluation. At the end of each section, each student is given a written evaluation. In addition, every student gets weekly code reviews. To provide even more feedback, monthly awards are given to the student of the month and most improved student.
It Ain’t Cheap
It costs us about $500,000 to grow our own C/S experts. This figure includes recruiting trips to schools; salary and benefits for 10 students; salary and benefits for two full-time instructors; independent instructors; administrative costs, classroom, network support; and computers, software, supplies, books, T-shirts, candy and pizza.
Half a million dollars is a lot of money. Most managers will find it very difficult to get that much funding approved for training. We worked up to that amount by proving our training was a good investment with one-week and six-week classes. The graduates of those classes convinced management to fund a five-month class. Since then, each set of graduates has justified the next class.
There are disadvantages to conducting a C/S university. It has huge up-front costs. There are also opportunity costs; you can’t bill out students sitting in the classroom. You lose some of the company’s best developers for five months while they serve as instructors. Finally, recruitment is a factor. If a company is going to invest an average of $50,000 in a new employee, the hiring manager wants to be sure he is hiring the right person. This makes recruitment more risky and thus more difficult.
Despite these issues, we believe that growing our own C/S experts is the right thing to do. Our highly trained experts have made our organization successful, and our training program has become our number one asset for recruiting top new talent. n
We give each student a copy of these books:
• Active Template Library: A Developer’s Guide by Tom Armstrong (IDG Books Worldwide, 1998)
• Code Complete: A Practical Handbook of Software Construction by Steve McConnell (Microsoft Press, 1993)
• Effective C++: 50 Ways to Improve Your Programs and Design by Scott Meyers (Addison-Wesley, 1997)
• Inside COM by Dale Rogerson (Microsoft Press, 1997)
• Peter Wright’s Beginning Visual Basic 6.0 by Peter Wright (Wrox Press, 1998)
• Visual Basic 6 Secrets by Harold Davis (IDG Books Worldwide, 1998)
• The Waite Group’s C++ Primer Plus by Stephen Prata (MacMillan Publishing, 1998)
In addition, our instructors use these books, among others:
• About Face: The Essentials of User Interface Design by Alan Cooper (IDG Books Worldwide, 1995)
• C++ How To Program by Harvey M. and Paul J. Deitel (Prentice Hall, 1997)
• Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides (Addison-Wesley, 1995)
• Developing COM/ActiveX Components with Visual Basic 6 by Dan Appleman (Sams, 1998)
• Hardcore Visual Basic Version 5.0 by Bruce McKinney (Microsoft Press, 1997)
• More Effective C++: 35 Ways to Improve Your Programs and Design by Scott Meyers (Addison-Wesley, 1995)
• The Mythical Man-Month: Essays on Software Engineering by Frederick P. Brooks, Jr. (Addison-Wesley, 1995)
• Rapid Development: Taming Wild Software Schedules by Steve McConnell (Microsoft Press, 1996)
• The Unified Modeling Language User Guide by Grady Booch, James Rumbaugh and Ivar Jacobson (Addison-Wesley, 1998