This seems really badly argued. The second version seems much worse and harder to extend. Looks like classic ORM style database abstraction wrapped with hand written types. This type of code usually leads to inflexible data models and inefficient n+1 query patterns. Relational algebra is inherently more flexible than OOP/ML-style type systems and its usually better to put as little clutter between your code and the db queries as possible in practice.
Collisions are violations of the pairwise non-intersection constraint between bodies. Collision forces are Lagrange multipliers of these constraints. Collision normals are the (normalized) partial derivatives of the constraint function wrt one of the body's configurations.
That sounds like the kind of thing which works if you're doing physics at 1kHz+ with an integration algorithm with good numeric stability which honours conservation of energy, but in games, we're often running physics at down to 30Hz using some ad-hoc Euler-Chromer, which requires very different approaches
It's still the same principle even in games. If you are trying to explain where forces come from and how resolution works, you need to ground it in something. Otherwise you are just adding extra assumptions onto assumptions.
In proper physics simulations, everything's about forces, most things are springs, and you never teleport stuff. In games, modelling the ground as a spring really doesn't work and teleporting entities when they collide with parts of the world often makes a lot of sense. It's just not the same.
EDIT: If I'm incorrect, please explain how. I've written some game physics systems and seen some proper physics sim systems and these comments reflect my understanding of the situation, and if I've said something wrong, please correct me instead of just downvoting.
The principle of least constraint is the basis for rigid body mechanics based contact forces. This has been known since the days of Gauss and Hamilton, and is fundamentally how restitution and collision forces are derived in Lagrangian mechanics. There's a long literature on this going back more than a hundred years.
It's true that some commercial solvers like Ansys use spring/penalty methods, but this is due to the spring forces being easier to couple to other solvers. It's harder in the Ansys force/velocity formulation to combine things like elasticity and fluids to their rigid body solver. To deal with the instability of systems of many stiff springs they have to take many small timesteps to avoid convergence issues.
More recently techniques like XPBD have been gaining popularity, particularly in film, which use purely positional constraints and variational methods to combine many different types of physics simulations. There's a really great and approachable series of videos by Matthias Muller on youtube which goes through how to implement all this in JS https://matthias-research.github.io/pages/
Finally it's funny you should mention games, since many older games used spring methods for physics. It was only when constraint based solvers became popular after Havok/Half-Life 2 did we start to see games with real rigid body dynamics and stable stacking of boxes. Older physics games like Trespasser ( https://en.wikipedia.org/wiki/Trespasser_(video_game) ) had many bugs due to the use of hacky spring physics. For a good explanation of how games do it today look at Erin Catto's work on Box2D https://box2d.org/publications/
Most games since Half Life 2 use constraint forces like this to solve collisions. Springs/penalty forces are still used sometimes in commercial physics solvers since they're easier to couple with other simulations, but they require many small timesteps to ensure convergence.
TI92 graphing calculator and the instruction manual. Hundreds of pages of weird math functions to try out and understand. Triggered some kind of weird pokemon-esque collect em all ocd instinct in me and I ended up learning programming as a side effect.
I think one thing that's missing in a lot of current programming education is too much focus on the grammar and basic constructs and not enough focus on the nouns and verbs. Environments like MATLAB, QBasic and even JS are great because they have lots of little bits of random stuff you can just start poking at and plugging together. I wish there were more beginner references which start with lots of random facts about assorted bits and bobs instead of trying to preach some boring grand unified theory of coding.
In china an employer is required to pay something like 30% of your salary if it elects to enforce a non-compete. If the company doesn't pay you, then it's non-enforceable. Assuming you were at some decent compensation, this can actually be quite a bit of money. So if these workers took that pay cheque, they get to enjoy the timeoff during the non-compete and go party or start a family or whatever. The downside of the non-competes in China though is that because you are being paid to NOT work, if you start moonlighting or doing something sketchy the penalties are way more severe. I actually kind of like this approach to non-competes and it is in some ways better than how it works in many US states.
The big problem with this system is not the penalties for breaking it, but the fact that it can sabotage you if you get hit too early in your career with a big gap. On the other hand, it gives you a nice opportunity to take a year or two off to start a family, spin up a new business or go back to school.
30% of an entry level job is not a living wage, let alone a lot of money.
This guy was getting about $6k per year for his non compete, and has been sued for $60k. This has effectively destroyed the prospects of this guy’s entire life. He couldn’t mentally endure what they were demanding, and then they gave him a non living wage while simultaneously forbidding him from finding employment.
“Yao’s agreement prohibited him from working for rivals for nine months, during which time he would receive Rmb3,700 ($513) a month. It was too little to live on, Yao said.”
Yeah, and it's very weird to bring a non-compete down on an entry level worker like this. Under what circumstances is it even worth it for PDD to spend the resources to enforce and monitor this kind of an agreement? I wonder if there's more to this story than the FTA?
Also keep in mind this guy could have easily gotten a different job while still collecting the non-compete pay at a non-rival company, even still doing programming. Something about it doesn't quite add up to me.
> Under what circumstances is it even worth it for PDD to spend the resources to enforce and monitor this kind of an agreement?
Do you know that the marginal cost for monitoring an extra ex-employee is that large? If they catch someone like him, it seems like it has to pay for itself.
> they get to enjoy the timeoff during the non-compete and go party or start a family
On one hand, you have a guaranteed income for a few months, but I wouldn't be starting a family or partying if was living somewhere where I expected to make over 3x more. Here, rent alone is expected to a third of your income.
> 30%
> Assuming you were at some decent compensation
Assuming your compensation was well above average and you lived quite frugally and well below your means.
There are countries in Europe where you can claim unemployment even if you left on your own and that would pay more so it doesn’t seem like a very good system at all. Of course nobody would really expect a “communist” country like China to not have garbage tier workers rights..
The financial analysis of how AI cloud contracts are structured in the middle of this article was very interesting, but the whole thing is marred by this tired discussion of AI hallucinations.
It's true present models aren't perfect, but they're improving fast and they're still quite useful for many applications. The real question I think for many observers right now is will these things continue to improve quickly or are we approaching some kind of plateau?
Imagine you are developing a thing like Chat-GTP or whatever Google calls Bard this week.
You see it is growing quickly. You could productionize now, or invest a bit longer and make it 2x better.
An independent problem is that your model is really powerful, but left to it's own devices it spouts the worst of 4chan right alongside high quality reddit comments.
When do you ship? You have 2 criteria: After you yoke it to not be a Nazi and once returns on quality investment start to fall.
Both Google and OpenAi hit the point where returns started to diminish. It turns out the hard part was yokeing it. OpenAi, being more agile, throws massive pools of borderline slave labor at the problem while Google is still ramping up their "let's just throw supervised training at the problem" solution.
These products were released past the inflection point of the sigmoid. The marketing is strong to re-create the old moore-law hype to re-loosen investors wallets, but the return quality investment is already diminishing. The primary way it is changing is in finding composition of tools and new use cases.
Clean the marketing scales from your eyes and feel welcome to the plateau.
And yet, ChatGPT can generate these strings. Somehow despite using the wrong loss function it still seems to work by simply absorbing more training data.
It can also recognize them, albeit it tends to cheat by shelling out to python (which makes sense, since it tends to lose count on large strings just like a human...)
ChatGPT incorrectly put a space between the as and bs, but if we let that slide, there's still the issue that the best trained model in the article got 77.3% of the first 1500 strings correct, i.e. even if ChatGPT performed exactly the same, you'd expect it to get a single example correct more often than not.
The difference is that you told it the language you wanted to recognize. In the paper, they are trying to learn the language from example strings alone.
