+
+ it's an ML-style language yay
+
+
+
+ Darklang is a statically-typed, functional/imperative hybrid programming language designed primarily for building cloud-based backend services. Its functional aspects draw inspiration from languages like OCaml, Elm, and Rust, emphasizing simplicity, type safety, and productivity while avoiding complex functional programming concepts like monads or category theory.
+
+
+
+ Immutability:
+ Darklang embraces immutability, a core functional programming principle. Values in Darklang are immutable by default, eliminating race conditions in concurrent execution and making programs easier to reason about.
+
+
+
+ No Exceptions, Use of Results and Options:
+ Instead of exceptions, which can complicate reasoning in functional programming, Darklang uses Result and Option types to handle errors and optional values. This approach, inspired by languages like Rust and OCaml, ensures explicit error handling and avoids issues associated with nulls or unchecked exceptions.
+
+
+
+ First-Class Functions and Pipelines:
+ Darklang supports first-class functions, enabling functions to be passed as arguments, returned from other functions, and assigned to variables, a standard feature in functional languages.
+ It makes heavy use of pipelines (similar to F# or Elm), allowing developers to chain function calls in a readable, declarative way. For example, operations like List::map are used to transform collections functionally
+
+
+
+ Implicit Returns:
+ Like many functional languages (e.g., Elm or Haskell), Darklang uses implicit returns, where the last expression in a function is automatically its return value. This reduces boilerplate and aligns with functional programming’s focus on expressions over statements.
+
+
+
+ Simple Type System with Records and Enums:
+ Darklang employs a straightforward type system based on Records and Enums (also known as variants or sum types), similar to Rust, Elm, or OCaml. These types are expressive enough to model complex data structures while remaining simpler than object-oriented class hierarchies.
+ For example, a Url type might be defined as a record with fields like scheme, domain, and port, while a UrlError enum could represent possible errors like InvalidScheme or EmptyDomain. This approach avoids the complexity of inheritance and aligns with functional programming’s preference for algebraic data types.
+
+
+
+ Functional/Imperative Hybrid:
+ While primarily functional, Darklang is described as a functional/imperative hybrid, drawing from OCaml, Elm, and Rust rather than purely functional languages like Haskell. This hybrid nature makes it accessible to developers familiar with imperative or object-oriented languages, avoiding esoteric functional concepts like monads, lenses, or combinators.
+ The language prioritizes developer productivity by allowing imperative-style code where needed, but its functional core ensures type safety and immutability.
+
+
+
+ Asynchronous Programming Without await:
+ Darklang’s runtime is fully asynchronous, but it avoids the explicit await keywords common in languages like JavaScript or TypeScript. Instead, it uses data dependencies to manage concurrency, a functional approach that ensures operations wait for their inputs without exposing threading complexity.
+ This design eliminates race conditions (due to immutability) and simplifies concurrent programming, aligning with functional programming’s emphasis on declarative concurrency models.
+
+
+
+ Unicode-Aware Strings:
+ Darklang’s string handling is designed for modern applications, using Extended Grapheme Clusters to represent characters (e.g., emojis like 👨👩👦👦 are treated as single characters). This functional approach to string representation avoids the pitfalls of byte-based or UTF-16 strings in older languages, ensuring predictable behavior in text processing.
+
+
+
+ Reliability: Static typing and immutability ensure that compiled code is robust, a critical feature for cloud backends.
+ Concurrency: Immutability and data-driven async execution simplify concurrent programming, a key requirement for scalable backend services.
+ Productivity: Features like pipelines, implicit returns, and gradual typing make functional programming accessible and efficient, aligning with Darklang’s goal of simplifying backend development.
+
+
+
+ Traces are a core feature of Darklang that enable developers to work with live request data to build and debug applications efficiently.
+ Acting as an "omniscient debugger" traces provide complete visibility into the state of an application at any point in time, allowing developers
+ to see exactly what data flows through their code and how it behaves without needing traditional debugging tools like print statements or external loggers.
+
+ Traces power Trace-Driven Development, a workflow where you start by sending requests to non-existent endpoints.
+ Darklang records those traces, which you then use to write code that handles real inputs.
+ This approach ensures code is developed with actual data, reducing guesswork and errors.
+
+ Traces are records of HTTP requests (or other events) made to a Darklang app. Whether your code runs locally or in the cloud,
+ traces automatically capture inputs and intermediate values during execution for:
+ - HTTP handlers
+ - Worker `emit`s
+ - Function calls
+ - CRON responses
+ - CLI application calls
+
+ A trace includes:
+ - Request Inputs: The full HTTP request, including headers, query parameters, body and metadata.
+ - Intermediate Values: Values computed during the execution of a handler, such as the results of expressions or function calls.
+ - Live Values: The evaluated results of expressions for a selected traceThese update in real-time as you write code.
+ - Return Values: The final output of a handler
+
+ All traces are securely and centrally captured in the package manager, and made available in your editing environment.
+ This approach streamlines debugging, improves accuracy, and makes refactoring safer—all by letting real data guide the development process.
+
+ );
+};
+
+export default TraceDriven;
diff --git a/src/pages/TypeChecking/index.tsx b/src/pages/TypeChecking/index.tsx
new file mode 100644
index 0000000..e93c8f7
--- /dev/null
+++ b/src/pages/TypeChecking/index.tsx
@@ -0,0 +1,40 @@
+import React from "react";
+
+const TypeChecking: React.FC = () => {
+ return (
+
+
+ Runtime is done-ish
+ Parse-time is barely there
+
+
+
+ Type checking:
+ - Darklang is fully statically typed with Gradual Flexibility, ensuring that types are checked at compile time to catch errors early. This helps developers ensure that changes across large programs are safe, particularly for refactoring or scaling systems
+ - Unlike traditional functional languages where the entire program must compile, Darklang employs gradual static typing. This allows incomplete or partially typed code to run, enabling developers to prototype quickly without ensuring every part of the program type-checks immediately
+ - Darklang uses small compilation units, meaning that type checking is localized to specific parts of the program, such as a single HTTP route. This reduces the scope of type changes needed when prototyping or making small modifications
+ - Instead of modifying existing types, developers create a copy of a type, make changes, and test them. Once validated, semi-automated tooling helps propagate these changes across the program, minimizing the effort required for large-scale type updates.
+ - The language supports Option and Result types for error handling, replacing nulls and exceptions to avoid common pitfalls like null pointer errors
+ - Types and functions in Darklang are versioned and immutable, ensuring that changes don’t break existing code. This is particularly useful in the package manager, where types and functions are individually versioned
+ - When updating types, developers can test new versions without affecting the entire program, and tooling assists in migrating to the new type once it’s finalized.
+ - Future plans include implementing an at-rest/static checker to perform comprehensive type checking, including preventing invalid operations (e.g., adding a String and an Int). This will leverage Darklang’s access to trace data for advanced diagnostics
+
+ Benefits of Darklang’s Type Checking
+
+ - Safety: Static typing ensures type mismatches are caught early, reducing runtime errors and making large-scale changes safer
+ - Productivity: Small compilation units and gradual typing allow rapid prototyping, akin to dynamic languages, while retaining static typing benefits
+ - Error Handling: The Option/Result types simplify error management, eliminating the need for exceptions and reducing null-related bugs
+ - Maintainability: Versioned types and editor integration make refactoring and maintaining code easier, especially in evolving projects
+ - Diagnostics: Integration with trace data provides unique insights into type-related issues, improving debugging and development efficiency
+ - Scalability: Versioned types and small compilation units make it easier to scale and refactor backends as projects grow
+
+
+ for more content inspo:
+ - https://blog.darklang.com/real-problems-with-functional-languages/amp/
+ - https://blog.darklang.com/an-overdue-status-update/
+
+
- 
- 
- 
- 
-