Anyone here into Lua?

[agentwiggles]

One of my courses this semester is focused on the use of software tools that are handy to programmers. It's been a really interesting class - I've learned about things like revision control (through git), debugging (gdb, eclipse debugger, etc), and the like. Currently, we're looking at Corona SDK, which is a whole development kit for Android.

At first, I admit, I had kinda turned up my nose at Corona. I think I kinda felt like using it to develop for Android was cheating, like the work you did belonged to Corona. But I've been playing with it extensively over the last week, catching up a few homework assignments for that course, and I have to say I really like it. It uses lua scripting, which for those who don't know is a sort of middle-man language which uses one data structure and dynamic typing. I was a little weird on lua at first, too, but I've started to get a better handle on it, and I think it's really cool.

I had initially planned to learn Android development through pure Java, but Corona and Lua have been really good for allowing me to start experimenting and getting apps onto my device so I can screw around with something I actually made. Dynamic typing is really kinda fun - declarations are as simple as

Code: Select all

var1 = "BTW"
var2 = 42

and the tables (the only data structure) are really cool as well. They're super versatile - sort of like a bastard child of arrays and structs, which have multiple variables of whatever type you like, declared like this (dynamic types also offer super easy string concatentation with the '..' operator:

Code: Select all

table1 = 
{
    label = "BTWRoolz"
    version = 4.899999999
}

print (table1.label .. " Version " .. table1.version)
>>BTWRoolz Version 4.899999999

It's all very easy, and kinda fun for a C++ oriented programmer (who usually has to be very, very careful in telling the computer exactly what to do). Anyone else into lua? Any cool scripts or anything you've made with it?

[magikeh]

Never done lua, but I've found javascript a fun language to mess around with. Its pretty fun to make the most fucked up webpage that you can. Every little action the user does (click or mouseover events) causes some sort of reaction. Currently playing around with the 3JS library.. :)

[agentwiggles]

Yeah, I've messed around with JS too, only a little bit. If you like that, you'd like lua for sure.

Also, here's a cool little javascript game, this was actually my first introduction to it.

[BinoAl]

I've used Lua a bit, mostly in tandem with Love2D. Love2D is actually what was used for Mari0 (SMB with the Portal Gun), which I'm sure somebody here has at least tried out.

[ExpHP]

An embedded scripting language like Lua is a neat concept. Certainly easier than writing your own scripting language and parser in C++.

The most fun I've ever had though was Ruby.

Code: Select all

array = [0, 1, 2, 3]

array.each do |x|
    puts x
end

Ruby, where lambdas are a beginner concept. <3

[AdmiralJonB]

I tried out Lua with ComputerCraft for quite a bit, and as a primarily C/C++ programmer... I really got weirded out by a lot of things. Can't remember what exactly it was now, but I don't plan on going back to it anytime soon. If I choose to use a scripting language, I go straight to python :)

[William the tuba]

I agree with AdmiralJon8 here. Lua can get very weird, as most of the idioms we associate with modern procedural/object oriented style have to be implemented by yourself using metatables and other lua-only things. Not to mention some stylistic choices that might seem counterintuitive, like arrays indexed from 1 and a lack of operators like +=, but nothing that can't be worked around. There's a whole class of gotcha's coming from python, which is my preferred scripting language.

For android development, I'd probably use either Xamarin (C# or F#) or Haxe/OpenFL, depending on what I'm doing.

[userzero]

For android my two top picks (on the free side) are libgdx if your using java or cocos2d for c++. I only messed with android briefly before decided it wasn't worth it and focusing on IOS instead, I did write a fe games with libgdx while learning opengl and I liked it but found it lacking when I moved on to 3d. Libgdx is also nice if you want to delve into the underlying framework a little bit but still have the libraries to get things done without needing to code from the ground up.

[PatriotBob]

I understand the need for scripting/interpreted languages, times when compiled languages are not as fitting. In-game scripting, etc. But lua, it's just... infuriating. Don't expect it to be useful in a meaningful way beyond basic scripting. It just get too unwieldy and unmanageable.
Not that I have a particular love for Javascript, but it's able to to the job better, faster and your code doesn't try to eat your soul.

Programming languages are funny things. The reality is the last real progression made in programming languages was C. And that was primarily just a syntax progression. So my question is, if we keep making new languages that are just reincarnations of the old. Why do we keep revisiting the bad ideas as often as the good?

[Mr_Hosed]

When I tried learning Lua (10 years ago?) It felt like the code had the same pitfalls as LISP: great for writing, but a NIGHTMARE when reading. A lot of programmers forget that you actually spend more time reading code then you do writing it.

That being said, I've never shied away from easier to use languages. The more you get done faster, the better. No one really cares if you managed every pointer and unwound every loop if it takes you a month to do what someone else did, bug free, in a week using a higher level language (or scripts).

[jkievlan]

Yeah, I've messed around with JS too, only a little bit. If you like that, you'd like lua for sure.

Also, here's a cool little javascript game, this was actually my first introduction to it.

That's a neat concept. I was frankly disappointed with the depth of the content, though...I'm halfway thinking about making a better version of it :)

[Gilberreke]

The reality is the last real progression made in programming languages was C.

If that is truly an opinion, you have lots and lots to learn about language research. As a language geek who reads language papers daily, that statement is just an affront to all the hard work that was put into languages the last two decades.

I do agree with you that Javascript runs circles around Lua any day of the week. Then again, Javascript's is arguably the world's most popular programming language, so it seems logical. The days that Javascript was a language used for websites is long, long past us, with its uses ranging from extremely small foot-print embedded systems to full-scale video games.

[PatriotBob]

The reality is the last real progression made in programming languages was C.

If that is truly an opinion, you have lots and lots to learn about language research. As a language geek who reads language papers daily, that statement is just an affront to all the hard work that was put into languages the last two decades.

I do agree with you that Javascript runs circles around Lua any day of the week. Then again, Javascript's is arguably the world's most popular programming language, so it seems logical. The days that Javascript was a language used for websites is long, long past us, with its uses ranging from extremely small foot-print embedded systems to full-scale video games.

Name something that is new to programming languages from the last decade.

Edit: I should add more than just that statement...

Javascript has definitely come along in it's pervasiveness. And with the progress V8 has made and now asm.js, it's performance is no longer the concern it once was. But the language has some large inherent flaws that will prevent it from seeing major use. Don't get me wrong I love what node.js has done for the language. But when a corporation/organization is looking for a language to build and application with, Javascript isn't very high on that list. If it's on it at all. (Maybe for the web portion, but in reality that isn't a major portion of a large application)

Right now I'd say the major contenders for languages are Java and C#. They both bring to the table the best of what's come before. I'd also argue that Clojure is one of the better langauges available for wide use, as it's a good example of learning from the past and takes everything that works and leaving what doesn't. It still misses the mark in a few areas but it's what I would consider the forerunner of languages to come.

This is of course all for main-stream consumption by the masses. C/C++ is still king for what is now considered low-level programming. But that is definitely not for everyone.

[0player]

Lua is crazily good, and one of my favourite games, Tales of Maj'Eyal (http://te4.org/), is written almost entirely in Lua. The tables are amazing concept for data representation, and syntax is so flexible, you'll probably find yourself twisting it sooner or later. Obviously, it has some dark corners, like the "local" word (why not the other way around? Why?), but all in all, it's pretty fun and fast, thanks to JIT.

Name something that is new to programming languages from the last decade.

For the record: C was invented four decades ago. Time flies fast. Amazingly, it wasn't that much of an innovation, but a child of its ancestor, BCPL. C was, I think, the first one to bring complex types to the table, but that's about the only innovation it got. It is still widely used (as a reference point, too) thanks to UNIX, and C calling convention which is simple to interface with.
Dynamic typing was pretty innovating, although you can say that LISP got it. The whole object-oriented buzz (originated in Smalltalk, 1970s, after C) was pretty big deal. Modules, which allow to organize code, originated in Modula-2, late 1970s. Portability, originated somewhere in 1990s, and still present in most popular PLs in one or another form. Haskell, The Revolutional Language that raised rapid interest to functional programming, of which all modern languages reap benefits: first-class functions, closures, templates, lambdas, released in 1985. Just-in-time compilation, which bloomed on the corpse on Self and in the Java Virtual Machine, saving our disk space and our time, in 1999. Read-eval-print loop, the glory of which will penetrate the centuries, as will the shame of languages who still don't have them (cannot pinpoint its birth, but probably Haskell). LINQ, an amazing concept by Microsoft, and its blood brother, list expressions, for non-.NET languages. Coroutines, and concurrency support in general, a solution to many deadlock and stall situation. Generators, which allow saving the state for later without any fuss. Transactional memory, which is yet to bloom, but is already firmly standing on its legs. Laziness, introduced back in 1976. Distributed programming and its angel, Erlang. If it's still not enough, tell me, I'll come with more.
The last decade brought us:
- further development of functional programming, metaprogramming, concurrency and distributed programming. Yes, development is "something new";
- reflection, reification and metaprogramming at its finest;
- researches on massive parallelism;
- breakthroughs in JIT and aforementioned transactional memory;
- Unicode;
- Rust, with its hardcore type inference, the notion of variable lifetime, and unique types.
That's ones Im presonally intereseted in.

[garrak_x86]

Name something that is new to programming languages from the last decade.

Soo, how do you make function calls by reference in C (lambdas, not c++!)? Just wondering.

Well, and just because i feel like it, here a second thing: native multithreading support for at least some functionality (not handling multithreading by yourself for big heaps).

To be explicit on this. There's nothing which wasn't "possible" long time ago, since high-level languages are just that, a more abstracted version of the stuff that is going on in the background, with the goal to be more productive. Performance wise, it is not possible to abstract some concept without also loosing some cycles.
But the hardware architecture didn't change also, did it? (in means of what basic components are used, that is).

Welp, back to topic. I used LUA just in Computercraft / coding my keyboard. I didn't like it that much. The native functionality is kind of limited* and i personally didn't like the syntax. I really enjoy doing stuff in Python / Javascript / PHP though.

* may be, because i didn't find any nice info-pages for it, but since that's a part of developing stuff.....

[PatriotBob]

The last decade brought us:
- further development of functional programming, metaprogramming, concurrency and distributed programming. Yes, development is "something new";
- reflection, reification and metaprogramming at its finest;
- researches on massive parallelism;
- breakthroughs in JIT and aforementioned transactional memory;
- Unicode;
- Rust, with its hardcore type inference, the notion of variable lifetime, and unique types.
That's ones Im presonally intereseted in.

I hate to snip all that but I must for the sake of space. These points all kinda reinforce what I said. As you pointed out, all "new" developments of programming languages in the past decade are really just distillations of what's already come. Every single feature you listed was done first by a previously langauge. I would go item by item, but you've already listed them all.
So yeah I guess my argument really boils down to that I don't consider progress in an existing feature, something new. I wouldn't ever argue programming isn't make interesting progress. Just that as a profession, the defining points have already come. The argument that progress makes it new is kinda weak in my opinion. That would mean anything not completely dead is always new.

But yeah, can we all at least agree that the core aspects of programming all stem from the languages all long dead? (more or less)

[Gilberreke]

Just to name a few things:

- C was released around 1972
- Strong typing on which all OO languages are based was conceived in 1974 (AFTER C and that's conceived, not implemented)
- In fact, almost every object-oriented concept was conceived after C's invention.
- All concurrent based programming as a language feature was invented in the 90's and only got traction in the last decade
- Aspect-oriented programming is seeing a lot of real-world use, the concept was invented in the 90's
- Prototype-based programming was invented over a decade after C and only received traction years later

That's just a few of the concepts that are in super widespread use and none of those were invented before C, some of them over two decades later. I can give you tons more examples, that aren't in widespread use yet, but you wouldn't accept those as significant innovations, so I'll wait 10 years to tell you "I told you so". An example is decoupling contracts from data, which is seeing some radical new innovation and might just become an important paradigm down the line.

But the language has some large inherent flaws that will prevent it from seeing major use

It's only the most widespread, most-used and most popular programming language in history, it has still to see major use </SARCASM>

[PatriotBob]

- C was release around 1972
Correct
- Strong typing on which all OO languages are based was conceived in 1974 (AFTER C and that's conceived, not implemented)
LISP (1958) Smalltalk (1972) and C (1972) are all object oriented languages
- In fact, almost every object-oriented concept was conceived after C's invention.
Nope, see above.strides
- All concurrent based programming as a language feature was invented in the 90's and only got traction in the last decade
LISP? Functional languages are inherently able to be run concurrently.
- Aspect-oriented programming is seeing a lot of real-world use, the concept was invented in the 90's
This one is actually an interesting point. Over a decade ago, but still. I have to dig more into the origins of this.
- Prototype-based programming was invented over a decade after C and only received traction years later
This confuses me prototype languages don't provide anything. It's a somewhat different approach to achieving object oriented concepts.

Programming has developed quite incrementally for almost the past 50 years. The major innovations where really made in the first 2 decades. Yes we regularly improve and increment on these core concepts. But I don't see any revolutionary progress, just refinement.

It's only the most widespread, most-used and most popular programming language in history, it has still to see major use </SARCASM>

http://www.tiobe.com/index.php/content/ ... index.html
It's not. And it's frequency of use does not have any bearing on whether or not that language has flaws. Look at PHP. Very popular, very terrible.

[Gilberreke]

LISP (1958) Smalltalk (1972) and C (1972) are all object oriented languages

I didn't say that OO was invented after C, just most of the major concepts like strong typing. Neither LISP or Smalltalk has strong typing.

LISP? Functional languages are inherently able to be run concurrently.

FORTRAN is able to do concurrency. That doesn't say anything. I said that concurrency as a language feature only came decades later. After all, we're talking about programming languages.

This confuses me prototype languages don't provide anything. It's a somewhat different approach to achieving object oriented concepts.

Not really true, I've read papers that easily prove that prototype-based programming is a super-set of object-orientation. It's more powerful and can express concepts that class-based languages can't. For example, it's trivially easy to express higher order kinds with prototypes.

Programming has developed quite incrementally for almost the past 50 years. The major innovations where really made in the first 2 decades. Yes we regularly improve and increment on these core concepts. But I don't see any revolutionary progress, just refinement.

You are somewhat correct that language development slowed down after the first rush where they found out most of the concepts, BUT it's simply not true that there's no revolutionary progress. Most of it is just not in mainstream use yet. In fact, it's a golden age of programming languages right now.

Beside that, you said that C was the last innovator to come by. I can't think of anything new that C brought to the table.

It's not. And it's frequency of use does not have any bearing on whether or not that language has flaws. Look at PHP. Very popular, very terrible.

Of course Javascript is not a beautiful language, but it has lambdas, it's a functional language, it has dynamic typing and it's prototype-based. For a stunted language it actually has some pretty advanced capabilities.

And the TIOBE index? REALLY? It's based on search engine hits. My point is that Javascript is available for more devices than C is. It's a language known to more programmers than any other language. It's probably in the top of most programmer hours spent writing it world-wide. It's embedded in applications themselves as a scripting language. It's the DE FACTO language of the Web. How is it not in major use yet, when it's arguably the biggest language we've ever seen?

[0player]

I hate to snip all that but I must for the sake of space. These points all kinda reinforce what I said. As you pointed out, all "new" developments of programming languages in the past decade are really just distillations of what's already come. Every single feature you listed was done first by a previously langauge. I would go item by item, but you've already listed them all.
So yeah I guess my argument really boils down to that I don't consider progress in an existing feature, something new. I wouldn't ever argue programming isn't make interesting progress. Just that as a profession, the defining points have already come. The argument that progress makes it new is kinda weak in my opinion. That would mean anything not completely dead is always new.

But yeah, can we all at least agree that the core aspects of programming all stem from the languages all long dead? (more or less)

Huh. No, I must disagree. Transactional memory -- last decade. Tracing JITs (as opposed to JVM-style; they are really very different) -- last decade. All features of Rust I named -- last decade.
Though 80s and 90s were more fruitful, it is expected; the first years of quantum physics development were also much more fruiful than the recent years.
I'd not agree on your last statement, seeing as:
- Fortran is considered mother of all programming languages and almost-first one, and is still widely used in numerical applications;
- C, which started the trend of "C-like" and coined the terms of "modularity" and "data-oriented programming", is still alive.
- Haskell, which started the trend of functional languages? Still alive.
- Smalltalk, the father of OOP? Not quite dead, too.

Also, "not being dead" and "breakthroughs in developments of core concepts" are kind of different.

- C was release around 1972
Correct
- Strong typing on which all OO languages are based was conceived in 1974 (AFTER C and that's conceived, not implemented)
LISP (1958) Smalltalk (1972) and C (1972) are all object oriented languages
- In fact, almost every object-oriented concept was conceived after C's invention.
Nope, see above.strides
- All concurrent based programming as a language feature was invented in the 90's and only got traction in the last decade
LISP? Functional languages are inherently able to be run concurrently.
- Aspect-oriented programming is seeing a lot of real-world use, the concept was invented in the 90's
This one is actually an interesting point. Over a decade ago, but still. I have to dig more into the origins of this.
- Prototype-based programming was invented over a decade after C and only received traction years later
This confuses me prototype languages don't provide anything. It's a somewhat different approach to achieving object oriented concepts.

Programming has developed quite incrementally for almost the past 50 years. The major innovations where really made in the first 2 decades. Yes we regularly improve and increment on these core concepts. But I don't see any revolutionary progress, just refinement.

- LISP and C are not object-oriented. They lack encapsulation and polymorhism, and yes, these are important features. C is often referred to as "data-oriented" or "procedural" language.
- Functional languages are not "inherently able to run concurrently", unless they don't deal with imperative world around, which they do. Also, fun fact: LISP is not functional language. It got "functional" features (like lambdas) which are just result of extreme code-data duality.
- Prototype languages are used more and more widely; though this is an approach to object-orientedness, it helps to deal with cases when objects can not really be classified. In fact, class-instance systems can be and are easily emulated by prototypes, but not vice versa.

[PatriotBob]

This is quickly deteriorating beyond usefulness. There's nothing new in Rust that wasn't possible before. JIT isn't an aspect of a language but the VM is runs on. Transaction memory, as non-hardware implementation has been around for a very long time. All I see in recent history, is the move of the burden of these features from the developer to the language maintainer.

The code written 30 years ago, is not dissimilar to code we write today. And I don't see that changing.
But I'll concede this argument, I don't see it serving a purpose for anyone else at this point.

[Gilberreke]

Fair enough. We do understand your point, almost everything was pioneered in the 60's.

But to say that we are still programming the same way we were in the 70's? Maybe you are, I certainly am programming in ways that weren't possible, even in the 90's.

[AdmiralJonB]

Soo, how do you make function calls by reference in C (lambdas, not c++!)? Just wondering.

Function Pointers. I hate the syntax for them, but they exist. I've used them a bit when I've been coding some weird stuff for my job. I must be one of the few researchers in my area in the world that code in C/C++ rather than MATLAB, but I'm all the more grateful I rarely have to use it. I can't stand MATLAB.

Code: Select all

int (*functionPtr)(int,int);
...
functionPtr = &otherFunction;
...
(*functionPtr)(4,2)

I think the one thing I did like about lua (and hated at the same time) was the way it handled functions as if it were just another variable. In ComputerCraft I ended up replacing the turtle api in my own code just by setting them to a different function and making sure I could handle the original usages (I wanted to track my turtle's position in its memory). I hate it because it means that if I write code, someone could just overwrite it easily and you could have real problems on your hands...

And as for if programming has changed in the last decade or so? From when I started learning programming as a young kid in the 90s till now, there's a lot less emphasis on making efficient code and more on making 'nice' code. Whether that's more object orientation, or what other forms, coding is a lot easier in many ways and forms. Even C++ has changed to accommodate this with C++11 introducing Lambdas and many other concepts that make certain tasks a LOT easier.

Gil, didn't realise there were that many papers on programming languages. You're making me want to start searching for some ^^.

[Gilberreke]

Gil, didn't realise there were that many papers on programming languages. You're making me want to start searching for some ^^.

It's a very active research area. I kinda just stumble unto them, so I don't have links for you. They can be found on most university research sites.

[garrak_x86]

And it's frequency of use does not have any bearing on whether or not that language has flaws. Look at PHP. Very popular, very terrible.

Lol'd, thanks. GLaDOS already said, i'm a terrible person, oh well, still getting my stuff done so it's fine. However, i understand that many people see the freedom to shoot yourself as a bad thing.

[...]Function Pointers. I hate the syntax for them, but they exist.[...]

Thanks for pointing that out. Made me go blurry a little though ;) (mixed those reference restrictions to some another language)