Hacker News new | comments | show | ask | jobs | submit login
The Squirrel Programming Language (squirrel-lang.org)
72 points by cia48621793 on June 12, 2016 | hide | past | web | favorite | 50 comments

I appear to be a dying breed. A young ( < 30 years old ) programmer, self taught, who loves classic, "mainstream" languages like C, C++, Java...



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.

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

On the swing now that compilers are smart enough to do most of the typing guarantees without your input.

That was true in 1973.

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()


   // ...  


   // ...  

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.

it's its

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.

When Apple introduced its main new programming language for OSX and iOS, it went from dynamic typing (Objective-C) to static typing (Swift).

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.

C is weakly typed.

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.

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.

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.

What about the better typed languages - Coq, Agda, Idris, etc.? Java is not that strongly typed after all.

Heaps of modern language development focusses on types. Take rust for example.

If you want a nicely embeddable language with strong typing, why not check out AngelScript?

I agree, there might be an open niche for a typed scripting language.

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.


    class Klass
    //struct Klass
    	int_t i;
    		print("Klass constructor", i);
    		print("Klass destructor");
    Klass k = new Klass();
    typedef int_t int;
    int test10(int x)
    	if(x > 10)
    		goto dente;
    		goto done;
    		return true;
    	return false;
    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))

But now Haxe http://haxe.org/ has several advantages that's worth consider.

Also worth look at Skew http://skew-lang.org/

Ideally it'll lead to something like Terra http://terralang.org/ or Cxx.jl https://github.com/Keno/CXX.jl

How does this compare to Lua? It seems to be going after a very similar market.

This seems to be making some good points but I'm only reading it now


Huh, it actually seems like an older language, it's been around for a while and it's used in some major studio games.

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

To me, it looks like the only improvement of Squirrel upon Lua is automatic reference counting. Everything else seems like a step backwards.

* 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 :)

How is separate types for arrays and dictionaries worse? They are two different data structures with different uses so should be separate.

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.

I was referring to portability. Being written in ANSI C is one of Lua's biggest strengths in that regard.

I am curious, why do you consider make-your-own-classes a superior approach?

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

There are efforts to unify OOP to be compatible across codebases: https://github.com/bartbes/Class-Commons, but yeah I agree it is still somewhat of an issue.

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

    local subclass = OBJECT:new()

This, combined with tables and closures, has suited me just fine.

Do you need OOP? Then Squirrel.

No? Use lua.

Lua supports OOP, it can be written in < 20 lines of code. It's just not built-in.

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.

This language is used in Electric Imp, an "IoT" oriented ARM ╬╝Controller with WiFi, used in Wink products and Lockitron : https://electricimp.com/docs/squirrel/squirrelcrib/

I think Ron Gilbert uses Squirrel in his upcoming game Thimbleweed Park.

How does this compare to Lua which seems to be the go to scripting ish language in games like world of Warcraft

I had to do one project in Squirrel when I was in university and I have to say the experience was terrible.


Yeah I would also like to know this.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact