In Axiom, there is no unnecessary syntax like semicolons (statement delimiters in Python/C++) or colons (conditional/loop delimiters in Python) or curly braces (block delimiters in C++/Javascript). Unnecessary syntax is often an annoyance when forgotten, but also can be abused to pack code into fewer lines (minification). Since Axiom is focused on simplicity and clarity, such packing is unsupported.
Axiom uses whitespace to indicate blocks, like Python. This reduces the need for curly braces (like in C++/Javascript) or "end" (like in Ruby/Lua). Unlike Python, only tabs are allowed (not spaces). Valid Axiom code is properly-formatted Axiom code, so Axiom requires no linter.
Like other high-level languages (Python/Javascript), Axiom supports weak typing and duck typing. Like Python (but unlike Javascript), no declarations (var, let, const) are required. Like Javascript (but unlike Python), types are automatically converted (coerced) as needed.
Like Javascript, all instances of classes (objects) are also associative arrays (maps) However, unlike Javascript, Axiom has proper classes. Also unlike Javascript, functions, arrays, and strings are not objects. This avoids the hacks needed in Javascript like hasOwnProperty() and prototype chains.
There are only six types in Axiom: null, number, boolean, string, array, object. Class instances are simply objects (maps) with with the "class" attribute set, which allows the engine to find the proper context when calling methods.
There are no annotations, decorators, spreads, comprehensions, lambdas, closures, generators, iterators, promises, observables, effects, etc. Because Axiom is designed for simplicity and clarity, it eschews syntactic sugar, which is just a way to hide or compress code, but often makes the code opaque. At its worst, syntactic sugar can hide poor design and lead to irregular code.
Axiom does not have exceptions, inheritance, or gotos. I consider all of these to be "convoluting", meaning that they are able to escape traditional block syntax and jump to un-obvious places in the code.
All these features lead to spaghetti code, because they cause the flow of execution to jump around without any obvious indicators as to where it will go.
Again, Axiom is designed to be simple and clear, and convoluting syntax is the opposite of that. Exceptions are often confusing for beginners and often lead to extraneous code such as writing "throws Exception" everywhere in Java or "try/catch/except" everywhere in Python/Javascript.
Inheritance is problematic and is implemented differently in every language. For example, C++ allows multiple inheritance, Java allows only single inheritance but multiple interfaces, and Javascript uses prototype chains. This is an indicator, to me at least, that inheritance is not a very well-thought-out idea. It is often misused or used as a crutch in place of a missing language feature. For example, languages without duck typing use inheritance to force multiple objects into the same collection. Often times there is a better design pattern that can be used in place of inheritance:
Axiom lets you import code from anywhere on the web simply by passing a url to import() (similar to Deno). This removes the need for a separate package manager (like pip, npm, maven) or centralized hosting service owned by one entity. Remote imports are cached locally in the folder ".axiom".
Axiom supports native threads, unlike most other high-level programming languages. It is the programmer's responsibility to avoid race conditions.
Also called a native interface or "foreign function interface" (although kind of a misnomer, since a foreign function in a foreign language is usually a native function), this is similar to ctypes in Python or cgo in Go. This allows you to easily link with external libraries and call native functions without having to do anything special (like write your native code in a certain way or recompile anything).
Axiom supports mutable strings, unlike most other high-level programming languages. In other languages, in order to change a single character in a string, a new string must be created. In Axiom, changing a single character is as simple as assigning to the position (s[1] = 'a', for example).