D vs Haxe

With few exceptions, D will either compile C code to work exactly as when compiled as C, or it won't compile - it won't quietly change the semantics of C code and give unexpected results. This means that D contains an improved C, as it fails compilation where type safety is missing in C.

This allows learning the same machine operations available in C and other low-level languages.

When you're just starting out, dealing with manual memory management and its bugs is a huge pain! D is garbage collected by default, which removes a huge class of things that could go wrong. And later on, if you decide you don't want or need the GC, you can turn it off.

D is usually up to 10 times faster than C++. Having a language that compiles this fast means that you are free to write highly optimized code because of the relatively low cost of experimentation.

D provides unittest blocks to insert code that verifies functions preform their expected behavior and document edge cases. Since these are enabled with a compiler switch, there is no need to teach new programmers how to install new libraries and import modules, instead training on test driven design can start from the very first function.

D provides a structure that builds on C's arrays called slices. A slice is a segment of an array that tracks the pointer and the length of the segment.

Slices are extremely powerful because they combine the protection of knowing the length of the data with the garbage collector that manages the memory backing that data, thus avoiding most memory corruption issues.

For a new user adding types can feel tedious, and takes focus off the meaning of the code, but they are also important for checking logic. D provides static types, and a good system to infer types, so types are checked when calling functions, but do not need to be specified everywhere, making it feel more dynamic.

The compiler can check that functions don't have side effects, extremely important for functional programming in concurrent scenarios, and can check immutability.

Therefore, the compiler will prove that your programs are functionally pure and respect immutable data, if you want it to.

Because all types can be treated as objects, all files can call functions in the same manner -- even stdin and stdout. stdout.writeln(); stdin.readln(); file.writeln(); file.readln();

D practically has the same memory structure as C and C++; all D does it build a structure around that. The entire C standard library is accessible at no cost (syntactic or speed) and it's being worked on allowing the same for the C++ standard library.

Supports first-class functionality for both concurrency and parallelism, offered as part of the standard library.

if (exists(file)) {} may be written as if (file.exists) {}.

writeln(file); may be written as file.writeln();

isDivisibleBy(10, 2); may be written as 10.isDivisibleBy(2);

writeln(isEven(add(5, 5))); may be written as 5.add(5).isEven().writeln();

Haxe allows you to develop for Web, iOS, Android, Blackberry, Windows, OSX, Linux and others, all at once, without the need to switch languages and maintain separate code bases.

This is possible because Haxe can compile to JavaScript, ActionScript, Flash AVM bytecode, C++, Neko, PHP, C# (.NET) and Java.

Support for even more platforms and languages is under development.

The language was designed to be very expressive with the smallest possible amount of syntactic sugar. There are actually fewer keywords than other languages with similar power.

Haxe can easily compile over 100,000 lines of code to JS in seconds on a mid-spec computer.

The language is very easy to learn for those with background in JavaScript or ActionScript 3.

Haxelib (common library repo) and other sources contain large codebases for anything from cryptography to communications. A lot of these are fully cross platform and work with the JavaScript target.

The JavaScript target can be used for everything from node.js server applications (with code completion) to games using either the Flash-like OpenFL library or direct canvas or WebGL programming.

Haxe has been around for more than 10 years (since 2005) and whilst not the most popular project, has had continuous growth.

Highly unlikely to disappear or for support to stop.

Friendly community

One big advantage over pure javascript, (or some other languages listed here) is that Haxe will pick up a whole range of errors when you compile, saving you the pain of having to try and debug them later. This includes everything from syntax errors ("Unexpected ;") to type errors ("Class user has no field username. Suggestion: username").

Code completion is built into the compiler and available to the IDE allowing for much smarter code completion that can actually parse and understand the syntax tree.

The output that is generated can be trimmed using "dead code elimination" to only include those functions and libraries that are strictly necessary. All code is very readable with only minimal extras for specific functionality.

Small output is good for frontend development as file size is a major concern.

After a type is inferred from its context, it cannot be changed to a new type, and type safety is done at compile time so it stays safe without the extra maintenance required for static typing.

Syntactic macros allow you to extend compiler features at the syntax tree step. Macros come into play after code is parsed into the abstract syntax tree, and macros allow you to transform it before the rest of the compilation completes.

This provides for immense power, while at the same time scoping the extensibility at a level that is powerful, but well constrained.

You can use the same classes on the server as you do on the client where applicable. This saves a lot of time.

Haxe has the ability to use "externs". These are haxe files which describe the usage of existing JS libraries. Get code completion and compile-time-checking for everything from jQuery to Node.js.

Even without externs, native JS code can still be used through untyped code.

Haxe has the power and expression to not need the npm dependancy hell that is common in js and typescript, bit it's still simple.

Using a remoting proxy you can get type safe server to client communications, allowing for remote method execution on the server as if they were part of the client side code.

Package tree is just directory tree, it's wonderful!

Haxe supports conditional compilation, so depending on compiler flags Haxe will include or exlcude sections of your code. Making it easy to have debug and release builds.

You can define constants in an abstract enum and when used in a switch/case statement Haxe checks for exhaustiveness, making sure every constant is covered - with no runtime implication.

Haxe compiler will check types when using externs for existing libraries.

You should use externs when calling non Haxe code, but if you just need to call one or two external JS functions, you can skip type checking by calling untyped code.