Is anyone not just me hesitant to run their own servers? I think about patching and it becomes a full on devops job to set up something safe and stay on top of upgrades etc.

One idea Ive had is that if the web facing part of the software is just a form saver. It persists the form to disk for retrieval by the local-first server that I run on my laptop after pulling all records.

Would like to talk to persons about this topic: local first and low-maintenance service design SAAS

I wrote about an imaginary cloud service that would be about hosting forms for batch processing later this is similar to the workspace.zip in this article but this is used for the app itself.

https://www.halfbakery.com/idea/Secure_20Form_20Endpoint_20S...

The source code of the widgets we use everyday - such as text editing or graphical editors are or your web browser's Javascript engine, are enormous.

'Just do X, too' is really difficult with what is already there.

My thoughts in this is to somehow create a system where additional rules or changes to behaviour have marginal cost.

I am interested in the Rete algorithm, a rule engine algorithm. But we could run this sort of thing at compile time to wire up system architecture.

Boilerplate or configuration is an enormous part of programming and I feel there really could be more tools to transform software architecture.

I like these kinds of posts, about wholesome satisfying work

I found a similar feed to HN on https://bearblog.dev/ at https://bearblog.dev/discover/ that might be helpful for persons to find new posts that are interesting.

The JVM is a reliable stack. I used it at work on most projects.

I had frequently thought that I would prefer to maintain a batch system than an online system.

I like the GitHub collected archives of "awesome" that is lists of things that persons have created or done

https://github.com/sindresorhus/awesome

In other words, every new thing was something that may have been before but it was "this is how things work from now on". The platform defines and upholds the character of interaction. Twitter and Reddit do that and as pg highlights how twitter recipients is by algorithm. (From OP: "where you don't specify the recipients.")

I have fond memories of writing HTML from magazines and in the eras before me it was handwriting text games into BASIC interpreters.

In my spare time working with C as a hobby I am usually in "vertical mode" which is different to how I would work (carefully) at work, which is just getting things done end-to-end as fast as possible, not careful at every step that we have no memory errors. So I am just trying to get something working end-to-end so I do not actually worry about memory management when writing C. So I let the operating system handle memory freeing. I am trying to get the algorithm working in my hobby time.

And since I wrote everything in Python or Javascript initially, I am usually porting from Python to C.

If I were using Rust, it would force me to be careful in the same way, due to the borrow checker.

I am curious: we have reference counting and we have Profile guided optimisation.

Could "reference counting" be compiled into a debug/profiled build and then detect which regions of time we free things in before or after (there is a happens before relation with dropping out of scopes that reference counting needs to run) to detect where to insert frees? (We Write timing metadata from the RC build, that encapsulates the happens before relationships)

Then we could recompile with a happens-before relation file that has correlations where things should be freed to be safe.

EDIT: Any discussion about those stack diagrams and alignment should include a link to this wikipedia page;

https://en.wikipedia.org/wiki/Data_structure_alignment

And the pattern of including "check" transaction item is how we manually maintain data integrity (characteristic of Atomic in DBMS)

And we know which transactions are writing because they told us they wanted to write in the prepare phase (the part that the transaction manager handles separate from the one shot transaction information perspective from the client with its own communication between the transaction manager and storage nodes)

I implemented a toy dynamodb that is a trie in front of a hash map, it handles the "begins with" query style.

How do you feel about Kubernetes?

It would be good to have some interesting tasks to do?

I think the tools should do also much of the work. I actually prefer batch systems that are a simple execution of a program against a dump which are just process all the data and generate data with the new states than a networked online system that breaks all the time and due to DNS

Micro services keep me awake but a simple CSV processing I can fix in my own time.

For intermediate representations this is better than printf to stdout

I am also agreeing that relational approach to in-memory data is a good, efffective thought.

I recently compiled some of my C code with the sqlite database and I'm preparing to think how the SQL model of my standard code could be used as the actual implementation language of in memory operations.

Instead of writing the hundredth loop through objects I just write a SQL query instead with joining with seeing the internal data representation of the software as an information system instead of bespoke code.

I was hoping to make it possible to handle batches of data and add parallelism because arrays are useful when you want to parallelise.

I was thinking, wouldn't it be good if you could write your SQL queries in advance of the software and then parse them and then compile them to C code (using an unrolled loop of the SQLite VM) so they're performant. (For example, instead of a btree for a regular system operation, you can just use a materialised array a bit like a filesystem so you're not rejoining the same data all the time)

I was thinking of ways of representing actors somehow communicating by tables but I do not have anything concrete for that.

These kinds of software pipelines can be strangely satisfying to implement.

The development style of thinking of stream processing and online algorithms

It's also inspired by mapping and filtering and functional programming with flatmap.

It reminds me of factorio

I am curious: how low maintenance is this?

Is this something that can be hosted for long periods of time without security interventions and updates?

Is it fire and forget?

You can use io_uring with epoll to monitor eventfd to wake up your sleeping with io_uring wait for completions.

I have implemented a barrier and thread safe techniques that I am trying to turn into a command line tool

My goal is that thread safe performant servers are easy to write.

I am using bloom filters for fast set intersection. I intend to use Simd instructions with the bloom hashes.

The low level uops (microops) of a CPU seem to be relevant.

Openttd is another example of a game where you can implement train signalling.