I remember SQLWindows of Gupta Technologies (later renamed to Team Developer of Centura Technologies IIRC) which had an outline IDE. Quoting from https://yagnipedia.com/wiki/sqlwindows :
> SQLWindows had an outline-based code structure — not braces, not BEGIN/END, but an indented tree that was simultaneously the code and the IDE’s display. You wrote code by expanding and collapsing outline nodes. Classes were outline headings. Methods were sub-headings. Code lines were leaf nodes. The entire program was a hierarchical outline that the IDE rendered as a collapsible tree.
And corporate UX/Design teams are eager to modernize those cards; yes they're already flat, but canary yellow is so last century and some glass effects or abolishing the rounded corners will be the next thing.
Do you have a real-world example where we would like to preserve `$?` after the `if` (which `if` specifically branches on the result code of the command it tests)? Where we want to use the actual return code that the `if` did not handle itself.
I am asking because I have never needed preserving the `$?` outside of an `if`, nor have I ever seen this in somebody else's scripts, and I'm curious.
I believe you missed a semicolon after `exit 1` and before `}`. `}` closes the opening `{` only at the start of a command (POSIX rules; don't remember now if bash recognizes it when it's just a command argument).
Commodore 64 was quite popular in Europe too, but I believe more successful was the Sinclair Spectrum (and some copycats behind the iron curtain).
In my case, too, it was the Speccy and later the Sinclair QL, when it got really affordable; I owe my life to the QL :)
And in eastern Europe, due to economical reasons, its popularity extended well into the 90s. There's a whole group of people that grew up with the Commodore that are a decade younger than their western peers.
Yep. My father build a ZX Spectrum clone for me somewhere around 1991. Few years later he also got Commodore 64 as a gift from German engineers he was working with.
I think both of these machines are really good for learning BASIC: much fewer distractions, you type commands and computer does something.
Speccy for me too, and most of the local people I knew.
Aged 11, going through the ring-bound orange manual just after Christmas, because the cassette-player we had was broken. When a replacement was obtained in the new-year I started playing games with my sisters, but I'd already been "forced" to play with BASIC and I never really stopped..
> Speccy for me too, and most of the local people I knew.
Dundee? :-D
There's a theory made popular by Chris van der Kuyl (his dad Tony owned an Apple II, the first home computer I ever used - I played the Lemonade Stand game on it in his kitchen) that the reason Dundee is that everyone had a ZX Spectrum and so anyone with any talent got good at programming them.
And why did everyone have a ZX Spectrum in Dundee? Because they were made in the Timex factory just off the Kingsway (the building is still there, it's a furniture factory now), and everyone's dad knew someone who could "get" a Spectrum for them, bypassing the usual supply chain hassle.
The Planet Bar in Lochee probably shifted more units than John Menzies ever did.
I grew up in Yorkshire, though I'm half-Scottish there's no link to Dundee!
But the Spectrums were the best-selling UK machine at the time, so I'm sure there were lots of regions where they were super-common.
I think I had a friend with a BBC Micro, but I can't recall anybody else having something different.
(There was a bit of console-split later, between NES and Sega Megadrive, and later still between Atari/Amiga, before we all settled for big grey boxed PCs.)
Exactly. In cases where I expect long-running parallel connections from separate processes to the same sqlite file, I make sure that all read transactions do `BEGIN DEFERRED` so `COMMIT` releases the read locks, and all write transactions do `BEGIN IMMEDIATE` so that `SQLITE_BUSY` timeout is not side-stepped.
There was one case where all transactions were implemented using nested `SAVEPOINT bla` so `BEGIN IMMEDIATE` could not be used without more hassle, so this ended all “I know I'm going to write” transactions to instantly update a single-row table so that their lock would not begin as DEFERRED and eventually switch to `IMMEDIATE`; this way almost all `SQLITE_BUSY` side-steppings disappeared. (timeout was set to 30 seconds but all read/write transactions were instrumented to have less than 5 seconds duration).
lol, I briefly thought of such a technique, but in the end, found it simpler to just use a synchronization primitive at the application level to serialize db access on transactions where I knew I was going to write. it amounts to about the same honor code.
> I once had to clean up a project where some code had accidentally been writing the strings '1' and '0' to a column which was intended to store booleans (1 and 0). That was not a fun debugging story.
So this was a write to a column that did not have INTEGER affinity. If it was intended to be used as a boolean, then it should have INTEGER affinity. I know because I've tried hard to enter integer- and float-like strings as strings in INTEGER affinity columns, and I haven't managed to; I could only insert them as BLOBs, or prefix the string with say '\' and check/remove at the application level. (That was for an ontology-like database, where table EAttribute.eatvalue could have any type.)
Elastic tabspots everywhere would be ideal. But in the real world I think 'tabs to indent, spaces to align' is the superior way, as every dumb text editor will support it.
> SQLWindows had an outline-based code structure — not braces, not BEGIN/END, but an indented tree that was simultaneously the code and the IDE’s display. You wrote code by expanding and collapsing outline nodes. Classes were outline headings. Methods were sub-headings. Code lines were leaf nodes. The entire program was a hierarchical outline that the IDE rendered as a collapsible tree.