System simulation is the definition, control, and implementation of algorithmic models that replicate a system's real world behavior. Developing a useful simulation model requires a clear abstraction of the system. Software engineering supports abstraction by imposing a consistent structure on objects. One structural feature introduced by recent programming languages is strong [data] typing, aiming at two benefits: clarification of the design and enhancement of model verification. Strong typing clarifies the design by controlling the characteristics of an object, and enhances model verification by revealing errors early in the design cycle. Designers have traditionally viewed strong typing only as over-restricting the mixture of data units (e.g., meter versus degrees), an experience which has left a bad taste in many mouths. However, strong typing is a multifaceted tool which can apply to a broad range of software design problems. Simulation model designers can use Ada types to define, control, and implement models yielding:

(1) requirements consistency and traceability,

(2) interface definition/control,

(3) maintainability,

(4) reusability, and

(5) portability.

Because designers imagine and implement complex systems in parallel, projects can suffer from the fracturing effect of multiple visions of the final product. Strong typing can unify the system design, however, strong typing is only a tool - the availability of which does not ensure its correct application. The challenge is to successfully implement it. This paper examines the successful use of Ada types for the design of simulation models, and points out the pitfalls of extreme approaches such as no-typing and over-typing. It presents Ada types as a scheme for enforcing a single system structure and as a foundation for generic simulation models. Finally, the paper discusses how types impact the software's lifecycle.