A major problem with decoupling property taxes on owner-occupied housing from market prices is that it removes the biggest incentive for a homeowner to vote for policies that keep the local real estate market in check. An owner occupied house in a desirable area where there is no disincentive to politically engineering a supply shortage becomes a financial investment. Any increase in housing value becomes profit for the owner (or their descendants). This leads to supply restrictions and escalating prices and an increasingly unhealthy society as the young and the poorer are pushed out of the city, county, or even state.

This is essentially what has happened in coastal California over the last 60 years.

Why shouldnt coastal property be crazy expensive? It's the most scarce land there is.

The land should be expensive, the housing doesn’t need to be.

With different policy, there could be more housing built on the same land. The most scarce land there is shouldn’t be predominantly zoned for only low density single family homes.

Land value tax solves this

We could easily build apartments on the coast in CA and then non multi millionaires might be able to live there. We have decided that only multimillionaires deserve to own a coastal house by restricting zoning in the coast so heavily

It's funny because it happens at all levels.

The uber wealthy have their gated communities in the hills.

The very wealthy have their lock on places like Carmel.

The upper-middle class in Santa Cruz or Half Moon Bay try to prevent new condos (or student housing) from being built, because it "destroys the community character."

Everyone wants to pull the ladder up behind them.

Yea, the point of property taxes is to stop that from happening.

Austin has been begrudgingly growing up, not without a raft of complaints from locals, because the property taxes are high enough to make selling to a developer tempting. In return, Austin has remained relatively affordable in comparison to other tech hubs.

This then means there is no real fix to anything since basic human greed always prevails. May explain why things move slowly if at all.

Not true, we have infinite coastline.

If those places became worse places to live as a result, wouldn't that drive property values down?

According to the massive drop of properly value near a certain Tenderloin quarter, yes.

Use the split-debuginfo setting in your Cargo.toml to have the DWARF bypass the linker (on Linux, YMMV on other platforms).

Rebuild civilization while avoiding the mind worms.

If you don't _need_ subnormals MXCSR.DAZ/FTZ (which you can get gcc to set via -mdaz-ftz) will let you ignore all of this.

Most people who believe that they do not need subnormals do not actually know whether they need or not subnormals and it is very likely that they need subnormals.

The options mentioned above are guaranteed to generate big errors, so they are acceptable only when errors really do not matter, e.g. in graphics for games.

The only correct option for avoiding subnormals is to enable the underflow exception and handle it in a manner that is considered more suitable for that application than the use of subnormals.

IIRC intel’s compilers enable FTZ/DAZ, at least at higher optimization levels.

Which is certain to produce big errors at every instance where a subnormal result would have been generated or propagated otherwise.

Such options exist only for games or for experts in numeric analysis, not for general-purpose programming.

GCC does with the infamous -ffast-math as well.

IIRC that has been since split out of the flag and need to be asked for separately at link time.

If you use -ffast-math when linking an executable but not a shared library, both gcc and clang will link in crtfastmath.o which has the bit of code to set the DAZ/FTZ flags.

right, but the issue was that if an application was linked with a library that happened to link with a fast-math shared library, it would unknowingly bring along the crt code. Now the only way to get it is to use the fast-math flag when linking the final binary, which at least is an explicit request.

If the folks at OpenAI aren't qualified to be operating these systems who would be?

One obvious reason to have an LLM output a high level language even if you are never going to read the code is because it will require fewer output tokens and therefore be cheaper.

Typescript is not meaningfully a higher level language than Java, C#, or even Rust. Typescript exists for exactly two reasons:

1. JS is a privileged language and allows you to tap into web and node

2. Type safety is good

But TS is not a good language overall. It's just much slower than alternatives and much less safe.

It's not immediately clear to me why having an LLM output code in JS or Python should inherently consume more tokens than C or assembly. I'd expect token usage to correlate with the complexity of the algorithm being implemented, not with what specific language syntax it's being implemented in.

But either way, token consumption is only a relevant concern if you still expect to be using SaaS LLMs by the time you're ready to have them target lower-level code for you.

If LLM-generated code continues the human pattern of having roughly the same rate of bugs/LOC regardless of language, then I also expect LLM-generated code in high-level languages to be less buggy.

But why would we expect LLMs to continue that pattern over time?

Yes, it's management with little concern for human factors because you can abuse or and even fire your reports and summon new ones of equal competence at will.

Isn't that just regular management?

Regular management, no matter how bad the tendencies go, is still, at the very least, constrained by a cost to fire people, which can be years of salary and some paperwork on top.

That's odd, I seem to see the incentive to fire people with stock value improving as a result.

And since management is often paid in stock, they seem to care more about stock price than this "years of salary and paperwork" cost you mention.

You're conflating two things (probably intentionally, but I'll go with it). If you are firing someone without replacing (a layoff), then presumably, that person cost more than the value they provided, and so laying them off should improve the value of the business (after incurring the costs the parent post mentioned).

If you are firing someone to replace them with someone else, you are incurring a lot of cost (hiring is time consuming, difficult, risky, and requires a ramp-up time before the new hire is productive), and hoping that the long term benefits outweigh that cost.

Based on that logic, layoffs should sometimes cause the stock of a company to go down, if the shareholders think those employees contributed more value than the company saves by laying them off.

In reality layoffs almost always cause the stock to go up. The market seems to think layoffs are an unalloyed good.

It’s also odd as it screams a different problem too.

If the employees were advantageous, I agree laying them off should be a long term negative as you seem to suggest.

Kinda like cheering the warmth of a burning bed on a cold night.

If they were inefficient/ineffective then management is crappy for not dealing with the problem sooner.

Sure, companies are resilient. But the first year or two of lost competence from layoffs can be quite rough…

Based on my personal experience and general observation, it seems like companies are both slow to hire, and slow to fire. So, paradoxically, both actions seem like they should signal "this company is going to be better in the future", because companies only either hire or fire when it is really obvious they should.

> Based on that logic, layoffs should sometimes cause the stock of a company to go down, if the shareholders think those employees contributed more value than the company saves by laying them off.

You are treating short-term stock market movements as a signal of how well the company is performing.

you still seem to be conflating layoffs with firing someone where you have to train their replacement.

there are numerous well known aphorisms about the irrationality of markets, so not sure why that should matter.

Wrong etage. Stock value is not very responsive to the fact that some line manager fired two poor shmooks, but it is responsive to the news of company laying off two digit percent of the same. That will be of course corrected somewhat once fresh quarterly results will show how effectively those enlightened souls managed to oppress the work takers.

Now if your line manager fires somebody for no good reason and then has to still pay the salary of this person for a year and a half and also pay the salary of their replacement -- that, when accumulated, starts affecting bottom line at some point.

No regular manager has an infinite hiring pool, so no.

Disgruntled AI won’t kick your teeth in, yet.

your context has grown beyond manageable size and you are starting to hallucinate so we are going to have to let you go. We wish you the best of success in your new role.

ctrl-C ctrl-C

Mr Meeseeks

Governments are famously tolerant of other actors seeking to rival or usurp their power.

Unfortunately with the current administration there is a non zero chance that the usurpers merge with the existing government… that wouldn’t be too surprising for Thiel to push for, he’s already the one who made Vance VP and has been pushing the Republican Party to its current anti-democratic form

The error here is assuming that government's intolerance to others in post-usurping times is in the interest of the public - then it's no more than suppression of rivals, including those who might actually be willing to help the public.

Worth noting that as written the "trick" results in memory usage proportional to the size of the input rather than the output. If the filter rejects most of the input the difference could be quite noticeable.

I disagree in the sense that you can rewrite the code to use the trick and also not allocate in advance. Nothing about the trick requires you to allocate up front: before writing to out[n] you can extend the vector if it’s out of bounds. Or, after incrementing n, do out.push(0).

You should try writing it out. Doing it without introducing another unpredictable branch is harder than it looks.

I discussed this with a coworker earlier this week and the best they were able to come up with was

    for &x in input {
        out.push(x);
        n += (x > threshold) as usize;
        out.truncate(n);
    }

which works but is ugly af imo.

Yep realized this after that my second solution (push a 0 if n is incremented) has the same branch prediction problem.

I think yours works. Alternatively in the loop:

    if out.len() < n {
        out.push(0);
    }
    out[n] = x;
    n += (x > threshold) as usize;

In this case the if will be predicted well because it only triggers log(N) times, given how the std lib extends vectors.

Generally the default fund in a decent 401(k) (employer managed but largely employee funded retirement plan) will be a "target date retirement fund" that contains a mix of equities and bonds according to the expected risk tolerance of someone at that age, and generally the equity component is also split between US and foreign equities.

e.g. Fidelity's fund for people planning to retire around 2050 https://fundresearch.fidelity.com/mutual-funds/summary/31579...

3% less annual returns than the S&P500 over 10 years and the entire fund lifetime. That's a considerable difference.

Yes, diversification results in lower returns than investing in just the best performing asset class.

That's what happens when you are in a 10+ year bull market. That doesn't mean 100% US equity allocation is a good idea starting now.

target date funds always confused me, b/c they don't account for the rest of my portfolio.

My IRA/401(k) actually has close to 100% cash/bonds to minimize annual taxable impact and the rest of my portfolio is equities.

Many people don't have a "rest of their portfolio".

There is no annual taxable impact in a 401k nor IRA