alexisread

And this comment is being downvoted as well to hide the fact.

Wow this was moved fast off the frontpage! Now on page 3 after 50min. Just FYI.

Relevant paper on lattice types (BloomL): https://dsf.berkeley.edu/papers/UCB-lattice-tr.pdf

In addition to this, you’ll need a causal register (per-key merkle clock) to order concurrent edits, rather than drop one.

Lastly, you’re likely to need a Pijul style VCS to handle semantic merges.

The ST got preemptive multitasking in 92 AFAIK with MINT/Multitos https://en.wikipedia.org/wiki/Atari_TOS

Thought this was a reference to this parody

https://youtu.be/xE9W9Ghe4Jk?is=wmaIJ6LXNW-mZ49Q

Completely different. The ST and TT used bitplanes whereas the Jag is chunky, and can support both YUV and RGB colourspaces. 640x200 is possible at least https://youtu.be/XI3Pvx5Yh1U?si=2bp93CeNYPTGZZic

OOI why did you go with RC at the lattice bottom rather than generational refs? Not sure how in touch you are with the author of Vale?

What would be good is if effects are used to discharge the ownership obligations, that should dovetail well in Ante. BTW I appreciate the clear effects handling in Ante, very nice!

Yes that’s pretty much how I’ve used AI, though phase zero and one had to be hand-coded until there was enough code for the AI to iterate off. Hand debugging and then showing the AI helps to narrow the number of errors, and how to triage for the next run.

Depends what you define as a cyberdeck. If you look low power/ non-linux there are many innovative decks: https://hackaday.com/2023/03/06/low-power-challenge-the-pota...

https://www.youtube.com/watch?v=HK0uAKkt0AE colorforth deck

https://www.youtube.com/watch?v=Kn0MxHlima0 discrete deck built like the tandy 1000

If Cyberdeck builds get people building, then it's all good. Farming does encourage others to build so it's all heading in the right direction :)

You might be interested in the Baochip

https://www.crowdsupply.com/baochip/dabao/updates/our-campai...

Probably the most open chip on the market, and sits between a pi and a pico

Not quite the same thing, but you can build a similar thing to run linux relatively easily, and the keyboards can be really good that way. You can swap out the SBC for one of your choice eg. https://www.lattepanda.com/lattepanda-iota (why don't AMD do small SBCs?) and cut a space on the left/right hand side for a trackpoint/optical trackpad (operate from the side)

https://github.com/penk/penkesu

There’s a wealth of retro machines out there that cater to this. A sample: https://www.olimex.com/Products/Retro-Computers/Neo6502/open...

https://www.olimex.com/Products/Retro-Computers/AgonLight2/o...

Or with keyboards: https://wildbitscomputing.com/

https://www.kickstarter.com/projects/spectrumnext/zx-spectru...

Or you can go mobile: https://www.clockworkpi.com/product-page/picocalc

https://andywarburton.co.uk/post/gr3ml1n-a-compact-handheld-...

And if you want a real challenge, the one euro computer:

https://www.olimex.com/Products/Retro-Computers/RVPC/open-so...

There’s a definite overlap between this and the Cardputer Zero: https://youtu.be/lhS0trmBAAU?si=lLmCKdK3eHyMMAR0

M2 slot or a clipon addon? Nice to see more Swiss Army knives in this space

Consider the bulldog…

Douglas little has a neat trick for dynamic voxels, see the ‘sparse voxel octree’ demo:

https://youtu.be/nHsgdZFk22M?si=Yt_m0W6OozSm4TkW

Allows Minecraft on a 16mhz Falcon

I think that’s the beauty of PG here, you can find solutions to most of this:

Index creation https://stackoverflow.com/questions/23876479/will-postgresql...

JSON->DB schema https://jsonschema2db.readthedocs.io/en/latest/index.html

Pg shared disk failover is similar but RAC is quite unique, you’re not going to use though with a rented cluster?

https://www.postgresql.org/docs/current/different-replicatio...

Personally for me any technical advantages don’t outweigh the business side, YMMV :)

Good points, but Postgres has all those, along with much better local testing story, easier and more reliable CDC, better UDFs (in Python, Go etc.), a huge ecosystem of extensions for eg. GIS data, no licencing issues ever, API compatability with DuckDB, Doris and other DBs, and (this is the big one) is not Oracle.

This is the same Israel that has attacked Iran, Gaza, Lebanon, Syria, Yemen, Quatar and Sudan (https://youtu.be/pRxKltphg6c?si=bDSB_jA-KPM4Efzu) and globally trafficked children?

(https://youtu.be/RJhqGDZbqBI?si=MQFuah6er7TvHcaD)

Or is it the Israel that deliberately destroys crops (https://youtu.be/Lyp9Xfess3Q?si=1_4usvB1yjgYhKSb)?

Maybe it’s the Israel that ignores ceasefires (http://youtube.com/post/Ugkxn4SkyNfKESV6nPO_ZzgOhdaH8lb_FAkx...) or fills in wells (http://youtube.com/post/UgkxaPo3ERDtr5fQKPAHnFgxwYkMaEeMgdlo...)

Or it could be the Israel that shoots and kills 234 peaceful protestors (https://www.972mag.com/gaza-return-march-idf/)

Restraint is not really in Israeli vocabulary, and the story being sold is a lie.

Thanks! One last question is whether it can boot from external EEPROM? This is mainly with reference to Ken Thompson’s Reflections on Trusting Trust paper (https://www.cl.cam.ac.uk/teaching/2324/R209/Reflections-Trus...).

What would be good is to be able to program the eeprom with hardware, boot the bao with the eeprom and then bootstrap the rest of the OS.

Lastly I was thinking on the inclusion of 4 bidirectional (transputer) links so to speak. I’m guessing you’ve thought about clusters of these chips?

Thanks

Great work on the chip, I’m really onboard with the trusted computing aim!

Is there a way to bootstrap binary code into the reram? I’m thinking being able to ‘hand-type’ in a few hundred byte kernel rather than use a flashing tool

If you don't mind, could you drop some code? I'd be interested to see the result :)

Apart from transputers mentioned already, there’s https://greenarrays.com/home/documents/g144apps.php

Both the hardware and the forth software.

APIs in a B2B style would likely be much more prevalent, less advertising (yay!) and less money in the internet so more like the original internet I guess.

GUIs like https://en.wikipedia.org/wiki/SymbOS

And https://en.wikipedia.org/wiki/Newton_OS

Show that we could have had quality desktops and mobile devices

Very impressive demos! I did a quick look through the docs- it’s single threaded (in the cpu sense) and not multi process yes?

It was a massive shame the TV-toy project at Sinclair did not work out. It was a SOC/low cost computer based on the Inmos transputer (Called the T400, an M212 without dedicated link hardware) around 1983. That might have kept Inmos afloat- they were responsible for a lot of the RAM chip innovation, VGA standard, transputer etc. so the world would have looked very different. I do wonder what could have been with that chip paired with the Slipstream chip, oh well.

https://en.wikipedia.org/wiki/Transputer TV-toy

https://www.abortretry.fail/p/inmos-and-the-transputer TV-toy

https://www.transputer.net/tn/50/tn50.html M212 details

https://forums.atariage.com/topic/271372-flare-technology-an... 9.2mb/s bandwidth+sequencer_list

Tip of the hat there, it’s a very selfless thing to commit to caregiving. From a 50kft view, we have an aging demographic globally, and the bet seems to be robotics- hopefully they will get good enough to help meaningfully in this capacity. What happens to an economic system predicated around having more kids (GDP growth) is another concern.

I get the impression that the Atari AMY chip was an inspiration? Wonderful to see how the Alles speakers are implemented!

I agree you would need to specify the markdown to allow more implementations. https://github.com/jgm/djot Would make a good DSL inside languages, combine that with compile-time execution so that blocks can auto-recalculate and you have a more available mechanism than emacs/org in other languages.

I think this is the crux of the issue, use like this is like a real program, just built up incrementally in a notebook rather than a repl or shell-with-pipes, and with manual error handling. The STEPS project was all about this- a way of incrementally building blocks that can be composed.

With org mode in mind, ideally you would have language support for this ie. Comments are scoped metadata that can be formatted, tested, linked etc.

You need a well defined spec like djot as a DSL for this to work, so that parsers can be easily written for it. This level of language support allows many different views onto the source code. We’re not there yet.

Although it’s a bit weird, Able Forth has the explicit word ~

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

I do prefer this as it keeps the language more regular (fewer surprises)