What is the best alternative to Smalltalk?

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.

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.

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...

Not very stable and has a rather small community.

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...

Starting off as a beginner with assembly language could prove very daunting. I suggest learning a high level language first (e.g. C) to get a good grasp of programming - especially dealing with bits, bytes, numbers, accessing memory with pointers (which is why I suggest C). Then once that person...

Red is still under development and not considered stable.

It mostly works. It's good enough for building usable applications, but some planned features are missing.

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.

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.

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.

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.

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,...

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.

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.