alexisread

Couple of things here, you're discounting completely the effect of distributing the passenger load across a network, secondly there's no reason why small minicars can't run on the network on high-traffic routes in addition to the smaller ones.

The important points are:

Point-to-point unlike trains (hub-hub) and busses (every stop). As a result, load is distributed across the network. Small offline stops like busses. Complements other systems (tube, freight trains etc.) - if you can separate freight from passenger rail that's a massive win (eg. capacity, schedules). In-car switching lowers headway, does not require centralised coordination. Cars do not need to park - recycled on the network. Sleeper cars. Cars can go direct from warehouse to local shop, as the small cars can berth inside the warehouse/shop for loading/unloading. Power supplied in-track, possibly with backup batteries, but not neccessary depending on implementation. Separate track from pedestrians etc. Prefabbed track for quick build-out and maintenance. Rail and road require preparing the surface rather than driving poles into the ground. Separated steering, load, drive systems, unlike rail which has to compromise with a single conical wheelset. No derailment. Tighter turning than busses and trains, so you can fit it where they cannot go, note we don't always need to run at high speeds in cities, only intercity. Suspended systems can easily tilt - better ride comfort and tighter turning at high speed. Weatherproof, more so than bus or rail. More tolerant of natural disasters if above grade (flooding, earthquakes etc). Better land use if pole-mounted, lighter cars (say 20 people max) than light rail allows lighter-weight structures, and hence lower wear and noise. Heavy vehicles wear roads and rail much faster.

Dumb cheap rails, only power, no switching or coordination. This is a big cost for trains which need to rely on slots and schedules. Coordination is done via protocols to allow for decentralised on-demand use. 3D track allows say transport to halfway up a building. If you have dual-size compatibility (big and small) this allows individual parcel delivery, recycling collection, use in factories etc. with the small system.

Conventional trains cannot do any of these things (tilt is not as good). Yes they are THE most efficient at transporting large numbers of people / freight from eg. the Superbowl, but history has shown they are far from a complete solution.

The features I'm talking about here are not gadgetbahn ideas, they are real advantages for what is a new system, not a car, a bus or a train. This can complement existing systems. Cost is a misnomer when you factor in switching and coordination for busses and rail. Last mile becomes much less of a problem. Pitching a more personalised transport is easier. If you standardise the track and protocols you can have many companies building it. You can run fibre, power, solar panels (if suspended) in the same track for infra buildout in 3rd world countries.

For comparison, the numbers for an example system: At full occupancy (which seems to be what everyone quotes for rail, discounting economies of running routes off-peak etc.) 20 people with 10sec headway = 7200 people /hour on one rail. If we say we can fit 2 rails per train rail width-wise and another 2 heightwise, that's 28800 people down the same railtrack profile, which is comparable.

This is also leaving out platooning eg. Virtually coupling 2 cars together, so slightly longer platform which doubles your throughput to 57600. This is different to a train as platooning is a temporary arrangement.

Given a 2min loading time, you would need say 12 platforms to support this from a single station, but that's normally aggregated from multiple stations funneling into the same track, so you'd only require that at terminuses for instance.

No you don't have to converge to that. Railways and trams tend to be defined by track switching. In-car switching creates a different class of system as the track is dumb, headways can be much tighter, and with a network of rails you don't have to go to a central hub, to go to another central hub, to then go to where you actually want to go.

Stations can be frequent and offline, individual transports can be smaller to transport a family / sleeper car / pallette-load of goods, land use under the track becomes available ie. new routes over farmland become viable, tracks can cross easily in 3D, and can as they are prefabbed, a line can be constructed and repaired quickly.

Although it's (IMHO) not ideal, https://openprtspecs.blogspot.com/2011/11/climbing-chain.htm... can give you an idea of the possibilities.

Freeforth (implicit) and Ableforth (deliberately explicit)

TBH this is a good case for Linq-style queries, over SQL-based ones. Linq style allows you to narrow the query deterministically vs Sql eg. Mytable1.select().where().join(mytable2)

This applies the filter before the join, compared with:

Select from mytable1 join mytable2 on... Where...

Which relies on the query plan to resolve the correct application of where, and hope it puts the where before the join.

This becomes more important in the cloud, where Iceberg tables cannot be benchmarked in the same way as single-cluster relational DBs.

It implements defining words ie. Additional compiler words.

It does this by doing something now, and later (you could read create does> as now later>)

So for

: CONSTANT CREATE , >DOES @ ;

This makes the defining word CONSTANT, which when run (now) compiles the next word

So CONSTANT myvar will compile myvar. Myvar, when run (later) will get it's value and push it to the datastack.

You can replace it, there are two (nearly 3) forths that replace it:

https://github.com/dan4thewin/FreeForth2/blob/master/ff.asm

which uses a double loop to lookup first macro words, and then immediate words

https://github.com/ablevm/able-forth/blob/current/forth.scr

Ableforth implements a defer/expand operation \ to effectively quote words. The basic loop is then simply parse a text word, look it up and execute it.

Both make use of macros (code generators) to implement deferred behaviour, as well as code inlining. Ultimately all these operations implement defer by manipulating the execution flow, something that algebraic effects also do.

I have a feeling that algebraic effects can be used in a Forth to implement DOES.

There have been a few. Maybe this one? https://youtu.be/Z3We5h8pt0Q?si=btvxgZhPqDkTqNEc

The UK trialed a cassette version here https://youtu.be/4qqnHtH1RAs?si=Y9dKvKtwPVXheLWU

That's a nice take. Implicitly though, that implies treating words not as functions but as coupled routines, possibly because forth is untyped.

If anything goes wrong during development you need that model of the stack in your head to debug- I think that's the main differentiator, and if you had a typed forth with local variables, it would enable greater readability ie. I can scan the individual words/ functions without needing that stack model.

Just my POV, not sure if that resonates?

Nothing involving forth (only Java really) where I'm working, but I wanted to send some appreciation for Embed forth (meta-compiler), the documentation is particularly good :)

The code will be polling the input, so it's effectively quantized, and games can treat movement as a vector. Seems to work ok: https://www.youtube.com/watch?v=atHTzwcx4Og

Obviously it'd be better to have a protocol like the megadrive, but given the setup in the ST, this is a hack without having to change the ST hardware.

You have a point, but the ST bottleneck during development appeared to be the software, so there was possibly space for hardware tweaks. The BOM would go up slightly but remember they would have saved on developing and shipping a separate disk drive which would cover a lot of these changes.

Realistically it's amazing the ST was as good as it was, given the 6 month development time and the kings of penny pinching at the helm :)

On the right (ie. Mirror of the STE 15pin ports) would mean that they could keep the electrical layout ie. Connected to the keyboard, and hence a separate keyboard unit. For 2 player games you would be swapping it a lot- there were adapters just to help with this.

I agree it would be difficult to design a correct socket, but from interviews it was always the plan to have a blitter, and a socket as standard would have helped adoption.

The main thing is that the T212 is a great coprocessor, faster than the 68881 fpu and with a 2k cache. Introducing the transputer as a coprocessor would potentially have changed the computing landscape

Just that you can't go up and down at the same time, so it's a valid electrical signal for another button, and importantly standard so games would take advantage of it.

So many missed opportunities with the ST, given the breakneck development speed.

If the all-in-one design was used from the off (save on moulds and shipping disc drives) they could done a pro conversion kit:

https://youtu.be/atw3FYKzog4 Also, move the joystick ports to the right rather than under the keyboard.

A few tweaks here and there would have pushed it a lot more:

Unified clocks for genlock and scrolling: https://youtu.be/yexNdSLEpIY?si=pa46sJOr_9Fin4LC

Stereo output like the CPC464: https://m.youtube.com/watch?v=0yY4BlPfLf4

AMY included, along with a 1bit PWM on the DMA chip for DMA sound.

The ST had a janky RTC anyway: https://atariage.com/forums/topic/303859-battery-pack-inside...

3 button joypads from the start, using U+D and L+R combinations for 2 more buttons

Double-sided drive from the start.

Finally, they should have included the blitter socket and a full 2x32pin expansion instead of the cartridge port. The blitter socket especially would be handy to drive a T212 transputer in 87, when the blitter was available, instead of producing the ATW.

Looks nice, but it should really say single RGB camera AND a boatload of processing power. TLDR the camera feeds 1280x720 images at 120fps to a PC (with graphics card). While you could reduce this to an on-chip processing block, it will also have to deal with people looking away halfway through typing etc. which adds to the processing overhead, and requires integration with the headset (6 axis sensors etc.).

IRL this has been somewhat tried with the Humane AI pin, with gestures, less than instantaneous response is noticeable, so latency has to be paramount.

Don't mean to rain on the parade as it's a nice piece of work, but comparing to say chording (low cpu requirements, better accuracy, faster, but you have to learn how to chord) shows the different tradeoffs.

>>>Throughout the book he makes the argument that if you remove the legal frameworks that enforced segregation, that people would over time choose to integrate as they found mutual advantage in doing so. Reasonable people can disagree with this assessment.

Not to weigh in on the quote, but as to this opinion statistics might disagree, and is kinda the basis for positive discrimination: https://ncase.me/polygons/

Try https://github.com/JohnEarnest/Mako/blob/master/docs/makoBas...

and

https://github.com/ablevm/able-forth/tree/current

In addition to the others mentioned here. It's a shame the able gui was not open sourced.

If you're looking at really from first principles, it's hard to beat forth systems. You can type in Plankforth (https://github.com/nineties/planckforth) in a hex editor ie. this can be built from zero software, by effectively morse-coding it into bare memory.

In terms of accessibility though, I'd recommend Forthkit (https://github.com/tehologist/forthkit), Miniforth (https://compilercrim.es/bootstrap/), Sectorforth (https://github.com/cesarblum/sectorforth), Sectorlisp (https://justine.lol/sectorlisp2/) Freeforth (https://github.com/dan4thewin/FreeForth2 contains an inlining cross-compiler for MSP430)

The problem with forths is that they don't seem as scalable as say lisp, from a social perspective. At a larger level, Project Oberon (https://projectoberon.net/) builds from the base CPU on FPGA, and A2 (https://en.wikipedia.org/wiki/A2_(operating_system)) show what can be done to scale up.

Steps (https://github.com/robertpfeiffer/cola/tree/master/function/...) also was supposed to do this, but the available code is rather disjointed and not really easy to follow.

Playing devil's advocate here, but is that simply validation that stuff you've written is actually useful? This could be seen as a proxy for self worth, which if something is useful, helps stave off that nagging anxiety in the back of your head? The question here is, is that a useful driver to build new things, or do we let things go? That's kinda similar to the article's premise.

(takes one to know one here)

Have you looked at Kernel and wat? They use a fundamental operator (vau) to make macros, instead of a special form: https://github.com/manuel/wat-js

maru has this vau operator implicitly, rather than explicitly: https://github.com/attila-lendvai/maru

Actually, it can do a fair impression as well: Crownland has transparent parallax https://www.youtube.com/watch?v=dN5fSp0XGzI

You're right about the bonkers 3D! https://www.youtube.com/watch?v=qwcN9FraNjQ https://www.youtube.com/watch?v=KatdrdEVEwY&t=532s

I think the main thing was that Atari (pre83 company) abandoned the 8 bit line too early, and didn't make the 5200 cross-compatible.

Interestingly Wat (https://github.com/manuel/wat-js) handles Dynamic Variables, which fit well with serialized code, in that the serialization boundary can be better partitioned into variables you need to serialize (locals etc.), and environmental (dynamic) variables which are subject to their runtime env.

Wat also happens to have a good concurrency model, and a portable bytecode. Worth looking at in this space.

I'd guess the best approach is similar to security - minimal TCB (trusted computing base) that you can verify by hand, and then construct your proof checker on top, and have it verify itself. Proof and type checkers have a lot of overlap, so you can gain coverage via the language types.

I can't recall exactly, but I think CakeML (https://cakeml.org/jfp14.pdf) had a precursor lisp prover, written in a verified lisp, so would be amenable to this approach.

EDIT: think it was this one https://www.schemeworkshop.org/2016/verified-lisp-2016-schem...

Not sure that will swing it, have a look at https://github.com/JohnEarnest/Mako/tree/master Which is basically a Forth for games, that runs on the JVM, and in the browser.

The issue as I see it, is that you have to have a model of the datastack in your head at all times. That's fine for your own code, but for other people's code, stack diagrams will only take you so far.

The ability to scan code, rather than reading it, allow you to mentally drill down when you are ready. Forth requires immersion.

Something like https://xorvoid.com/forsp.html I'm guessing is really the bridge. Something that allows variables without being too complex.

Absolutely: https://www.transputer.net/tn/46/tn46.html

Too bad the UK gov were so shortsighted, or that Atari, instead of making the ATW (https://en.wikipedia.org/wiki/Atari_Transputer_Workstation)

should have simply used a T212 in the ST blitter socket as a coprocessor. That way people could have slowly gotten familiar with the arch :|

People are building new hardware to run transputers though: https://forums.atariage.com/topic/369254-pre-annoucement-atw... so maybe this amazing code can be resurrected on real hardware!

Edit: Found it. This is the paper on 3d parallel transforms: https://repository.arizona.edu/bitstream/handle/10150/611934...

Later transputers also had DSP instructions built-in.

1ct5 44t t5

One evolution of (You're probably aware of re:axisofeval) Kernel is Wat (https://github.com/manuel/wat-js), which implements the Vau operator (hygenic F-exprs), full delimited continuations (as opposed to the usual Shift/reset functionality of most lisp-based langs) and dynamic variables (variables which can break out of the usual lexical ie. compile-time scope and take environmental ie. runtime values).

It's quite fast with all of that. The continuations allow you to define promises, threads, channels, exceptions, branching and so on. Thing is, syntatically the continuations are required to carry quite a lot. Algebraic effects layered on top would have a nicer syntax.

Similarly, I would suggest that dynamic variables and continuations are more understandable in a forth-like language where the return and data stacks are first class. What's more, forth-like languages use a concatenative (streaming) syntax which allows streams to be more first class. Forsp (https://xorvoid.com/forsp.html) is such a language, that supports both lisp-like, and forth-like semantics

Furthermore, forth-like languages give you explicit parsing to be able to handle quasiquote and special chars etc. This parsing can be layered, you can have a low-level parser along the lines of able-forth (https://github.com/ablevm/able-forth), and a higher-level (word/function level rather than char level) parser like rebol (https://en.wikipedia.org/wiki/Rebol) /ometa (https://wiki.squeak.org/squeak/3930).

There's a lot more to say about GC, compilation steps, DSL towers, formal verification, meta-compilation and so on, suffice to recommend checking out the afore mentioned languages!

You might want to take a look at the piumarta branch of https://github.com/attila-lendvai/maru/tree/piumarta

This is Attila's attempt at more formally evolving maru through several iterations, and includes gezeira etc.

Personally I find able forth's meta compilation to be more manageable (https://github.com/ablevm/able-forth/tree/current)

But your mileage may vary :)

Disappointingly, the able gui etc was not open sourced, and I fear lost to time.

Most countries restarted funding when Israel did not produce any evidence of UNRWA malfeasance to back up their allegation.

The arabs within Israel do not have equal status to Israeli nationals, and less than any Jew who claims lineage but has no connection to Israel. Refugee status is also maintained by Israeli rulings about refugees from Palestine, in order to delegitimize right of return: https://en.wikipedia.org/wiki/Israeli_citizenship_law https://www.aljazeera.com/opinions/2021/6/29/israeli-aparthe...

Furthermore, the UN have ruled that the right of return is valid, as opposed to the current nationality rules around Jewish heritage that make no sense - no other countries allow similar things: https://news.un.org/en/story/2024/09/1154496

Neighbouring countries accepting refugees could well be considered an endorsement of ethnic cleansing. TBH Gazans should not have to move, the current state of Gaza is entirely down to Israeli destruction which was completely unnecessary - hostage exchange could have happened at any time in the last 15 months, and Netenyahu has blocked that discourse 10+ times before, as it has not been in his interests to seek a resolution to the conflict (witness the complaints by the families of the Israeli hostages).

Sadly the UK has a long history of underinvesting in cutting edge tech, from aerospace (https://en.wikipedia.org/wiki/BAC_TSR-2 https://en.wikipedia.org/wiki/British_Aerospace_HOTOL further development of Concorde)

to transport (https://en.wikipedia.org/wiki/Advanced_Passenger_Train https://en.wikipedia.org/wiki/Tracked_Hovercraft https://en.wikipedia.org/wiki/Hovertravel https://en.wikipedia.org/wiki/Sinclair_C5 https://en.wikipedia.org/wiki/Maglev#Birmingham,_United_King...)

to chip design (https://en.wikipedia.org/wiki/Inmos transputer, static RAM, VGA standard).

Interestingly, the 3 British designers who made up Flare Technology, had a big influence on console and computer designs in the 80s/90s: They were responsible for the ZX Spectrum (partly), Konix Multisystem, Atari Falcon, ATW (and Blossom graphics card), Atari Jaguar, Super FX chip, Nuon