[Date Prev][Date Next][Thread Prev][Thread Next]
- Subject: Re: S.W.O.T analysis
- From: Lorenzo Donati <lorenzodonatibz@...>
- Date: Thu, 20 Oct 2011 08:51:48 +0200
On 19/10/2011 14.48, Patrick Mc(avery wrote:
On 11-10-19 08:42 AM, Enrico Colombini wrote:
On 19/10/2011 13.54, Patrick Mc(avery wrote:
If Python runs something in 200ms and Lua runs it in 50ms I don't care,
it's still a blink of an eye.
In a game environment, for example, 1 ms per frame could be way too
much. Same thing for memory, in many embedded applications.
I fail to understand this drive to "let's change Lua to make it the
same as any other generalist language".
Actually I don't want to change Lua per say, it's just that with all the
module discussion I feel that a large part of the list is arguing for
the wrong sort of things. I think that there should be more attention
paid to making it simpler to use. Perhaps that puts me in the
anti-module camp but if it does, I don't think the revision goes far
enough to bring it to the easy of use of python/import, PHP/include.
Again I don't understand the internals and if this sort of thing will
cause too much overhead then it's pointless as Lua has to find some safe
space between the fat/feature-rich languages.
You proposed to add a text-based include mechanism to lua arguing it
will make it easier for non-programmers (if I got it right - I got lost
in this thread so sorry for any misunderstanding).
I disagree very strongly with this proposal and with the argument that
it will make Lua easier for non-programmers.
I don't know PHP but from other posts it seems very similar to the
#include directive of C preprocessor. If this is true, I don't think it
will make Lua *so* easier.
Text-based inclusion is a powerful mechanism if used (very) carefully by
experienced programmers, but also a (very) messy one. Newbies will
indeed have an easier time to understand *how* it works, but most
probably won't understand all the implications of its use and *how to
use it correctly*, except for the most trivial tasks.
But once the newbie gains more experience, will probably want to use
that mechanism for more advanced use (and will try all the dirty tricks
a future programmer has done when evolving from the non-programmer
stage!), and then they will get hurt badly.
Code written using "include tricks" *will* come and haunt you in the
future (unless you are an experienced programmer - hopefully!), and is
difficult to maintain.
Of course if you only write throwaway scripts this could be bearable,
but then you are proposing a change that will hurt every non-programmer
that wants to become a programmer (I'm oversimplifying - I know).
The point, as collectively the list has tried to communicate (as usual
in its sometimes chaotic way), is that text-based inclusion is bad
because it doesn't fit Lua spirit: it is messy, it doesn't play well
with scoping rules (even non-programmers should know the benefits of
structured programming - it's not advanced CS - it's basic programming
methodology - and scoping is central to structured programming), it is
In short, it won't make Lua easier, but harder to understand once you
want to do more that the most basic things.
You said, IIRC, that it will simplify typing code, but this is hardly
ever a good reason to add a feature to a language: programs should be
easy to *read*, typing is secondary (as Steve Donovan pointed out, a
good editor/IDE could help a lot for that). Again, this is a basic
programming principle, not advanced CS.
C has this feature (in its preprocessor - not the language itself) but
keep in mind that:
1. C is an old language (70s IIRC): it was designed when machines where
*much* less powerful than today (so more advanced features were too
costly) and there were *much* less non-programmers toying with computers.
2. it was meant to build system software (an entire OS - Unix!). It was
an higher-level replacement for assembly language!
OTOH Lua has proven quite successful for non-programmers (as WoW modders
know). Its success comes also from its small size (in the sense that
there are few feature to understand) and the absence *apparently* easy
features. Easy features are, more or less, just that - easy (there are
gotchas - of course - but not so many for simple things).
Most gotchas come up when you start using advanced features, such as
OOP, closures, metatables, etc.
Please, bear in mind that the beauty of Lua (and its ease of use) comes
also from its carefully balanced design - there are tradeoffs, but they
are well thought-out.
IIRC you said you are a non-programmer (sorry if I got this wrong, as I
said I was overwhelmed by this thread and its spawns), so please trust
all the good programmers on this list when they say that text-based
inclusion is not a good thing *in general*. And this has almost nothing
to do with performance, but with code clarity, readability and