264 karma · joined January 1, 2022
https://meipouchou.com
To be clear, the million dollar scenario was intended as one in which the landlords collectively lost their minds and plunged themselves into long-term economic doom. In a more realistic pricing scenario, they'd collude to determine the absolute maximum price they could charge and still get tenants.
And when you think about it, that's how markets are supposed to work. Landlords want to charge as much as the market can bear, no more, no less. Renters want to pay as little as possible, and in a perfect market, it would reach price equilibrium.
But from the federal government's point of view, it's not as simple. Housing must be profitable in order to encourage new investment in housing. We're currently playing musical chairs with too few residential units for too many residents because there hasn't been enough housing investment since the 2008 crash. At the same time, they want to keep rents low, since money spent on rent isn't going into productive areas of the economy. They also want to keep rents variable, because strictly stratifying locations based in income has bad effects in society. (E.g. police officers not being able to afford to live in the large cities they work in.) Retaining the ability for lower-income renters to negotiate rent is helpful in that regard, but obviously not a silver bullet.
One thing I would be careful of though, is comparing rental prices to inflation. Housing costs are the single largest factor in the CPI-U, so it's almost a tautology that rents rise at the same rate of inflation, because inflation is largely measuring the rate at which rents rise.
Comparing to fed rates is more interesting. If you're getting less of a return on your investment than the current fed rate, you'll make more money by divesting yourself of your properties and putting the money into bonds. (And I believe this is the biggest driver of recent mass layoffs.)
One of the cases specifically being looked at in this investigation is Washington D.C. Google tells me that around 60% of rentals in D.C. are in large apartment buildings, but that's just a quick search so take that with a grain of salt. ProPublica says that 90% of these apartments are using the software. If we accept these numbers are close, and knowing that 90% of buildings doesn't necessarily mean 90% of all apartments, we can guess that means somewhere around 50% of all rental properties in D.C. are priced using this software. The number might be higher, since I don't know if any non-apartment buildings are using this software, or it might be lower if the data is inaccurate.
So yes, the remaining 50% of the market could undercut the 50% using the software. However, it's still possible for 50% to have an effect on the housing market. This is because the housing market is generally considered to be inelastic and because it is difficult to increase supply quickly.
Compare it to, for example, soda, which is an elastic market with a lot of production. If Coke and Pepsi lost their minds and started charging $100 for an 8 oz can, they're creating a lot of potential for other companies to undercut them at, say $2 a can. As long as $2/can is profitable, they can win Coke and Pepsi's market from them overnight.
If 50% of rental properties started renting for $1 million/week, obviously, very few people can afford that, and I doubt anyone would pay it. But what could the other 50% of the market do? They could keep their rates lower, but all the rentals will fill up. Again, numbers are hard to find, but vacancies in D.C. are probably around 6%, so prospective renters will play musical chairs for the 50% of rental properties that have more reasonable rents. There's a potential here for companies to build new properties and undercut the 50%, but building is lengthy, expensive, requires permitting, etc. The market can't respond very quickly, and because new construction tends to be expensive, rents from new buildings tend to be higher.
That was the crux of the case. Spotify was accepting payment through their web site in addition to taking payment via the App Store. And because they were processing their own payments, they could offer the same subscriptions for a lower price than on the App Store.
The issue was that Apple was not allowing them to inform App Store users that they could pay through a browser.
To keep things simple, let's say a city has two landlords, Alice and Bob, who each own around half of the residential rental properties in the city.
Textbook definition of price fixing is if Bob and Alice agree to never rent for less than $5 per square foot.
Next scenario: Instead of a minimum price, let's say that Bob and Alice agree a formula on how to price their properties based on vacancies. The formula can be as simple or as complicated as you like. But in this scenario, if the formula never gives them a result less than $5/square foot, it has the exact same outcome as the textbook scenario. And since there is direct coordination between Bob and Alice, this is definitely price fixing. In fact, it's even worse than the textbook scenario, because now they're coordinating on exact prices, and not just a minimum.
Forgetting formulas for a minute, let's say Charlie, who is unrelated to Alice and Bob, approached them separately and offered to sell them information on how to set their prices. In this case, there's no algorithm involved. They each pay Charlie a small fee per month, and he tells them not to rent for less than $5 per square foot. There's no direct communication between Bob and Alice, but because they both know that the other is acting on the same advice from Charlie, the result is the same as the textbook scenario. You could even argue that there is indirect communication between them, and that Charlie is running some kind of price laundering service.
Finally, you can combine the two. Bob and Alice both tell Charlie how many vacancies, delinquent payments, etc. they have. Charlie feeds all the data into his computer, which contains a really complicated formula, and that computer tells them how much to charge. And wouldn't you know it, that formula never produces a result less than $5/square foot. Again, because Bob and Alice know that the other is using this service, and because they have an exact price, rather than a minimum, they know they don't have to negotiate with potential customers. The other landlord won't give that customer a better deal.
But I'm a bit confused by your statement. There's a lot of overlap in the domains that C++ and Rust serve. Isn't it a good thing for job candidates to have an interest in learning about other approaches to their work? To understand what makes C++ better or worse than Rust in difference circumstances?
Why would a mere mention of Rust be a red flag?
Like, the article's good enough that it doesn't need an image. Or if you really think you need it, grab some free stock photo or clipart or something.
Or get good AI art. Don't settle for bad AI art.
I don't really care of it's AI or not. The picture is just strange. The empty hoodie just standing by the window, watching a worker who is seemingly undisturbed by it. The odd placement of the desks, the fact that all of the text is gibberish, but looks just close enough to real that you pause to examine it. Except for the big "CHECK" on the wall, which isn't something you'd actually see in a real establishment that cashes checks.
More and more, I see companies using art that they would refuse to pay for if a contracted illustrator turned it in. Seemingly because it's AI, it's like they become blind to how bad it is.
I say this as someone who loves the Mac, and goes out of his way to avoid electron apps, but in most cases, it doesn't make sense for a company to produce native Mac apps. Especially if that company is VC funded.
I worked in shops in the late 90s into the 2000s that produced cross-platform Windows/Mac programs. It was a lot of fun in many ways. But even the best-run teams with the best cross-platform stacks suffered from slower development times than they would have if they were targeting a single platform.
Even when like 90% of the code is cross-platform.
There are lots of reasons why. Some of it is due to platform differences. Sometimes the same feature couldn't work the same way across platforms. That meant either correctly doing extra design and planning ahead of time, or figuring out that you messed up and calling emergency meetings to figure it out. It meant extra work producing documentation that called out the differences. It meant training support staff on the differences.
Another issue was keeping all the teams on the same schedule. If you've got "one good person" working on the Mac side of things, and they get sick for a week, then either you ship the Mac update late or you delay every other platform.
Finally, there's always been a lot of churn on the Apple side. APIs getting removed. The platform moving to a completely different programming language. Toolbox. Carbon. AppKit. SwiftUI. Pascal. C. C++. Objective-C. Swift.
So a lot of teams went the route of trying to create their own cross-platform framework in C++, and focused their platform developers on just implementing the framework, so all the app work could be done by the cross-platform devs. The Mac people could thus isolate the app from the technology churn on the platform.
This never worked out. It almost always ended up being faster to write separate apps from the ground up for each platform, because the cross-platform framework would balloon into a monstrosity. You'd spend more time on the framework than any app, and somehow, you'd still lack functionality that the cross-platform devs discover they need for the latest top-priority feature coming down from management.
But typically, on the best teams, it wasn't just one person per platform. Because of the need for so much coordination between platforms, lots of time was spent in meetings, so you'd need at least a few people working on each platform. These are things you don't have to worry about when you're an independent developer working on an app that hits the company's API.
You might be temped to point out that this could all be avoided if you just had a server team write the server software, and one-person platform-specific teams that just wrote native apps that communicated with those servers. Sure, you still have to produce different documentation and support resources, but most companies skimp on those anyway.
You'd also have a bunch of apps with different features, shipping at different times, but they're all great apps, so that doesn't matter, right?
The result is that you'd come up with decently great apps for each platform. The project managers might even be able to recognize that they're cool, great apps.
But you'd still be like a cat bringing them a dead rodent. What are they supposed to do with this?
Admittedly, some of this has to do with how middle-level project managers justify their jobs. They spearhead features and make sure they get delivered into the product, theoretically increasing its value, and therefore the value they delivered to the company.
But it's not all that kind of bullshit. Sometimes it's essential to the company's bottom line, or to an attempt to improve that company's bottom line.
To use Slack as an example, at the start of the COVID lockdowns, Zoom usage shot up tremendously. Slack felt that this was a potential threat to their place in the market, and they introduced huddles. It took like a year, and Slack huddles are still worse than Zoom, but it was still probably good enough to retain some subscribers.
If it took a year with Electron alone, just imagine how much extra time it would have taken to plan and coordinate the feature across multiple platforms. Since it's important to the company, you can't just let the platform teams roll it out on their own schedule, or decide it doesn't fit well with the feature set they've cultivated for their platform. You need it out, you need it fast, and you need it to work the same.
Electron was the first cross-platform solution that worked well enough to make that a reality. It sucks in many ways. It doesn't follow platform conventions. But it's good enough that people can use it. And, bonus, the apps are all written in a language and an API that millions of Web devs are familiar with. No need to worry about the schedule slipping because one employee was sick.
In a fast-pased business, you need fast, universal turnaround on important functionality. It's more impactful to your bottom line than customer experience, even if that functionality is just some dumb BS like Discord super reacts or something.
Looking at data from 2022, about 13.6% of the population is White Evangelical Protestant, but that's been on the decline. It was around 25% a couple decades ago. Overall, just over half of the country is Christian, most being Protestant of some denomination.
But it's the White Evangelical Protestants that are the big driver here. You might think it's the 12.6% White Catholic and the 8.6% Hispanic Catholic populations that are the most fervently anti-abortion, but most actually vote for more liberal politicians.
The thing is, Evangelicals, if I understand correctly, weren't even that anti-abortion to begin with. That was seen as more of a Catholic issue historically. But what they're very big on is the idea that 1) America is the greatest country in the world, and 2) America is great because it's a Christian country. As such, they feel it's important to elect Christian leaders who feel and think like they do. And because they are predominantly white and their leadership is exclusively male, they want white men to be in control. (And I say this as a white, cisgender man.)
Because they've always been such a large percentage of the US population, and, more recently, because US distracting gives rural voters a greater voice than urban voters, they've been a large political force in the country since the 19th century, but in the 20th century, they were never so large as to completely dominate US politics. And this kinda worked well for both sides in the early 20th, since towns, counties, and states dominated by Evangelicals were largely autonomous enough to do whatever they wanted locally. But when desegregation came, and women entered the workforce in greater numbers, Evangelicals were forced to accept nonwhites and women holding important positions, even in their areas of the country.
Abortion became an issue they could use to gain support from Catholic voters, and as a wedge issue for the larger community. For Evangelicals, it was less about writing specific religious creeds into law, and more about forming strategies to gain political power so they could put the "right people" in back in charge of the country. It also helps reinforce that men are in control by removing autonomy from women.
https://www.prri.org/spotlight/prri-2022-american-values-atl...
As a practical matter, they know that many women won't realize they're pregnant until it's too late to feasibly schedule the procedure. They're minimizing the number of abortions while moving what the American public sees as reasonable from 24 weeks to 6. Once everyone's used to six, they can reduce it even more.
I mentioned this in another reply, but I was imprecise with my language here. I meant that regulators could decide it's not OK for Google to have both a dominant ad network and a dominant browser. Discontinuing Chrome would be one remedy here, but there are also other remedies, such as spinning off Chrome development to a separate company.
As for the legal basis for doing that, I'm not as familiar with UK or EU law as I am with US law, but this was in response to the linked UK ruling by the CMA, where I was expressing my awe at how much effort they were going to in order to try to balance competing interests. I don't think regulators are dumb or lazy, but the report very clearly identifies that the core of the problem is that Google has both a dominant ad network and a dominant browser, but they still went through a lot of trouble to try to find a workable solution.
As for US law, Judge Jackson did rule that Microsoft should be split into two separate companies, one for the OS, and the other for apps, but was overruled on appeal. However, that appeal was muddied by other issues as well, and the case never came before the Supreme Court.
You're right about the US congress, but Europe does seem more eager to go after big tech companies.
But I was a bit imprecise with my language there. There are other regulatory remedies to a ruling like that besides discontinuing Chrome. For example, it could be spun off into a separate company, one which does not share any data with Google.
As for the fantasy scenario where Google stops behavior-based tracking, reading that ruling, I think they could get away with it, but there would be some grumbling. Let's say Google stopped tracking on its end, and then six months later, decided to block third-party cookies by default. Regulators could insist that Google keep third-party cookies on, but what leg would they have to stand on? Yes, it would affect their competitors in a big way, but it wouldn't give Google a distorting advantage over them.
And with every other browser blocking third-party cookies, if regulators tried to force Google to keep them, Google could just stop developing Chrome. Without behavior-based tracking, they have no business reason to develop it anymore, and how could regulators possibly say, "You have to keep making a browser, even though your competitors don't"?
It's certainly interesting. The CMA seems to be attempting to balance interests of multiple parties, including both user privacy, healthy competition in the ads space, and the ability for digital publishers to generate revenue from displaying ads.
However, most of it appears to focus on the way Google's superior access to information could distort competition. It's not just about cookies. For example. Google could mine synced history data from Chrome.
Now, I'm not so naive as to think this would actually happen, but again, the Ars author's solution here could solve that particular problem: If Google ceased all behavior-based advertising in favor of, for example, subject-based advertising, there would be no distortions to competition. Google can't track you, and neither can other advertisers. Everyone has a level playing field.
Of course, that would drop revenues for digital publishers and advertising networks, including Google, but it would solve the problems of user privacy and distorted competition.
The one thing this ruling makes very clear though, is that it's very difficult to balance these concerns while Google makes a browser. There's a conflict between Google running a behavior-based advertising network and shipping a browser, and these regulatory bodies seem to be bending over backwards to try to find a solution where both of these things can exist. They could most certainly have taken the much easier road of forcing Google to discontinue Chrome.
Is this blog post a legally enforceable contract? Is Microsoft specifically indemnifying all users of Copilot against claims of copyright infringement that arise from use of Copilot?
The blog post says that "there are important conditions to this program", and it lists a few, but are those conditions exhaustive, or are there more that the blog post doesn't cover? For example, is it only in specific countries, or does it apply to every legal system worldwide?
What guarantees do users have that Microsoft won't discontinue this program? If Microsoft gets kicked in the teeth repeatedly by courts ruling against them, and they realize that even they can't afford to pay out every time Copilot license-launders large chunks of copyrighted code, what means to users have to keep Microsoft to its promises?
Of course, this pushes the problem down the road, but here's why I think this is the best approach if you're unable to move to one of the forks.
The OpenSSL 3 API is vastly different from the 1.0 or 1.1 APIs, and are currently poorly-documented. There's a migration guide, but but as lengthy as it is, I found it only minimally helpful in understanding how to transition from the 1.1 API to the 3.0 API. In short, a lot of structs and their associated functions have been deprecated in favor of using the more generic EVP_PKEY and its associated OSSL_PARAMS. OSSL_PARAMS is a struct that contains a sting key and a pointer value, and you get/set arrays of these params on keys. So instead of having C functions which clearly specify what their required parameters are, what they return, and the types of all these things, you get a few comments in the OpenSSL headers telling you which types go with which keys. The compiler won't warn you if you assign an integer value to a key that expects an octet string, for example.
The rest of the documentation isn't much better. Some man pages are great, but most still leave it up to you to piece things together.
Worse, there are quite a few use cases which are made more difficult and verbose by the new API. Browsing the github issues and the mailing list, there are quite a few scenarios that the OpenSSL team has said could be made easier in the future, but were somewhat of a blind spot during the initial design of the new API.
Perhaps because of this, few major open source projects have moved to the new API, even with the EOL deadline so close. This, in turn, makes it difficult to find real-world uses of the new API to help learn how it should be used.
However, the API is slowly getting better. In 3.1, OpenSSL added some functions to make building OSSL_PARAM arrays easier. By 2026, they may have improved the documentation, filled in the missing use cases in the API, and there may be more real-world examples to learn from. All of this would make moving to the new API much easier.
As far as I understand it—and this is just from watching Apple's presentations on the architecture—the lack of a discrete GPU is a big part of how the Apple Silicon machines achieve good performance per watt.
Instead of having discrete RAM or a discrete GPU with its own VRAM, all of the RAM is accessible to the CPU and and the GPU in a unified memory architecture. On the M2 Ultra, this allows for 800 GB/s of memory bandwidth, and also eliminates a lot of the need to copy data from RAM to VRAM, as both the GPU and the CPU can access the same memory. In return, this allows the GPU to match the performance of discrete GPUs that have a lot more cores.
Of course, the big downside is that you can't expand the RAM or install a beefier GPU. It's all baked in to the logic board.
After their initial announcement of the policy, Apple clarified that they would still reject bugfixes if the app violated section 5 of the guidelines, the section titled "Legal". On the surface, this would seem reasonable. After all, can't go violating legal requirements. However, this is still counter to the spirit of what they had promised. If it's up on the store already, if it's violating the law (e.g. for scamming users out of money), it should be taken down. If it's not violating the law, it's better that customers get the bugfix.
They also copied a bunch of rules from the other sections into section 5, to give themselves more leeway.
https://developer.apple.com/app-store/review/guidelines/#leg...
My personal bias is that open source authors and maintainers don't owe anyone anything. They're making their code available to anyone for free, and it's on you if there's something you don't like about it. You can always fork it if you need to. Heck, you don't even have to use it. Write your own thing if something fundamentally bothers you about it.
And yet there's a large group of people who think they're somehow doing you a favor by using your open-source code, as opposed to the other way around. I've tried to talk to some of them, to try to get some idea of it. It typically boils down to either
1. I used and advocated for the project, making it more popular, and therefore they owe me.
2. Using an open-source library is an investment. I'm making a compromise by not writing it myself exactly how I want it. I'm attempting to do things their way, which in some ways is mentally harder than writing it to begin with, so when it changes radically or goes away, or they ask me for support, they have done me dirty. I deserve better.
3. #2, except they recognize that the author/maintainer doesn't owe them anything and hasn't acted maliciously, but they're still bummed that they either have to change things or fork the project and maintain it themselves. It's emotional rather than logical.
Of the three, I can kinda understand the last one, but I'll never agree with it.
> Kexts are no longer recommended for macOS. Kexts risk the integrity and reliability of the operating system. Users should prefer solutions that don’t require extending the kernel and use system extensions instead.
"System extensions", in this context, refers to extensions that the OS loads into userspace. Apple is developing userspace extension APIs to perform actions that were traditionally handled by popular kexts. The File Provider API is one of these system extensions. Dropbox used to rely on a kernel extension to intercept file access. File Providers allow them to do the same thing, but, as evidenced by this article, there are limitations as to where the files can live, and there are some bugs.
So if the File Provider API is so bad, and it's sill possible to load kexts, why doesn't Dropbox continue to use a kext?
- In 2015, Apple updated the OS to require that kexts be signed by a certificate in the Apple Developer program. This allows Apple to decide who can sign kernel extensions, and allows them to revoke the signing certificate for individual extensions. - In 2017, Apple updated the OS to require a multi-step user confirmation before installing a kext. This initially caused some headaches for system administrators automating the deployment of multiple machines, but eventually solutions to this were implemented. - In 2020, Apple started shipping ARM-based Macs, and by default, they don't allow the loading of any third-party extensions. Instead, users have to go through a process to enable them, and this process can be disabled on managed machines. Here's how Apple describes that process.
> Kext management by the user requires a restart to recoveryOS to downgrade security settings. The user must press and hold the power button to restart into recoveryOS and authenticate as an administrator. Only when recoveryOS is entered using the power button press will the Secure Enclave accept the change of policy. The user must then select the checkbox Reduced Security and the option “Allow user management of kernel extensions from identified developers” and restart the Mac.
All of these requirements can also be bypassed (if the machine is unmanaged or the sysadmin allows it) by turning off System Integrity Protection, which is a similar process as described above. However, disabling SIP disables a lot of security protections in the OS, and turning it off shows a lot of scary dialogues to dissuade users from doing it.
And for most users, SIP is a good tradeoff. It protects against a lot of things that malware can do. It prevents code injection, so dtrace doesn't work with SIP on, but if you're not using dtrace, there's little reason to turn it off.
Either way, the process is complicated enough that not enough users will do it in order to provide a mass market for Dropbox. Apple is also pushing Dropbox to use the File Provider API with the implicit threat of revoking Dropbox's signing certificate for their kext. Apple will not issue signing certificates for products that can be implemented using the userspace system extensions instead, and it's likely that they will continue to restrict the loading of kexts further in the future. Even if users can disable the signing requirement by disabling SIP now, there's no guarantee Apple will allow that to work in the future.
The reality is that AppKit has had its ups and downs recently. There are obviously people in Apple trying to do their best to patch things up, and there have been some nice improvements because of their efforts, but some really bad bugs have been introduced, only to sit unfixed for years. It's gotten to the point where I dread the yearly OS updates, not because I dread having to update my code, but because I worry what has broken.
In my experience, if you don't get your bugs filed within the first week after WWDC, they'll never get fixed, and even if you do, it's a toss-up. But testing your existing code isn't always enough. If you're writing new code to take advantage of some of the new OS features, you can be a month into the beta cycle before you find a bug, and by that point, its too late.
Also, and this might have been fixed already, but a couple years ago, there were problems getting updateUIView to run in response to ObservableObject updates.
The promise of UIViewRepresentable is a lot like SwiftUI itself. It's great when it works, but there's little you can do when it doesn't.
A couple years prior, he had faced a similar problem from Scottish nationalists, so he approved a referendum on Scottish independence. He was against independence, but when Scotland voted to remain a part of the UK, it weakened the arguments of the Scottish nationalists, making his job easier. He figured he could do the same with Brexit. Nobody seriously expected leave to win.
Problem was, it turned out there was a lot of money in leaving the EU. It would make tax dodges easier for the ultra-rich, and it would allow disaster capitalists to make a killing by shorting the market. So money flowed into the leave campaign from wealthy donors hoping to make a killing. As a result, leave ran a much slicker campaign.
All this might not have been enough for leave to win, but people were also pissed off at the government for years of austerity policies and a flagging economy since the 2008 crash. Lots of people, saw the vote as a way to express their displeasure in the government. Some of those who voted leave never expected it to win.
SO yes, you're right. The referendum was poorly worded and poorly planned. This was evident in the immediate aftermath. The House of Commons could not agree at all on what to do. A large chunk still backed remaining, but not a majority. Lots of MPs decided that, even though they knew Brexit was a bad idea, their constituents had voted for it, so they needed to switch sides. They didn't all switch to the same side though. Some wanted a no-deal Brexit. Some wanted to remain in the customs union and single market. Others wanted different arrangements. There was no majority for any course of action, because the referendum didn't describe a course of action, and it paralyzed UK politics for years.
It never sat right with me that I should have to pay a private corporation to eFile my taxes, and they've always been simple enough that I didn't need a professional to prepare them, so I stubbornly printed them out and mailed them in every year. I didn't like that FFFF was provided by Intuit, but at least I wasn't giving them money directly.
Then, for the 2020 tax year, they stopped providing the service for state taxes, but I no longer have a working printer. I had to go to a local print shop to get everything printed out. It was still cheaper than eFile software, but it was a drag.
Like the other reply though, I keep my private SSH key on the YubiKey, protected with both a PIN and a password. I can SSH from any computer as long as I can install gpg on it.
I could be missing some less obvious use cases, but if you're just authenticating to your personal machines, it doesn't seem worth it. It's not any more secure than SSH keys, and you have to also manage and secure your CA key.