You might wonder how Honeywell Air Transport Systems ever got involved with making the HADS tool set, since its purpose is to produce avionics for commercial aircraft.

The origin goes back to the 1980s. Sperry Flight Systems was making the transition from building analog flight controls to using digital computers and software for the controls. At one point in the process, Sperry designed its own computer chip and had a software team make a hybrid version of Pascal for this processor. They recognized that the type checking provided by Pascal provided some safety advantages and added some features that were important to writing software for flight systems. When the Ada language became a standard, they became interested in the language for developing software for safety-critical flight systems.

In 1985, Sperry Flight Systems began looking at Ada for a fly-by-wire system for the proposed Boeing 7J7. The target processor was to be a member of the Intel 80 x 86 family with an Ada development system from a compiler vendor named DDC-I. DDC-I was respected as a compiler vendor, especially for the quality of its tools and runtimes for the Intel 80 x 86 family of processors. It also helped that DDC-I had a sales and engineering office in Phoenix, Arizona, where Sperry Flight Systems was located.

As part of the software development process for flight-critical software, all routines included in the system must be well documented and have tests written to ensure code coverage. An effort was undertaken to document and test the DDC-I Ada runtime system to the level required for DO-178B, the FAA guideline for software. In the middle of this process, Sperry Flight Systems was sold to Honeywell. The part that dealt with large aircraft such as commercial jetliners was named Honeywell Air Transport Systems Division.

Meanwhile, my wife and I were working as assistant professors at Indiana-Purdue University in Fort Wayne, Indiana. In the summers we did software consulting at a Magnavox facility in Fort Wayne. Magnavox was an early adopter of Ada, working on the first really large Ada project, called AFATDS (Advanced Field Artillery Tactical Data System). In 1988, we decided that my wife would continue her education by working on a Ph.D. in computer science and I would support the family by finding a job in industry.

My Ada experience matched Honeywell's needs, and I was hired to be a member of a small team that was to reverse-engineer, document, and write coverage tests for the DDC-I Ada runtime system that was to be used for the 7J7 project. For speed, the runtime was written in assembly language, so the first part of documenting the runtime was to reverse-engineer the code and write a higher-level pseudocode description of each of the algorithms. The purpose of each subprogram and when it would be called was also documented. This team got to the point of having the runtime documented when the 7J7 project was cancelled by Boeing.

Honeywell Air Transport Systems had a continued interest in Ada, and knew that it would have future Ada projects, so I began working on developing design and coding standards for Honeywell's use of Ada. I also developed an in-house training class for Ada. Both of these were important because few software developers at Honeywell had any Ada experience or experience using many of the software engineering principles that Ada was designed to support. In short, I was the in-house Ada guru.

It wasn't very long until Boeing began to develop its next airliner, the Boeing 777. Honeywell Air Transport Systems was awarded large portions of the software.

Among the software to be developed was a system called AIMS (Aircraft Information Management System). This system was to be written completely in Ada. Previous flight software would have one CPU per line replaceable unit (LRU). AIMS integrated the functionality that had been distributed into multiple LRUs into a single system. A single processor would run several applications. For software that was flight-critical, underlying software needed to guarantee that one application could not steal time from or corrupt the data of another process. Because multiple time-critical applications that shared information were to run on a single processor, AIMS required a powerful processor.

Weight on an aircraft is always important. Every pound that is flown requires fuel. As part of the weight savings, AIMS was to be passively cooled—no fan was to be used to provide for cooling.

The hardware engineers at Honeywell did an extensive study of the available processors and rejected the most popular Motorola and Intel chips as either consuming too much power (therefore being too hot to passively cool), or not having enough processing power to handle the job. The analysis and the fact that the hardware engineers were able to build some early prototypes led the engineers to require the AMD 29050 processor for AIMS for the 777. The host system for development was DEC VAX computers running VMS, and later, DEC VAX workstations.

This presented an interesting problem, because Honeywell had promised Boeing that it would do the AIMS software in Ada, but there were no Ada compilers available for the AMD 29050. In my role as Ada guru, I recommended that the choice of the 29050 should be revisited. Since the quality of the compiler and support tools would have a great impact on the development, I felt that the choice of a mature compilation system was vital. The hardware engineers insisted that only the AMD 29050 would meet their needs, so Honeywell needed to find a development system. They approached a number of Ada compiler vendors about producing a compiler and related tools, but for various reasons, none of these worked out. So, Honeywell decided to make its own compiler and development tools. After all, it had made compilers before. It did realize that an Ada compiler and tools was a more complicated task than creating a Pascal compiler, so it formed a partnership with DDC-I. It would use the DDC-I frontend technology as the starting point. In addition, two DDC-I employees would work as consultants on the project. Several engineers from Honeywell's Software Tools section were also to work on the project. I was not one of the original members of the team. I was to continue my guru role. The product to be delivered was called HADS, the Honeywell Ada Development System.

DDC-I had just completed a project of making an Ada development system for the Intel I960 processor. Since it and the AMD 29050 both are RISC-like processors, the source code for that project was selected as the starting point for the project. An Ada compilation system involves much more than just a compiler that generates source code. It also requires a runtime system to manage tasking, exception handling, and storage management. Ada's tasking is a way, within the language, to allow for communication and synchronization of independent threads of control. Exception handling, while now common in languages like C++ and Java, was not a well-known concept at the time. Ada's storage management allows for the management of a general heap as well as other specialized heaps.

The compiler and linker are host tools, and DDC-I had used its DEC VAX native Ada compilation system as the tools for developing its Ada I960 compiler, so this was a natural choice for writing the HADS compiler and linker.

The runtime portion of the compilation system is code that runs on the target. Since the HADS compiler was not yet available for generating the needed code, the runtime was written in C and AM29050 assembler. The portions of the runtime that would be included in the safety-critical portions of final AIMS applications would need to be documented and tested to DO-178B standards.

Since I wasn't originally on the team, my recollections of the initial team are based on things I could overhear while I was sitting in my nearby cubicle, as well as things told to me later. Some developers' names I will be using are not the correct names. Some of this is because I truly don't recall the name of a person, and some to avoid any possible embarrassment.