The last thing this world needs is one more design language. This is an odd statement to open a book about one more design language, but it is true nonetheless. What the world does need are solutions to problems that help produce cheaper, more reliable engineering solutions. Although the introduction of VHDL and Verilog revolutionized digital hardware design, today they represent venerable, established solutions to RTL design problems. The time has come to move ahead to new solutions to the new problems introduced by heterogeneity, resource constraints, rapidly evolving implementation fabrics, safety and security requirements, and system-level complexity. More of yesterday’s solutions will not solve today’s system-level design problems.

Rosetta was inspired by a problem whose solution demanded a paradigm shift—the design of “systems on chip,” or system-level design of electronic systems. In 1997, the Semiconductor Industry Council met in Dallas, Texas to discuss potential solutions to the system-level design problem. Specifically, the industry was beginning to see the edges of what its design methods and tools were capable of supporting. The ability to fabricate systems was growing exponentially, outpacing even Moore’s Law. However, the ability to design systems was growing only linearly; the causes were deemed to be lack of formal semantics in modeling languages and processes, inability to account for performance requirements during design, inability to predict emergent behaviors in heterogeneous systems; and too much reliance on simulation, among others.

During two days in Dallas in 1997, the Industry Council defined a collection of requirements for a language to support system-level design. This consensus of original motivating requirements still hangs on my wall—representation of performance requirements; precise, formal semantics; support for specification heterogeneity; and reduced reliance on simulation. Although the name has morphed from system-level design (SLD) to electronic system-level (ESL), the problem remains the same.

Almost ten years and one technology boom-and-bust cycle later, we present Rosetta. Through it all, we have tried to hold Rosetta to initial requirements while responding to the unspoken, evolving needs of system-level designers. Rosetta is formal as embodied in co-algebraic semantics supporting both simulation and modern formal analysis techniques. Rosetta represents performance constraints and supports complexity management using abstract, declarative specification. However, above all other things, Rosetta supports heterogeneous specification. This is the linchpin for effective support for system-level design decision making.

Rosetta’s most important contribution to system design is heterogeneity. Heterogeneity means simply that not all elements of a specification are represented using the same semantic basis. It is embodied by the use of continuous-time semantics for analog circuits, state-based semantics for digital systems, and temporal logic for constraints all within the same design. What Rosetta provides is a language and semantics for writing such specifications and integrating them to predict system behavior. Support for heterogeneity is the enabling capability for system-level design. Without it, we are wasting our time.

Heterogeneity was woven into Rosetta’s fabric from the first discussions of its semantics. Rather than establish a specification model for all systems, we have tried to establish a language framework for defining and integrating specification models. The expression language and type system provide a computation-neutral mechanism for declaring things and defining their properties. Being lazy and largely non-strict, the expression language is a means for describing calculations, rather than computations. The facet system provides means for choosing a modeling semantics, defining models using the expression language to specify properties, and composing models to define complete systems. Finally, the domain and interaction systems provide mechanisms for defining modeling semantics and interactions between models in different semantics. Because models are homogeneous and nonorthogonal under composition, we can write models for different system aspects and understand their mutual dependencies and interactions.

What this book attempts to do is provide a gentle introduction to Rosetta and the modeling techniques it supports. After working through the text, I hope that you will be able to begin writing Rosetta specifications in the base Rosetta design domains. What this book does not do is provide deep insight into Rosetta’s semantics or advanced usage. It is not an attempt to replace the Rosetta standard, but instead to provide a path to understanding why the language is designed as it is. It is best to walk before we run, both as a reader and an author!

In the grand scope of electronic system-level design, Rosetta is still a young language. The standards process has started and early adopters are moving forward. There is much left to discover and more work to be done. I hope that ultimately this book will pique your interest in getting involved with the language specification and tool development efforts.