"Design" as practiced today by computer people tends to be heavily based on the idea of negative space: that good design is what's NOT in a system, and by extension, what is NOT ALLOWED TO BE ADDED to the system by a user.
A "design-heavy" system, then, is inevitably highly restrictive about user actions, lest they "ruin the cool design" by adding their own desired features that "make it messy".
But users WANT control over their own space.
Is there a "design" that empowers users?
hypercard was an amazing thing and i still miss aspects of it, but language-wise hypertalk suffered a lot from mistaken ideas about english-like ergonomics, i think.
right, but that's not using X *as X* or to interact *with* CLI. It's using X just as a set of terminals for CLI that's completely unaware of X.
X, the system (as I understand it), does not use CLI. It sends and receives messages of its own devising and format but doesn't expose these to the user or use the CLI or pipe system to do it (except for some command options for programs which are mostly now ignored)
Tcl/tk, though, I think does use Unix pipes?
and yeah, X is a giant weird beast and i've never actually written code against it in any meaningful way, but i use stuff like xclip, wmctrl, dmenu, rofi, etc., to control facets of it pretty routinely, so it's at least situated in a cli & scripting-driven environment that i use to control my own space.
Well, because X is about *graphical components* of which 'windows' are just one tiny, tiny subset
Like you might want your program to accept input from and send data to buttons? Grids? Charts? Images? Textboxes?
None of that is even really possible with the 'a simulated VT-100 running just inside a window' use case of X.
So CLI is not interfacing with X 'as X', just X 'as a VT-100'.
@dredmorbius @pnathan @brennen all of that though is probably possible with Tcl/tk and maybe with some of the oldschool CLI tools you mention? (which really, really don't get much press at all even among hardcore Linux fans)
like to properly represent the state of X as CLI I think you'd need at least an object model? cos things on the screen ARE objects, they have persistence and state
Maybe all I want is a modern Tcl/tk that works with all the shiny GUI toolkits and OOP systems?
@natecull @pnathan @brennen NB: I'm massively hampered in all this discussion principally by /never having really grokked GUI application design in the first place/. My sense of "application" has always been "something that works on a stream of inputs or polls regularly for state", but not "and presents this with a bow and cherry on top".
I could use pointers on some good books on GUI UI/UX. Don Norman seems to be one source. Brett Victor another.
It seems quite hard to think of how to encapsulate the IO flow and state of a GUI component.
ie the input stream could be a stream of events (mouse/keyboard or underlying widgets, data model) and a similar output stream... but it all seems a bit confused and intertwined compared to a simple script that reads a stream of records and writes a stream of updated records.
Could *maybe* separate the IO flow into 'channels' like 'standard output' and 'standard error'
For sufficiently simple stuff, I write utilities that I'd otherwise use a spreadsheet for. E.g., summing a sequence, or generating univariate moments.
excel is a funcprog environment that
1., normal people use, and normal people use to great effect to get things done
2. actually offers a non-linear way to do programming; instead of a linear program, you operate on cells of a 2D space containing either data or formulae, and operating on ranges is easy
adding VBA was a terrible mistake that added complexity and inelegance
I'm contesting that it's a /good/ FPE.
It is *VASTLY* too error-prone and difficult to debug. Not to mention awkward. OTOH, *it is often the only tool available since "real" programming tools are denied to front-office workers.*
Ray Panko, Univ. Hawaii, has studied Excel errors since the 1990s:
I think perhaps copying ideas from SQL for structure and drilldown would be interesting (another funcprog environment with good ideas, but clumsy tooling; SQL feels like funcprog if it were implemented by programmers who only used COBOL, and half the functions are missing - i'm convinced SQL is also why people swear of RDBMSes to the point of using Mongo et al)
those caveats do matter, though. my hunch is that mostly people get lured into garbageware like mongo because sql rdbms systems make manipulating schema a difficult, largely out-of-band sort of task relative to most of their interface.
@brennen @natecull @dredmorbius @pnathan see, I always think talking about "schemaless" is a red herring when it comes to NoSQL - it's really about SQL as a query language & about making the DB just plain ol' serialization of Plain Ol' Objects - this is easy for a programmer, and it's a *schema*, typed language or not
SQL is only lovable if you're a 70s DBA. I'd want a modern RDBMS protocol of sorts, that makes queries and serialization easy - with strict schemas, since the other end has those
@brennen @pnathan @dredmorbius @calvin yeah, a database where defining a schema is an out-of-band operation seems a little like a functional programming language where you can't pass functions to functions.
One of the defining characteristics of data is that it exhibits recursive structure: things inside other things.
RDMBSes in the SQL model, however, are built assuming that there are certain Things (databases, tables) which May Not Ever Be Put Inside Other Things.
@natecull @brennen @pnathan @dredmorbius well, hierarchial DBMSes exist (a lot of NoSQL can be considered as such) but then you lose the advantages of RDBMSes. the problem is that mappings in SQL between tables are clumsy. what if RDBMSes had typed pointers between objects that made it easier to related between objects between tables?
Relational 2D data is convenient. It does /not/ fit all sets of circumstances. Normalising hierarchical data may or may not be possible. And often you're dealing with a cross of "what is present state" and "what is most recently-added transaction" (or "what is the full transaction history"?)
At which point you realise that it was easier for the programmers *then* to simply duplicate the paper record in electronic form than to rationalise it.
so it's naturally a lot simpler to work with 'an object full of objects full of objects'
'a database, which I gotta get my RDMBS administrator to spec a server and provision for me and define a schema which if I ever then change I gotta file a helpdesk request to do it and butwhooops the user just put a new data type in and crap...'
ANYWAY, this thread is a lot of fun but now i'm going to go fuck around with a pile of music gear i don't understand, which is probably also a good place to think dark thoughts about the state of interfaces and modularity.
yes and yes.
I keep thinking that JSON is the new '80-column IBM card'.
It's terrible, but it's at least a defined 'plug shape and pinout'
so data stores are gonna assume it as the 'shape' of the data they store, just like 80-column screens and text files stayed the standard well into the disk and VDU era
@natecull @calvin @dredmorbius @pnathan @brennen To me, many of the problems of SQL arise because of how we use it: 1. Very restrictive with permissions. How much easier to solve problems if you can creat a ton of temporary tables. How much easier the queries. 2. Embedding it in apps. It’s like embedding vi in an app. Useless! But using it directly is cool. Like having awk and creating new files is cool. But better.
@kensanata yeah, perhaps. i do use (and like) sqlite for some stuff, but the limitations are real. i really haven't followed up on these thoughts by incorporating a relational db into much of my personal stuff, so i'm not honestly sure how much i'd feel those constraints if i just used sqlite for more things.
I think the argument is that SQL is a tool for working with and analyzing data like vi(m) is a tool for working with text files. So embedding SQL into a program artificially solves the problem by shoehorning in a tool's "interface" (magic strings) and at the same time introduces tons of second order concerns (sanitization, etc) as well as domain-specific middleware.
@dredmorbius @wrenpile @kensanata I think your statements/questions are orthogonal. SQL and RDBMS aren't coupled. No one is arguing against "SQL is a general data language". But is embedding SQL into binaries a good thing? Does that answer depend on ORM support for the language? Or sanitization libraries? Or sharding libs? I'd argue SQL-RDBMS coupling and SQL-as-a-general-data-language are orthogonal to these concerns.
@wrenpile I don’t mind embedding SQL in apps given that I don’t want two different ways to access data in a database. Being able to copy and paste SQL statements from source code and trying them in a general REPL is great for debugging. For people who come from a strict programming background (Java only for example) the embedded SQL (strings, no type safety, no compilation) is abhorrent. That’s why we have Java based QL now and it makes debugging hard. 😒
@kensanata Thanks for clarifying.
When you have a complex query with multiple joins and subqueries, having a REPL is vital not just for debugging, but also for prototyping.
As for Javaworld snobbery toward SQL, hey, SQL SELECTs are functional programming, and Java is … ?
@wrenpile Haha. Well, what can I say. At the office they are all gung-ho about getting rid of SQL statements and replacing them with a QL that generates the statements and thus guarantees type safety (database tables generated from interfaces and bind variables generated from the same interfaces). I tell them that this catches the kinds of errors I don't make and makes my life more difficult regarding the errors I do make, but it's not helping.