weitzj

I would guess it is the pelican on a bicycle reimagined ;)

Thank you for the article. I remember using Google Soy templates roughly 10 years ago. I think this is similar to what is used now when you make Helm templates for example or Go Templates. It has the html escaping, JavaScript escaping etc built in.

Is there maybe a Zig wrapper for Google soy around?

Thank you for your response. So time as you mentioned can be made explicit.

I am probably looking for something like the request context with timers and cancellation signals propagating through the call chain like in gRPC but more fine granular.

So you could implement arbitrary response times of functions. So you could say like:

This whole request must finish in 5 seconds, otherwise abort.

And these 5 seconds can be made very low so that you reach latency of NUMA vs Single CPU.

I don't know how you call this, maybe "latency budget"

Side question as I am following zig only losely and do Go Programming:

Zig has the feature that you can drop in your allocator from the caller. Now with 0.16 you also "bring your own IO" implementation with you.

And for my understanding this looks like the pattern Go uses with its Context package, where you pass in transitive data, cancellation signals and timers to for example stop an SQL query in server B, since a user canceled a web request in their browser before hitting server A, whilst all elements delegate the Context.

Then yesterday was total unrelated article about NUMA architecture, and I remember somewhere that the creator of Erlang mentioned (Joe Armstrong) that you cannot get around physics and it takes time to call a function between servers, therefore so not try to hide the latency between the calls.

And now to my question:

Would that in any way make sense for zig to go even more in this direction, where you pass in your allocator, IO, but now with something similar to Google Go context, but have it even more fine grained?

So that your functions could actually in their interface expose somehow the time in between CPU cores (NUMA) up to the request cancellation as Google go context is used for timeout signals, cancellation signals.

Also probably making time an external dependency as well.

So in essence , every function would be treated as a remote procedure calls, whereas remote would mean: "other cpu", other server/service

JAM as a Service

I still use this background Color on my Mac or Linux.

Joshua

There is also a Website https://coproduct-opensource.github.io/nucleus/architecture/...

I have stumbled on this project while dabbling around how to launch many firecracker VMs on a MacBook with >= M3 cpu to isolate agents.

What do others do to isolate agents?

Maybe Roger Penrose has some meaningful Input https://youtu.be/iTVN6tFknCg

regarding …“One was the realization that a purely mechanical computer can, in principle simulate the laws …“

As far as I unterstood,there is no theory of quantum gravity and therefore this is not being simulated on a computer. I think he makes other arguments.

So you cannot say for sure that you can simulate a human brain on a computer

Thank you

I was thinking of people were to use an image…:$my_tag on the host cluster and some roughe pod on the child cluster (but same underlying physical nodes) somehow overwriting the local cached :my_tag, you could do something on the parent cluster.

But I don’t fully understand what you meant with content adressed :)

Maybe one has to ensure in the host cluster that the image pull policy is set to Always or all references to images have to be based on the shasum rather than Tags.

Thank you for your feedback.

I understood from the host cluster perspective you won’t see the child cluster pods. And what is the perspective on nodes?

Can you have like a host cluster spawning on host nodes and the host cluster has control over spawning separate physical nodes which contain the child cluster (api server) + workload pods ?

I don’t understand how they are separating security in the virtual mode as they only mention pods. It seems every workload still shares the underlying node, even when in virtual mode. Take for example the OCI cache on the nodes. What about cache poisoning?

Love it. And from my experience the need for Go Routines is not that urgent.

Sure when I started Go there were Go routines plastered everywhere. And now I think harder: “do I really need a go routine here?”

I tried Nix. Worked. Then I forgot the syntax.

Therefore my middle ground is devbox.

It is like python vietualenv but backed by Nix. So I have a devbox.json file to define packages and devbox will do the Nix part for me.

I am getting a MacOS and Linux setup from this for aarch64 and x86

I love hammerspoon. That's it :D

It's lua, so you can get creative with https://fennel-lang.org/

Maybe for your personal workstation this might be the experience you have. But from my experience for enterprise there is RHEL, Suse and maybe Ubuntu Pro. If you are an AWS Enterprise customer you might justify Amazon Linux

Will this have an impact on Loadbalancers? Like does one have to do client side load balancing like in gRPC?

30 days in Germany + Public Holidays

I was quite happy and entlohntes when I dropped an HTML table Formates with Emojies into my prompt and told to turn it into a terraform module.

But how do you quality check this part? I am proofreading all these transformations and I am not sure if this is really faster than actually recording a VIM macro, which will do the steps I need.

Love it. Also using UTM with Amazon Linux 2023 x64 on an M1 works, so you can create a local HashiCorp Packer Pipeline using the Packer UTM plugin (similar to the QEMU Packer plugin)

source "utm-cloud" "this" { iso_url = "${path.root}/dev_images/al2023-kvm-2023.6.20250303.0-kernel-6.1-x86_64.xfs.gpt.qcow2" iso_checksum = "sha256:0dc2797fe19847f6c75878dd344ab478ac0657077d9a15f2907bb2df41d8c3de" vm_arch = "x86_64" cpus = 2 memory = 4096 display_nopause = true boot_nopause = true export_nopause = true skip_nat_mapping = true communicator = "ssh" ssh_clear_authorized_keys = true ssh_private_key_file = data.sshkey.this.private_key_path ssh_host = "192.168.64.100" ssh_port = 22 ssh_username = "ec2-user" shutdown_command = "echo 'packer' | sudo -S /sbin/halt -h -p" use_cd = true cd_label = "cidata" cd_content = { "meta-data" = <<EOF local-hostname: vm-hostname EOF "user-data" = <<EOF #cloud-config ssh_sftp: enabled: true password: ec2-user ssh_pwauth: True chpasswd: expire: False users: - default - name: ec2-user lock_passwd: false plain_text_passwd: ec2-user ssh_authorized_keys: - ${data.sshkey.this.public_key} EOF "network-config" = <<EOF #cloud-config version: 2 ethernets: enp0s1: # dhcp4: yes addresses: - 192.168.64.100/24 gateway4: 192.168.64.1 nameservers: addresses: - 10.0.2.2 enp0s2: dhcp4: no state: down EOF } }

From the Enterprise Perspektive at least for my use cases(fine grained permissions using extra id) , elasticsearch with kibana always had a solution available.

For grafana cloud and Loki you can close to a good usability with LBAC (label based access control) but you still need have many data sources to map onto each “team view” to make it user friendly.

What is missing for me is like in elastic a single datasource for all logs which every team member across all teams can see and you scope out the visibility level with LBAC

Another interesting one https://youtube.com/shorts/tWthV06ZIDo?si=JdKPvykIuv5q7RGY

I think this person has also interesting content regarding No and Yes

https://youtube.com/shorts/DjuC8xauWWk?si=VkGFbgbqyzKqPjLD

Love what they are doing. At least you get the chance to introduce Nix in the enterprise with the MacOS installer, having figured out private CAs and the MacOS keychain for example. Then MDM.

Thank You. Nice. Fennel lang

I am finally settled on aerospace.app which is close enough to i3 for me. Now hammerspoon for some Automation :)

Would you mind Sharing your hammerspoon Config? Are you tiling your windows similar to i3 or sway?

Yes. From the documentation there are some Screenshots and this is possible. Like starting a standalone Firefox browser inside docker desktop and accessing it via a browser vnc session.

But you get to control the keyboard/clipboard and it can add apparently watermarks to the vnc session for DLP functionality and you have a web http to take screenshots of your vnc sessions.

Great idea. Just a tip. You can wrap your lua part into cosmopolitan C. This way you get lua on many architectures and os. Also cosmopolitan can be bootstrapped with tiny cc I guess. And personally wrapping your lua code in https://fennel-lang.org/ would be nice.

This way with libcosmopolitan, you could just checkin a copy of your build tool in a project, to be self sufficient. Think of it like gradlew( the gradle bash/bat wrapper) but completely self contained and air gapped

https://github.com/jart/cosmopolitan