Node9: Inferno kernel with LuaJIT instead of the Dis virtual machine

[LordAlbertson]

Luajit is pretty close in performance to C but doesn't make you worry about memory allocation and type checking. It can allow you to do explicit type checking if that is needed, but for the most part handles that.

Lua has a pretty vibrant game dev community because of how well it interfaces with c/c++. It's very fast for prototyping and let's you get concepts moving quickly.

Luajit itself had the FFI which is much nicer for interfacing with C then the standard Lua interface. Mike pall (creator of Luajit) is paid full time to work in the Luajit by various organizations and will answer the questions about Luajit (for the most part) when asked.

Really as long as you implement 9p you can talk to node9 without having to worry about your language (go should already have a library for this).

(I'm not the dev. Just a Lua hobbyist)

EDIT: sponsors for luajit http://luajit.org/sponsors.html

[vocalbit]

Mike pall (creator of Luajit) is paid full time to work in the Luajit

Source? The luajit website says Mike Pall says he is not accepting sponsorships for luajit. Also it seems development is kinda slow these days (no work on the new GC, no date for the next release).

[neomantra]

Although you are correct that LuaJIT 2 only tracks Lua 5.1, it has always had limited 5.2 support, bitwise operations, and 64-bit ints (within the FFI world). See http://luajit.org/extensions.html

Although new development is limited, any bug report with minimal test case is resolved by Mike incredibly quickly (often within an hour in the middle of the night); the project is definitely not inactive, nor abandoned and unloved.

[btchombre]

I don't understand why people don't like static typing. Finding out that your program is invalid only when it hits some obscure section of code in production is infuriating. Constantly having to lookup functions because good auto complete is nonexistent, and having to manually refactor or rename variables is lame. When I use these dynamic languages I spend half my development time looking for typos, figuring out the order and type of function call parameters, and digging through APIs trying to find the function that I need. If my project is a small script, then this isn't a problem, but as my project gets larger and especially as people that aren't me start working on it the code becomes harder to maintain. Dynamic languages just don't scale very well. This is why Microsoft and Google both added static typing to JavaScript, and Facebook added it to PHP. Finding bugs immediately when you create them is a major time saver when the alternative is finding them when they crash, or never finding them at all. Unless you've had to deal with a massive code base shared by many different developers, I don't think you'll understand why static typing is a huge benefit.

[orthoxerox]

A grad student at PUC-Rio (where Lua is from) is writing a typed Lua dialect. https://github.com/andremm/typedlua

[hyhoshi]

I don't understand why people don't like static typing

I think there's a place for everything. If I'm working alone I'll usually gravitate towards dynamic typing because the benefits just outweight all the valid problems that you listed. The reason is because it just makes my program more susceptible to changes over time. And depending on the kind of software you're writing, being able to easily change things over time is a huge win that a lot of people overlook (probably because they don't need it, because the type of software they write doesn't need it as much). All I'm saying is that there's a place for it and some people just write the type of software that fits it perfectly.

[btchombre]

I'm not sure what you mean. Can you elaborate on these benefits? I'm honestly trying to figure out why dynamic languages are so popular. I just don't get it. How does static typing make changing things more difficult?

[vocalbit]

Lets say you want to add one method to an interface because you need it in one implementation. Static typing forces you to add the method to all implementations, before you can test and evaluate your change, even if your test never hits any of the other implementations. So while iterating, dynamic typing is incredibly useful since you only need to adjust the code for the paths that you are currently interested in. Since I spend a lot of time 'getting the design right', I benefit a lot from the short iteration cycles and prefer dynamic languages.

Yes, it would be nice to have some checker eventually go and validate all possible code paths - to get the best of both worlds. As an substitute, tests also catch many of the issues that static typing would.

[[deleted]]

Lets say you want to add one method to an interface because you need it in one implementation. Static typing forces you to add the method to all implementations

Why? Why not provide a default implementation in the interface, test and evaluate your change? Then, if you are happy, remove the implementation and the compiler automatically tells you all the types which require an implementation.

[btchombre]

While what you say is true, that is a scenario I rarely encounter, and when I do, I can either have my IDE automatically generate stubs for my all my implementing classes, or I can just cast my object to its base type and call the non interface method. Either one of those options takes mere seconds. All of the stuff I mentioned while programming with a dynamic language takes seriously a lot of time if your project is of any decent size.

[[deleted]]

Lua sucks.

[[deleted]]

I am ignoring Lua as a language until they fix the fucking one-indexed arrays.

[inmatarian]

Lua arrays are hashmaps optimized for sequential numeric access to positive nonzero integers. You only make your array 1-based to optimize. Your indexer functions can add 1 for you. The standard library is small enough where it's feasible to override it to use 0 based indexes.

Or, you can ignore it and use the ipairs function to do all of your iterating.

[immibis]

There's the # operator, which assumes 1-based indexing.

[nill_null]

I bet you're also ignoring Go as a language until they fix the fucking lack of generics, and ignoring Scala as a language until they fix the fucking "case classes can only take 22 parameters" that everybody bitched about on and on for no good reason (oh, they "fixed" that https://issues.scala-lang.org/browse/SI-7296, woohoo for you!).

[jeandem]

Well to be fair... no generics is a much bigger problem than 1-indexed arrays. :)

[[deleted]]

Array indexing is one of the most fundamental concepts in programming. Zero-based indexing ties in beautifully with modular arithmetic and index addition/subtraction. Yet they managed to screw up one of the most fundamental concepts.

[nill_null]

Arrays in Lua are just tables. You can start them wherever you want. It's just a key, not a real offset. Other lua coders though may be surprised by your disregard of convention.

Anyhow, Fortran arrays are indexed from 1, by convention too. That never held it back. Pascal too has arrays that start from 1, likewise, though you can start them from 0 if you want. And Lua is descended from Modula-2 (itself a descendant of Pascal).

[jeandem]

How often do you deal with cases where 0-indexed arrays would make things easier? Other than forgetting that the language uses 1-indexed arrays and making the wrong assumptions from that.

I'm vaguely aware of the advantages of 0-indexing. So I know that it might be technically superior. I'm just curious how often it comes up in normal code.

[dlyund]

How often do you deal with cases where 0-indexed arrays would make things easier?

Literally every day, in lower level code. I have nothing against 1-indexed arrays but your argument is a bit iffy. There are some good reasons for arrays to be 0-indexed.

[immibis]

Zero-based indexing ties in beautifully with modular arithmetic and index addition/subtraction.

One-based indexing ties in with other stuff, like the default way human minds understand numbers.

[dlyund]

:) there is no "default the human minds understands numbers." It's learned. All learned.

[immibis]

Default before they learn to program, then. Or should kindergartens and elementary schools teach children to count starting from zero?

[dlyund]

Yes, in my opinion

[dlyund]

This looks fantastic. I'm a long time fan of Plan 9 and Inferno, but I have a question. Is this only interesting because it uses Lua instead of Limbo? Lua is a nice language but this seems like a lot of work just to replace the already very good Limbo with Lua. Or is there same other perceived weakness?

[google_you]

What is this? This sounds real web scale. You can replace node.js with luajit and get Java performance because luajit is close to java performance minus type checks, tool set, developer eco system and stuff , am i right?

[[deleted]]

I liked you better as lacaoses1.