how much did people actually follow the mandate? I looked through the pictures, and it seems to be ~not at all for picture/social situation, and maye 50% for general?
336 karma · joined October 8, 2021
how much did people actually follow the mandate? I looked through the pictures, and it seems to be ~not at all for picture/social situation, and maye 50% for general?
I'd like to play with it a bit, to compare patterns I've done before and am too lazy to copy+paste ;)
I.e. it can only be used by a single consumer, that consumer doesn't get nice things like ther kernel's file systems or device mapper (raid/crypt/verity...) features. This can be fine, e.g. when the consumer is a database that just needs a block device, or something like ceph/minio etc. that provides the storage api to its consumers.
It'd have to use something like NBD (~fuse for block devices) to actually integrate and then my previous post describes some of the downsides to that setup.
For the more technical points:
The kernel needs to have it available in a somewhat complex way to be able to mount the drive. I.e. init becomes a lot more involved with an initram that first needs to load the driver (potentially loopback it?) and the mount actual root.
To some degree there can also be issues around syscall boundaries. I.e. the usual monolith vs. microkernel. I haven't checked the API they hook into to provide the device to other components. But it likely requires the kernel to jump back into userspace in various "hot-ish" paths for IO.
And yes, in general a photo of a larger gathering is fine, singling out any person is not. So the original would be fine, the derivative not.
I.e. in practice it gives everyone the right to have their right to their own likeness enforced. Which most of the time isn't taken too serious, but is an important feature at times.
LMU down to 85 for Munich While that doesn't include a full Semesterticket, it's cheaper than Dortmund without
When I studied (2014-2018) I paid 100-150€/semester Slight trend upwards, might be 200€ now
And that was in Munich, which tends to be expensive.
There should be a service running as uid=0 that exposes an unprivileged API.
This service then takes the RPC and does authorization with polkit.
I.e. the unprivileged part doesn't talk to polkit directly. But a privileged part uses polkit instead of a custom sudoers style config.
Debian's sshd only uses libsystemd for the notify api. I.e. it doesn't need any feature that uses libxz. If it's dlopen()ed, it does not need to be loaded into the process context to use an unrelated feature.
FWIW, IMO upstream systemd should split their monolithic library and allow users to pick better that way, but this has other implications on DX.
Which the recent xz attack used to mess with `sshd`, even if it never actually used functions from the library.
dlopen loading only loads the library *when it's actually used*, and doesn't include everything and the kitchen sink on startup.
If the libraries are used seldomly enough, it might also allow to make more dependencies optional in package management.
Which isn't always in sync with their GitHub username. Which might even be "root".
Do you have the protocol defined somewhere? Wstunnel is one of our options, and we'll likely add a golang library for the solution we chose. Would be easier if I don't have to figure out the frame format from code.
We are still looking into something like wstunnel and websockets, though I'm preparing myself for the day when we have to add "normal" http1.1 support :(
TTL is still in seconds, but every hop has to decrease it by at least one.
I'm not sure if there is any implementation out there that cares, but if e.g. wifi retries or a massive buffer queue lead to a packet spending more than a second on a hop, it should decrease by two.
The thing that people usually complain about is systemd forcibly setting its process manager at pid=1. I.e. the thing "discussed" in https://github.com/systemd/systemd/issues/12843
There is a secondary feature to run per-user managers, though I'm unsure whether it does run doesn't run without systemd PID1. Though it might only rely on logind.
While in theory it doesn't it reduces the possible connections quite a bit. Though STUN servers are plenty on the internet and free to use. There's even a service providing TURN (US geo though), but I have no idea who runs it and what their business model is, so I wouldn't rely on it.
Consens algorithms are important in both safety and distributed (High Availibility) scenarios. There's no necessary link from research into that, and blockchain in general, and the Proof of X style crypto blockchains specifically.
Can you point to some research of Waller? I've tried to find it to see if it's more directly related, but the only somewhat famous person under that name I can find is a historian, not an expert in computing related topics.
There's some interesting technology blockchains lean on (remember, git storage is a blockchain) but the value proposition of crypo currency blockchains (largely 0 trust) have so far not materialized outside speculative currency.
Which is partially due to misaligned incentives (the developers of e.g. game assets in the NFT case) where the party that would have to enable something do not have an incentive to give up controle.
I should look into how to provision users at some point. but OTOH GKE takes care of it for our prod, and other clusters can be run with just admin.
But doing proper users on k8s is hard. I suspect they just run with admin credentials and no real way to generate users.
When the company is set up well on k8s, then choose k8s. If the company is set up well on VPS, then choose VPS.
If it got neither, I'm unsure what's the better way to go on a greenfield. k8s has nice tooling, but part of that is required because it is massively complex.
But with managed k8s providers (e.g. GKE with autopilot) you can just put in proper CPU and memory limits and essentially get yourself a VPS provisioned without having to worry about anything by k8s measures.
If you have different pricing or location constraints, then it might be better to go with different models and some custom orchestration.
The `.gov` tld is explicitly for US gov tasks. Whether the service is trustworthy or not is a different question. Whether it makes sense to use an external service for identification is another.
But if it's used for official means, they should at least get a branding contract and brand and host it properly. If only because the governance of `.gov` can and should be used to mark things official.
The breakdown one looks good, but the follower seems like the background got reduced width, but the active button is moving full width
2. I always wonder whether that's a timing thing vs. NetworkPolicies and encrypted inter-node traffic. Are the realistic attack scenarios where it's possible to read out intra-cluster traffic but not mess with the cluster, or even read the intra-pod traffic?
3. I've been quite disappointed with how little k8s provides here. I wish it was easier to move traffic off of an old version and only shut the pod down once the last connection was done :/ Maybe I need to look into a service mesh for that?
4. What's the difference to e.g. kubeshark, or just attaching a tcpdump debugcontainer to the pod? Another instance of first to market / potentially nicer ecosystem?
5. I get squeemish with infra-level activities like this. Yes, technically the http method and some headers should make it obvious whether that's save or might break at-least/at-most once or similar semantics. But that requires well behaved applications. While the premise here is infra imposing behaviour to allow applications to be looser around these kind of things.
Network routing can be implemented in (e)bpf. It's even the original use case.
But there's also the LSM based on ebpf, there's a user space scheduler (Google iirc), seccomp and some cgroup filters can be done in bpf...
It's the Lua of the kernel at this point. Provides a lot of extension points.
Nil requires pointer values. I.e. it's impossible to know whether something is a pointer to allow for nil, or because a copy would be prohibitively expensive and therefore references are used, or even because it's into a mutable structure.
Go's overlapping of implicit nullability and by value/by reference marker make it entirely useless to build information into APIs / necessarily promotes the value into a different type to use.
Thanks for demonstrating that you forget how to write software around erros.