chronial

Draw a square around Einstein's face. Call the side length of the square a and the area of the square A. We have A=a^2. Einstein takes up some portion p < 1 of that area, so Einstein has area E = pA. Now we scale the whole thing by factor f. So the new square has side lengths fa, and thus area A' = (fa)^2 = f^2×a^2 = f^2×A. Since the relative portion the face takes up doesn't change with scaling, the face now has size pA' = p×f^2×A = f^2 × pA = f^2 E.

Does that help or was that not the part you were missing?

Note that the official 7z build supports zstd compression since version 24: https://github.com/ip7z/7zip/releases/tag/24.05

What are these called / do you have a source for that? I never heard of that and a quick Google didn't turn up anything except for changes planned for 2028.

I really like this video essay that also covers convict leasing: https://youtu.be/j4kI2h3iotA?si=9-VanyLpw1rJLLUI

The right was calling Obama Hilter long before that. https://digitalcommons.usf.edu/etd/3598/

Which old times are you referring to / what are "sensible" names?

I thought about it and I don't know what a better name would be. Off the top of my Head, I know Perforce, BitWarden, Subversion, fossil and git. And then the abbreviations CVS, RCS and SVN.

Do any of these qualify as a descriptive name?

You deliberately misquoted the article, you are clearly not discussing in good faith. I won't respond any further.

photos or videos of extremely thin girls and women or bodies that serve as weight loss motivation and ideal images

Glorifications of eating disorders. That is very dangerous content, especially for minors. If you want more information: https://www.klicksafe.de/en/verherrlichung-von-essstoerungen

It's because of the headlights - they bias right and would blind oncoming traffic.

One repo uses `master` but a subtree uses `main`. If you make a mistake and checkout `main` you end up clobbering your whole working tree with the subtree.

If you replace checkout with switch/restore, that foot gun goes away.

A very effective solution for that is a well-configured shell. IF you summarize the state of the repo in the prompt, it is always visible while typing a command.

That's the reason why it was replaced by two separate, more sensible commands: git switch for switching branches etc, which is safe, and the inherently dangerous git restore for reverting changes in your working directory.

Funny, I did just exactly that at work yesterday. If your branches have linear histories, here's what to do:

1. Make sure all branches touch separate files. I would strongly recommend git-filter-repo over git-filter-branch. It's way simpler to use and orders of magnitudes faster.

2. Generate the list of commits in the correct order:

git rev-list --date-order --reverse branchA BranchB BranchC > revisions.txt

3. Go to any branch and: git rebase -i --root --force-rebase

Paste the contents of revisions.txt into the sequence editor and add "p " at the bigging of every line. Run the rebase and you are done.

I would say of the top of my head:

• Employee rights

• Health insurance

• Militarism ("What is an appropriate amount to spend on military")

• Global Warming

Are you saying that the same positions would count as "center" in Europe while "left" in the US?

Not GP, but yes – that is clearly the case.

Why would I care about the other cases?

Because you talk about the other cases when you make general statements like:

it's that FireFox just isn't as fast as Edge.

I can't change my code,

I wasn't suggesting you change anything about your code. Remember, the context of this conversation is this Statement by GP:

I hate that I know exactly why. It's because they were only ever tested on Chrome during development.

The reality is that Firefox has a tiny market share at this point, so it is questionable how much time should be invested into optimizing pages to make them fast on Firefox. But that is a problem with Firefox's market position, not technology.

My point was that when code is slow in Chrome, you change it and never notice whether Firefox would have been faster in those cases. You only test code that is sufficiently fast in Chrome in Firefox. Thus, you don't usually see the cases where Firefox is faster than Chrome.

It's not that I haven't tested, it's that FireFox just isn't as fast as Edge.

Only in this one specific case. You don't know the other cases. What you do is write code and check if it's fast enough in Chrome. If it's not you change your code. You never check if it's fast in Firefox instead and then go on with your day, saying "well chrome's just slow".

I feel like some of the nuance got lost in at least two places:

"trying to do the wrong thing with ChatGPT" vs "using ChatGPT in the wrong way" "have been "approved" by this AI" vs "have been reviewed and approved by this AI."

I prefer the original phrasing.

Besides Rust everything else is a toy without stability and backwards compatibility and/or lack of libraries. Rust is fine, it’s just that the problems it tries to solve aren’t something that experienced C++ devs often struggle with.

The single main reason for Rust's success is that this statement was proven wrong again, again and again. C/C++ devs kept repeating it, severe bugs keep getting discovered.

How would you use this with a C/C++ codebase, where you build your dependencies yourself and don't get them from a package manager? All vulnerability databases seem to refer to package repos. Is there anything that works with only library name + version?

Why would I be paying for bathroom breaks and idle time?

You want your workers to compile the code before committing it and moving on to the next task, right? But don't feel like you should pay for that?

Or are you assuming that people are like fleshy machines that can just store the data they just used on disk and work on something else while the compilation is running and then they just put that data back into RAM once the compilation is done? People don't actually multitask that well.

[...] some of this idle time is spent thinking about problems to solve related to the job, but it's something that can be done in your free time, or while commuting.

Now that just sounds like you don't feel like you should pay workers that do intellectual work for their work at all – they can do their work in their "free" time? By that logic I don't see why you don't just pay for the 1 minute it takes to commit the code once it's finished – in the end that's all you care about. Why would it be your problem how they get there?

Is this sarcasm about our absurd reality of hyper-capitalism or are you serious?

Wouldn't the perfect AI for Human^2 Chess be just the original AI you started with?

Does the CPU constantly hold the turbo speed under a single threaded workload?

Yes, I did not go into details where the differences are coming from. The base clockspeeds are the same, which is obviously the number that GP noticed not changing over the last 10 years.

Other things changed. The turbo clockspeed is one of them.

Single core clock speed hasn't changed in over 10 years now?

This is not true. I thought the same thing and you are right in regards to base line clock speed. But the performance is still increasing. I just got a new PC at work with a 2021 high-end CPU and it has 200% single core performance of the 2015 mid-range CPU in my private PC:

https://www.cpubenchmark.net/compare/4597vs2599/Intel-i9-129...

I can only quote OP on this:

But if you feel the need to transform simple linear code into a map of higher order functions because of some abstract benefits you're probably doing stuff that's too easy for you and you should get your mental challenge from solving a more difficult problem instead.

This code is only complicated because you insist on following some abstract ideal. The actual way to solve this in python is:

  total_foos = sum(elem.foo for elem in elems)
  pruned = [e for e in elems if e.foo < len(elems)]

  total_foos = 0
  pruned = []
  for elem in elems:
      total_foos += elem.foo
      if elem.foo < len(elems):
          pruned.append(elem)

I didn't mention lambdas because this is obviously transitive

  def f(myVar):
      def foo():
         return myVar + 1
      return foo

pulling those out may lose access to required lexically-scoped variables

The only situation for this that I can think of is inside a list comprehension / generator expression. You are aware that you can define functions at any scope in python?

that's not what the GP was asking for in this case.

You really think that when they mentioned the dynamically allocated `Vec` in Rust (which has fixed-sized arrays) and "manual memory management" in C, what they were actually talking about was a static array?