With an annotation-based framework, how do you do the same? You could find usages of the annotations, and then manually read the thousands of places “@GET” is referenced?
3,664 karma · joined March 9, 2009
I previously built virtual power plants at Tibber, databases at Neo4j and fleet management Equipmentshare.
jake@davis-hansson.com https://tech.davis-hansson.com http://github.com/jakewins
With an annotation-based framework, how do you do the same? You could find usages of the annotations, and then manually read the thousands of places “@GET” is referenced?
The PR review is in public and heavily scrutinized by paying customers and passionate community members. APIs cannot be broken, and even with automated tooling it's very easy to accidentally introduce a change that breaks tens of thousands of deployments. And the code itself is really sensitive. If a bug gets in and released, it can be several days of grind to get a patch out, and after that many months of new tickets for the bug from customers that won't move to the latest patches.
Now I work somewhere where the code I write runs in-house. If a bug sneaks in, it's usually a 5-minute redeploy to resolve and the cost is borne primarily by my own team.
So I think the answer to your question is: it really depends on the environment you're writing code in. In some setups the cost of introducing mistakes is very high, so it makes sense to pay a lot at the review stage; in others the correct balance is less strict review and fast fixes/rollbacks instead.
I have a simple example, starting from a “generate all possible combinations” python function, here: https://tech.davis-hansson.com/p/price-wars.html
As for verifying Jepsen, I’m not entirely sure what you mean? It’s a non-deterministic test suite and reports the infractions it finds; the infractions found are obviously correct to anyone in the industry that works on this stuff.
Passing a Jepsen test doesn’t prove your system is safe, and nobody involved with Jepsen has claimed that anywhere I’ve seen.
I asked @theacodes on here this same question, on a post they'd written that like.. actually got into "ok, I'm putting this capacitor here, because it's gonna do <x> for me, another way I could do the same thing is..", and their reply is here: https://news.ycombinator.com/item?id=33484848
I do think there'd be a lot of value in blog or youtube series of experienced circuit designers showing how they approach things, why and how they pick components etc, it's a great way to learn. The blog post that HN thread is about is really good as an example.
I've had several people recommend "The Art of Electronics" as a reference for circuits building as well, but haven't read it yet
That the design of the plant does not directly heat water from sodium is great, but it still is useful to know the plant becomes sensitive to water issues like flooding.
Eg you can’t just do equality on collision, you need to do equality on every lookup at least once.
How do I ensure that at each customer site, my library has the set of dependencies it needs, with versions that it is known to work with? Each installation method has a different constraint solver, a different means of specifying dependencies.
However: poetry still falls short in managing the python runtime, I am continuously having to divert time to help our data scientists untangle the messes poetry makes with virtualenvs and their local python setups.
Also, they broke backwards compat on the lock file format? So now devs running newer poetry versions break projects for devs on older versions because the lock files aren’t compatible?!
Python packaging is fine for small local dev; problems arise in distribution, rollouts of upgrades and ensuring your apps work in the zoo of local setups your users have
It’s so thoroughly broken, every day a dev on some team gets their poetry env entangled with some system installed python, or numpy suddenly decides all the CI builds will now compile it from scratch on every build, or.. Today it was segfaults on poetry version X on the M1 Mac’s, that went away in version Y but of course version Y broke pandas for the windows devs..
I don’t follow this, my read was that their focus was the question: “Does the LLM maintain an internal model of the state of the board”.
I think they conclusively show the answer to that is yes, right?
What does overfitting to the rules of othello have to do with it, I don’t follow?
Also, can you reference where they used a pre-trained GPT model? The code just seems to be pure mingpt trained on only Othello moves?
https://github.com/likenneth/othello_world/tree/master/mingp...
You can look at an LLM trained on Othello moves, and extract from its internal state the current state of the board after each move you tell it. In other words, an LLM trained on only moves, like "E3, D3,.." contains within it a model of a 8x8 board grid and the current state of each square.
Thorvald
The forest by <tiny village in Sweden>I am having luck currently with embassy-rs, on rp2040, including Wi-Fi, not BLE tho.
I think overall the space is improving rapidly year-over-year. It’s hard with suppliers focusing on the C stacks and the Rust stuff being all volunteer.. but IMO things are getting better.
Mixed experience, would definitely not put it in a system that isn’t ok crashing frequently.
It segfaults on Alpine (argh, C++!), and force exits the whole NodeJS process when it gets unexpected HTTP responses from S3.
In an archive run of 2M pushes it’ll crash the process 4-5 times.
Overall still really, really like it, but learned to not trust it
Emmer contains twice as much gluten as modern wheat according to this summary paper of chemical composition, see table 3: https://www.researchgate.net/profile/Anna-Zaparenko/publicat...
If you want the worth of something you do the integral of the demand curve, not the marginal price times your volume for sale.
This is the point of my apple example; once you’ve sold the first of your billion apples, the next apple you sell will earn you slightly less, until either your supply or the demand curve runs out.
This is someone taking the "if someone's willing to buy an apple for $100 and I have a billion apples, then my apples must be worth $100 billion"-crypto math to space.
Skillset wise for software people we are looking for senior devs, ideally with experience in Python or .NET. Stack is AWS, Postgres, Kafka, Airflow, Databricks.
For management roles we are looking for someone to help build the team, eg. hiring, laying skillset puzzles etc. I'm not sure if they are open to hiring management roles outside Stockholm.
Tibber is at the center of the energy transition. Our software shapes electrical loads to match supply, allowing the grid to take on more intermittent renewable energy. We control millions of devices in hundreds of thousands of homes across the EU, things like EV chargers, heat pumps and smart radiators.
We are hiring for roles on the energy trading team. You'd work with me and a bunch of smart people at the intersection of optimization problems, electrons and climate change.
- Engineering Manager
- Software Engineers (senior roles, Python/Typescript/.NET stacks)
- Quantitative Analysts (algorithmic trading, Python)
- Power Market Traders (short-term EU power markets)
Some, but not all, roles listed here: https://jobs.tibber.com/jobs
If you're interested but don't see a role you like, or have questions, my email is in my profile.
This removes a whole slew of attack surfaces that JS and Python have, and leverages an existing “prove you are who you say you are” infra