lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]

hi all! :)

i think lua have the shortest learning curve of all the languages that
im familiar with (except bf and whitespace :D however whenever youve
done with learning of the language everything else is just art and as
easy as pushing buttons - or maybe im wrong about it)

i think that lua is simple and easy with the right guidance for a
fresh meat in the world of codes, but mostly i suggest them to learn
something else before starting lua to see and appreciate the beauty of
the language. ive felt lucky with my previously achieved knowledge,
and made things cleaner for some stuffs ive learnt before.

i dont think that your proposal will make lua that much easier, maybe
a bit more easy to see the difference and find the right place for
whatever anyone is searching for. probably it can be a bit more
optimized. this can be good, but on the contrary maybe it can make
sometimes those stuffs harder that accept both lists and tables, like
a dump and like how we already have to count with nondefault
metatables for a lotsa things. so it can optimize and can make the
opposite all for speed size and readability, but in most cases i think
it can be good.

on the contrary i deeply like the flexibility that comes with this
combination. as i already told you 1-2 times back in time, that i came
from python land, where are array, tuple and dict types, and its fine
that i can instantly select the best for a special purpose. combining
them and making universal stuffs for them have never made my life
easier. we have to do something for this and that or convert on the
fly (i think thats expensive). whatever works on hash tables those
works on arrays, but with tuples dicts and arrays with different
usecases, handlers and rulesets making universal stuffs harder, and i
like those the most. it is still possible to make arrays accepted
everywhere where mainly hash tables are expected, but makes some
complexity in the implementation of lua itself i think. i balk
metamethods for the same reason til i have no reason to use any, even
if i really like that lua have this possibility, just i have the
intention that a lotsa ppl overusing them, however its totally legit
for much cases.

combined array and hash table is a selling point for me. i think
lua5.1 is enough for everything by its knowledge, like i dont feel it
needs anything more than optimization that luajit does well (the
best?!) however i like tablifying(?ftw) things around, and goto, id
even like to see preprocessor and func defs for lj ffi, but there is a
preprocessor out there that i dont know the quality, and just followed
some links from lj list i think (graphics binding) and found a tcc
binding, so it seems like everything is given. i was afraid for a long
while about floats as array keys and that they wont ever become
precise, but ive learnt that floats have an assembly lvl setup for
rounding (upwards downwards or nearest) so this way i understood why
its enough to floor(/ceil?) it to be the right array key instead of an
another one or a hash key - but correct me if im wrong about this! :)
and lj have cdata, so i have integers in case of need. so after all i
generally dont feel the need of change, but ive seen kinda good news
by the time, even stuffs like i disliked when came up. i think the
best is to not try to give it a different path but crystallizing what
it is already.

most proposals are like pushing lua into the direction of python like
give a fixed form for everything and give it a s#itload of sugar, and
i dont really like those. (its not straightly about python, just i
know that well enough to use for an example but i could have much
other examples as well, just weigh stoursoup for c++, ive seen a huge
amount of variations maybe for fibonacci or factorial in haskell, php
have a tool for everything (actually i like php too), and i believe
no1 ever read through msdn for c# nor java docs, ruby on rails,
moonscript and coffeescript have too much sugar for me - but i dont
see enough from these 3 to be sure that my words are legit for them,
and i dont know what to say about javascript, however i like that as
well, except when not :D ) so back to python (that have kinda much
everythin of those previously listed) i see them as opposed roadmaps,
and i like to use tools with batteries included, i liked python very
much back in time, before lua and before i couldnt find the perfect
toolset when the 2.x 3.x break happened, and i can understand how this
makes it popular... however i like such things only for working, but
not for myself. for myself i want flexible easy to use lightweight
powerful stuffs, and lua (or luajit) is the nearest to my hearth of
all the languages cuz the deepest simplicity in every aspect related
to others. the most im thinking about how it would be like with {} for
blocks, but that would make mess with tables, so its fine to have one
more char for the 'end'.

what im afraid the most is any change that would break compatibility
between lua versions, like now there are so much libs that can work
with lua5.1-5.3+lj2.0-2.1 and this is a very good stuff, but on the
contrary i think all this is mainly cuz lj still mostly at 5.1, but
the kawlest features from later lua versions are already available. im
very very interested where all these gonna lead the world of lua, and
im a bit afraid as well that it will take the path of python 2.x 3.x
break that still deeply dividing it... rip python.

btw i dont think its hard to explain the differences through a well
written set of dummy examples maybe with a one liner description

i wont read back what i wrote cuz i have to work, but probably i could
write some good thoughts, so feel free to ask back for any part of it,
and sorry!!!

and all the bests for every1 around! :)