What is the best alternative to Assembly?

Most use of this language will be found in jobs supporting legacy code. It will be hard to find things to do with this language outside of that niche.

After the Wirth era, practically there is no official Pascal language standard. Delphi used to be the dé facto standard especially for industry, but today Free Pascal is starting to get better support. However, there are some other Pascal language variants such as Smart Pascal, Oxygene (from RemObj...

Some popular libs like JQuery have maintained externs, for any specific code or lib already in JS you have to write the externs to use it in your haxe application.

There is currently no support for Qt.

Smalltalk and its implementations are no longer popular languages to use. Available jobs are scarce (but do exist), and online communities are relatively small. There is little to no modern books or resources made for the language, although older, very good books do exist.

Smalltalk wants to be the whole OS. While this has tremendous advantages internally, interacting with the world outside the VM is not so easy.

Since every operation is considered a message sent sent is a specific order, all arithmetic operators have the same precedence. E.g. 2 + 3 x 4 translates to 2 + 3, and the result is multiplied by 4, giving an answer of 24 (instead of the correct answer - 14). Once you are learn this, it can easily...

Ceylon 1.2 needs a language runtime of 1.55 MiB, and the Collection library adds another 370 KiB. That's a lot for the Web... Now, this has to be put in perspective: if you use Ceylon to make a web application, these files will be loaded once, then cached by the browser (that's not casual...

We should hope Red Hat or anyone interested would take the time and write one. That would strengthen the maturity of the language, but Ceylon is rapidly developing which can make the author's efforts futile because his or hers work will become obsolete soon. The second hindrance is, of course,...

There are editor plugins, but neither of them support basic features yet like navigate to referenced definition show expression type

Elm is missing a lot of syntactic sugar that Haskellers may consider core, such as 'do' notation, 'where' clauses, pattern guards, and operator sections.

Some users claim that Elm adds an additional layer of abstraction, meaning that it is one more hurdle between the brain and the product.

Python is abstracted far enough that if it's your first language, it will be harder to pick up lower level languages later versus going the other direction.

A large subset of the Python community still uses / relies upon Python 2, which is considered a legacy implementation by the Python authors. Some libraries still have varying degrees of support depending on which version of Python you use. There are syntactical differences between the versions.

You can use frameworks like Kivy, but if your ultimate goal is to write mobile apps Python may not be the best first choice.

Since Kotlin does not enforce any particular paradigms and is not purely functional, it can be pretty easy to fall back to imperative programming habits if a programmer comes from an imperative background.

The need to make Kotlin interoperable with Java has caused some unintuitive limitations to the language design.

Not very stable and has a rather small community.

Some design choices could have been a little more appealing, for example: using "do...end" comes natural in Ruby for blocks but Elixir uses them for everything and it looks pretty weird: Enum.map [1, 2, 3], fn(x) -> x * 2 end or receive do {:hello, msg} -> msg {:world,...

Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it.

You can put anything in. This makes reasoning about code after a time has passed very hard.

Some language constructs were obviously created as workarounds for JVM limitations. This makes the language much less elegant than it could have been. Also, the JVM has a very cumbersome FFI.

When writing a function, if a programmer forgets to declare a variable, that variable will be declared at global scope. The code will seem to run fine at first, but if another function uses a variable with the same name, but fails to declare it, it will create subtle, incredibly difficult to find b...

Lua features a prototye-based inheritance model. While this is also used by Javascript, it's not used by many other mainstream languages, and so some of the concepts learned while learning Lua won't be very applicable to other languages. Another thing that makes Lua different from other pr...

Lua is so small mainly due to many of the components not being included in the core package. A lot of people need the functionality provided by the Lua module management system LuaRocks and libraries such as Penlight.

Presents some advantages compared to Javascript, but because it is designed to be a superset of Javascript, it means all the bad parts of Javascript are still present.

The default type when declaring and using a variable is any. For example, the following should break but does not: function add(a:number) { return a + 1 }function addAB(a, b) {return add(a) + b}addAB("this should break but doesn't :(", 100) In order to avoid this, you have to decl...

Even in cases were there is no ambiguity, you still have to use "this.fieldName" instead of just "fieldName".

You have generics, you have interfaces, you have inheritance, you have a lot of things at your disposal but you don't have Type Clases. They can be emulated using some clever constructs but there's nothing like having the real thing.

Julia was released in 2012. Due to its short existence, there is a limited amount of support for the language. Very few libraries exist as of yet, and the community is still quite small (though growing quickly).

This design probably come from Matlab, but makes it unnatural to interface C and C++ and python.

Haskell lends itself well to powerful abstractions - the result is that even basic, commonly used libraries, while easy to use, are implemened using a vocabularly that requires a lot of backround in abstract mathematics to understand. Even a concept as simple as "combine A and B" is ofte...

Haskell's language extensions, while making the language incredibly flexible for experienced users, makes a lot of code incredibly unfamiliar for beginners. Some pragmas, like NoMonomorphismRestriction, have effects that seem completely transparent in code, leading beginners to wonder why it...

Haskell allows users to define their own infix operators, even with their own precedence. The result is that some code is filled with foreign looking operators that are assumed to be special-case syntax. Even for programmers who know they're just functions, operators that change infix preceden...

Dart builds to JavaScript but the entire app needs to be built to JavaScript at once for now (that may change in the future).

While implementing callbacks, passing a type to any function that gets passed to Javascript causes the dart2js compiler to crash.

This missing (but very popular) feature requires to use 3rd-party packages developed by the personal enthusiasts or very small groups of enthusiasts, which is not very convenient because they are all very fragmented in terms of content, the essence and capabilities.

Scala is an industrial language. It brings functional programming to the JVM, but not with a "start small and grow the language" perspective, but rather a very powerful language for professional programmers.

The type system is too complicated yet still less powerful than Haskell's.

Even for seasoned programmers it's a difficult language.

Go was designed for large team projects where many contributors may be incompetent. That Go can still get things done under these conditions is a testament to its utility in this niche. Go's infamously weak abstraction power is thus a feature, not a bug, meant to prevent your teammates from doi...

Go is famously regarded as very simple. However, this simplicity becomes problematic in time. Programmers who use Go find themselves over and over again writing the same thing from a very low point of view. Domains not already served by libraries that are easy to glue are very difficult to get int...