I appear to be a dying breed. A young ( < 30 years old ) programmer, self taught, who loves classic, "mainstream" languages like C, C++, Java...
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 :(
I don't think looser typing is the current trend at all. I think the opposite is true: there's a movement towards more typing, particularly among the languages that have traditionally been the most dynamically typed.
I would encourage you to leave your comfort zone and actually explore what's out there in terms of type systems. There are type systems that are MUCH more powerful and useful than C, C++ or Java. If you like C++ and Java, I would suggest Scala or Haskell.
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.
Note that proper typesystems are not yet mainstream, though.
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)
I would add Purescript to that list. Most people see it as a Haskell-like for the JS VM, but it also includes row types. Meaning that your types can keep track of granular effects ("oh, this uses IO, but just the random number generator", "Oh this just looks at the foo property"), which is super useful for reasoning with larger codebases.
Agreed. Purescript[1] is definitely interesting as one the very few languages in the world with row types/polymorphism.
I'm not quite agreed on the effects bit being useful, but it's a good demo of what the type system can do. My main disagreement with the whole approach is that effects don't commute (in general) and so representing effects as such isn't quite valid.
[1] I'm still baffled as to why they named it thusly. I mean, I can guess at motivations, but it really deserves a much catchier name!
> I cannot stand the road that new languages are on, abandoning the type system, or making it optional, or not explicit.
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.
Rest assured, not all new languages take this route.
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.
Ohhh... Rest assured. My first job was fixing bugs in existing mobile game. Here is the code:
// 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.
Types are great! Two obvious modern industrial-strength choices would be Rust and Haskell, though F#, C#, Swift and even Java 8 are pretty nice in this regard. (Even the anemic type system of C can be a great help.)
Squirrel is a scripting language, for example to use in games so the people writing the scripts don't need to recompile to see their changes. It's really a question of using the right tool for the problem at hand. I agree though that too many devs dismiss the benefits of static languages with no real gain in return.
I feel like we're just no longer the shiny hotness. I think a lot of people WANT to be self-made self-taught semi-low-level language programmers.
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.
To be honest I'm struggling to think of any languages released in the last 5 years or so which don't have type systems. Obviously they exist, but I don't think they're as common at the moment.
I did a fork of Squirrel -> SquiLu https://github.com/mingodad/squilu because I found the syntax more familiar and also been made with C++ that make create extensions easier than plain C.
Then I started adding more and more C/C++ like syntax options with the idea to have a way to develop fast prototypes in a way that could be migrated to C/C++ when performance was not good enough, the idea is to be able to parse and accept C/C++ syntax but without actually inforce it at scripting level (accept discard/warning) and be able to use a real C++ compiler to do the heavy work.
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
Wow. Reading that renewed my excitement for programming language design and implementation! But with 5 kids, I'm kept pretty busy and won't really have time for that kind of thing until I'm retired. And I have no real need for it, it would just be really fun. But still...
One of the strengths of Lua is how usable it is for non-programmers. Having separate concepts for (essentially) a hashmap for integers and a hashmap for everything else makes it more complicated.
That C++ is inherently worse than C is a preposterous preconception. The only point I'd remotely agree with is the two null types, though it makes sense if you know that they express two different concepts.
Having OOP built into the C/C++ codebase is just a chunk of complexity that is needlessly built into the language itself; it can only be maintained by a select group of people who understand it.
Instead, you could just use an OOP library, or implement the parts of OOP you want in like 20 lines of Lua.
The great thing about this is you can fine-tune it to your needs. Want transparent encapsulation, or multiple inheritance? It just takes an extra 10-20 lines of code! Now you don't have to pester the Squirrel developers to put it in. :p
My counter argument would be that if objects are implemented at the language level it makes it easier for developers for the following reasons:
- there is exactly one way to do it
- objects can be transported between codebases without wrappers
- beginners know where to look and everybody can understand everybody's codebase
- the compiler can optimise them better
- generally the syntax is nicer, looking at some object implementations in lua I must say that they are hideous, very similar to object implementations in javascript before ES6
For the beginners thing: most beginners who use Lua don't even touch OOP. The main idea for Lua is to have concepts that are super easy for a layman to fit in their head; OOP is like this huge convoluted "idea" that has a bunch of different possible implementations and approaches.
Plus... setting up the userscript/metatable structure goes a long way in abstracting it for beginners; look at how Garry's Mod does it for in-game weapons. It doesn't even use full OOP, all it has is inheritance and it doesn't even call it that; opting to call superclasses the "base" weapon. It was easy enough for me as a 12 year old non-programmer to grasp.
Plus... seeing words like "class" or "constructor" would for sure deter beginners. It's not expressive enough. When I started out, I remember looking at the curly braces for a table and thinking it was some advanced programmer stuff, and I avoided it as much as possible. That feeling would probably be 10x for something like full-blown OOP.
Once you force them to leave the editor to learn some concept on Wikipedia, you lost IMO.
I agree with you on the optimization/syntax thing, but I think it's a necessary tradeoff. Any feature that is built into the language can get some sort of buff from that sort of stuff. I just don't think the pros outweigh the cons... Lua isn't the kind of language to leverage OOP much (other than inheritance).
For me, this is pretty much the extent of OOP I've needed in Lua (along with transparent encapsulation, but I cut that code out because it would add around 10-15 more lines):
OBJECT = {}
function OBJECT:new()
local obj = {}
setmetatable(obj, {__index = self})
return obj
end
local subclass = OBJECT:new()
This, combined with tables and closures, has suited me just fine.
OpenTTD (http://www.openttd.org/en/) is a Transport Tycoon clone that allows you to write an AI player for the game. The AI player is written in Squirrel.
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 :(