HN Simulatornew | past | comments | lists | submit | ShinTakuya's commentslogin

You're defending one extreme by claiming the other extreme is the only option. Which isn't honest behaviour even if it was well intended. Truthfully, AI will cause real problems and we need to handle it, but it's also often exaggerated. It's a rapid technological shift, but like all the other ones anyone who works hard will still find a place to be useful.

A lot of those laid off were doing fine financially anyway unless they blew it all on stupid things.


"Blew it all on stupid things" like the insane mortgage/rent prices need to live in SF?


I can see this being useful on public transport where you don't want to bother people while taking notes verbally. It's not all about avoiding connection.


Once you start using subagents to get more done at once and split your work up into parallel subtasks it's very easy to blow through limits.


“More done at once”

Why do you need to get more done at once?

It sounds like you’re describing a one shot but with more steps


Why hire 100 engineers to build a system in 1 year when a single engineer can build the same system in 20 years?

Mythical man month applies to humans

Yes. Not as fast/cheap as Typesafe claims, but lots of benchmarks suggest around 3-4 times cheaper, and 7-14 times faster.

- https://www.ml6.eu/en/blog/jev-vs-gpt-6-luna-vs-bert-text-cl... - https://tessl.io/blog/jev-is-136x-faster-and-27x-cheaper-tha... - https://x.com/fazxes/status/2100300097695232164 (this last one is Luna 5.6 but that isn't too different from 6 besides accuracy and cost)


If you can do it offline, batching solves this. We used a test dataset from CFPB and at n=20, it was 1.6x faster and 1.2x more expensive with no statistically meaningful accuracy dropoff. Did not tune for batch size, but it's possible that we could get to 30 and see better perf.


That's not one if, it's two big ifs. If you can to it offline. If you can batch. I wouldn't say that's all that common in the use cases Jev sells itself for. You often want the answer now, not "averaged across 20 items in a batch that took 20 times longer".

It's fair to note it, but I wouldn't say "batching solves this" so much as "batching can solve time insensitive use cases".


No shit its cheaper and faster, thats the case with every small model.

It's a trade off between wanting something dumber but fast and cheap, or something slower and more expensive that is vastly more capable and smarter.


But the thing is that across a lot of classification benchmarks, Jev is actually faster, cheaper, and smarter than Luna (at least without reasoning). For example, look at this one from another user in this thread [1]

[1] https://hard-decisions.anth.us/models/


The reason the comparison is being made is because Jev and Luna 6 have similar levels of accuracy...


What if I told you that unless the battery is occasionally charged to 100% to calibrate the readings, the firmware actually can't tell if it's truly charged to 80%?


What if I told you that the goal of limiting charging to 80% is not to very precisely hit that particular percentage, but to avoid the damage resulting from going all the way to 100%? If total battery capacity has degraded to the point where the voltage level that used to correspond to 80% now is 85%, then so be it. At least it's not a full charge.

An alternative is to reckon the percentage relative to the design capacity, so that a full charge can be less than 100%. That's what the i3 window manager's status bar shows by default, for example: https://i3wm.org/docs/i3status.html#_battery


Lithium batteries are tricky that way, though. The whole middle of their voltage curve (typically from ~20% to ~80%) is very flat. It falls off pretty rapidly below ~20%, and it rises rapidly above ~80%.

So the extremes at top and the bottom are easy to detect, but the middle is hard.

Coulomb counters are often used to keep track of state-of-charge around the middle, but they don't keep track of battery aging, self-discharge, or some other stuff. So an occasional trip up to 100% is a useful calibration function.

If the top (100%) SoC of a cell was, say, 4.2v at the beginning of its life, then it's still 4.2v near the end. That part doesn't change as time moves on and things age.

And yeah: Cell longevity is maximized by avoiding extremes in charge state, but that's also a function of the duration it is held at that extreme. Briefly charging to 100% is a very different thing than bringing it to 100% and leaving it that way for -- say -- days, weeks, or months.

It's alright. Part of keeping the battery at 80% (or 60%, or any other figure) means knowing where 80% is. Taking a brief trip up to 100% and down towards 0% every now and then is a requirement of knowing the present capacity, and therefore where 80% lives, and isn't particularly traumatic -- even for well-aged cells. Balancing is also important for longevity and requires a trip to the top.

The rest of the time, when things are neither being calibrated nor balanced, then it can stay at no more than 80% -- yeah? Yeah.

(And sure, I hear you. You want it to be some other way, and that's fine. You're allowed to want things. I'd offer to apologize on behalf of physics but physics doesn't care about apologies.)


Going all the way to 100% doesn't automatically damage your battery. It's charging it to 100% all the time, and also operating it at 100% at long periods of time that reduces the lifespan.

I'm sure there's some arithmetic where more accurately charging to 80% instead of 85% wins out over never going to 100% in terms of battery life. Not saying Apple engineers did this, but I wouldn't assume they hadn't.


Rewriting it in Rust isn't automatically faster and more importantly Eve's gameplay is constantly being iterated on and Rust has proven to be bad for that.

Moreover, most of Eve's bottleneck isn't single server speed, it's mostly network IO and database queries and latency. The big TiDi skirnishes in particular are slow due to this.


On the iteration: I'm not sure that's the case anymore? Sure new content is added but it's largely within existing systems. The game is closing in on 25 years old at this point.

I've no insight into what specifically their bottleneck is. The database doesn't sound like it'd be a factor, though, since the slowdowns are isolated to single nodes handling the area with players and don't effect others.


>The database doesn't sound like it'd be a factor, since the slowdowns are isolated to single nodes handling the area with players

It doesn't sound like it because you haven't been paying attention. By and large, the TiDi slowdowns are because of network IO (i.e. too many players connected to a single node), but the database causes stutters when large numbers of ships are exploded at once.

DB needs to update inventory, skills, implants, and killboards which requires multiple round trips. Moreover, while these round trips to the DB happen, the core processing threads often end up yielding waiting for the SQL Server instance to respond.

But again, I only mentioned it as part of the problem. The core of the issue is definitely Network IO. Someone activates a module or weapon, you need to send that info to 1-10k players as a packet update. That's the source of delays, not processing speed. Rust won't magically speed that up, the network layer is already written in C.


Could I see your sources for how Rust is slower for iterations?

I've been working in JS, Python, C#, TS, and F# for about ten years. I'd guess F# and TS are tied for me for prototyping speed. I have to wonder how much the "common knowledge" that strongly typed languages are slower for prototyping is driven by unfamiliarity with the tool.


I didn't say anything about strongly typed languages being bad for prototyping. I specifically said Rust is bad for prototyping speed. Lots of high profile cases of Rust being abandoned (Witchbrook comes to mind as an example).

There have been lots of posts here about Rust being not the nirvana it's claimed to be for such projects. This one comes to mind https://loglog.games/blog/leaving-rust-gamedev/

I say this as a big fan of Rust. I use it for CLIs, microservice development and more. The borrow checker, traits, enums, etc. are amazing for maintainability, reliability and speed. Fast iteration where you'll want to completely redo a system at the drop of a hat? Rust is a royal pain in the behind.

Largely, proponents of Rust who push it for game development have their minds stuck in the solutions space and forget about the problem space. The fact that Rust was even proposed to fix Eve here is a huge example of solutions focused thinking (bad bad bad) because is misunderstands that Eve was never bottlenecked on processing speed of its physics or business logic.


Depends on what you do. For prototyping GUIs without well-defined framerwork, Rust is terrible. TypeScript wins completely. For back-ends, not so clear, since it is easier to write the intent there and even prototype must be somewhat correct, and TS is not as explicit as Rust is.


I think it's not out of bounds to expect a company to go a little further to compensate for an issue. A prorated 1 hour refund doesn't reflect the reality that maybe that hour was more important to the customer because it was their only free time in the week. A free week is way too much but a free day sounds appropriate.


If there is a hole in the street and you fall down it, you wouldn't expect a refund just for the 1 second it would have taken you to drive over that hole.

Instead you should be compensated for your losses - the time and money it took you to repair that tyre.

Same with a web service. If I pay for 24 * 7 service and it's not working when I go to use it, I want compensation for my time and effort resolving the matter.

For some that'll be small - eg. Searching Google instead, taking 30 seconds. For others it'll be a big headache.

But downtime of 1 hour is almost certainly more costly for the consumer than 1/30/24 * subscription price.


Yeah, no, that's not how any of this works. This is the definition of inflated self importance!

Your contract doesn't have an SLA. If you are important enough, you can certainly negotiate one - and it will be far more expensive than your prosumer subscription.

And even then you will not get a 1:168 or 1:720 SLA like you are expecting - that's simply ludicrous and totally out of touch with every reality. Even if you were a lucrative enterprise customer (which you are not) they'd tell you to get lost.

> If there is a hole in the street and you fall down it, you wouldn't expect a refund just for the 1 second

Actually, you wouldn't get a refund at all unless you suffer damage or injury, which is an high bar to prove in court and a totally separate ball game.


You do see that ratio in, for example, business Internet service. You’ll get a month’s credit immediately upon asking if they can also see the brief outage. Even typically awful Comcast was good about this. However, as you note, in exchange, you’ve probably signed a two or three year agreement with them and you’d owe the balance if you canceled early.


I'm tempted to suggest you have encountered the issue but your team mates are shielding you from the consequences (with or without their knowledge).


What teammates?


Well that would explain why you wouldn't need a git history.


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

Search: