Programming Language Developer / Language Designer to $4000

You might be a fit if you:

• Have developed a programming language (or major contributions to compilers/interpreters/parsers)
• Are fluent in functional programming paradigms (especially F#, Haskell, OCaml)
• Have experience with static type systems, type inference, or metaprogramming
• Understand language design principles, compiler theory, ASTs, and parsing
• Bonus: Familiarity with COBOL, ADA, and/or legacy systems

We want a functional fixed-point language inspired by Cobol, ADA and F#

We think that the best way to achieve this is to use F# as a base, adapt it to Cobol and then compare all of these functions with ADA Python and others to ensure it is complete before testing it in various scenarios.

Features of the Language

a) Functional Programming
— Pure Functions: The functions must not have side effects, guaranteeing predictability and ease of testing.
— Default immutability: The data is immutable unless explicitly modifiable, which improves security and facilitates reasoning on the code.
— Support for higher-order functions: Functions can be passed as arguments, returned by other functions or stored in variables.
— Pattern Matching: A powerful system for deconstructing complex data structures.
— Lazy Evaluation: Lazy evaluation to optimize performance and manage infinite structures.

b) Class-Based Object-oriented Programming + Reflexive Meta-Programming
— Classes and Inheritance: The language must allow the creation of classes with single or multiple inheritance, depending on the needs.
— Reflective meta-Programming :
— Dynamic access to object metadata (for example, inspection of properties and methods).
— Modification of the behavior of objects or classes at runtime.
— Support for annotations or custom attributes.
— Traits or Mixins: To avoid the limitations of multiple inheritance, the language could include traits or mixins to compose functionalities.

c) Structured High Level
— Abstraction: The language must provide powerful abstractions to hide the complexity of low-level operations.
— Automatic memory management: Use of a garbage collector to simplify resource management.
— Rich standard libraries: Include libraries for common tasks (file processing, network, databases, etc.).
— Clear and concise syntax: An easy-to-read and easy-to-write syntax to encourage productivity.

d) Static Typing

— Type Inference: The compiler can infer types automatically, reducing verbosity without sacrificing security.

— Algebraic types: Support for unions and type products to model complex structures.

— Generics: Parametric types to write reusable and safe code.

— Exhaustive type checking: The compiler must detect type errors before execution.

— Extensible type system: Possibility to define new types or customize the behavior of existing types.