value-based execution
fundamental types of lists and interfaces
list comprehension
else and nelse
minimize ambiguity
function overloads should be general (i.e. the "sort" function on different containers would be defined once with the functionality that applys to all ordered containers, and the compiler will handle type specific semantics )
all implicitly typed variables are clearly defined, with the type determinable from within 1-2 lines of the first use of the variable
variables should not be recycled
sparse names
extend definitions of existing functions before defining new ones (i.e. defining the concatenation of two types should overload "+" rather than create a new function such as "concatStringInt")
reduce the number of variables by grouping data by associated with each other in a structure
reduce the number of variables by using context regions for values
reduce the length of variable names by using built-in and custom aliases
horizontal over vertical, short over long
use the "for" loop (i.e. iterations, enumerates, conditional iterations, list comprehension)
use specific functions and operations when possible (i.e. rather than y==1 & y==3, do y in [1,3])
every line should have at most one loop and one if clause
logic over efficiency
leave micro-optimizations to the compiler
leave inline comments
use libraries
choose the best algorithms for general efficiency
use functions and variables in such a way that it does not matter how they are internally implemented (i.e. do not expect sort to maintain the relative order of equivalent value elements)
bottom up hierarchy
simple operations should be implemented before more complex operations (i.e. a function returning the max and min of a list should depend on both max and min functions, rather than iterate through the list itself)
modifications to dependency functions should modify the process of any overarching functions
override the read and write fields of variables to serve as logical accessors and modifiers (i.e. given n and inverse n, inverse n should return 1/n when read and should set n to 1/inverse n when written to)
The goal of this project is to create a programming language that is more maintainable, efficient, and readable, as well as reduced in physical length, so programmers to focus on the logic of a program.
MERL is a general purpose, high level programming language that derives its structure from mathematics and simple English. MER supports functional object-oriented programming at a high level, and has built-in, high level data structures, but runs at the low-level, making it highly efficient. MER's logical syntax and dynamic typing intend to improve the maintainability, efficiency, and readability of code.
The focuses of MERL include introducing more keywords and operations for commonly used routines, reducing dependence on types in favor of functionality, providing more support for large data, and providing syntax that allows others to comprehend a program's logic without former programming knowledge.