bjconlan

I would also be interested in the outcome of these tests.

Did you test against other protocols ? I've been meaning to do some tests using the c++ implementations of each used in userver.tech (specifically flatbuffers/protobuffs also unsupported sbe & captnproto) for etl processing "generally" (Again more variables are to be weighed in here for my case but would be interesting to see these things against payload sizes)

I really need to get my head across some of these things. I've been meaning to also look into https://www.kernel.org/doc/html/latest/networking/tproxy.htm... (in regards to udp(quic)/ztunnel-esque behaviour). This will serve as a great reference, thanks.

I read this as "Weird Al personality tests" and thought its a great idea. More places should be employing based on their Weird Al index, would finally improve the "fun place to work" aspects

It's a double edged sword. A closed source non-transparent solution without a reported cve is also laughable as "secure".

Also the most recent release 22.0.2 only has 3 (known) vulnerabilities. https://www.cvedetails.com/vulnerability-list/vendor_id-25/p...

Cosmopolitan build support! I know jart had this compiling in the examples but it's nice that fbellard has added 1st class support.

Ok and there is the top level await support (among others that are truly beneficial to the language support; I didn't even know about "in" until this change log)

Yeah the whole thing reminded me of the blog post they talk about regarding a time travelling debugger...

https://temporal.io/blog/time-travel-debugging-production-co...

Anyways I wish all the best for flawless as this problem is worth solving/popularizing.

Yeah, I'm with you, I thought this thing was just waiting for some "function colouring" behaviors to be ironed out in zig before it was to be polished. I guess comments from https://news.ycombinator.com/item?id=35991684 made me think this but it's good to have been informed that this in fact is not the case (and is closer to a com.sun.net.httpserver.HttpServer as a ref for us ole java folk)

I've really been liking what I've been seeing with the [Ubuntu micro cloud](https://canonical.com/microcloud) product. It's basically a well coordinated effort of a deployment on lxc/lxd cluster using a (micro) ceph and ovn implementations. I think I like it because it attacks the problem at a level I can understand. (Proxmox does lxc/lxd etc also and has already been mentioned).

Again this is really more of a vmms setup so you need to orchestrate on top. (So perhaps your nomad cluster can sit on this (assuming there is some customer/org infrastructure splitting)

Absolutely, I've fallen in love with F# using Ionide (vscode extension(s)) on Linux. MS have really come a long way (I would say I would take a good long hard look at .net 8 before picking up my go-to tooling (java/spring dev speaking here)

I would highly recommend this also,- but firstly you need to understand how it fits into an organisational system.

I founds this YouTube very informative as to how [all these things hang together](https://youtu.be/cUQcNi_obIc?si=HtZ9iLc76KF2iB2L). [This is perhaps relevant for passkeys](https://fedoramagazine.org/fido2-for-centrally-managed-users...)

Alternatively you can go down the OIDC or SAML paths (generally the path of a developer)

While I've worked with keycloak I've always found the [Curity's resources](https://curity.io/resources/openid-connect/) for understanding OIDC core and extensions very good.

The order in which you learn these things isn't really important but they're both important (but really depends on your problem domain)

Mira... interim CEO? What's Nat Friedman up to these days?

I can't help but think he might be someone that fits the profile of the company from both sides of the partners involved.

I know this is only gonna add to the fire of the 'microbench' misdirection statement; but I noticed userver just reached 1.0. Would the author be so kind to throw that into the mix at some point (given time... and heck I might check myself later today given the code for others are provided)

Haha, software has more seasons than the fashion industry. If you observe it for long enough everything seems somewhat derivative. But I wouldnt want it any other way. All diversions are welcomed within the choices of those working within the choices of those before us.

Is the kernel module how they claim the 5x performance over tailscale? I haven't really done any real tailscale performance metrics but can't see how else they can claim this (unless there is infrastructure performance differences).

The final var

s/C++ UI/React/

The statement still holds. This one is just the status quo

Beyond the rendering which as noted is nothing that hasn't been done before (in general) the inherent OT/multi user + tree sitter functionality is something that entices me.

I'm surprised nobody pointed out lite/litexl here either it's rendering of ui is very similar (although fonts are via a texture; like a game would) and doesn't focus overly on the GPU but optimises those paths like games circa directx9/opengl 1.3

There are great details of the approach taken with lite at https://rxi.github.io

Lite-xl might have evolved the renderer but the code here is very consumable for me.

Isn't this where Mr Moore's (of Forth fame) cpu designs have gone? (see https://www.greenarraychips.com).

Ok maybe not the 'actor' model per say (unless actor channels are thought of core interconnects (I think there is also a global state but I cant remember much of these details at the moment without re-watching the linked strangloop vid.)

https://www.youtube.com/watch?v=0PclgBd6_Zs&t=2s or https://news.ycombinator.com/item?id=22021262 is probably the best for groking

Yeah this is bound to happen again. But it's always going to be the case with "native" becoming less important.

I've been keeping my eye on what the Godot UI team has been up to and it looks like a pretty good starting point. But I think an evolution of UI input and interactivity is among us so fingers crossed we're going into a second (or 3rd depending on who you ask) UI renaissance... Or maybe were just looking at another "famous framework"

This might be the right developer tool workflow tool for today. Like vs code pulled me out of emacs, this might be the tool that pulls me out of org-mode.

Congratulations on v1 and I look forward to giving this a try.

Yeah the duffs device did it for me too. I remember reading it in some game programming book but shocked to see it used in qt/embedded for it's software rendering.

This is up there for me or there's also that amazing recursive template class for n-dimentional vectorspaces written by Tim Sweeney. I can't find the page anymore but there is reference to it in the archive https://www.flipcode.com/archives/Unrolling_Loops_With_Meta-...

If he does find the bot accounts significant enough to identify that he has been "duped" is there any recourse? I suspect this might be the canary in the mine (of social-media businesses) and Elon is passionate enough to release said numbers which could be used as a litmus for all business that marketed 'number of "users"' as something of a validator.

Wow congratulations on the funding also. It's a pretty good idea and puts a unique spin on SE employment opportunities.

Yeah, I'm with you on this. I'm hoping that there is more to come soon that might flesh out this story. (I mean, surely just having an entrypoint into wasmtime + args or runtime of choice) gets these things inline with existing docker goals.

I think this is mostly a land grab to have docker image repositories be the distribution method of choice for wasi.

I think they're getting at the fact that you can create statially linked binaries without dependencies beyond posix or LSB (much like go). Compiling said code probably will require some well defined version of the compiler (which is trivial to containerize) as noted by pid-1 and why the linked project exists

The "irrelevant" part is questionable and based on the author's thinking at the time, not gospel.

This is great. I recently too a break professionally and was looking for something like this (for small personal projects with clear progressive outcomes; mostly for learning) I've missed a few of the items suggested (and motivation has waned, which happens). I've always been impressed with how the ziglang has started & kept things flowing with great ticketing so I leaned on some of those practices which have a nice cross section to these

I totally agree with and think we've all accepted it's (docker/oci's) place regarding deployability on infrastructure not managed by java developers.

Recently I've done a few migration projects and the biggest pain-point (not really a pain but not k8 friendly) is the containerization of JEE servers/services. As these solved most of what containers provide (deployment wise) albeit only for java. 'DevOps' generally killed this (and the related tech debt) but it's hard to validate the utility of any of this as the 'generalized' solution feels like it's compromised down to a point of convenience.

In saying that I do enjoy having a deployment platform that is always going to be Linux(like).

I don't think I would use it either for a personal project; but I would perhaps investigate how hard it would be to add some level of "kublet" (cri) like jvm integration

Their current version/vision perhaps is yes. But they're still the market leaders (Although Apples problem with innovation procrastination when market leaders is frustrating).

I guess we have to wait for competition here before we see things move faster(particularly better human interfacing etc). All in all they shoot to the expectations of their users. (And the competition simply plays catch up)

Im waiting for the "total recall" (the new one) style hand/pane/internal projections but that might skip watches and go straight to a neuralink thing.

I was very impressed by this https://youtu.be/jMkR9VF2GNY which also states minix 3 (from the author) is now a microkernel and hosts a modified netbsd like (service based) system.

This is based on little kernel from recollection (noted somewhere in the docs)

https://github.com/littlekernel/lk