1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
# Teliva - an environment for end-user programming
> “Enable all people to modify the software they use in the course of using it.”
> — https://futureofcoding.org/episodes/033.html
> “What if we, and all computer users, could reach in and modify our favorite apps?”
> — https://www.inkandswitch.com/end-user-programming
> “Software must be as easy to change as it is to use.”
> — https://malleable.systems
## What's this, then?
An extremely naïve, [brutalist](https://en.wikipedia.org/wiki/Brutalist_architecture)
attempt at packaging up simple [Lua](http://www.lua.org) ([5.1](https://www.lua.org/manual/5.1))
apps with all the stuff needed to edit and build them.
```
git clone https://github.com/akkartik/teliva
cd teliva
make linux
src/teliva hanoi.teliva
```
Here's an example app (the [Tower of Hanoi](https://en.wikipedia.org/wiki/Tower_of_Hanoi)):
<img alt='screenshot of Teliva running the Towers of Hanoi' src='doc/hanoi.png'>
No matter what app you run, you are always guaranteed access to a single
obvious, consistent way (currently the hotkey `ctrl-e`) to edit its sources.
And to run the updates after editing.
<img alt='screenshot of Teliva editing the Towers of Hanoi' src='doc/hanoi-edit.png'>
Toggle the same hotkey to restart the app with the new sources.
Over time I hope to improve the experience for error messages, failing tests,
undoing changes and so on. The emphasis will be on maximizing hackability
rather than functionality. In addition to Lua 1.5, this repository currently
packages:
* The [ncurses](https://tldp.org/HOWTO/NCURSES-Programming-HOWTO) library for
building text-mode user interfaces. ([Alternative documentation](https://tldp.org/LDP/lpg-0.4.pdf))
* A port of the [lcurses](https://github.com/lcurses/lcurses) library
providing Lua bindings for ncurses. ([Documentation](http://lcurses.github.io/lcurses))
* The [Kilo](https://github.com/antirez/kilo) text editor. ([With a fantastic
walk-through.](https://viewsourcecode.org/snaptoken/kilo))
Send all praise to them, brickbats to [me](http://akkartik.name/contact). I
plan to be extremely parsimonious in taking on further dependencies.
## Isn't this just an IDE?
There's one big difference: these apps are not intended to be runnable outside
of the Teliva environment. Editing the sources will always be a core feature
that's front and center in the UI.
At the moment this isn't much of a restriction given how trivial the
differences with Lua are. You also don't get much benefit in exchange for
taking on this restriction. Let's see if that changes.
A second, more subtle difference: it's primarily an environment for _running_
apps, and only secondarily for editing them. Starting up the environment puts
you in a running app by default. Creating an app from a clean slate is a
low-priority use case, as is lots of specialized support for developing
complex apps. The sweet spot for Teliva is simple apps that people will want
to edit after using for a while.
## Why Lua?
It's reputedly the fastest interpreted language per line of implementation
code.
## Will it run any Lua program?
Not quite. My priority is providing a good experience for newcomers to
comprehend and modify the programs they use. If it's not clear how to provide
that experience for some kinds of Lua programs, I'd rather disable support for
them in Teliva and let people use regular Lua (or other languages and
environments!) for them.
- This approach doesn't make sense for batch programs, I think.
- I don't know how to obtain a simple, shallow graphics stack, so there's no
support for graphics at the moment.
- Teliva initializes the ncurses library by default, so apps should assume
they have access to a text-mode window for printing text to, and a keyboard
for reading unbuffered keystrokes from. Compare `hanoi.teliva` with
`hanoi.lua` to get a sense for what changes are needed.
- I want to provide sandboxed access to system resources (file system,
network, etc.) which will likely create incompatibilities with the standard
library. I'm disinclined to try to ‘improve’ on Lua syntax,
however. It's not my favorite, but it's good enough.
Teliva is not tested much at all yet. This is my first time programming either
in Lua or within Lua. So bug reports are most appreciated if Lua programs
behave unexpectedly under Teliva.
## Will it run any ncurses program?
Hopefully. ncurses is extremely portable; I don't test on all the
configurations ncurses supports. In particular, I assume terminals with colors
and UTF-8 support.
## Will it run any Lua [lcurses](https://github.com/lcurses/lcurses) program?
There will likely be some exceptions that I'll record here as I encounter them:
- lcurses has some strange “smarts” that result in
`window:getch()` not behaving like the global `curses.getch()`. Teliva is
consistent with the underlying ncurses.
## What's with the name?
Teliva is the Tamil root for ‘clear’. Very much aspirational.
|