linkdd

The website and wikipedia article about transcendental meditation raises some huge red flags, looks a lot like a sect.

> lowlife

Get down from your ivory tower...

> If you're caught or admit to cheating even once in a professional competitive career that's it - You should be out for good

Yeah, justice!

If you steal something once in your life, straight to jail, for good. If you have a speeding ticket, no more driver license for the rest of your life.

After all, people don't change, any mistake in life should be fatal and destroy your entire future.

</sarcasm>

I like to have a message bus to send messages to queues and have systems consuming those queues.

The shared mutable reference to this message bus would be provided to each system requiring it. It's easily achievable in Rust with Bevy, or with Unity DOTS.

When I don't use Unity DOTS and simply good old MonoBehaviours, I call the message handlers as soon as the message is published instead.

A database API not following the https://peps.python.org/pep-0249/

Weird, but let's see...

https://isqlite.readthedocs.io/en/stable/howto.html

  > Since sqlite3 converters and adapters are registered globally,
  > importing isqlite will affect the behavior of all sqlite3 connections
  > in your application, even those that use the sqlite3 module directly.

That's a big no no. But I'm not sure that's entirely `isqlite`'s fault.

Rust + Clap

Go + Cobra

Python + Click

> When you come at people with the attitude the author has, you should expect it right back at you.

The attitude being: a clickbait title immediately dismissed as "an opinion" -->

  An opinionated approach to writing (GNU) Makefiles that I learned [..]

  Use the above as guidelines, not dogma

But maybe you haven't read the article and was just offended by the title. Still not a good reason to insult people like you did. The author of the article never insulted anyone.

> it should have no place in professional presentations

Good thing then that this article is posted on a personal website. It's not even the author of the article who posted the link on HN.

Still not an excuse to insult people.

There are a million other ways to express your opinion without ad hominem insults.

Learn how to communicate and chill, no one forced you to read the blog post, and you could just have ignored it.

TBH, I understood it was sarcasm. I thought it was funny to note the combination of "NFT" and "no scam" anyway.

"NFT" and "no scam" in the same comment. Bold.

Those damn internet points brings out the worst in people.

But there are almost no internet points on HN.

Erlang/Elixir and Kubernetes are, IMHO, the best platform to write distributed applications:

- who needs microservices when you have the OTP framework and gen_servers? - "let it crash" philosophy: supervisors will restart your processes automatically - design fault tolerant systems at the application level with supervisors and OTP applications - design fault tolerant systems at the infrastructure level with Kubernetes - bring the two together with Horde and libcluster - store in-memory distributed state with Mnesia (who needs Redis?) - Phoenix and Ecto for the web stuff

Currently working on https://kubirds.com , a Cloud-Native Supervision Engine. Think alerting similar to Nagios/Icinga/Centreon but as a Kubernetes Operator which can run almost any Docker image.

We are also building on top of this a trading bot with a FinTech company, and a SaaS website monitoring service for non-tech people.

We are also considering building, still on top of Kubirds, a No-Code notification automation/aggregation platform -> https://1-click-notify.carrd.co/

Because running a VM or a Container is still not a trivial task.

Will you use a Virtualbox backend? Hyper-V? VMWare? Something else? How much RAM and CPU will you require for it? What about networking configuration which can easily change from system to system?

If it's based on Kubernetes, my associate and myself are working on https://kubirds.com/

But I guess you might want to go with either Icinga or Zabbix if it's not based on Kubernetes.

I was talking about std::vector (and Rust's Vec). Those are dynamic arrays (as in, growable allocations of memory that store a contiguously typed value).

Well, the data structure is called a dynamic array

For a contract based language and a "really dynamically typed language", I'm working on https://letlang.dev

And it's because I haven't thought yet about how to do static type checking with such a feature.

I haven't got any time to work on it in the past few weeks, and I'm the only dev (would really love some help). So, it will be ready when it will be ready :P

Thank you! This is the one!

Thank you for the link.

But once again, this is not it :(

This website shows you snippets of code and you have to guess the answer. The website I'm talking about showed you outputs, and you had to guess the snippet of code.

Thank you for the link, but unfortunately no.

The website I'm talking about was like a game, you had a textarea where you type in the snippet, and the website would evaluate it and tell you if it matched the output or not.

It did not provide the solutions, you had to come up with them.

Unfortunately no.

This repository is a list of weird javascript stuff, the site I remember was a list of exercise and you had to find/input the snippet of code in a textarea that was then evaluated.

For the record, it's not https://jsisweird.com/ as well since here it asks you what the output is.

It's not a joke, I meant to say that the executable is standalone and does not need to be installed in `Program Files` or whatever.

Genuine question, how does a project, where every example returns a 404 and the source code is not available anymore, can reach the frontpage of HN?

It's quite frustrating when most of my submissions die without ever reaching the frontpage. Am I so out of touch with the HN community?

Author here,

I've always been a fan of Lua and how well it is designed. I wanted to try myself to implementing something similar in Rust.

This project is still a Work In Progress, but I'd love some feedback from more experienced Rust devs.

My current implementation is very naive and probably do too much allocations.

Yet, I think this can be a huge plus for the ecosystem to have a GC-less interpreted language similar in design to Lua.

What I especially like about Lua is how it is easy to interface it with C / C++, so that is the first thing I copied: the ability to interface easily with Rust code.

Jaffa kree!

"pool of talents" vs "pool of people who jumped on the hype train 2 weeks ago"

Many people are searching for Rust jobs, but few have a really strong experience with it.

The initial setup (managed k8s + nginx + cert manager) takes 1h top.

Writing a Deployment/Service/ConfigMap/Ingress is about copy-pasting, `helm create your-chart` will even generate those for you, and you only have the values.yaml to fill out.

From experience, there is really no overhead to that simple setup. Our Github repositories each have a CI/CD workflow (github actions) to build and push the Docker images to our Dockerhub account. Creating a new repository requires copy/pasting (in fact, we automated this with a template repository).

We have a repository where all of our Kubernetes resources/helm charts/... live and are deployed automatically when merged to master/main (github actions again). This was setup once and requires no maintainance. We have no need for ArgoCD/FluxCD (aka: divergence reconciliation) at the moment, so this is enough.

Everything else I listed are extra that are not needed for small companies, but can be added later as you scale/grow.

My point is that when you scale/grow and start needing this extra complexity, the existing setup do not need to be changed.

> I remain of the unpopular opinion that k8s is really only suitable for companies which are the size of google (imho)

This is simply not true if you use managed K8s (DigitalOcean, Google GKE, Amazon EKS, Microsoft AKS, ...).

Kubernetes provide a unified API to handle almost every aspect of your containerized application (networking, load balancing, rollout deployments, storage management, service discovery, ...).

You might not need many of those, but you won't have to learn another tool to set it up once you do need it.

Buy a cheap managed k8s with a single node, helm install nginx ingress controller and cert manager (with letsencrypt). Make your app read config from an environment variable, put it in a Docker image, push it to either ghcr.io or a gitlab container registry. Write a Deployment, a Service and a ConfigMap, eventually an Ingress resource and voila. Your app is up and running in no time.

Repeat the last 3 steps for all your apps. It's that simple.

You can then work from there if needed:

  - setup a terraform to automatically setup your managed k8s and managed databases (if you need it)
  - setup a CI/CD pipeline to build/push your docker images (github actions, gitlab CI, jenkins, whatever)
  - add Prometheus monitoring and a /metrics endpoint in your app to scrap it
  - add HorizontalPodAutoscaling
  - store secrets in a Vault and inject them in your pods with k8s based auth to the vault using the pod's service account
  - add more nodes to your cluster
  - ...

None of those steps are required to start doing things, and all can be added without changes to your apps.

Yes, for small needs systemd+docker on an EC2 instance can get you far enough. But you'll need to rewrite everything when you need to scale. With Kubernetes, you won't need to rewrite anything.

If you want to self host and operate a k8s yourself, that's a complete other story, and I agree with you that you should not do that if you don't specifically need it.

> Getting deterministic behaviour out of it is.

As you said, there is `pip freeze`, but also the Pipfile.lock for pipenv and the poetry.lock for poetry.

> but sooner or later you'll want to upgrade something that depends on something you froze, and so then you have to unfreeze everything and hope that nothing else breaks

Same for Rust with its Cargo.lock, same for JS with it's package-json.lock or yarn.lock, same for everything that lets you freeze your dependencies.

EDIT: That's also what test suites and CI/CD are for.

> The Python ecosystem has many options because they all suck.

They let me write software, manage dependencies and virtualenvs, there is even pdm which supports the recent PEP for __pypackages__ (equivalent of node_modules) instead of a virtualenv.

Can you clarify how every single one of them suck?

> they still haven't managed to catch up with where Maven was 20 years ago

What does Maven do to prevent the problem of upgrading frozen dependencies?

> I'd argue they've actually gone backwards in some ways, e.g. including pip in newer versions of Python

Care to clarify?