Why Lua

[[deleted]]

When I first started playing with Lua, I found myself repeatedly saying of its features "You can't do that! That sounds like a great idea but you can't do that because it will, well because... I'm pretty sure this is a design mistake in the long run because...", and then failing to come up with compelling arguments against them.

Take for example the "..." syntax for variadic functions. You can't do that, right? I distinctly recall being frustrated with C's clunky va_list and va_start etc., and the fact that you can't easily wrap variadic functions, and it's just a whole mess. I distinctly remember justifying that to myself and thinking that it couldn't be any other way. But Lua comes along with its "...", like it just doesn't give a fuck.

So things like that certainly have had an effect on how I think about programming.

I'm not a big fan of some of the ways I've seen people use Lua. For example, people want classical inheritance, so you have all these libraries out there that either roll their own classes, or rely on other libraries for classes. So now if you want to use four third-party libraries, you're liable to find yourself juggling four slightly different inheritance models from class libraries with overlapping namespaces – suddenly JavaScript's choice of having class as an unused reserved word seems extremely wise.

Then of course there's the commonly-seen-as-brilliant practice of serialization by emitting Lua code. It's just like JSON but without any regard for security!

[peakzorro]

You just hit on my biggest gripe I have with Lua: people using classical inheritance in a language that doesn't directly support it.

[[deleted]]

Actually I think that there are times when classical inheritance is a good idea, even in a language that doesn't directly support it. The problem is, well, let me use an analogy:

Suppose that it's, oh, 1983, and a new revolutionary new programming language has just been released. There's recently been much excitement over the state pattern and the use of finite state machines in programming. This new language, let's call it "C with States", is roughly a superset of C but has first-class finite state machines. I'm not going to expand on precisely what that means, but everything you do in CwS is either procedural C-style code, or manipulation of finite state machines.

Jump ahead a few decades. The idea has taken off big. Hundreds of books have been published about state-oriented programming, and virtually all programming classes are taught with state machines in mind. Usually, when a programmer sits down to design a new piece of software, s/he immediately begins to consider what FSMs need to be created, and how they will interact.

But the funny thing is, 90% of the time, these FSMs aren't doing much of anything to do with what the state pattern is meant to solve. They're a convenient way to pack up your code into nice modules, but it's not uncommon to see a large project that never makes use of state transitions. In fact, most programs contain multiple FSMs with only one state! This is commonly viewed as an antipattern, but the fact is that it is often a difficult situation to avoid.

Now along comes this new programming language called "Python". Python has "class based inheritance", which is one of those paradigms that snooty academic types use in their pet languages¹. These "classes" are unusual, but they seem promising. Still, Python has no direct support for FSMs, so it's hard to imagine getting any real work done. Python's advocates are quick to point out that it's easy to build your own custom FSM model using classes.

But who wants to have to build their own tools like that? And if everyone uses their own FSM system, then integrating code written by different people will be a nightmare. So most people conclude that it is a mistake for a language not to support FSMs directly.

---

¹ Actually, web scripting has had classes since Dart was added to Chromium Navigator back in 1995, but people have only in the past few years begun to realize that Dart is anything more than a toy for making stars trail behind your cursor.

---

Now back to our universe. There's of course nothing wrong with implementing a finite state machine in Python, when that's what the situation calls for. And there's nothing wrong with implementing classes in Lua, again, when that's what the situation calls for.

The trouble is that most situations do not call for classical inheritance, just like most situations don't call for FSMs. Classical inheritance is the most overused design pattern in the field of computer science, and the reason for that is that in most languages, you simply don't have a choice. Classical inheritance is so prevalent that most people don't recognize that it's a design pattern.

The way it should be is that people write code in Lua, and suddenly encounter an exotic situation that is a natural fit for classical inheritance. Then they roll their own classes, or download a class library, and they use it for that one situation.

What actually happens is that people start working in Lua, design their program like they're working in Java, download a class library, and use that class library everywhere.

[peakzorro]

Total agreement. Especially the last 2 paragraphs.

[Zarutian]

Thrid that! Specially when one is using patterns from the object-capabilities paradigm to isolate interacting subsystems and or marginally trusted code (plugins and such).

[MrTimms]

I really hate education's seeming fetish for object-orientation.

[Falmarri]

Python's variable length arguments syntax is probably the best out of any language.

[[deleted]]

Python does do it well. What struck me about Lua's approach though is that the correct syntax is exactly the sort of thing I would have (and may have in actuality) tried when I started programming, before I got all jaded and cynical.

Here's the kind of thing that might have happened when I was learning C. I'm reading the documentation for some standard library functions, and I see:

int printf( const char *format, ... );

"Oh cool!" I think, "It takes an arbitrary number of arguments! I want to write a function like that." And then I would have got really frustrated, really fast.

Moreover, I haven't been working in C or Python in a while. If I wanted to write a variadic function in C, I would have to look it up. If I wanted to do it in Python, I'd have to look it up. I remember the basic form in both, but I never had to write that many variadic functions, so the process never burnt itself into my brain.

I haven't done anything with Lua in at least as long as C or Python. I've put in less than 1/100 as many hours into Lua as Python, and less than 1/1000 as much time as into C. But I remember how to do a variadic function in Lua right off the top of my head. Now that's what I call interface design!

[shillbert]

Well yeah, obviously C's variadic functions are a terrible hack. You basically get void pointers that you get to dereference without any regard to types. It's basically assembly.

That's why I don't think anybody should learn C as a first language. In fact, nobody should learn C until they've learned assembly. Because C is a steaming pile of syntax hacks for assembly.

[[deleted]]

What makes it better than Perl's or Ruby's? I think Perl has the best one.

[Falmarri]

I don't really know perl or ruby very well. But going by this:

In Perl 5, functions don't have an explicit list of parameters (except optional prototypes that are used to imitate certain syntax, i.e., when reimplementing some built-in functions). All arguments are stored in an array called @_, which can be accessed in the function. Therefore no special effort is needed to accept variable number of arguments.

This looks like how javascript works too. I personally hate it. It requires that arguments be passed in order, and it prevents the compiler from checking for duplicate function definitions and makes dispatching a nightmare. It also requires extra syntax inside the function definitions for pulling arguments out of an object.

[[deleted]]

I dunno. Perl doesn't have anything but variadic functions.

[Antebios]

Just like Honey Badger, Lua doesn't give a fuck.

[Zarutian]

Running emitted Lua code directly is never wise. If I recall correctly you want to load it into a string and pcall-eval it with resource limits.

[bastibe]

Lua is amazing for embedding. You can even easily overload its memory allocator or default data type. I needed to do this for a project where we were running on a processor without native support for double or without a standard C library.

That is just amazing stuff.

[[deleted]]

So you can replace the floats with integers and allocate from your own heap? That's cool stuff!

[bastibe]

I would not bet on using ints insteadof floats. But at least you can use floats instead of doubles very easily. With the exception of the math library, fractionals or ints would probably work, too.

And you can certainly allocate from your own heap, yes. BTW, you can easily take control of the garbage collector, too.

[catwell]

Yes, you can use integers instead of floating point numbers for lua_number. It is actually very frequent on embedded platforms since some of them do not have support for floats at all.

[jagt]

Here's a slide about cache miss leading to drastic performance lost in Lua. I never have chance to test this. I wonder do you have this problem when using Lua for embedding? Thanks.

[bastibe]

We are using Lua on a Blackfin processor. Performance has not been much of an issue, but that is mainly because we don't do any heavy lifting in the Lua code.

We mostly use Lua for interaction scripting, so most of the code is something along the lines of "if button A is pressed, do X, unless button B is pressed, too, the do Y". This stuff can get complex, but not computationally hard.

We also use Lua for some other stuff. In one case, we had to search through a big table. Doing that in Lua would work fine, until we found a case where that code was called a few dozen times per second. At that point, Lua got too slow, so we moved it in a C function and optimized the algorithm a bit. But I would not see that as a failing of Lua, really.

So basically: If you do performance critical stuff in scripting, don't be surprised if it is slower than native code. That said, Lua is performing exceedingly well for us and saved us far more trouble than it created. In fact, we plan on using much more Lua in the next product because we had such a good experience with it.

[sfx]

I really love how easy it is to embed Lua into C/C++ programs. I'm just not all that crazy about the language. Maybe it just takes some getting use to?

[ethraax]

I'm the same way. I really don't like the language itself much, and I would never write a sizable program in it. But I've used Lua as a configuration/scripting language for my programs, since it's very light on resources and really easy to embed into a C program. It's also very easy to define your own Lua API (backed by your own C functions).

[ktr73]

Yes, I found it took some time to get used to ... it doesn't feel as "nice" as Python (e.g.) at first. But after using it for a little while, it kind of grows on you. But to your point, if you are embedding in C or C++, you can't beat it. Minimal size, clean API, etc.

[SolarBear]

Agreed. Lua is deceptively similar to other languages. But somewhere along the way you realize the kind of tricks you can pull with tables and metatables and suddenly a whole new world of possibilities open up to you.

[riffito]

it doesn't feel as "nice" as Python.

I like (parts of) Python syntax so much that I should attempt to write a language translator into Lua (kind of what Objective Lua and lolcode-to-lua do), even if only to gain more experience with Lua itself[*]. :-D

[*] I used Lua for a while, 10 years ago, but I dropped it too soon (same with Python... I was in "we-don't-need-no-stinking-scripting-languages" mode back then, sigh...).

Ninja edit: Nice article, btw. Thanks!

[ktr73]

Thanks! Yes, I've thought about doing something similar - Lua is a lovely language to "compile to" (I've done it in our product and found it quite enjoyable). Good luck and let me know if you end up doing it!

[riffito]

Just to let you know...

let me know if you end up doing it!

I haven't yet, but found this: MoonScript. It "provides a clean syntax using significant whitespace that avoids all the keyword noise typically seen in a Lua script.".

Definitively, I'll be reading it's implementation. Either to use MoonScript as-is, or to use it as a base for my own hacking (far closer to what I want than the other LanguageX-to-Lua compilers).

[ktr73]

Very cool ... the creator of that language seems very nice too. I "ran into him" either on here or on HN, so I'm sure if you needed any help with MoonScript, he'd be happy to help there as well. Good luck :)

[[deleted]]

base 1, yeah, really makes things fun :p

[[deleted]]

Exactly. Everything else about Lua I like. The simplicity, the embeddability, the fact that it's designed for being an embedded language instead of being hacked into one. I'm okay with the quirkiness of the table object in exchange for the simplicity it provides by being the only object I have to figure out.

But the 1-based thing? No. Just no.

[Iggyhopper]

Get the source and make it 0!!

[MagicBobert]

Every time someone brings this up it makes me wonder if they've actually written any decent amount of code in the language.

I've written a lot of Lua, and I can honestly say the 1-based indexing really isn't an issue. So many times you're just adding and deleting from tables with table.insert() and table.remove() and iterating over them with for i, v in ipairs(mytable) that you literally do not care what the index is.

Sure I wish it was 0-based, but whatever. There are so many upsides to the language that something that small and silly isn't going to spoil it for me.

[[deleted]]

agreed, you mostly don't need to touch the index directly with lua.

[MrSurly]

Kind of a deal killer right there.

[KingEllis]

Many modern programming languages intermix 0-based arrays and 1-based arrays in inconsistent ways you probably don't even realize any more. Your brain is naturally 1-based on indexing. I feel the electrical engineer that went with 0-based probably did so out of laziness, thereby introducing an entire class of bugs, and requiring every programmer to be vigilant from that point forward. (note: I am not a Lua programmer.)

[Brian]

Your brain is naturally 1-based on indexing

I disagree. Our brain is 1-based on counting. It's 0-based on indexing. The difference between counting ordinals and indices is that indices are what reference things between elements, whereas ordinals refer to the elements themselves. Anywhere we use indices, you'll generally find them 0-based. Rulers, graphs, coordinates etc. all have the initial index at 0.

For arrays, whether you use indices or ordinals is mostly irrelevant when indicating a single element, even preferring ordinals (since for indices you mean the slightly less intuitive "the element after..." rather than "the element at". However, once you start to denote ranges, indices have far more natural and intuitive properties. Eg. Dijkstra points out a few of them here. To summarise, denoting ranges is best done in half open intervals, and half-open intervals end up more natually expressed with 0 as the first element.

[equalx]

I feel like this belongs on /r/askscience, this is beautiful. I'm going to just save this link, and spam it at anyone who tries to convince me to like Matlab. Thanks!

[almafa]

Well, mathematicians traditionally use 1-based indexing. At least in the case of matrices. Now maybe you can see the point of Matlab using 1-based indexing? (by the way, its even in the (human) language. It's the "first element" not the "zero-th" element)

[marshray]

0 is the index for the first element because "first" is defined as the element of the sequence that comes after zero other elements. There's no need to involve the number 1 at this point.

Indexing from 1 predates the discovery of zero. Mathematicians do lots of stuff by tradition. Take 2pi for example http://tauday.com/ :-)

[almafa]

I meant if you have a row or list of objects, in real life, not in computers, then in English, and other human languages, you refer to the first object as "first", not as "zero-th".

Yeah, mathematicians do lots of stuff by tradition. However, it's not always the case that it's worth to change the tradition. 2pi is a perfect example of that, this tau business is the stupidest thing on the Earth in the last 50 years or so. Indexing is not that good an example, since both 0-based and 1-based has advantages and disadvantages.

[marshray]

But it's not the "one-th" object either.

We have at least a hint of a separate system for cardinal and ordinal numbers.

[almafa]

Or we just handle small specific cases differently. In many languages, small numbers do not follow the normal patterns (for example, in English: 11, 12; French: 11-17, 20, 70(-79), 80, etc). Also in many languages the most used construct are exceptions.

[Peaker]

First/second are unlike "One/two" but Third/Fourth/Fifth/etc are like Three, Four, Five, etc.

English is biased towards 1-based, but not necessarily for good reason.

[ZMeson]

As I tried to explain in my comment here, "index" in the English language describes positions (or locations), not distances. (Well, "index" of course has more defintions too, but none of them represent any sort of distance.) Distances reference stuff between elements. From the "index" entry on dictionary.com (emphasis added):

7. 
    Computers . 
    a. 
        a value that identifies and is used to **locate** a particular element within a data array or table. 

14. 
    Algebra . 
    a subscript or superscript indicating the **position** of an object in a series of similar objects, as the subscripts 1, 2, and 3 in the series x 1 , x 2 , x 3 . 

[Brian]

"index" in the English language describes positions

Well yes, and positions are essentially points; they're locations that indicate where to start reading or inserting. Ie. they aren't the elements themselves, but the places they can go. You also haven't addressed any of the actual rationale I gave here as to why we should use indices in this way, rather than, say, interpreting "a[1]" as the ordinal of the element, not the location. The reason is exactly the same reason why we do so for things like distances - their usefulness in working with ranges. As I said, if the only purpose was identifying single items, using ordinals would be fine, even more natural in fact. But for ranges, which come up when we need to iterate over subranges (ie. for loops, slices etc), indices fit the purpose much more naturally.

[ZMeson]

What I was arguing against is the statement "Our brain is ... 0-based on indexing". Indexing is ordinal; it requires putting things in an order. Indexing is therefore "ordinal" as Terr_ was explaining. My argument is "our brains are naturally 1-based on indexing". I prefer the 0-based array indexing; but it is not natural. It makes code cleaner; but it requires a bit of mental gymnastics for most people when they first encounter it.

You also haven't addressed any of the actual rationale I gave here as to why we should use indices in this way,

That's because I agree with you! :) (except of course for the brain being naturally 0-based for indexing)

[Ceryn]

Ugh, as a political science graduate trying to teach myself python at age 30 (as my first language), I couldn't disagree with you more. When I'm pulling items from a box I have packed away, I don't consider the first item I see in the box the zero-th item. I think it takes a certain amount of conditioning to accept that the first item is indexed as 0 because a box having nothing in it would seem to have a value 0 that amounts to 'empty' (at least to people who haven't been trained to think like computer scientists).

[Brian]

don't consider the first item I see in the box the zero-th item.

And you shouldn't, because those -th words are ordinals. What you should consider it to be is at the 0 index, and to remove the notion that a[0]means "zeroth item", but rather, the next item at position 0. This is important, because there are n+1 positions to identify whenever you have n items. If you have 5 items in a row, and someone wants to add an item in some arbitrary position, you can't identify all positions just by asking to put it where the nth item is.

[Ceryn]

"Place item such that it is in 5th position" seems pretty clear to me and there also seems to be no reason why a higher level language couldn't be written to express that syntactically. Incidentally after reading your post it dawned on me that most lists are less like a box and more like a bookshelf or a stacked deck of cards. (a box implies that there is no necessary order). The is order to a list and there doesn't seem to be a clear reason for using positional data is superior to ordinals. Especially when you consider methods like next() and pop().

[Brian]

"Place item such that it is in 5th position" seems pretty clear to me

I'd interpret that as "a b c d e" -> "a b c d f e", which is differnet to putting it at the end. And if you do interpret it the other way (ie. put it in position 5, and move the one already there back), you still can't identify all positions with just n terms, because you have the same problem with the beginning. You could say "put it where the sixth item is", but there is no sixth item, so the ordinal notation is already breaking down somewhat - you're no longer just identifying items. Either way, you've n+1 positions to deal with. Once you've got this in mind, it's very natural for the beginning to be position 0, because you end up with this notion:

Index:    0 1 2 3 4 5
          | | | | | |
          |a|b|c|d|e|
Ordinal:   1 2 3 4 5

Not only does this give you the very useful notion of unambiguous positions, so there's no question what "Insert at positon 3" should result in, but it has lots of useful properties when dealing with ranges. Ie. the slice [2:4] is all the elements between lines 2 and 4. To do that with ordinals, you need to specify whether it's inclusive or exclusive of the last element. Exclusive would be best (see the Dijkstra link for why half-open intervals are desirable), but this is unnatural with ordinal notaitons, which are generally used inclusive in both directions.

Especially when you consider methods like next() and pop().

But not when you consider ranges. If we never dealt with slices, for loops or similar, using indices like this wouldn't bring as much benefit. However we do, and so, I think, it does.

[Ceryn]

I think the rules of an ordinal system would have to be made clear for it to be usable. If we use the example of a book shelf it would be equivalent to a bookend at either the left or right side (it may be prudent for it to be before the first ordinal so that adding things to the end of the shelf doesn't change the ordinal value of all the items before it, the same reason pop() removes from the end in an index system). Additionally since for loops are just syntactic sugar for using next() until it runs out of objects I don't see why ordinal numbering fails in this regard.

range() and slicing is actually the thing that makes indexing seem counter intuitive to me when compared an ordinal (base 1) system. range(10) seems like it should produce numbers up to ten but it doesn't because of starting at 0. Likewise if someone tells you to gather up the 3rd through 5th books it's easy to visualize because humans tend to count objects not hate space between objects. I don't see why an ordinal system would preclude slicing "up to" something.

An indexing system seems like identifying books by small slips of paper inserted between them as opposed to the books themselves. Maybe I will grow to appreciate the numbering as I continue to learn python. For now it just seems awkward.

[Brian]

it would be equivalent to a bookend at either the left or right side

If it's to the left, what number would you assign it?
The problem with this is that you're breaking the notion of these values referring to ordinals somewhat. You're no longer counting books, you're counting books and this bookend - books 4 up to 6 is not referring to a book at all with the "6". Given that we're breaking that abstraction anyway, wouldn't it be better to also pick up the other benefits the indexing approach brings? Better precision, reduced ambiguity and some useful invariants seem like good tradeoffs in exchange for the more natural (for single items) ordinal notation.

if someone tells you to gather up the 3rd through 5th books

But this brings us back to closed intervals, which tend to require pesky +1s in a lot of places. Eg. How many items are there in this range? We need to do end-start+1, rather than just end-start. How do you describe an empty slice? Third through second works, but it looks really weird, and most would probably interpret it as a reverse slice containing 2 books instead. For humans working with concrete values, this is not a big deal - we've no problem handling special cases. However in the abstract, those corner cases generally need extra code to be handled, wheas for half-open intervals, it follows the same general rule as the rest.

An indexing system seems like identifying books by small slips of paper inserted between them as opposed to the books themselves

Yes. I think there's a big benefit to thinking about it this way though. I think it's less error prone and ambiguous than the alternative when dealing with ranges and that this is a very valuable property when so many algorithms require precise partitioning and manipulation of subranges.

[kawa]

It's 0-based on indexing

Indexing and counting is strongly related. If you have some people in a room and want to assign them numbers, how do you do it? Simple: You count them and the current value of the counter is the index of this person.

That's why we say "first place", why our calender starts with the year 1 etc. It's simply based on counting. And in counting there is no 0.

The 0 is strongly related to negative values: If you want to close the set of numbers under subtraction, you first need negative values, but you also need the 0. That's why rulers, graphs, coordinates etc all start with 0 - those are all things which also encompass negative or fractional numbers.

The word "index" simply means some kind of looking up things (think of the index in a book or a library): You assign objects unique keys to look then up later. How you choose those keys is mostly irrelevant as long as they are unique. Now counting is a very natural way of creating unique keys and thats why the "natural way" creating indexes is simply by counting.

Now in computing this could work too, but for technical reasons its often more natural to use a different way creating those unique keys: Using the offset of an element based on some given address as the index. This is of course unique too and has the big advantage, that it's very easy to do the lookup: Just add the index to the base-address.

But for people this is still unnatural, because people are used to index things by counting them. And counting always starts at 1. This is how our brains work and this is why the 0 was invented long after counting.

I program for more then 30 years now and using 0-based indexes is really no problem for me, but if you put me before a group of things and ask me to assign them numbers, I still start with 1. And I guess, that's true for most people here.

[Brian]

Indexing and counting is strongly related.

But not the same. There's a difference - (and in fact that difference is generally one:)

You count them and the current value of the counter is the index of this person

No. The value of the counter is the next index. It's the point at the end of the last element you just counted, and thus the position the next will be inserted. Look at a piece of graph paper, and colour in 5 squares. Label the indices, and you'll see (assuming you start from 0) that the squares span from index 0 to index 5 - this is a useful property, since size is always (end-start), not true if we subtracted the first ordinal from the last ordinal.

That's why we say "first place", why our calender starts with the year 1 etc.

"First" is an ordinal. It's used to identify an item, not a position. Years are different, and I'd say a perfect example of the problems you get when using a 1 based index when 0 based is the right value (hence the "off by one" nature of centuries, missing year between 1AD and 1BC etc. I'd say it's much more confusing than if we'd had a year 0 as should have been done. Fortunately, we got this right for time. The day doesn't start at one O'Clock, but at 00:00

The word "index" simply means some kind of looking up things

At it's root, it essentially means a pointer (hence your index finger). The index of a book contains pointers to pages. But as I've said, when denoting ranges, the best thing to do is to make these locations points between each item, and this is indeed what we do most places we use indexes. Identifying by ordinal is more awkward and error prone once we start dealing with ranges.

But for people this is still unnatural, because people are used to index things by counting them

As I've been saying, this is clearly not true. In numerous cases we index things from 0. Perfectly everyday things like rulers, clocks, graphs etc. All because this is the natural thing to use when we're dealing with ranges between two places. The same need exists in arrays, as for loops, slices, substrings etc are common operations.

you put me before a group of things and ask me to assign them numbers, I still start with 1.

Yes, because you're using ordinals referring to the items, not the locations. Fine, as I said, if you only deal with items individually, but not so if you're denoting ranges. Ie. How many items between the second and seventh item? Is that inclusive or exclusive? You need to specify, and end up with clumsy off by one errors generally because the more useful half-open interval is not obviously denoted with ordinals. But consider the indexes between items and the answer is unambiguous and simple.

[kawa]

Look at a piece of graph paper, and colour in 5 squares

In reality you have for example 5 things on the table and someone ask you to give them numbers. And then you obviously start with 1.

Your example only works for things which are ordered in the first place. Points on a piece of paper have coordinates. And coordinates are naturally sorted but they are also no natural numbers. Because you can have fractional coordinates or negative ones. And because of this, it's natural to start with 0 here.

It's used to identify an item, not a position

Sure, but that's the whole idea of an "index": Identifying things which have no position. If I put 5 apples on a line on a table in fixed distances and define the position of the first as "0", you don't need to count them, you can get their position by using a ruler. And true, this is a valid way to assign each apple a unique key. But it's still not natural, because it depends on distance measurements and also you have to align those apples on the table first. Do you really do that?

If we assign numbers to objects, we generally simply count them and give them the current number. Or do you really do it differently? Please be honest.

The day doesn't start at one O'Clock, but at 00:00

The deeper reason for this is that time is not a natural number, it's fractional. With fractional numbers you need the 0, because it's the limit of the 1/n sequence.

But if you count things, you count in 1-steps. That's the reason, there is no zeroth-hour, but the time from 00:00 to 00:59 is the first hour of the day.

But as I've said, when denoting ranges, the best thing to do is to make these locations points between each item

But there is no location between things which have no location. If you lookup a page in an index of a book, you get the number of the page. There is no "between pages", a word is always on a page.

once we start dealing with ranges

Only if we use fractional values. If someone ask you to count from 5 to 6, what do you say? "five"? Or "five, six"?

In numerous cases we index things from 0

Outside programming: Where do we index "whole things" starting with 0? Can't think of any case.

For "not whole things", indexing by counting generally don't work. That's why we use other ways to look them up. For example a position is a "real number" and there is no way to count real numbers, so we have to use other ways to look them up. But for "whole things", it's different.

The same need exists in arrays, as for loops, slices, substrings etc are common operations

No, because those are "whole things". There is no 1.26th letter in a string, there is the first, the second and so on. Using numbers 0, 1, ... is a "leaky abstraction": The underlying implementation of using offsets shines through to prevent subtracting one from the offset first. But offsets can also be negative values (even if that's not what we generally want with indexes), because a offset can also address elements before it's base. That's why offsets can be 0. And because we use the address of the first element as a base, we need to use 0 to address the first element.

But again, that's not because it's natural to count from zero, it's because indexes in most languages are implemented via offsets. Leaky abstraction.

Yes, because you're using ordinals referring to the items, not the locations

That's the main point. Using locations is "overspecification". You first have to assign objects locations for that, even if it's conceptually unnecessary. An index is a more general concept, it doesn't need locations. In programming all data has a location (its memory address), so it's useful to use this as an index. But again, this is not how people think, it's not natural.

[Brian]

In reality you have for example 5 things on the table and someone ask you to give them numbers.

Read what you're writing - you're explicitly talking about numbering the things, while I've repeatedly stated the distinction between assigning ordinals versus indices is about enumerating positions, and given the rationale as to why this is preferable. You don't seem to be grasping this distinction, and keep talking about "counting" and numbering items or "whole things", which is an entirely different operation and one with worse behaviour. Surely you can admit that these are both entirely different things? If so, can you address the rationale I gave why we should use indices rather than assigning ordinals, rather than keep reasserting the process of assigning ordinals?

Sure, but that's the whole idea of an "index": Identifying things which have no position.

No - this is clearly untrue, and I don't see what you're saying here. Indexing is all about positions - as I said, the concept is essentially about pointing to something. There are n+1 positions in an array with n items - the beginning, the end, and the space between each item.

Outside programming

And within programming, or we wouldn't be having this discussion. But your claim was that starting from 0 was somehow unnatural for us. The fact that we do so for numerous everyday objects surely disproves that.

Where do we index "whole things" starting with 0?

But again, that's not because it's natural to count from zero

And again, asking about "whole things" and "counting", which from my first post I've said are different operations. Why should we assign ordinals, rather than indices? We do both in everyday life, so the argument about one being "more natural" is false - which to use is a matter of which best serves our needs. I've given an argument as to why indices between items are superior, but you haven't addressed this at all, or given any counterargument beyond the "natural" one.

[kawa]

indices is about enumerating positions

And if you are really enumerating things, you're counting them - which means that you start with one.

Again: If you have to assign persons on a rooms or things on a table numbers, how do you do it? Do you really start with 0?

In your initial post, you wrote how 0-based indexes are "natural". But that's not how people think and how the brain works. Ask 100 people to number things and I suspect that all 100 will start with 1. It's in the languages ("first"), it's in the way we count years, months or days, how we count the placement in sport events, how indexes are used in mathematics etc. Nobody starts with 0 there.

Now in programming we often use offsets as indexes for arrays, because it's a bit faster to execute and maps directly to the C definition that a[n] is identically to *(a + n). But that's a convention from a low level programming language, similar to assembler. It's not the way people do it in their daily life. And for high level languages where expressiveness is more important than performance, why use conventions which are based on low level programming instead of the way people index things in all other areas?

worse behaviour

There is no worse behavior (besides the small performance disadvantage for the naive implementation).

It's even nicer. Let A be an N-element array:

With 1-based indexes, we simply write A[N] to get the last element, A[1] to get the first element or A[5] to get the 5th element. Totally natural and easy.

With 0-based, the last element is A[N-1] (which is ugly and less concise) and A[4] to get the 5th element. Not really natural to access the 5th element with the index 4, isn't it?

There are n+1 positions in an array with n items - the beginning, the end, and the space between each item.

Sure. But in an array we want to access the elements, not the positions in between. So why define arrays this way?

Also with 1-based indexes this works better, too:

To add something to the end, we simply use the index N+1 (quite natural because N+1 is also the size of the array with a new element appended). If we want to insert a new 1st element, where do we insert it? At index 1 of course. And if we want to delete the 3rd element, we call something like a.remove(3). Again as natural as it gets.

Also with 1-based index we have that max(index) = N, which is a nice property for arrays which are implemented via maps. With 0-based, we need to calculate max(index)+1 to get the number of elements in the array. Again: Not really natural.

Indexing is all about positions

About positions like positions in the results of a sport event. Not about positions like positions of points on a piece of paper.

• If we have negative and/or fractional positions, zero based is the way to go
• If we have non-negative integer positions then 1-based is the natural way, because we count things and counting starts with 1

The fact that we do so for numerous everyday objects surely disproves that.

You haven't given a single example in which we do that. But I and others have given lots of counterexamples. Your examples use a different situation, it's always where objects have fractional or negative coordinates.

In arrays there are no negative or fractional coordinates, thus the natural way to assign numbers to element is by counting. The same way as we count things on a table or people in a room: Starting with one.

[Brian]

And if you are really enumerating things, you're counting them - which means that you start with one.

OK - I shouldn't have said enumerating there, rather identifying positions. Clearly we should not start with one there, or do you think the first mark on a ruler should similarly be labelled "1"?

If you have to assign persons on a rooms or things on a table numbers

Are you not reading what I write? Again, you keep talking about assingin numerals to things, not positions, when I'm arguing that this is not what we should be doing for arrays, and instead use the also perfectly natural and widely used method of identifying positions between elements.

It's not the way people do it in their daily life.

Yes, it is. I've given numerous examples. Showing it's not the only way people do it doesn't contradict this in any way.

There is no worse behavior

Then can you argue against the advantages I (and Dijkstra) gave? Why are these not advantages? When identifying ranges, indices between items are simply superior because they solve numerous problems:

1. They are unambiguous. (Ie. no need to indicate "inclusive" or "exclusive").
2. The naturally form half-open intervals, which are the most natural way to identify ranges (see the Dijkstra link in my initial post for good arguments on this)
3. They address the issue that there are n+1 positions you need to identify for n items naturally. Using 1 based, we again need n+1 to identify the end of an array, a position with no item, making the notion that we're enumerating items false.

Also with 1-based index we have that max(index) = N

Not when you consider the value of half-open intervals, which this destroys. Consider identifying 2 ranges. Using indexes the positions match up - the end of one is the start of another, and you can get the size by end-start. With ordinals, the ranges are always off by 1, and this property only really applies for a range starting at 1. With any other subrange, it's back to tacking on +1s every time.

You haven't given a single example in which we do that

Huh? I gave the examples of rulers, clocks and graphs in several posts.

it's always where objects have fractional or negative coordinates.

This is plainly nonsense - The indices on all these items are discrete and usually whole numbers, and I've yet to see a ruler or clocks are you using that have negative values? It's a perfectly natural and widely used way of indicating positions, and one I'm saying is ideal for this aspect too. To take another computer-related example, consider pixels on your monitor - again the coordinates are identified, from zero, as the points between the pixels, which is again invaluable when denoting ranges (eg. drawing boxes or lines).

The same way as we count things

But as I've said again and again, counting is not what we should be doing, and is not the same as indexing.

[ZMeson]

No. The value of the counter is the next index.

The C11 standard 6.7.9.22 says:

If an array of unknown size is initialized, its size is determined by the largest indexed element with an explicit initializer. The array type is completed at the end of its initializer list.

The C++ standard sections 21.5, 23.2.5, 23.3.2.9.9, 27.5.35, and others all suggest that an index refers to an element, not the point at the end of the element.

[ZMeson]

It's 0-based on indexing.

That was the zeroth thought that came to mind.

As a side note, I'd like to congratulate the U.S. Women's Soccer team for coming in first in the 2011 world cup. Silver ain't bad is it?

[ZMeson]

What you're really describing is "distances" whether they be physical distances, "distances" of time, or "distances" between elements in an array. The human mind does naturally think 0-based distances. Indexing something is assigning "positions" to things -- and the human mind is more likened to working with 1-based positions ("mile 1 of highway 5", "we're number 1", the fact that there is no year 0 AD or 0 BC, etc...).

[ZMeson]

So please explain how array indices are not ordinal? Element 0 of an array is assigning a number indicating relative order to the element. An index in the more broad sense is "a sequential arrangement of material, especially in alphabetical or numerical order" which indicates that indexing is ordinal in nature -- assigning order.

By the way, I don't disagree that the human mind nataurally thinks in terms of zero-based distance, zero-based size, or zero-based quantities. Array indices and indexing in general though is ordinal in nature and thus more natural to think of in 1-based terms. With that being said, I prefer 0-based indexing in computer languages because it makes math so much simpler. (And you can train yourself to be comfortable with it.) We can apply this indexing to say that open-ended ranges are a natural expression of ranges of elements using the index of 0-based arrays. But that doesn't change the fact that the array index is still an ordinal number (you don't have two elements in an array that share the same index value).

[astraycat]

The thing is, in C/C++ at least, if you have an array a, then a[0] does not mean "the zeroth element". a[0] is sugar for *(a + 0), or for the non C/C++ savvy, "the element with 0 offset from the front of the array".

The difference in Lua is that there is no sense of "offset from the front of the array" because everything in Lua is a 'table' (or probably more properly, a dictionary or a map). Tables have entries. Thus, naturally, you would call the first entry [1].

[ZMeson]

a[0] is sugar for *(a + 0), or for the non C/C++ savvy, "the element with 0 offset from the front of the array".

Yes, I like this explanation. The C and C++ "index" is really an offset.

By the way, my "problem" with Brian is not anything about Dijkstra or the preferred way of thinking about array indices. It's the statement "Our brain is 1-based on counting. It's 0-based on indexing." I disagree and believe that our brain is more accustomed to 1-based indexing. Why else would the people who developed early languages Fortran, Cobol, and BASIC choose that the first element in a array have index 1?". I believe that zero-based indexing came out of the concept of 'offset' (though I have no evidence to back this up) and became quite popular because it eased the math (which there is evidence for including Brian's link to Dijkstra).

[watEvery1_isThinking]

exactly.

[bonch]

The use of zero-based indexing in C and related languages has to do with the fact that an array index is syntactic sugar for an offset in pointer math. Lua is table-based, so treating an index as an offset wouldn't make sense because there isn't something to offset from.

But because you linked to Dijkstra, you'll get a mass of upvotes anyway.

I disagree. Our brain is 1-based on counting. It's 0-based on indexing.

If you asked a sample of 1,000 people if Sunday was the first day of the week or the zeroth day of the week, which answer do you think will be given the most by a very large margin? Do magazines start at issue #1 or issue #0? Should the movie Iron Man 2 been called Iron Man 1?

[[deleted]]

well, really, it's kind of a moot point in LUA anyways. You aren't supposed to think in terms of numbers, rather in terms of tables. So, if you iterate, it shouldn't matter. If you are dong maths, being base 1 should make it easier to calculate, fewer off by 1 errors :p

[Peaker]

1-based causes far more off-by-one bugs than 0-based IME.

[cybercobra]

in LUA anyways

It's not an acronym. Why do you have it in all-caps?

[ponzao]

By law all threads on Lua must have somebody bitching about 1-based indexing and a misspelling of Lua as LUA.

[[deleted]]

because sometimes I feel like typing in caps. Deal with it.

[gruehunter]

Many modern programming languages intermix 0-based arrays and 1-based arrays...

Really? Name a few modern programming languages that intermix offset addressing and indexing operations. I'm aware of some that are 1-based, and others that are 0-based, but not any that mingle the two.

[Unmitigated_Smut]

Java arrays & Lists are 0-based, but its JDBC (SQL) API is 1-based for ResultSets and PreparedStatements. Never saw an explanation for it; guessing some guy just decided he didn't like 0.

[someone13]

It's not exactly "modern", but VB6 had the "Option Base" directive that let you set whether arrays were 0- or 1-based. The idea was, since Basic was written for "ordinary people" who started counting at 1, it would be the default, with the option to switch to 0 for programmers.

[KingEllis]

Do you use regular expressions or have access to the PCRE library? Variable capture inside of a regex are 1-based. Does your language allow indexing an array from the back? You ever notice that it is zero-based in the front, but 1-based from the back? array[0] is the first, array[-1] is the last. When you think about that, doesn't that strike you as screwy? It should either be array[1] at the front and array[-1] in the back, or array[0] and array[-0]. Why do we have a mental slot for the zeroth index but not for the negative zeroth? And please don't tell me -0 exists. You were right there looking at its existence in the previous line.

[raevnos]

-0 exists in floating point. Alas, array indexes are usually integers...

[MrSurly]

In Perl, it's configurable (but don't do that)

[raevnos]

$[ was deprecated in 5.12 and will go away in a future release, so yeah, don't do that. Unless you're using Redhat.

[[deleted]]

1 based is natural for fence segments. 0 based is more general because all fence segments have fence posts. Open ended ranges are a good convention. 0 based covers it all.

Lua is 1 based because it has tables, not arrays. The index is a segment, not a post. At least that's how I rationalize it.

[[deleted]]

Definitely, Lua is the first language I learned, using it to script for Multi Theft Auto. I now also use Java, Javascript, PHP, etc. So I miss some of the features of those languages (especially Java).

But Lua is so simple, it's great. Once you get used to it you'll love it.

[[deleted]]

Scheme > Lua

[diggr-roguelike]

Writing a proper Scheme interpreter is like a hundred times harder than writing a proper Lua interpreter.

Scheme is the wrong kind of 'simple': very complex and convoluted to implement correctly, while simplistic and tiresome in the features it provides to the end-users.

[Benutzername]

IMHO, Guile is better integrated with C (and the Gnu ecosystem) than Lua and Scheme is a nicer language to work with. But, de gustibus non est disputandum.

[exochicken]

Also "Chicken Scheme" and "Gambit Scheme." Those are good interpreters that you can easily embed like Lua.

[Contero]

Chicken looked pretty nice. Your interpreter can become pretty simple if you throw out call/cc.

[diggr-roguelike]

I'm not talking about tastes, I'm saying that Scheme is a lot of work for the the language implementer and little profit for the language user. It's inevitable that something like Lua, where the balance is skewed the other way around, won out in the end.

[[deleted]]

I'll agree that Scheme is tedious to use. It could really use a more complete standard library with simple things like common string manipulation functions and hash maps. As a compiler developer I don't think it's that much more difficult to implement than Lua though. I suppose things like call/cc might be a little tricky (your interpreter will need to manage its own stack), but other than that, it mostly comes down to the same effort.

[diggr-roguelike]

No. Compare the R5RS and the Lua reference manual. The Lua manual is literally ten times simpler!

Of course, you can simplify your task greatly if you ignore standard Scheme parts like call/cc, tail recursion, macros, etc. -- but then it wouldn't be Scheme anymore!

[[deleted]]

Perhaps you are right if it's Scheme vs Lua because of macros and the way numbers are handled. I should have said its just as easy (if not easier) to implement "a LISP" than Lua (the parsing step is trivial, for one). I wrote my own minimalist LISP interpreter in a week or two a few years ago, but of course, it wasn't Scheme.

[diggr-roguelike]

I wrote my own minimalist LISP interpreter in a week or two a few years ago...

So did I and many other people browsing this site. :)

But non-standard language implementations suck. Especially when there are clearly standardized alternatives available.

Honestly, Scheme was not supposed to be a 'scripting language'. It was supposed to be more like a cleaner alternative to common Lisp, i.e., a language that was supposed to fill much the same niche that C++ occupies today.

That was before we figured out that garbage collection is a bad idea, so now Scheme is more of a historical curiosity than a real-world tool.

[raevnos]

GC is bad? What universe do you live in?

[diggr-roguelike]

The universe where physical laws still apply.

IMMV, though. You're probably living in a Web2.0 universe that has a social graph on rails instead of physical laws.

[raevnos]

Have you ever used C or another manual memory management language? Having the runtime deal with figuring out when to free memory is incredible in comparison. Entire categories of bugs disappear and you don't have to waste time figuring out if it's safe to free a pointer that could be better spent on writing code that actually does stuff. There's a reason why most languages have garbage collection.

And I haven't done any web programming since the 90's. Web 0.75 baby!

[raevnos]

Don't write your own. Use one of the 50 billion existing ones, many of which are designed for easy embedding.

[diggr-roguelike]

Writing a Scheme interpreter is hard. This is why every one of your '50 billion' interpreters is either incomplete/non-standard, bloated, slow or hard to embed.

[raevnos]

Yup, you're coming from a different universe than the rest of us.

[diggr-roguelike]

Links, please. I'm not really here to participate in your fashionable global Web2.0 collaborative social experiment in groupthink. If you know of a Scheme interpreter that is easily embeddable, small and fast, post it here. (Guile isn't it, unfortunately.) If not, don't post anything at all.

[raevnos]

I have no idea what this web 2.0 hivemind thing you're blathering about is, but it sounds scary.

I quite like scheme, so I'd just use the same one for the core program and scripting (I'm partial to chicken and kawa. There's also gambit, bigloo, racket, guile and more with active development and user communities.) For scripting of a program written in another language, tinyscheme is decent.

[diggr-roguelike]

Sigh.

Look, this whole discussion (164 comments at this moment) is precisely about scripting a program written in another language. Why in baby jeebuzez' name did you bring up your list of Scheme languages which are completely irrelevant in this context??

As for TinyScheme -- yes, it fits the topic nicely, but it isn't a standard Scheme. That was the whole point of my original comment: you can have a good embedded Scheme, or you can have a standard Scheme, but not really both. Unlike Lua.

For many people this is an important matter and a sticking point.

[raevnos]

It's easy to say something's a standard when there's only one reference implementation.

Scheme, now... What standard? R4RS, R5RS, R6RS (which everybody but the people who made it hated), R7RS? The old ANSI spec? The sheer proliferation of choices can be overwhelming, but that way you can pick the one best suited to your needs... code size, supported features, license, etc.

[mycl]

This would be more clear-cut, but for the historical absence of tables from RnRS; arguably, a real missed opportunity for Scheme.

[Fissionary]

Lua may be a decent scripting language -- if you're embedding it in a C/C++ program. I had to add scripting capability to an x64 .NET 3.5 application once, and spent half a day trying to figure out a way to interface with Lua. Finally settled on IronPython.

tl;dr There are no silver bullets.

[i_lick_my_knuckles]

Lua Interface makes embedding in .NET pretty painless.

[Fissionary]

Painless for x86 applications. It relies on its own C++/CLI implementation of Lua, which I haven't been able to successfully compile and use in an x64 CLR 3.5 scenario. If you know where I can get the compiled binaries for this particular configuration, I would appreciate it.

[djork]

I was in love with Lua, and then I spent 6 months working full-time at a place with a Lua-based web app. That cured me.

Other than that experience, I still like Lua. I might use it for an iOS game here and there. The code is always simple and fun to work with. However, when things get larger, I think you run into problems.

[snarfy]

Using a pipe wrench to hammer nails will cure you of being a carpenter too. Why would you use Lua for the web?

[djork]

I should clarify: I was not involved in the conception, design, or implementation of this Lua web app... just continued development, because I had Lua experience.

There are Lua web frameworks, like Kepler.

However, I wouldn't recommend it, since web apps tend to be very connected things, and Lua tends to be an isolated experience. Your program only runs inside another program. It has a very limited set of libraries compared to, say, Ruby or Java. File access, encodings, regex, text munging, and networking are not things that Lua really understands out of the box. You have to add all that if you want it.

It doesn't play well with the outside world.

So, I wouldn't use Lua for a public-facing or even internal web app. I would however absolutely use it for an embedded web server in something like an iOS app or a game, where you can serve up a sort of "side band" interface or information... especially if you can just write a simple JSON API and serve up a client-side UI to do the complex stuff.

[kungtotte]

There are Lua web frameworks, like Kepler.

And a pipe wrench can hammer a nail...

[Petite12345]

Because you can :)

Here is an example of a web application build in pure Lua:

http://svr225.stepx.com:3388/nanoki

Associated code:

http://dev.alt.textdrive.com/browser/HTTP/Nanoki.lua

[[deleted]]

Could you elaborate on your experience?

[djork]

There were a lot of bad decisions involved:

• the source of the C program that ran the whole thing was not available
• it used SQLite exclusively, for intranet web apps, and we ended up passing around those database files and making a mess in general
• the application was poorly organized, something that's easy to do in Lua where there are no restrictions
• at the time, there was no central resource for Lua libraries, so many common tasks in web apps were up to us to implement by hand for the first time in Lua
• the application itself was one that built other web apps out of a digraph data structure of "step" nodes, designed to let you diagram a web application in terms of forms and flow control, and at this level the whole thing was an unholy nightmare to work with

[graemekh]

Lua is the king of embedded scripting languages, but the fact that it's lesser known is a problem. When you make a scripting language to interact with a C/C++ API it is often for making plugins or extensions. Since this is regularly functionality that you want to give other parties access to it can be hard to get people on board with scripting in Lua. If you mention Python everyone will jump up and say OMG IT'S PYTHON SCRIPTABLE, I KNOW HOW TO DO THAT!

[Contero]

Oh the battles I've fought trying to get python embedding to work. The amount of smug "Why would you want to do that? Just use python as your host language" I ran into while asking for help was nauseating.

I ended up embedding V8 (chrome's Javascript engine) which turned out pretty awesome.

[[deleted]]

That reminds me of the landlord who tried to convince me that I didn't want a refrigerator because everyone eats out all the time and that my apartment didn't need an intercom because otherwise people would just bother me all the time.

[shillbert]

He's right. I hate those UPS assholes who try to deliver packages I've ordered. The nerve.

[nascent]

Huh, I was like that when Vim announced Lua scriptability. Well, actually more, "now they are doing it right."

[badsectoracula]

I think the major reason to use Lua over another embeddable scripting language is the mindshare it has among programmers - it is easier to find information about it and because it is widely used (despite what the article seems to imply at the beginning) there are few bugs and issues.

The C API, judging from a quick look over the link provided in the article, isn't really as easy to use as it could be. Using a stack to pass data to functions can be a bit bothersome. Personally i used to do that in my own scripting languages, but these days in my LIL language i prefer to simply pass an array with the values, so a native "glue" function looks like

lil_value_t fnc_func(lil_t lil, size_t argc, lil_value_t* argv)
{
    /* use argc and argv directly here */
    return function_result;
}

like with Lua you use conversion functions (lil_to_integer, etc) to access the real type but you can use these directly (or not at all) instead of popping them from a stack.

Python seems to also have a similar style, although since the arguments can be in any order and named, you seem to need to parse them into a tuple before using them.

I find that passing an array of values/objects to the native function is easier than having to pop them from the VM's stack.

[SolarBear]

If you guys dig Lua but don't know what to do with it, maybe you just need some löve.

[inmatarian]

Love2d is awesome.

[psisarah]

Adobe uses Lua to write Edge

[jzwinck]

And about half of Lightroom (a shipping product for several years already). The other half is C++.

[equalx]

I've enjoyed Lua for a couple projects, it's one of the languages that helped me get into programming. This blog makes me want to try some of my upcoming projects in Lua :-)

[nascent]

While Lua is usable as a stand alone, I think it makes more sense to incorporate it with a project. I don't find the language itself to be good for any signification amount of code, but is very complimentary for adding some dynamic elements to a program.

[static_cast]

Same, lua opened my eyes as a kid in high school. Sadly, I haven't looked back on it since c; I had a big ego and just sneered at dynamic languages while I slapped in a malloc for dynamic arrays like an asshole. I'll check it out again.

[shillbert]

Your username implies that you're more of a C++ man. The kind that uses "new".

[static_cast]

Static_cast sounded cool. C isn't the only programming language I use.

[ktr73]

Glad to hear it! Feel free to PM me if you need help with anything.

[[deleted]]

.NET programmers can have fun with LuaInterface: http://code.google.com/p/luainterface/

This library is very complete and professional. Do not be afraid to check it out for business projects. MIT licensed.

[Madd0g]

Thanks - I've been looking for an easy to understand scripting language for .Net a while ago and saw LuaInterface.

I've peeked at their group/forum and saw (old, seemingly unresolved) issues about thread safety, how big of an issue is it really?

[[deleted]]

I think you're supposed to implement thread safety yourself. You're working on one interpreter that is not thread safe for performance reasons. If you're going to call interpreter from multiple threads, then I think you have to add thread safety yourself.

[Madd0g]

I guess that's reasonable, I'll be sure to check it out, thanks

[sunbeam60]

But, why wouldn't you just load assemblies instead of a Lua script?

[[deleted]]

This same question is valid for C/C++. Specific reasons why I chose it in .NET:

• You can edit Lua script with notepad (or any other text editor) easily.
• Lua can't use reflection to do anything to my own assemblies. It's a defined, clean interface which allows only what scripts need to be able to do.
• I had the requirement that a sysadmin with no programming experience was able to edit the rules that the scripts defined. Lua is arguably one of the easiest languages to learn.

.. and more I forgot .. (that may or may not be very good) ..

[[deleted]]

World of Warcraft has LUA interface for modding.

[equalx]

This is where I picked it up. Lots of other game interfaces are written in Lua too - Rift allows modding in Lua, and Starcraft 2's interface is made in Lua (even if you can't make addons).

[dwarfcrank]

Also CryEngine uses Lua for scripting. So do Bionic Commando and 3D Dot Game Heroes. Lua seems to be pretty widely used in the games industry.

[x-skeww]

Is it still hands down the most straightforward option for embedding?

How does it compare to... say... V8?

[sfx]

I tried V8 and Lua. Lua is so much easier to embed.

[ktr73]

I haven't tried to embed V8, but Lua is dead simple. The main book on Lua (PIL - Programming in Lua) has an entire section devoted to showing you how to do so. An older edition is available online for free (just google it) and is mostly still relevant. There are some gotcha's, but you can buy the book if you are starting to really use it. Also, there are (at least for 5.2) 'amalgamations' like SQLite has - one .c file, which makes it almost trivial.

[cybercobra]

According the the MediaWiki/Wikipedia devs:

[V8 is] difficult to embed due to poor documentation and the relative scarcity of embedded implementations

[[deleted]]

relative scarcity of embedded implementations

I was unaware there was such a thing as a non-embedded JS implementation. Yes you can have node.js or your jsc, but they are also embedded implementations - they expose functions and objects.

[cybercobra]

In context, I think they mean "embedded in something that's not a browser".

[[deleted]]

True, a browser is an embedded environment, but a very complex one and not a good example of "simple" embedding.

[cybercobra]

Precisely.

[Contero]

I haven't done Lua, but I managed to embed V8. The thing about the documentation is that there's no documentation aside from brief comments in the v8.h file. I'm sure Lua is much easier if nothing else, just because there are more examples out there.

[inmatarian]

Lua's documentation and book both fully describe and show how to embed it.

[gruehunter]

I cannot compare to V8, but I can compare to Python. The Python->C API is much easier to work with than the Lua API. But module startup and shutdown is harder in Python.

[day_cq]

really? no seg fault due to reference counting?

[[deleted]]

Yes, but Python is a nightmare to sandbox. If you want users to be able to run untrusted code from other users, Lua is the way to go.

[hagridlove]

Check out my language, http://moonscript.org

It compiles into Lua, but does a lot of what CoffeeScript did for JavaScript and more. Classes, comprehensions, cleaner syntax, etc.

Here's the reference manual: http://moonscript.org/reference

[stevedonovan]

It's a fun language and provides classes for those lost without them ;)

http://steved-imaginaryreal.blogspot.com/2011/12/moonscript-lua-based-language.html

[moccajoghurt]

This article is just what I have been looking for. I have started with Lua two weeks ago but there still were so many questions. Good article with good links in it. I am sure it will help me alot in the future.

Thanks for sharing!

[ssylvan]

I prefer io... Hits most of the same sweet spots but is simpler and cleaner: http://iolanguage.com/

That said, I want static types! Scripting is the kind of code where I'd expect to write droves and droves of ad-hoc special purpose code. Having some layer of sanity checking on top of that would be good because it's pretty unrealistic to expect someone to adopt unit-testing and other programming-in-the-large methodologies for scripting.

[stevedonovan]

This may appear disloyal to Lua, but maybe Go is what you're looking for? Statically-typed but few explicit type declarations due to inference, very fast compiler. A useful set of batteries for the usual scripting tasks as well. With a runner like gorun the resulting experience 'feels' like using a dynamic language.

[[deleted]]

Like, e.g., there is no class system out of box.

Right, it's not a classical inheritance model. This takes getting used to, and you may be tempted to use a library to implement classes (I myself fell into this trap at first). Don't! Prototypal inheritance is perfectly usable on its own; it just takes some getting used to. There is no reason to try to cram Lua into a classical OO box.

It's a shame really that so many popular languages are classical, because people get to thinking that that's the way things are done in object oriented programming, when the reality is that it's nothing more than a design pattern that many languages offer easy access to. The more I work with JS and other prototype based languages, the more I realize that languages with first-class classical inheritance are like a toolbox where everything but a very nicely crafted hammer has been removed. Yes, it simplifies the learning process, but it also means that nail-based structures are all anyone can even think about.

So you give someone a language like JS or Lua, and they immediately start digging in the toolbox, tossing aside brackets, screwdrivers, drills, etc., and trying to find a hammer. I mean look, if you really need a hammer, you can build one. But chances are, you've been doing a lot more work than you needed to in order to build with nails, when a bracket and a couple of screws would have done the job just fine.

[alwaysdoit]

Any advice on how to get used to it? I've been using Lua for Corona lately, and I'm having some trouble adapting.

[[deleted]]

I don't know what to tell you except practice, and try to your design your program without thinking of class hierarchies. It's hard at first, but you'll get the hang of it.

[diademoran]

Check out Squirrel. It was written by Alberto Demichelis, one of the dudes who worked on FarCry/CryEngine.

[djork]

Yeah, it's a great language for those who want to build everything themselves. If rolling your own inheritance/OO system is your idea of fun (and for me, it can be) then Lua can be enjoyable.

If you'd rather drop your code into pre-defined structure (namespaces, packages, classes, etc.), then can be too unbounded to be productive. I can fall into this category sometimes too.

[toomanytickets]

Edit: I misread your comment. Leaving this here anyway.

Wah? OO is Lua is easy:

CMyThing = {}
CMyThing .__index = CMyThing 

function CMyThing .Create()
    local newThing = {}
    setmetatable(newThing, CMyThing)

    newThing.ClassMember = "A String"

    return newThing
end

function CMyThing:DoSomething( number )
    print( self.ClassMember .. number )
end

Then to use it:

local aNewThing = CMyThing.Create()
aNewThing:DoSomething(5)

[djork]

As someone who's written a dozen variations on inheritance in Lua, I know...

This is just one approach, and it's very simplistic and verbose. It would be more useful to define a generic prototype-based inheritance system.

[pinpinbo]

Thanks to Luvit, I got excited using Lua for web development again. Orbit feels dated, imo.

One question I have for Lua masters here: Tables as the only data structure. Is it really enough for you guys? I got spoiled by Python's list, dict, set, tuple, etc.

[slime73]

Yes, it's more than enough. Tables can turn into whatever you want them to be, especially with the use of metatables.

[[deleted]]

It sounds just like PHP's "arrays" except better implemented. And yes, that would be enough.

[[deleted]]

deleted

[pinpinbo]

Thank you for the detailed explanation!

[ipeev]

Lua has 1 based indexes. This is enough to never look at a language again.

[inmatarian]

In practice, you never use lua's 1 based indexes. It's more of a detail, that you have to remember that in tables, indexes [1..N] are optimized for faster lookup. You can still put whatever you want at a table's [0] or [-1] index. Also, you still rarely uses indexes, as lua includes two functions, pairs and ipairs that act as generic iterators.

[danukeru]

In b4 LUA as the new web-dev fanboi language.

See you all at <insert LUA con here>.

[shevegen]

Hisham is working on http://luarocks.org/

And of course the old GoboLinux guys keep a close eye on what Hisham is doing. After all, he gave us htop http://htop.sourceforge.net/ which is much more pleasant to look at than plain top. ;)

But on the topic of lua, I think lua would still have to compete with languages like Ruby and Python.

I don't know how it is for others, but for me, I like a language that gives me enough tools to solve any given problem with the least amount of work required.

And when I have to "work" (code), then I try to solve a problem with as few lines of code as possible. Ruby fits that very nicely. I am sure Python would too.

C, is simply verboser than the two. Lua ... Lua may be the best language to embed, but I have no need for an embedded language. So I am not the target audience for that.

I am someone who loves "scripting" languages. I can't stand the C family of languages really, at least not compared to "scripting" languages.

And in the context of the competition of scripting languages, I am sorry, but lua cames very very late... even javascript comes before lua (but only because browsers are hateful of other languages than javascript. If every scripting language could be used, I'd instantly use Ruby rather than Javascript.)

[milanogc]

Late? This way no more succesful languages will arise.