The Evolution of Lua, Continued [pdf]

I still prefer Lua personally. Their type system is easy for me to understand

Performance is up, but so is my inertia. So while TCL 9 could be transformative, for now it remains a white paper I've skimmed, not a revolution I've implemented.

https://www.usenix.org/legacy/publications/compsystems/1994/...

>Elk, the Extension Language Kit, is a Scheme implementation that is intended to be used as a general, reusable extension language subsystem for integration into existing and future applications. Applications can define their own Scheme data types and primitives, providing for a tightly-knit integration of the CIC++ parts of the application with Scheme code. Library interfaces, for example to the UNIX operating system and to various X window system libraries, show the effectiveness of this approach. Several features of Elk such as dynamic loading of object files and freezing of fully customized applications into executables (implemented for those UNIX environments where it was feasible) increase its usability as the backbone of a complex application. Elk has been used in this way for seven years within a locally-developed ODA-based multimedia document editor; it has been used in numerous other projects after it could be made freely available five years ago.

Also Gnu Guile:

https://en.wikipedia.org/wiki/GNU_Guile

>GNU Ubiquitous Intelligent Language for Extensions[3] (GNU Guile) is the preferred extension language system for the GNU Project[4] and features an implementation of the programming language Scheme. Its first version was released in 1993.[1] In addition to large parts of Scheme standards, Guile Scheme includes modularized extensions for many different programming tasks.[5][6]

Also Winterp, which used XLisp:

https://dl.acm.org/doi/10.1145/121994.121998

>Winterp is an interactive, language-based user-interface and application-construction environment enabling rapid prototyping of applications with graphical user interfaces based on the OSF/Motif UI Toolkit. Winterp also serves as a customization environment for delivered applications by providing a real programming language as an extension language. Many existing user-interface languages only have the expressive power to describe static layout of user interface forms; by using a high-level language for extensions and prototyping, Winterp also handles the dynamic aspects of UI presentation, e.g. the use of direct manipulation, browsers, and dialog. Winterp makes rapid prototyping possible because its language is based on an interpreter, thereby enabling interactive construction of application functionality and giving immediate feedback on incremental changes.Winterp's language is based on David Betz's public domain Xlisp interpreter which features a subset of Common Lisp's functionality. The language is extensible, permitting new Lisp primitives to be added in the C language and allowing hybrid implementations constructed from interpreted Lisp and compiled C. Hybrid implementation gives Winterp-based applications the successful extension and rapid-prototyping capabilities of Lisp-based environments, while delivering the multiprocessing perfor- mance of C applications running on personal Unix workstations.

And TCL/Tk of course!

https://www.tcl-lang.org/

And on the commercial side, there was Visix Galaxy, which was extensible in PostScript, inspired by NeWS:

https://www.ambiencia.com/products.php

https://0-hr.com/Wolfe/Programming/Visix.htm

https://groups.google.com/g/comp.lang.java.programmer/c/LPkz...

https://donhopkins.com/home/interval/pluggers/galaxy.html

https://wiki.c2.com/?SpringsAndStruts

>The Visix Galaxy project was a ridiculously overpriced and overfeatured portable GraphicalUserInterface. You could do things like swivel an entire panel full of their custom widgets 32 degrees clockwise, and it would render all its text at this new angle without jaggies. The company went out of business after gaining only a handful of customers. For USD$ 10,000 a seat they sure didn't see the OpenSource movement coming. Their last attempt before going under was (guess what?) a Java IDE.

Galaxy competed with Neuron Data Systems in the "cross platform gui framework" space (which got steamrolled by the web permanently and for a window of time Java):

https://donhopkins.com/home/interval/pluggers/neuron.html

Here is a great overview of User Interface Software and Tools by Brad Myers:

https://www.cs.cmu.edu/~bam/uicourse/2001spring/lecture05too...

https://www.cs.cmu.edu/~bam/toolnames/

https://docs.google.com/document/d/1hQbMwK_iyjX-wpu_Xw_H-3zL...

It's a Long Now Foundation thing: slower, deeper, longer. Y10K compliance.

https://longnow.org/ideas/long-now-years-five-digit-dates-an...

"The present moment used to be the unimaginable future." -Steward Brand

"How can we invest in a future we know is structurally incapable of keeping faith with its past? The digital industries must shift from being the main source of society’s ever-shortening attention span to becoming a reliable guarantor of long-term perspective. We’ll know that shift has happened when programmers begin to anticipate the Year 10,000 Problem, and assign five digits instead of four to year dates. 01998 they’ll write, at first frivolously, then seriously." -Steward Brand

10,000 Year Clock:

https://longnow.org/clock/

- Microsoft Java Virtual Machine: https://en.wikipedia.org/wiki/Microsoft_Java_Virtual_Machine

- Visual J++: https://en.wikipedia.org/wiki/Visual_J%2B%2B

https://cs.gmu.edu/~sean/stuff/java-objc.html

.NET was being designed with J++, Microsoft's Java extensions, Cool research language only became C# and took over J++'s role in .NET due to Sun's lawsuit.

The lawsuit is more than well known, and the background to .NET planned used of .NET is on the papers published by Don Syme of F# fame, regarding the history of .NET and F# HOPL.

That's also solvable using metatables.

Lunacy also has a few built in libraries which are not included with Lua 5.1, such as binary bitwise operations (and/or/xor). It also fixes some security issues with Lua 5.1 (better random number generator, hash compression algorithm which is protected from hash flooding attacks).

In addition, I have made a tiny Windows32 binary of Lunacy.

Don’t worry about the Lunacy changes; all of the examples in the book work with bog standard Lua 5.1 with a bit32 library (bit32 is common enough most OSes with a Lua 5.1 package also have a bit32 package for Lua 5.1).

> It's aimed at programmers who have some experience but are just starting out with game development, or game developers who already have some experience with other languages or frameworks but want to figure out Lua or LÖVE better.

Also on the topic of game engines with lua scripting, the wonderful Defold always deserves a mention https://defold.com/

None of these are published because the popular ones are better and provide more functionality, but I want to share what I believe is more valuable: what I learned while writing them.

  [ (x) | x ]

And for Lua 5.1:

http://lua-users.org/files/wiki_insecure/power_patches/5.1/l...

(I personally don’t use patches like this because “Lua 5.1” is something pretty standardized with a bunch of different implementations; e.g. I wrote my Lua book with a C# developer who was using the moonsharp Lua implementation)

The implicit conversions is a definite footgun tho.

That was not my experience when I was working with lua. Did anything change since? Asked google. Answered :

> In Lua, if a variable is assigned a value inside a function without being explicitly declared with the local keyword, it will automatically become a global variable. This is because, by default, all variables in Lua are global unless explicitly specified as local.

All of that is trivial when you consider the Lua reference implementation. It is beautiful.

As a scripting language for browsers this is an antifeature, and the fact Lua comes by default with a bunch of features that allow loading arbitrary binary code in the process makes it pretty annoying to properly use it as a sandboxed scripting language.

I love ++, but you know what? I was shocked when a co-worker pointed out that it is frowned upon to use ++ in javascript. It some big companies, their linter settings mark ++ as something that should be changed.

https://eslint.org/docs/latest/rules/no-plusplus

"But, just write good code" you will say. Just like with Perl, some languages are designed in a way to discourage writing good code...