Implicit is Wack!

The Peril of Implicitness in Programming

Implicit assumptions in programming are often the root of many software bugs and maintenance challenges. They introduce uncertainty into data type interpretation and usage, making code harder to understand, predict, and debug. The mDm programming language confronts this issue head-on by emphasizing explicit definitions over implicit assumptions, a principle that is core to its design philosophy.

Explicit Definitions in mDm

mDm’s approach to programming language design is ambitious and innovative, combining structured programming principles with modern features like macros, groupings, and advanced data handling. By explicitly defining every aspect of the program, from data types to operations within dSeqs, mDm aims to eliminate the ambiguities that often plague software development.

Type Annotations in dSeqs

In mDm, when defining dSeqs, type annotations explicitly declare the types of inputs, processing steps, and outputs. This explicit declaration supports mDm's objective of making each dSeq self-contained and easily understandable. Here is how explicit type annotations enhance clarity and predictability:

// An example of a dSeq with explicit type annotations
(int, int), add, (int)

In this example, the add function is clearly expected to take two integers as input and return an integer as output, leaving no room for ambiguity.

Type Safety in Modular Design

mDm's modular design, which emphasizes modules, packages, and namespaces, leverages type safety to ensure that interfaces between different parts of the program are used correctly and that data is appropriately shared or isolated. This design philosophy helps in maintaining a clean and understandable codebase, which is crucial for large-scale software development.

Type Inference for Ease of Use

While mDm advocates for explicit definitions, it also understands the need for ease of use. Type inference in mDm is designed to be beneficial for writing concise and expressive code, especially when the context of complex operations or algorithms makes the types clear. However, this inference is carefully controlled and applied only where it does not compromise clarity or introduce ambiguity.

Rejecting Implicit Assumptions

Implicit assumptions can lead to a variety of problems in programming, such as type errors, unexpected behaviors, and security vulnerabilities. By rejecting implicit content assumptions, mDm promotes type safety and ensures that every operation on data is intentional and explicit. This strictness minimizes the risk of type errors and reduces the complexity associated with casting between types, thereby enhancing program reliability and security.

Error Handling and Explicitness

In mDm, error handling is structured to explicitly manage exceptions and ensure robust program operation even in the face of unexpected inputs or states. Here’s how explicit error handling is implemented:

// Handling errors explicitly in mDm
(inputData), riskyOperation, result 
(result), if _, (handleError, _)

In this setup, the if _ checks explicitly for undefined results (_), triggering error handling routines if needed. This approach prevents errors from cascading through the system unnoticed.