eterps

Oberon System 3 works on Raspberry Pi:

https://github.com/rochus-keller/OberonSystem3Native

What you can do is use commands like ":peek prev" (takes you to the previous edit), ":peek 1h", or other time-travel commands to inspect previous states and manually recover overwritten changes if needed.

Thanks, I think that would work fine in most cases if you can open your editor with the 'prev' version and the current version in 2 panes (or in diff mode).

Conflict handling model: Later events take precedence when conflicts occur

Do I understand correctly that if 2 people add a lot of information to one issue only one of them 'wins' and becomes visible? Or is it more subtle?

If only the latter one becomes visible, how do you get to the edits of the other person and 'merge' it again?

all you need is to write to an on-duty officer and it will be unblocked

What if the pretty advanced e-government system decides it will not be unblocked?

I agree, Cucumber works really well with LLMs.

I use a mix of Markdown and Gherkin

Gherkin also has a Markdown based syntax that is not well known:

https://github.com/cucumber/gherkin/blob/main/MARKDOWN_WITH_...

I prefer that to the 'verbose' original syntax. MDG also renders nicely in code forges.

This is great! I remember running System 3 on a 386 back when MS-DOS was king.

I actually agree with that. And I enjoy the fact that TUIs are becoming popular. But there is more to it than just the 'vibe'.

If you think the 'mouse-clickable' aspect is bothering me, you missed my point entirely.

Sure, but my point was that UX matters for TUIs. A TUI with a UX that fits its paradigm , again like lazygit, works great over SSH.

This is nonsensical, there is nothing textual about the UIs being shown here. It doesn't stop being a GUI if you have a 1:1 representation of the concept within character cells.

The UX actually matters, and TUIs are generally built for effectiveness and power (lazygit being an excellent example). But once you start adding mouse clickable tabs, buttons, checkboxes etc. you left the UX for TUIs behind and applied the UX expected for GUIs, it has become a GUI larping as a TUI.

I could see a world in which we're all just writing tests in the form of something like Gherkin though.

That works great in practice, Gherkin even has a markdown dialect [1].

If you combine it with a tool like aico [2] you can have a really effective development workflow.

[1] https://github.com/cucumber/gherkin/blob/main/MARKDOWN_WITH_...

[2] https://github.com/jurriaan/aico

You could have a look at: https://github.com/jurriaan/aico

It does 2 things that are very important, 1: reviewing should not be done last, but during the process and 2: plans should result into verifyable specs, preferably in a natural language so you can avoid locking yourself into specific implementation details (the "how") too early.

You could give https://github.com/jurriaan/aico a try.

https://nowigetit.us/pages/8cf08b76-c5bc-4a7b-bdb4-a0c15089e...

The actual explanation (using code blocks) is almost impossible to read and comprehend.

I use my_ as a prefix.

Would love to hear more about this approach.

While I like the concept, the side-effect pattern might be difficult for the average developer to understand (without fp-pack knowledge) in a shared codebase:

https://github.com/superlucky84/fp-pack?tab=readme-ov-file#s...

Still, this approach is very useful for most business logic, too bad most programming languages don't provide a nice syntax for this.

What are popular charm/bubbletea based TUIs? I use TUIs often, but for some reason none of them are based on charm/bubbletea? Might be coincidence though.

While I appreciate Charm's aesthetics, I worry it leans too heavily on GUI paradigms, like popovers and buttons, rather than prioritizing the optimal keyboard efficiency used in traditional text-based interfaces.

Maybe this could be helpful? -> https://github.com/pimalaya/neverest

Wait until they get to the networking layer; you're going to hate what Vint Cerf did in the 70s :)

Ada, Nim, Pascal. I think C++ also offers it with a specific syntax.

Rust also offers it, but you need to specify it on the call side as well.

But I am using Oberon-07 as base, and I might deviate from it quite soon too.

I am curious about your thoughts on var parameters (i.e. mutable references), as in:

    proc increment(var x: int)
    begin
      x := x + 1
    end

    var i: int

    begin
      i := 10
      increment(i)  // i is now 11
    end

Isn't this wat streaming databases like Materialize and RisingWave do?

How does it differ from https://weasyprint.org ?

I don't care much for the eye candy either, but I do appreciate how gradient borders look:

https://cdn.imgchest.com/files/y2pckdepoa7.png

That's the only eye candy I would wish for in Sway or SwayFx.

5 points and 0 comments? IMO this looks like a very well researched project, not sure why it went under the radar.

It would be incredibly interesting to see how LLM code generation would hook into this.

Thanks! Sorry for being lazy, but I was wondering how you share something using the E2E-encrypted KV store (it wasn't obvious in the website)? In kbfs, I remember it was as easy as putting it in a comma separated usernames path.

TL;DR: FOKS is like Keybase, but fully open-source and federated

What features from a user perspective does it currently have in common with Keybase?

F.e. I remember Keybase mostly for secure messaging using public identities (HN, Reddit etc.), and sharing data/files.

What is the not-open source software used in OpenDesk?

The Calendar is closed source?

And probably also the e-mail client and contacts list?