In production mode, the type annotations can be completely wrong and your program will still function, and still be just as fast. Changing the Lua number type from a float to an integer type is something like a 3 line patch.

The syntax is described here. >IME, that's why they've historically been harder to read and navigate for humans. As a bonus snippet, this still parses in the exact same way as Lua 5.1 because we were not parsing from the context of a statement: The takeaways here, it seems, is that we’re going to have to design the syntax for Luau to be forward compatible and with least context-sensitive parse paths. A critical detail because one of our sacred values at Roblox is backward compatibility. The number type is double by default. We somehow managed to talk past each other and go out of sync and ended up responding to something that was not on the others mind. Hint: it has to do with static typing or lack thereof. Luajit is awesome too, but if you are looking for tighter debugger integration in MSVC then look at HavokVM - which is lua vm - you can mix native/lua callstack and it works just fine. This may be a consequence of language restrictions or just typical (and understandable) programmer laziness ("good enough!") This list[1] shows that there are plenty of options to go around. We want to be able to traverse the AST for deeper analysis, so we need a parser to produce that syntax tree. The discussion is whether there have been studies showing that statically typed languages produce less bug prone software. I do know that the older languaged programs I have seen are typically not in what one would call a statically typed language. Consider, Linus knows the linux kernel better than I can really comprehend. Makes sense. My point is if that is all you know, you don't know enough to make a decision. > Dynamically typed languages are OK for smaller projects but as projects grow in size, you have to write a lot of tests to be sure that everything works. If they are in a static language, then this should be an easy debate for you. The result changes depending on those circumstances and the interpreter/compiler just doesn't know enough to optimize it significantly.

In Typed Racket, you get actual guarantees about your types, and a type system that works for almost all existing untyped code. It doesn't take a lot of googling to find that Nasa used to use a Symbolics Lisp machine in their work. Haskell), Honestly, I wouldn't be surprised to find some lisp in there, just because. -- or, as you say, the lack of type unions. For a very long time, Lua 5.1 was the language of choice for Roblox.

Why have we not seen an effort to build a solid ecosystem around it the way node has with JS? Curious about this: Say you have to be (god forbid) irradiated.

the performance issues when crossing the typed/unityped boundary. My aim is more against the claims of the parent post.

Sorry. EDIT: FWIW, if I were to go with gradual typing, I think TR would probably be close to ideal. I confess to being somewhat in love with lisp at the moment.

BTW Typical x-ray machines do not have the power to kill you in a single exposure, radiotherapy units absolutely can, example Therac. No, googling those results doesn't really work. It's better than nothing, but not really good enough. The glomming of those things is so flexible and versatile that - indeed perhaps we see too much diversity in the Lua appliance world, for there to be any common centralized traction around promoting it, as has happened with node.

[1] http://en.wikipedia.org/wiki/List_of_tools_for_static_code_a... Shit, this is no different than the article making the rounds talking about the many "gotchas" in bash scripting. BTW I do love lisp a whole freaking lot. As we grew, so too did the demand for better tooling support as well as a more performant VM. Well, apologies for the nesting. I think what happens with Lua (which does, incidentally, have many solid ecosystems built with it) is that it just gets quietly used in industrial-strength ways which don't require too much fanfare/promotion in order to propagate it as a tool - which is not the case with node, which aims to be a solution to industry-wide problems which Lua solves in other ways. Has happened, and run companies to the ground. BTW a dynamically typed language with exhaustive static analysis is a statically typechecked language. BTW the very first line says the fault had nothing to do with Ada.

Everything else: you can get there with nil, number, string, function, CFunction, userdata, and table. > I wouldn't be surprised to find some lisp in there, [...] I'm open to being proven wrong.

> Also, projects written in statically typed languages are easier to read and navigate for humans.

Also, projects written in statically typed languages are easier to read and navigate for humans and it's also easier to write static analysis tools for them. Well, yes, since you have to write a static analysis tool for a statically typed language (since the compiler must include such a tool), its not at all surprising that the structure of statically-typed languages is always designed specifically to serve static analysis tools. If nothing else, it kind of follows from Curry-Howard correspondence. That is, it sounds like it would be applicable "at large." There isn't really much evidence of this out there, other than groupthink, in my opinion. That is essentially the question you gave me. There's definitely room for improvement (I suspect type unions would fix a majority of the times you are forced to use "any"), but I have found type declarations to be relatively low overhead for a substantial gain.

I know it's my own failing, but I've also had a lot of trouble with the incredible amount of parens and symbols in TR/TC -- I'm used to the near-math notation of Haskell dammit! As an example, I take any of the MIX algorithms in Knuth's books. I turned it around precisely to show that just knowing the type of language that something was implemented in is bloody worthless. It also means that we will need to be careful when adding new syntax in general, which is not necessarily a bad place to be. Lua is embedded in things like Redis, and is often uses as an extension/configuration language for small projects.

Neither Roblox Corporation nor this blog endorses or supports any company or service.

Note that there is a big difference between static tooling and statically typed languages.

", That is, I expect the tooling around them is ridiculously high. Lua is a very powerful language that allows you to overload virtually every operator in the language. (There's also the whole external/internal module confusion in TS, but that's not related to the general theme of gradual typing per se, so it's not really relevant to non-TS contexts.).

Experienced programmers may be able to get passed it with relatively few errors, but it's still going to suffer huge performance issues because there's only so much that can be known about the values passing through a block of code. The static languages are typically a bear on some algorithms because you have to provide so much more to the compiler for it to trust you. The idea is that you would only convert to the typed dialect in the parts of your program where that would suit you. How is having information written down instead of having to constantly remember and/or deduce it an impediment to reading?

This has real advantages, but also disadvantages, which you seem to be running into. Whereas if it were on a single line, it is a syntax error at the as token in JavaScript, but a valid type assertion expression in TypeScript.

Generally, statically typed languages are less bug prone than dynamically typed languages. We chose these syntaxes because they are already immediately familiar to the majority of programmers, and are in fact industry standard.

However, the attitude you are displaying of "if all you know is it was in Ada, then it is safer than the alternatives" seems to be the exact problem that led to that disaster. Most importantly typechecking does not preclude/replace testing, it complements it. Having finally added "-march=native" to my flags for a build of software, I'm literally amazed at how well optimized a compile can be versus just using "-O3".

:). Empirical evidence. And what is the differences of none and nil? Apologies for that, as well. As Lua Document says that there only 8 basic types in Lua. Of course, it might be more work to make it type check, since you have to get it right. This tutorial covers various topics ranging from the basics of Lua to its scope in various applications.

On the other hand, javascript offers duck typing, weak typing, dynamic typing, it's fine for certain applications (and essential for anything living in a web browser these days), but it's type system holds it back for large scale work.

Do you trust it more than a competing one that was implemented in machine language?" It’s basically a way to add extra type information to a program for the checker to verify. And note, I would not use that as an example of where typed safe languages are failures. To be clear, I think mistakes have been made with all paradigms of programming.

3. http://www.techempower.com/benchmarks/#section=data-r7&hw=i7... Typed Lua says it only works with Lua >= 5.2. The flipside of the complaint is that I've found it really quite nice to have type checking for libraries I don't know inside and out. I haven't heard anything about an official "typed Lua". This is the repository of tl, the compiler for Teal, a typed dialect of Lua.. Introduction.

Over the years we ended up substantially evolving the implementation and the language; to support growing sophistication of games on the Roblox platform, growing team sizes and large internal teams writing a lot of code for application/editor (1+MLOC as of 2020), we had to invest in performance, ease of use and language tooling, and introduce a gradual type system to the language. You do realize that right?

But cool as it is, saying that Lua "now has optional typing" because a research extension to the language has implemented it isn't really realistic.

Also, don't forget that gradual typing solutions such as Typed Lua are all about letting you program dynamically if you want. Typed Lua says it only works with Lua >= 5.2.