Hacker News Reader

Hacker News

Comment by bcrescimanno | Hacker News Reader

Parent Full thread

bcrescimanno

This comment thread on the previous conversation has a lot of good replies:

https://news.ycombinator.com/item?id=31908731

A few highlights:

* "If it ain't broke, don't fix it"

* People don't like Lua (or just simply prefer VimScript)

* Divergence over time means that they are not still compatible.

View on HN

> * People don't like Lua (or just simply prefer VimScript)

Lua is not my favourite language, but I'd sure take it over vimscript.

> People don't like Lua (or just simply prefer VimScript)

:shock:

I prefer VimScript over Lua. VimScript is really not that bad of a language and I think its deficiencies have been greatly exaggerated, and Vim9Script fixed most of the oddities that were in there (e.g. '1' == 1 and such, JS/PHP-style).

Lua, on the other hand, won't give me an error if I mistype a variable name, and the ecosystem doesn't really have good static analysis tools to catch these kind of silly errors. There's some other things I don't like either, like how "arrays" are really just hashmaps, as well as some other things. The whole versioning story wrt. compatibility is also annoying (it's basically a Python 2/3 story with every single Lua version).

It's not Lua is horrible, but the fawning over it from some Neovim people is something I always found curious, like it's a fantastic brilliant language. Meh, I found it quite average overall, at best. And if I look at some Lua vimrcs or plugins then it's all a lot more verbose and awkward than VimScript.

Not that VimScript is perfect by any means, but overall I find it's quite a decent DSL for an editor.

Fair, though neovim uses LuaJIT which is maintaining Lua 5.1 compatibility indefinitely; with their own set of extensions[1].

Through the use of metatables you can improve the undeclared global situation[2], through I admit it's kludgy.

We use luacheck for static analysis, but I'll admit it's far from perfect. The language doesn't lend itself well to static analysis.

I think what lua mostly has is a really good embedding story. It's a tiny C library with broad compatibility and a permissive license; and with LuaJIT it's also very fast (though less portable). This means it's used everywhere and a lot of people are at least passingly familiar with it. Vimscript on the other hand is fairly alien.

[1] https://luajit.org/extensions.html

[2] https://github.com/CorsixTH/CorsixTH/blob/master/CorsixTH/Lu...

I feel the same way. Legacy vimscript certainly had some warts but vim9script has been much nicer IME than lua. Elsewhere I've likened vim9script to typescript 1.0. It has just enough types to be useful but not enough to let you go down a rabbit hole. That's sort of the sweet spot when scripting another application.

> Lua, on the other hand, won't give me an error if I mistype a variable name,

Lua has pretty good lsp server and it gives me good warnings and completions.

I prefer vimscript when scripting vim.

> People don't like Lua

Who doesn't like Lua? That is right up there next to disliking kittens and puppies...

Arrays start at 1?

Just like in math, and Lua doesn't do manual memory management so aligning stuff with memory addresses is not needed.

They're both valid options and it's just about preference.

There are good reasons for zero-based indexing outside of pointer arithmetics: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...

It's a well-known argument. It's also widely recognized as highly subjective, starting with the notion that upper bound must be exclusive.

> Just like in math

I might be wrong, but I think math favors different starting indices based on the subject matter. I've seen Analysis textbooks favor 0 as the starting index. I don't think there's a clear argument for cultural transference from math.

I'm opposed to starting index from 1 because I think departure from very mainstream programming tradition should have a strong reason beyond preference, even if the de facto tradition appears equally capricious.

Indexing starts at 1 in math mostly because in history, people were afraid of 0, and it's hard to change conventions.

Debatable. It makes sense to say "the first element", regardless of mathematical connotations. We've had this kind of expression in almost every language across the world long before we invented multiplication.

Saying the "the zeroth element" is just... weird and slightly nonsensical.

Yes, because language developed at a time where people didn't know about zero.

Zero still would most likely wooldn't make sense. Zero is nothing, it can't be anything. Even ordinally.

1 is something and it fits very well for the first position... outside of programming :-)

In 1-based indexing, the index of an item is the number of items you've already seen, including the one you're looking at.

In 0-based indexing, the index of an item is the number of items you've already seen, excluding the one you're looking at.

I agree that is very weird at first. But after building a toy project including about 5,000 lines of Lua, I can say I got used to it fairly quickly. Most of the time, I was accessing arrays via iterators anyway, so I had to deal with indices very rarely.

Aesthetically, it is repulsive, but when actually writing code in Lua, it was not much of a problem. I felt much stronger about "do"/"then" and "end" versus curly braces for delimiting blocks.

Array index starts at 1

~= instead of !=

# instead of len()

Default declaration to global

-- for comments

Dereferencing something that doesn't exist returns nil

Reply on news.ycombinator.com