Why?
Types.
I cannot stand the road that new languages are on, abandoning the type system, or making it optional, or not explicit. Given that I appear to be a minority, I thank you for reading my rant... Have a good day :(
- Type hinting is a significant new feature in PHP 7.x: http://php.net/manual/en/migration70.new-features.php
- Python 3.5 introduces type hinting: https://docs.python.org/3/library/typing.html
- Ruby is talking about possibly adding a static typing system to Ruby 3.x (this is very early stage, but there appears to be interest): https://codon.com/consider-static-typing. Also 24 days ago Matz talked about possibly adding type inference to Ruby3x3: https://bugs.ruby-lang.org/issues/9999
- Flow and TypeScript add types to JavaScript.
- JavaScript is adding more structure to its type system with ES6 classes.
- Newer languages such as Swift and Dart are certainly more typed than the Python/Ruby/JavaScript generation.
- Rust is typed to the max.
I guess what I'm saying is that if you like type systems, the future is bright. :)
I'd like to note that what you're talking about isn't "typing" versus "no typing", it's static typing versus dynamic typing. Both of them have type systems - it's just a question of whether the compiler refuses to compile programs unless it can prove that your usage of types is 100% correct. Since you sound like you're an autodidact, you might want to read up on some of the theory behind type systems - particularly the competing ideas of "soundness" and "completeness".
There are also good reasons why many people choose to use languages like Python or Ruby - they aren't just blindly ignorant of type theory or the benefits of type checking. They write different kinds of software than you do and have different needs. It's not a contest, other people using languages with dynamic typing does not mean there aren't great choices if you prefer static typing.
Edit: Squirrel also isn't a new language. It's from 2003, and it was designed for the niche of game scripting where its main competitors (Python, Lua) are all very dynamic too.
You should certainly have a look at "less mainstream" languages whose type systems are more expressive and still simpler to use than those of the "mainstream" languages. For example (list is incomplete, but you'll get the idea):
* Haskell (very popular, hard to reason about performance, though)
* OCaml (possible to reason about performance, except for garbage collection)
* Idris (type system with dependent types!)
* Rust (type system that allows to reason about memory usage, aliasing, etc.)
* Elm (meant to replace JavaScript for user interfaces in the browser)That trend is so 10 years ago. Today the pendulum is swinging the other way again. ML is having a comeback. Look at F#, Rust and Swift. They are mainstream and they are strongly typed (mostly)functional languages.
On the other side of the spectrum, type systems get stronger and more powerful. Read about dependent typing in Idris, F*. Also, nearly all academic work focuses on improved type systems.
// Method in some class in squirrel script
function Move()
{
// ...
Jump();
// ...
So... Where is the implementation of function Jump? In this class? Or in C++ class, which might add some methods to squirrel? Or it's in base class of squirrel? Or in C++ class of that base[squirrel] class? Also methods might be overridden. So... You need to find last implementation of that function.
You also need manually build an inheritance tree.
It's impossible to navigate in it's code. While you can use Sublime and it's Find. You still need to look through all the usages of function Jump in entire game.
Squirrel made me love all static typed languages with it's instant jump to implementation of some function.
One of the more interesting contenders in the "compile to Javascript" universe is Elm, which is also statically typed.
Perhaps are simply unaware of what the major "new languages" are.
I listen to a lot of podcasts. My god, I just want a decent show that is NOT focused on web development. Is that so much to ask? Oh, and not ios/windows focused, 'cus then literally everything you talk about no longer applies to me. And not "a new language every week" because my god, you can't deep-delve into anything like that. Hell, not even javascript can be covered in an hour.
You have to declare types in the languages you mention. You shouldn't have to. Type inference was figured out decades ago, it can be done by the compiler, and in some languages, it is.
https://computerscomputing.wordpress.com/2013/02/18/lua-and-...
Huh, it actually seems like an older language, it's been around for a while and it's used in some major studio games.
* C++ < ANSI C
* two null types < one nil type
* separate types for arrays and dicts < tables
* C syntax < plain english
* Builtin classes < make-your-own classes
That's just my opinion though :)
No? Use lua.
Example:
class Klass
//struct Klass
{
int_t i;
//constructor()
Klass()
{
print("Klass constructor", i);
}
~Klass()
{
print("Klass destructor");
}
}
Klass k = new Klass();
typedef int_t int;
int test10(int x)
{
dente:
if(x > 10)
{
goto dente;
goto done;
return true;
}
done:
return false;
}
print(test10(23));
output:
test-class-constructor.nut:22:6 warning labels are only parsed right now
test-class-constructor.nut:25:7 warning goto is only parsed right now
test-class-constructor.nut:26:7 warning goto is only parsed right now
test-class-constructor.nut:29:5 warning labels are only parsed right now
Klass constructor (null : 0x(nil))
true