Hacker Newsnew | past | comments | ask | show | jobs | submit | nullwarp's commentslogin

This really is the honest truth, every interaction I have with the MS platform is somehow worse than an actual dumpster fire. AI is the only thing keeping the ship afloat. Then again maybe that's the point?

Payload is almost always your limit, not pure towing capacity. You need to look at the maximum weight payload your vehicle is configured to carry (usually on a sticker in the door jamb) - this limits how much you can tow because you need 9-13% of your trailers tongue weight on the hitch which your car carries 100%

If you have 800 lbs of payload, two 175 lb adults you now have 450 lbs left of payload for a trailer you are left with ~4500 lbs of tow capacity using 10% of that on the tongue. It's not just people either - anything in your vehicle lowers your payload (the physical hitch itself, pets, coolers, accessories, ect)

Lots of people just look at pure tow capacity but ignore tongue weight/payload capacity of what they are using to two.

Most common F-150 configurations are actually limited on their tow capacity by payload over their advertised raw tow capacity. My 2012 F-150 farm truck has 1400 lb payload, minus two people and the hitch you're at ~ 900 lbs left for tongue weight so ~ 9000 lb pull load or ~4t

The other thing people neglect to consider is just where they tow and WHAT they tow. There's a big difference between a flat utility trailer and a square cargo trailer.

I guess my point is numbers aren't everything.

Source: 20 years in the professional trucking industry


You're absolutely right, and I would hope people have at least some awareness of this. (There's enough trailer accidents & wrecks to indicate against that, sadly.)

That said, looking at the numbers still makes some sense to get a rough understanding of the design space of these cars though. (And, well, the numbers I was replying to were confusing the heck out of me.)

(My source: German class BE driver's license = car with heavy trailers. You're limited to 0.75t trailer OR (car + trailer) ≤ 3.5t without that, in B. The E is a separate exam, both theoretical and practical. Aside from theory bits on how cars with trailers behave, you have to parallel park or T-turn a trailer to pass it.)


Yeah I don't get the brag 5k lbs is nothing. That's like 450lbs of tongue weight. I've pulled that with a toyota corolla.

If you stay in first gear and avoid long downhills, you can tow almost anything with almost anything.

I did some towing of loaded ~1500lb trailers with a 1.6 liter Corolla twenty years ago and it was sort of OK... Not great, not terrible. Requires some patience and some extra planning ahead.


As a non mac user who's had to setup xcode and an apple dev account for the first time ever to compile and publish an app store app update for my company - the entire thing soured me on ever even attempting mobile app development.

It really surprised me what mobile devs put up with, just an utterly horrible hostile experience.


How have I not heard of hints mode before, that is amazing. Thanks for pointing it out I need to go remember some new hotkeys now.


Definitely stealing those hotkeys for my own terminal emulator! Was wanting similar functionality but wasn't sure of the shortcuts to use.


There is a go port of reticulum which I've used with success https://github.com/Quad4-Software/Reticulum-Go

There are also a few variants of Rust ports too (i like https://github.com/zevaryx/rettui for a full nomadnet replacement)


Now if someone did for Go what they did for rettui...


Oh thank you for mentioning it has vim mode that's been my only gripe and I had no idea it had it. don't know if it's new or not never noticed the setting.


FWIW I have Bose Frames which are great and do the same thing minus the camera.


I've never understood it either. I still deploy some things into their own respective manual deployments but for lots of things having a pre-made docker compose means I can throw it on my general app VM and it'll take 5 seconds to spin up and auto get HTTPS certs and DNS. Then I don't lose hours when I get two days into using something and realize it's not for me.

Also have you read some of the setup instructions for some of these things? I'd be churning out 1000 lines of ansible crap.

Either way since Proxmox 9.1 has added at least initial support for docker based containers the whole argument's out the window anyway.


Me neither. Docker is the platform agnostic way to deploy stuff and if I maintained software, it is ideal - i can ship my environment to your environment. Reproducing that yourself will take ages, or alternatively I also need to maintain a lot of complex scripts long-term that may break in weird ways.


I don't think I've ever seen a Helm template that didn't invoke nightmares. Probably the biggest reason I moved away from Kubernetes in the first place.


We have several Helm charts we've written at my job and they are very pleasant to use. They are just normal k8s templates with a couple of values parameterized, and they work great. The ones people put out for public consumption are very complex, but it isn't like Helm charts have to be that complex.


In my book the main problem with Helm charts is that every customization option needs to be implemented by the chart that way. There is no way for chart consumer to change anything the chart author did not allow to be changed. That leads to these overly complex and config heavy charts people publish - just to make sure everything is customizable for consumers.

I'd love something that works more like Kustomize but with other benefits of Helm charts (packaging, distribution via OCI, more straight forward value interpolation than overlays and patches, ...). So far none have ticked all my boxes.


Yeah too many times the Helm chart is barely less complex than writing all the manifests yourself because all the manifest options are still in the chart


fluxCD brings a really nice helm-controller that will allow to change manifests via a postRenderers stub while still allowing to use regular helm tooling against the cluster.

https://fluxcd.io/flux/components/helm/helmreleases/#post-re...


Yeah, but then it is yet another layer of configuration slapped on top of the previous layer of configuration. That can't be the best solution, can it? Same thing for piping helm template through Kustomize.


Yeah, this setup is both nice and insane. If you don't need much extra customization it's great. But I have a setup where I needed both postBuild and postRenderer's + actual kustomization layering and it was awful trying to figure out the order of execution to get the right final output.

In hindsight it would have been much faster to write the resources myself.


Use helm to generate the manifests with a Makefile, use Kustomize to change said manifests for prod, staging, etc.


Kustomize can render Helm charts. It's "very basic" as in Kustomize will call the Helm binary to render the template, ingest it and apply patches.

I wrote a tool called "easykubenix" that works in a similar way, render the chart in a derivation, convert the YAML to JSON, import JSON into the Nix module structure and now you're free to override, remove or add anything you want :)

It's still very CLI deploy centric using kluctl as the deployment engine, but there's nothing preventing dumping the generated JSON (or YAML) manifests into a GitOps loop.

It doesn't make the public charts you consume any less horrible, but you don't have to care as much about them at least


Yes, this is the key. Helm charts should basically be manifests with some light customization.

Helm is not good enough to develop abstractions with. So go the opposite way: keep it stupid simple.

Pairing helm with Kustomize can help a lot as well. You do most of the templating in the helm chart but you have an escape hatch if you need more patches.


That's generally what I try to push for in my company.

A single purpose chart for your project is generally a lot easier to grok and consume vs what can be done.

I think the likes of "kustomize" is probably a more sane route to go down. But our entire infrastructure is already helm so hard to switch that all out.


I've personally boiled down the Helm vs. Kubernetes to the following:

Does your Kubernetes configuration need to be installed by a stranger? Use Helm.

Does your Kubernetes configuration need to be installed by you and your organization alone? Use Kustomize.

It makes sense for Grafana to provide a Helm chart for Grafana Alloy that the employees of Random Corp can install on their servers. It doesn't make sense for my employer to make a Helm chart out of our SaaS application just so that we can have different prod/staging settings.


This has been my argument for years now.

I think it is because most engineers learn to use Kubernetes by spinning up a cluster and then deploying a couple of helm charts. It makes it feel like that’s the natural way without understanding the pain and complexity of having to create and maintain those charts.

Then there are centralised ‘platform’ teams which use helm to try and enforce their own templating onto everything even small simple micro services. Functionally it works and can scale, so the centralised team can justify their existence but as a pattern it costs everyone a little bit of sanity.


I'm ashamed to say it but I cannot for the life of me understand how kustomize works. I could not ever figure out how to do things outside the "hello world" tutorials they walk you through. I'm not a stupid person (citation needed lol), but trying to understand the kustomize docs made me feel incredibly stupid. That's why we didn't go with that instead of Helm.


Helm requires you to write a template and you need to know (or guess) up front which values you want to be configurable. Then you set sane defaults for those values. If you find a user needs to change something else you have to edit the chart to add it.

With Kustomize, on the other hand, you just write the default as perfectly normal K8s manifests in YAML. You don't have to know or care what your users are going to do with it.

Then you write a `kustomizatiom.yaml` that references those manifests somehow (could be in the same folder or you can use a URL). Kustomize simply concatenates everything together as its default behaviour. Run `kubectl kustomize` in the directory with `kustomization.yaml` to see the output. You can run `kubectl apply -k` to apply to your cluster (and `kubectl delete -k` to delete it all).

From there you just add what you need to `kustomization.yaml`. You can do a few basics easily like setting the namespace for it all, adding labels to everything and changing the image ref. Keep running `kubectl kustomize` to see how it's changing things. You can use configmap and secret generators to easily generate these with hashed names and it will make sure all references match the generated name. Then you have the all powerful YAML or JSON editing commands which allow you to selectively edit the manifests if you need to. Start small and add things when you need them. Keep running `kubectl kustomize` at every step until you get it.


this, our helm charts are flat and for year only passed in the image as variable


What did you move to?


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: