# strict programming language

> programming language

**Wikidata**: [Q28923017](https://www.wikidata.org/wiki/Q28923017)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Strict_programming_language)  
**Source**: https://4ort.xyz/entity/strict-programming-language

## Summary
A strict programming language is a type of programming language that follows strict programming principles, meaning expressions are evaluated and results are returned only when all their arguments are available, as opposed to non-strict languages that may delay evaluation.

## Key Facts
- Is a subclass of programming language
- Opposite of non-strict programming language
- Manifestation of strict programming paradigm
- Has 2 sitelink counts on Wikipedia
- Wikipedia entries available in English and Kaa languages
- Associated with Microsoft Academic ID 123741691 (discontinued)
- Related to Starlark, Elvish, TypeScript, and Visual Basic

## FAQs
### Q: What is the difference between strict and non-strict programming languages?
A: Strict programming languages evaluate expressions immediately when all arguments are available, while non-strict languages may delay evaluation.

### Q: What are examples of strict programming languages?
A: Examples include languages like TypeScript (2012) and Visual Basic (2001), though specific implementations vary.

### Q: How does strict programming differ from lazy evaluation?
A: In strict languages, functions return results as soon as all inputs are ready, whereas lazy evaluation delays computation until results are actually needed.

## Why It Matters
Strict programming languages represent a fundamental approach to computation where expressions are evaluated deterministically and immediately when all inputs are available. This approach ensures predictable behavior and eliminates potential ambiguities in program execution. The strict paradigm is crucial for systems requiring immediate results and deterministic behavior, particularly in applications where timing and resource management are critical. It provides a clear, unambiguous model of computation that simplifies reasoning about program behavior and helps prevent certain classes of bugs that can arise in non-strict languages.

## Notable For
- Represents the opposite of non-strict programming languages
- Is a manifestation of strict programming paradigm
- Has a dedicated Wikipedia entry with information in multiple languages
- Associated with specific programming languages like TypeScript and Visual Basic
- Maintained academic record through Microsoft Academic ID

## Body
### Classification and Relationships
Strict programming language is classified as a subclass of programming language, specifically representing languages that adhere to strict programming principles. It is fundamentally opposite to non-strict programming languages, which may employ features like lazy evaluation or non-deterministic computation.

### Technical Characteristics
The strict programming paradigm ensures that function calls and expressions are evaluated immediately when all arguments are available. This deterministic evaluation model provides predictable program behavior and simplifies debugging and optimization processes. Unlike non-strict languages that may delay computation until results are actually needed, strict languages maintain a clear, sequential execution model.

### Language Examples and Development
The concept of strict programming is exemplified by languages such as TypeScript (inception 2012) and Visual Basic (inception 2001), which implement strict evaluation semantics. These languages compile to JavaScript or run on .NET platforms respectively, demonstrating how strict principles can be applied across different runtime environments.

### Academic and Community Recognition
The concept has academic recognition, evidenced by its Microsoft Academic ID (123741691) and presence in Wikipedia with sitelink counts indicating community interest. The language has been studied and documented across multiple platforms, with the Wikipedia entry available in both English and Kaa languages.

### Implementation Variations
While the core principle of strict evaluation remains consistent, implementations vary in how they handle edge cases and performance optimizations. Some languages may incorporate hybrid approaches that combine strict evaluation with lazy features, creating nuanced execution models that balance performance and flexibility.

```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Strict programming language",
  "description": "A programming language that follows strict programming principles, evaluating expressions immediately when all arguments are available",
  "sameAs": ["https://www.wikidata.org/wiki/Q328", "https://en.wikipedia.org/wiki/Strict_programming_language"],
  "additionalType": "Programming language"
}