Language Characteristic
| Characteristic | Terraform (HCL2) | Python | JavaScript | TypeScript | C++ | Rust |
|---|---|---|---|---|---|---|
| Primary Paradigm | Declarative | Imperative | Imperative | Imperative | Imperative | Imperative |
| Evaluation Model | Expression-based | Statement-based | Statement-based | Statement-based | Statement-based | Statement-based |
| Static Typing | Partial / Gradual | No | No | Yes (erased) | Yes | Yes |
| Dynamic Typing | Yes | Yes | Yes | No (after compile) | No | No |
| Type Soundness | No | No | No | No | Mostly | Yes |
| Type Inference | Limited | Yes | Yes | Yes | Limited | Strong |
| Explicit Type Annotations | Optional | Optional | N/A | Optional | Required | Often optional |
| Gradual Typing | Yes | No | No | Yes | No | No |
| Runtime Type Errors | Yes | Yes | Yes | Yes (if unchecked) | UB / compile fail | No |
| Compile-Time Guarantees | Weak | None | None | Medium | Strong | Very strong |
| Union Types | No | No | No | Yes | No | Yes (enums) |
| Structural Typing | Yes | Duck typing | Duck typing | Yes | No | No |
| Nominal Typing | No | No | No | No | Yes | Yes |
| Flow-Sensitive Typing | No | No | No | Yes | No | Yes |
| Pattern Matching | No | No | No | Limited | No | Yes |
| Generics | No | Yes (runtime) | No | Yes | Yes | Yes |
| Value Mutability | Immutable | Mutable | Mutable | Mutable | Mutable | Immutable by default |
| State Mutation | No | Yes | Yes | Yes | Yes | Yes |
| Memory Management | Runtime managed | GC | GC | GC | Manual | Ownership system |
| Late Binding | Yes | Yes | Yes | Yes | Limited | No |
| Runtime Schema Dependence | Yes | No | No | No | No | No |
| Declarative Semantics | Yes | No | No | No | No | No |
| Sound Refactoring Support | No | No | No | Partial | Yes | Yes |
| IDE Type Recoverability | Poor | Poor | Poor | Good | Excellent | Excellent |
| Foreign Runtime Dependence | Yes (providers) | No | No | No | No | No |
| Execution Order Defined by Language | No | Yes | Yes | Yes | Yes | Yes |
| Compile Target | Graph + runtime | Bytecode | Bytecode | JS | Native | Native |
Definitions
- Primary Paradigm: The dominant style of computation the language encourages (e.g., declarative vs imperative). It affects how control flow, state, and effects are expressed.
Evaluation Model Whether programs are composed primarily of expressions (which evaluate to values) or statements (which perform actions). Expression-based models enable composition but complicate static reasoning.
Static Typing Types are checked before execution and do not change at runtime. Errors can be detected without running the program.
Dynamic Typing Types are associated with values at runtime rather than variables at compile time. Type errors are detected during execution.
Type Soundness A property where well-typed programs are guaranteed not to produce type errors at runtime. Unsound systems allow programs that type-check but still fail.
Type Inference The ability of the compiler or analyzer to deduce types automatically without explicit annotations. Strong inference reduces verbosity while preserving safety.
Explicit Type Annotations Programmer-supplied type declarations that constrain or document values. They may be required, optional, or unavailable depending on the language.
Gradual Typing A type system that allows mixing statically typed and dynamically typed code, with runtime checks at the boundaries. It trades completeness for flexibility.
Runtime Type Errors Errors caused by type mismatches during execution. Their presence indicates weak or absent static guarantees.
Compile-Time Guarantees Properties of the program that are proven before execution (e.g., type correctness, memory safety). Strong guarantees reduce runtime failures.
Union Types Types that explicitly allow a value to be one of several alternatives. They enable precise modeling of branching logic.
Structural Typing Type compatibility is based on shape (fields and operations), not declared identity. This enables flexible composition but weakens encapsulation.
Nominal Typing Type compatibility is based on explicit declarations and names. This enforces stronger abstraction boundaries.
Flow-Sensitive Typing The type system refines variable types based on control flow (e.g., after checks or pattern matches). This improves precision without annotations.
Pattern Matching A construct that destructures values and binds variables while enforcing exhaustiveness. It enables safe handling of complex data types.
Generics Parameterized types that allow code to operate over multiple types while preserving type safety. They enable abstraction without runtime cost.
Value Mutability Whether values can be modified after creation. Immutability simplifies reasoning and concurrency.
State Mutation The ability of a program to modify shared or persistent state. Mutation introduces ordering and aliasing concerns.
Memory Management How memory is allocated and reclaimed (manual, garbage-collected, or ownership-based). This strongly impacts safety and performance.
Late Binding Resolution of values, types, or behavior at runtime instead of compile time. Late binding increases flexibility but reduces predictability.
Runtime Schema Dependence Program correctness depends on external schemas or metadata available only at runtime. This prevents complete static verification.
Declarative Semantics Programs describe desired outcomes rather than execution steps. The runtime decides how to realize the result.
Sound Refactoring Support The ability to refactor code with confidence that behavior remains correct, enforced by the type system. Requires strong static guarantees.
IDE Type Recoverability How well tools can infer types and structure for navigation, refactoring, and error detection. Depends on language semantics, not just tooling.
Foreign Runtime Dependence Correctness depends on external systems or plugins beyond the language runtime. This limits static reasoning.
Execution Order Defined by Language Whether the language specifies a deterministic order of evaluation. Undefined order complicates reasoning and optimization.
Compile Target The form the program is translated into (machine code, bytecode, graph, or interpreted representation). This shapes performance and guarantees.