HNHacker News
TopNewBestAskShowJobs

nhoughto

451 karma · joined October 9, 2014

submissionscomments
nhoughto··on Parler drops offline after Amazon pulls support
Kinda interesting as a threat model, if 4chan/the wrong people can maliciously use your service enough to get it cancelled / shutdown just for the lols. I imagine a few startups aren’t building moderating content / moderation teams as part of their MVP..
nhoughto··on Draw.io and Terraform = Brainboard, Graphical Way to Do Terraform
All for trying to reduce env drift and divergence between things, but don’t think the documentation as the source of truth is the winning formula. Source of truth will inevitably be code (bc it has to capture the full weight of the complexity of your system), IaC is hard enough already with the dizzy height of the abstractions you are building on top of, having a system that adds another doesn’t seem like a winning formula to me.

All for better visualizations of terraform resources tho

nhoughto··on Analyzing the compromised DLL file that started the Solorigate attack
I was wondering the same, if the compromise is of the Orion product which presumably isn't just sitting there with open access to the internet? Like this doesn't seem to be a very broad exploit that could start on a machine with outside world access (like a Windows exploit itself) and then pivot into more sensitive areas.
nhoughto··on Tech Preview of Docker Desktop for M1
feedback loop is longer, if my workflow is:

make change -> compile -> build image -> deploy to k8s

then running docker/k8s remotely would be great but i need great upload bandwidth to be pushing fresh images everytime I make a change. In theory docker layers/caching should fix this but the reality is that you don't add individual files to an image, you had the compiled artifact/bundle/whatevs and if any file changes its going to upload it again, made worse by a change that effects many components/images/k8s pods. If you can solve the upload bandwidth problem (local servers? giant pipe?) then becomes more possible.

nhoughto··on Transitioning from Docker to Podman
“kind” is a example in my day to day, how do I run an ephemeral kube cluster in ci to deploy and test my app against without dind/kind? I want N clusters running on 1 host to support many CI jobs.

https://github.com/kubernetes-sigs/kind https://github.com/bsycorp/kind

nhoughto··on Transitioning from Docker to Podman
Docker in docker is a very common pattern in CI, in some cases is the only way to achieve certain tasks.
nhoughto··on Backblaze S3 API is having some downtime
But non s3, b2 api is up

https://f002.backblazeb2.com/file/blah

https://f003.backblazeb2.com/file/blah

nhoughto··on Backblaze S3 API is having some downtime
Looks like Europe is down too?

https://s3.eu-central-003.backblazeb2.com/

nhoughto··on AWS Network Firewall – New Managed Firewall Service in VPC
Ergonomics of SNI / domain rules suck, you think it’s ok until you have to choose whether or not to whitelist all of SQS or something and you end up having giant holes in your firewall because you can’t be specific enough and few services cater to those behind proxies..
nhoughto··on AWS Network Firewall – New Managed Firewall Service in VPC
Hmm transparent proxy, can do 5 tuple and domain filtering, can’t do URL filtering bc doesn’t terminate tls I assume? They Should update the product page and take out “URL filtering” before it confuses other people..
nhoughto··on Seamlessly Swapping the API back end of the Netflix Android app
I’ve been reading more of the Netflix engineering blog recently (got in a clickhole), what strikes about their more recent articles as they seem to be creating technical solutions (like BFF and friends) for what could essentially be process or coordination problems, and that is less exciting to me.

Sometimes you don’t own the whole thing and BFF is the best way, but in my mind that place wasn’t Netflix, but some slow moving bank etc

nhoughto··on Netflix is now doing per-shot encoding for UHD content
Interesting that it makes sense now because the economics of it have shifted, as the shift away from broadcast and towards individual stream has happened.
nhoughto··on Optimal Peanut Butter and Banana Sandwiches
He addresses people like you:

If you were a machine learning model (or my wife), then you would tell me to just cut long rectangular strips along the long axis of the banana, but I’m not a sociopath.

nhoughto··on Degoogle: Cutting Google out of your life
ironic that this is on .dev, of which google runs the TLD =/
nhoughto··on The AWS Controllers for Kubernetes
Yeah always been my thinking with aws or similar operators.

Lifecycle of resources has to be stacked like a pyramid.. I don’t really want the definition of a bucket or a database(!) to live as a crd in a cluster. I’m much more likely to destructively update a cluster than a bucket. Coupling then doesn’t seem to make sense to me.

Some upsertable stateless resources would be nice tho, like having a crd to create an iam role for a deployment would be neat, so I can deploy a workload and define a role and policy attachments using the same mechanism, works where the crd defines the entire scope of the resources, not just create a bucket that can be filled with stuff.

Begs the question of the threat modeling tho, the aws controller has god privileges in the account? If I get to use my iam crd to provision iam resources for me (super helpful) then aws controller needs high IAM privs. So now kube cluster compromise could be escalated to aws account compromise, not really least privilege. Convenient though...

But then also iam isn’t supported so ️

nhoughto··on On the Performance of User-Mode Threads and Coroutines
In my mind user-mode threads are much more about engineering productivity than raw performance. The comparison is wasteful blocking network calls using threads written in a simple synchronous way vs efficient user mode threads making network calls in a non blocking way also written synchronously.

Today to get non blocking efficiencies you need to write async code bc without loom there is no otb user mode threads, even if user mode threads aren’t as efficient in raw numbers it’s still waaay ahead of the predominant way threads are used today in Java (mostly wrt network calls).

nhoughto··on You don’t need reproducible builds
Just the build caching is worth the price of entry.

Gradle especially does a great job at this.

nhoughto··on Ask HN: How to avoid over-engineering software design for future use cases?
Summed up as YAGNI

You aren’t gonna need it.

As with anything tho, ruthlessly cutting stuff or rounding corners is in tension with supporting future capabilities, sometimes you do need it it turns out.

nhoughto··on Spark joy by running fewer tests
obviously the context matters, but putting time limits on some tests can really cause headaches.

We've had problems where builds failed when many jobs ran together because build runner contention meant that jobs took just a bit longer than normal.. and of course the re-run would work because contention is lower.. the function still behaves as expected just a bit slower, is that worth failing a test and hurting productivity?

The obvious exception is benchmark performance critical code, but run of the mill functional tests should maybe have an unreasonably high time limit bc it hurts less?

nhoughto··on Kafka Removing Zookeeper Dependency
yep so not 100% the same, but my point with linking to it is tunables / levers / control is useful. In other scenarios maybe you could get by without having to do a rewrite in Rust, maybe you could keep it in golang and tune the GC a bit.

Whilst I like the memory ballast as a clever solution, it does smell like a workaround to a solvable problem if a parameter existed to tune it directly.

nhoughto··on Kafka Removing Zookeeper Dependency
Sometimes having more control over GC is useful tho, could save a re-write.

https://blog.discord.com/why-discord-is-switching-from-go-to...

nhoughto··on Instant dev environments for cloud-native apps
Ah I see, I assumed it was a okteto managed cluster. I should rtfm more =)

Splitting parts of an env is against our principles tho, put everything together and test against real endpoints where possible, there is no api dev env or web or app, there is just a dev env.

nhoughto··on Instant dev environments for cloud-native apps
Yeah I guess that might work for some workflows, we try and keep local as close to prod as possible, and how we build local artifacts that we test as close to how we build prod artifacts. Giving us a fighting chance of being able to repro prod bugs for example, if a team was making a different set of trade offs that would work.

Thinking about it more, we have had the problem of docker desktop using a bunch of memory and slowing productivity, so shipping that giant vm elsewhere would solve for that, can I spin up 16gb+ namespace/env in okteto?

nhoughto··on Instant dev environments for cloud-native apps
“developers shouldn’t install Kubernetes locally as this requires hardware resources and deeper knowledge about this technology”

Totally disagree with that, developers should be sympathetic to the environment there code runs in, definitely spend the 5 mins to install kube through docker desktop and be done.. shorter feedback loop then too having it run properly local.

nhoughto··on AinD: Android in Docker
Could this be used to test android apps in CI? Where traditionally you run up against nested virt problems (in aws).

Not mentioned as a purpose..

nhoughto··on The war on food waste is a waste of time
Isn’t that basically the same thing? Power trip getting something banned for everyone ~= changing your own behavior and telling people about it
nhoughto··on The Slippery Slope of Docker Dev Environments
We very successfully run Kubernetes locally, in CI (via kind) and in npe/prod. There are some differences but they have been reduced over time, very strongly recommend this approach to teams for medium+ complexity apps.

We basically had Kube in prod, so worked backwards to make everything match that as closely as possible, solving the required problems along the way. docker compose for example is less likely to be used in prod and thus a poor choice.

nhoughto··on Scaling Bitbucket’s Database
I thought this too, but that then creates a likely unreasonable burden on the client. Not all user agents expect cookies either, think of all the varieties REST clients. Sounds like they would also need to internally reference the lsn too, so being able to look it up internally would be valuable.

Feels like there is something there tho in terms of approach, esp since they are keying it on user id.

nhoughto··on Tricks to start working despite not feeling like it
Feels like higher mind vs primitive mind

https://waitbutwhy.com/2019/08/fire-light.html

Loong but great read

nhoughto··on A Gentle introduction to Kubernetes with more than just the basics
Not quite the same, but good for CI jobs

https://github.com/bsycorp/kind

← PreviousPage 8 of 9Next →