In this section, we will focus on TypeScript's internal architecture and its original design goals.

The following list describes the main design goals and architectural decisions that shaped the way the TypeScript programming language looks today:

• Statically identify JavaScript constructs that are likely to be errors: The engineers at Microsoft decided that the best way to identify and prevent potential runtime issues was to create a strongly-typed programming language and perform static type checking at compile time. The engineers also designed a language services layer to provide developers with better tools.
• High compatibility with existing JavaScript code: TypeScript is a superset of JavaScript; this means that any valid JavaScript program is also a valid TypeScript program (with a few small exceptions).
• Provide a structuring mechanism for larger pieces of code: TypeScript adds class-based object-orientation, interfaces, namespaces, and modules. These features will help us to structure our code in a much better way. We will also reduce potential integration issues within our development team and our code will become easier to maintain and scale by adhering to the best object-oriented principles and recommended practices.
• Impose no runtime overhead on emitted programs: It is common to differentiate between design time and execution time when thinking about TypeScript. We use the term design time or compile time to refer to the TypeScript code that we write while designing an application, while we use the term execution time or runtime to refer to the JavaScript code executed after compiling some TypeScript code.

TypeScript adds some features to JavaScript, but those features are only available at design time. For example, we can declare interfaces in TypeScript, but since JavaScript doesn't support interfaces, the TypeScript compiler will not declare or try to emulate this feature at runtime (in the output JavaScript code).

The Microsoft engineers provided the TypeScript compiler with some mechanisms, such as code transformations (converting TypeScript features into plain JavaScript implementations) and type erasure (removing static type notation), to generate clean JavaScript code. Type erasure removes not only the type annotations, but also all the TypeScript-exclusive language features such as interfaces.

Furthermore, the generated code is highly compatible with web browsers as it targets the ECMAScript 3 specification by default, but it also supports ECMAScript 5 and ECMAScript 6. In general, we can use the TypeScript features when compiling to any of the available compilation targets, but sometimes some features will require ECMAScript 5 or a higher version as the compilation target.

• Align with current and future ECMAScript proposals: TypeScript is not just compatible with existing JavaScript code; it is also compatible with some future versions of JavaScript. At first glance, we may think that some TypeScript features make it quite different from JavaScript, but the reality is that all the features available in TypeScript (except the type system features) follow the ECMAScript proposals, which means that many of the TypeScript files will eventually be available as native JavaScript features.
• Be a cross-platform development tool: Microsoft released TypeScript under the open source Apache license and it can be installed and executed in all major operating systems.

The TypeScript language has three main internal layers. Each of these layers is, in turn, divided into sublayers or components. In the following diagram, we can see the three layers (three different shades of gray) and each of their internal components (boxes):

Each of these main layers has a different purpose:

• Language: Features the TypeScript language elements.
• Compiler Performs the parsing, type checking, and transformation of your TypeScript code to JavaScript code.
• Language services: Generates information that helps editors and other tools provide better assistance features, such as IntelliSense or automated refactoring.
• IDE integration (VS Shim): The developers of the IDEs and text editors must perform some integration work to take advantage of the TypeScript features. TypeScript was designed to facilitate the development of tools that help to increase the productivity of JavaScript developers. Because of these efforts, integrating TypeScript with an IDE is not a complicated task. A proof of this is that the most popular IDEs these days include good TypeScript support.