renke1

OOP is fun if we could treat everything to be readily available in memory and retrievable infinitely fast.

Function instances should stay alive for a certain amount of time. But you will pay the cold start price one way or another, so naively using Spring Boot is probably not a good idea. Spring Boot Native might help here, but I haven't tried it yet.

We had a small course in university on esoteric programming language. Each of us had to select a language (Brainfuck, Piet and a few others) and play around with it. I chose Piet and had a lot of fun with it, but to be honest, my small example application was not really aesthetically pleasing. I guess you have to be a Piet expert to make art with it.

Looks interesting. Does anyone have a good example that uses Client Components?

The best thing is that it does not seem to hard to extend KOReader to your liking (e.g. by writing plugins). On the other hand, I've had a hard time understanding the the actual Lua code (most likely because of my lack of experience using Lua though!).

What's really missing is a good way to browser by metadata (e.g. author, series or even your own custom tags). However, there seem to be some progress here [0].

[0]: https://github.com/koreader/koreader/issues/8472

I do often use this feature but sometimes fear I missing out because of some deliberate decisions by the author. Not sure if that worry is really warranted.

Seveneves was really good. Almost feeling the urge to read it again!

Designing Data Intensive Applications is really good, because it gives you an good overview of data systems. I had the feeling I don't have to understand all the details yet I would learn a lot.

Are there other books like this?

My own name is actually only used in the very country I live in. Unexpectedly, my daughter's name is apparently also used in Arabic countries, it means something like "Gift from Allah".

Although I had absolute no idea what I was doing when we played around with Agda in university, it was kind of fun constructing a few very basic proofs. It kind of felt like smashing some buttons until it worked. The Emacs integration with all the Unicode goodness was really something.

The worst thing is how often developers almost fatalistically accept that testing sucks. I don't blame them though because improving the test infrastructure has little short-term business value or so they say.

I'd love to try all those ergonomic keyboards, but the most ergonomic thing for me still is a Thinkpad-style trackpoint.

Thanks! I was only aware of a Zones proposal which was withdrawn I think.

A few of my colleagues and I had the silly (?) idea that you don't really need logs anymore. Instead of log messages you just attach span events [0]. You then just log the span title and a link to that span in Jaeger; something like [1]. I've only really tried that in my private project, but it felt pretty good. The UI of Jaeger could be a bit better to support that usage, though.

Edit: Actually, those colleagues are doing a talk about that topic. So, if you are in Germany and Hannover area, have a look at [2] and search for "Nie wieder Log-Files!".

[0]: https://opentelemetry.io/docs/instrumentation/ruby/manual/#a...

[1]:

    tracing.ts:38 Usecase: Handle Auth 
    tracing.ts:47 http://localhost:16686/trace/ec7ffb1e23ddbb8dd770a3f08028666b
    tracing.ts:38 Adapter: Find Personal Board 
    tracing.ts:47 http://localhost:16686/trace/e22d342316ab0d7d23230864008e27bc
    tracing.ts:38 Adapter: Find Starred Board List 
    tracing.ts:47 http://localhost:16686/trace/129f89cee26d54cfdc38abea368d9b4e
    tracing.ts:38 Adapter: Find Personal Board List 
    tracing.ts:47 http://localhost:16686/trace/97948127d77501ff0c65a5db21b21b5a

[2]: https://javaforumnord.de/2023/programm/

I think with native Promises (and async/await?) there is currently no way to implement something like Zone.js properly. I've tried to instrument my code manually, but it's really error-prone and verbose. We really need something like https://nodejs.org/api/async_context.html#class-asynclocalst... to be implemented in the browser.

Notes never really worked for me previously, but somehow I got it working with logseq [1] (it doesn't really matter which Roam-like tool you use). I feels like some kind of super power to be able to quickly access all sort of information. What helped me was thinking in projects (prepare conference talk XYZ, write article for tech magazine ABC and of course actual projects). Also I always link persons I interact with when I create notes for a meeting or similar situations. That way you can quickly show all relevant information about a person. Most important though is the ability to write down TODOs anywhere and later see them in an aggregated manner.

[1]: https://logseq.com/

Yeah, that always works, of course, even though you might want to externalize certain dependencies still. In this case I don't want to bundle the code (although I might end up doing that, anyway)

That's correct. However, I've tried to use prune now, not sure if I am using it correctly, but that's why I do:

I build my packages regularly (not pruned), then I prune with scope "backend". Apparently the pruned directory contains node_modules with empty packages, not sure what reason is for that; I just ignored it. In the resulting directory I then run `pnpm install --prod`. Only the regular dependencies will be installed. I think this is enough for my usecase. I am not sure if prune is supposed to be used for this approach though.

Can Prune be used to build a bundle (as in a zip) for, say AWS Lambda, which includes only the dependencies (and not dev dependencies)? I've played around with pnpm's deploy but it felt a bit lackluster. Especially talking about situation where one has a backend package and some shared package. The bundle should contain all dependencies (but not dev dependencies) of the backend package and shared package and of course the built shared package should also be include in the bundle's node_modules.

Having navigational keys on the home row is something every software developer should use (but almost no one does). Unlike Vim-style keybindings it just works everywhere.

Personally I am using an unused key on my keyboard (layout) as modifier to access them. My particular mapping is based on the Neo Layout [0]. Basically FPS-style WASD but shifted by one key to the right.

As tool to change keyboard layout I use Interception Tools [1] and a personal C program. The advantage of interception tools is that it works everywhere (even outside a desktop environment).

[0]: https://www.neo-layout.org/ – It's a German page, but you can look at "Ebene 4" on the keyboard thingy to see the layout.

[1]: https://gitlab.com/interception/linux/tools

I am currently using yjs. What would be the equivalent way as described here [0] for yjs to sync docs in Automerge? I don't need any WebSockets or real time stuff. It always seemed so complicated in Automerge compared to yjs. I just want to roll my own simple sync mechanism via HTTP.

[0]: https://docs.yjs.dev/api/document-updates#syncing-clients

There was also a different proposal that allows objects to be extended: https://github.com/tc39/proposal-bind-operator

Personally, I don't use classes much, but sometimes I think free functions are a little too hard to find, so I tend to experiment with the following pattern.

   interface User { … }

   const User = {
     rename(user: User, newName: string): User { … },
   
     getDisplayName(user: User): string { … }
   }
   
   const renke: User = { … }   
   
   console.log(User.getDisplayName(renke)); 

Which makes finding an operation for a certain type easier to find (just write User and trigger autocomplete).

The alternative is of course having renameUser (or userRename) and getUserDisplayName (or userGetDisplayname). The prefixed version would make autocomplete easier also.

Spatial navigation is a feature I really do miss. I don't think any other browser supports this. It made keyboard-based browsing possible without resorting to stuff like hit-a-hint. You could just hit Shift+Arrow Key (which I mapped to the home row) and select a the nearest link (or anything interactive) in that direction. I think it worked in a visual fashion so order in the DOM didn't matter at all. It behaves exactly like one would expect.

I've actually met the author of HerbstluftWM at the Konferenz der Informatikfachschaften (national student association meeting in computer science). Very approachable person. Coincidentally, the original author of Rack (Ruby) and the kind of inventor of tumblelogs was also there. Then again, where else would you meet people like that!

> We are working on this as we speak!

Perfect!

> However, it sounds like you like to see glob fan out of tasks.

Yes, the idea here being that I don't want to list all similar tasks (such as linting) explicitly in the turborepo config. Teams should be free to add any additional lint task if they think it's useful for them (and possibly only for them). Similar to Maven(Java) where additional goals can be bound to the standard lifecycle phases.

Turborepo is really good, but there are a few things I like to see implemented:

* tasks on the root package (e.g. tsc -b that typechecks all packages)

* treat tasks such as lint:eslint, lint:pretter as a single task lint (or maybe lint:*)

These are probably niche features though.

Yes, I think the JS ecosystem (which I am certainly part of) does sometimes ignore established terminology and solutions from other ecosystems. Although I must say that the JS ecosystem really has amazing tooling in certain areas (say prettier, eslint which I am missing in the Java world for instance).

I was actually about to mention Nix in my post as well. Being a casual NixOS user myself I wonder if there is any kind of monorepo tooling based on Nix? Without ever having used Bazel myself I always thought of it as Nix-like.

When I talk about monorepos in our company, I always try to make the distinction between JS monorepo tooling (say nx, turbo or more low-level pnpm/npm/yarn workspaces) and real (?) monorepo tooling (say Bazel). Whereas the latter has more focus on dealing with a wide variety of source code types and artifacts the former is exclusively dealing with NPM packages (which may include other stuff like Go/Rust sometimes). Does this distinction even make sense?

So I am planning to use CRDT sometime in the future.

Any thoughts on Automerge vs. yjs? – I am not doing a text editor. I just want to build a solid offline-first web application.

Also, is there any way to "squash" the history of changes? Let's say I have a central server through which all changes are synced (no peer-to-peer syncing). Does it make sense to force clients that haven't synced for a long time (let's say a weeks) to just discard their non-synced changed and use the "current" state as stored on the server?

Okay, one more question: Let's say I want to add an API to my server that uses the data that was synced to server (assuming the sync state of Automerge/yjs is stored somewhere). Would the server in this case just be another client that just get's the data from the synced state and stores in an appropriate store (say a SQL database, Elasticsearch, etc.)?

That's reason why I think the push to follow event-driven (reactive) approaches in ecosystems like Java is doomed to fail (okay, that may be a bit harsh) because there is lot of existing blocking code. It will take a long time until all of the old libraries catch up. It kind of splits the whole ecosystem into half. Specifically in Java I think it's fine we are relying on blocking APIs (and threads). For most stuff it scales properly, doesn't feel unnatural and is easier to understand. I say this as a big fan of JavaScript, I just don't see the approach being introduced after the fact as a good idea.