> Yes, horrible, but at what point does the consensus become that October 7 starts to look like a small event in light of the death toll on the other side
At the point when other side (free palestine and alike) start acknowledging it. Two wrongs don't make something right.
Start with teaching Palestine supporters that hamas is not the answer. And maybe, maybe after that people start seeing Palestine people as victims. Without it, most people will continue supporting Israel, not because they think that it does no wrong. But in comparison with hamas and their supporters Israel is lesser evil.
as someone who moved to Netherlands couple of years ago, I started to be much more annoyed by cyclist in other countries. In Netherlands if I hear ring I know I'm doing something wrong and I need to stop and pay asses whatever I'm doing right now.
In other countries rings now seem either unnecessary (they have enough space) or rude (I'm not on bike lane, why do you demand me to give you a way).
If infrastructure is shared it doesn't mean you have more rights to pass than pedestrian.
Moreover, bell as a way to warn doesn't work. Because pedestrians will mostly get startled because of it and can actually do this sudden move you are trying to make them not do.
So if you are on fast vehicle comparing to others in the same infrastructure, you need to drive in a way, that you can't be affected of sudden turn of someone in front of you. Which basically means you need to slow down or give enough space for others to do their sudden moves.
That's basically scaled up story of 'I store my files on my computer and it is 10x cheaper than using dropbox'
While disks fail rate is already explored in another threads here, there is one related thing that catch my interest. Disk failure in such setup is not just cost of new disk + replacement cost (someone has to go there and change it!). It also inconvenience with dealing with failing requests. Ok, you are willing to lose 5% of your dataset. But are your '200-lines of code' robust enough to handle such cases. What if disk didn't fail, but start to be veeeeery slow. Does your training process can efficiently skip such bad objects. Do you have enough transparency to understand how much data you already lost? Is it still below 5%? And so on and so forth.
I feel like this article was written right after they built this construction and before let say 6 months of usage. Because I'm pretty sure their costs will go much higher than they calculated here. Especially if they start including hidden costs, like the work needed to be done on training side.
Yes, cost for self-hosting most probably still be less than aws (aws is not cheap). But it might start to be comparable with storage solutions of small ('neo') cloud providers if you buy gpu there.
>if you're reading from, like, big Parquet files, that probably means lots of random reads
and it also usually means that you shouldn't use s3 in the first place for workloads like this. Because they are usually very inefficient comparing to distributed fs. Unless you have some prefetch/cache layer, you will get both bad timings and higher costs
>They shouldn't have sold the games on Steam in countries where PSN is not available
yep, as simple as that
this would have made the situation much better. Game would have gotten lower scores and player base overall.
Doing it now and like this leaves the feeling, that they got enough money from sales and now they want to bring some traffic to psn
If you give access to your DB directly, your API effectively becomes your API with all the contract obligations of the API. Suddenly you don't completely control your schema: you can't freely change it, you need to add things there for your clients only. I've seen it done multiple times and it always end up poorly. You save some time now by removing the need to build API, but later you end up spending much more time trying to decouple your internal representation from schema you made public.
while this is technically correct, difference is that your product won't survive without openai at this point. If you need the model quality openai provides you are stuck and your product can just disappear. Because llm is core building block, irreplaceable one.
I'm in Warsaw and I see countless of zelda ads: whole walls of huge buildings are covered with them. They probably spent insane amount of money if they advertise it like this everywhere
I guess it depends on what you do and your goals. It might be not necessary to do average developers job (and full disclosure, it wasn't necessary 10 years ago as well). But understanding fundamentals gives you insights to be better prepared to choose right 'interface' when you need to. Also you can see it as a way to stretch your 'programmer muscles'.
After going through lecture topics list, I think most of those you actually need to know as a working programmer. Not because they are prerequisites, but because after couple of years in the field, you will have to touch most of those topics anyway.
>Let's keep in mind that modern hardware and software is very stable, generally
Not at any significant scale. dimm will fail, power will be down, disks will need replacement.
It is all about risks after all. If you are ok to have couple of hours of downtime if one of the memory sticks stops working - good for you. But generally any large enough business won't tolerate such risks.
I'm not saying that the cloud is the answer, but I don't see any future for single instance solution. And if you design your system like this, you are taking much more risks than necessary.
their point is simple: during the last 20-30 years we had efficiency improvements by orders of magnitude. Still we didn't have developers jobs reduction in any way. We evolved into doing more and more high-level and high-scale jobs. So no, -10% of time needed to build the same unit of functionality won't lead to -10% reduction of workforce. It will change the scope of said workforce.
>Imagine replacing poor in-memory reimplementation of database queries that most graphql servers do with actual opttimised database queries. And a better code on top.
but you are actually talking about optimizing system design, and not reducing virtual functions calls :).
And that the point of this thread: you need to optimize parts that slow you the most.
So no, in most cases optimizing virtual calls won't bring you from 1s to 30ms
no
take your tupical web service application. Even if you use design patterns that are 10x slower, your program will still be as fast as your DB and overall system architecture. And the choices on your DB schema, indexes and caches will have 100x more effect on your 99pp response time than design pattern you use.
>all things being equal, writing code with virtual functions that do a tiny amount of work and "hiding implementation details" makes performance worse, sometimes by an order of magnitude
but all things are not equal. You can spend a lot of time improving performance of you function calls and get virtually nothing out of it. Because if you optimize something that takes 0.01% of overall execution time, 'order of magnitude' performance gain is still negligible.
Also articles like this usually fail to mention code maintenance cost. For example by reducing usage of virtual calls you can make your code unmaintainable/expandable and suddenly every new change will cost you 2x more in development time.
That's why in the real world most of the time you choose clean code and you use optimized nonclean code only on places where you need it. If you look at any lets say web framework internals, you will find a lot of non-clean code, which makes framework faster. But an interface will be done in clean fashion and most of user of the framework will enjoy clean code without need to care about unclean internals.
>Write slow code now, profile and optimize later is how we got all slow software because second step
We got slow software because we were ok to get slow software. If being fast is not in requirements it means it doesn't matter (for whoever is responsible for defining priorities). Places where performance matters it is never sacrificed.
I knew a _very_ talented female software developer. And she was radically against any benefits based on her being female. For example she actively tried to avoid female discounts some conferences offered.
It seems that people who drive DEI don't have real connection with people they are trying to 'protect'.