you're explaining a clerical issue that lost a client a case caused by compatibility issue to other lawyers in a bar hgearing because your client sent you a document in a format that does not respect user freedom
they ask how you've managed to avoid this problem so far, and it turns out that you've been battling it nonstop for years
How do you justify that as a lawyer on the basis of "user freedom"?
Honestly your best defense is probably true ignorance or bad decision making that led you to choose something that, to non-developers, really only works as a way to save $100/yr or do some crazy new thing that didn't work. But that's still pretty bad.
Even if you're some crazy unix hacker wizard who for some reason works as a lawyer, how does never using Word help your client?
It's a certainty that your clients and colleagues will be using Word to work with you and the rest of the legal system, and some files will use docx.
It would be pretty bizarre to turn down work or make things harder for people outside your firm because you refuse to use Microsoft Word.
You could use another tool that handles .docx but if it's not directly compatible with Word you're almost guaranteed to run into compatibility issues or maybe serious errors. If you don't even touch Word at all, then the first person to run into them would might be your client. Do you not just immediately decide that it's not worth saving $100/yr to eliminate that kind of risk? If not then you have to say something like
"Actually, it's more important that software be free and open source than that thing you pay me to do for you, that costs about two minutes of billable hours, and which every other lawyer uses?"
I don't think someone with that kind of decision making should be a lawyer, not necessarily because it's wrong but because even if it's true, imagine explaining to the bar association that Arch started opting you into nightly builds?
Obviously there should be lawyers trying to use open source software, but I can't believe a real person would never run into compatibility issues. Richard stallman as a lawyer explaining that he can't open files sent in formats that do not respect user freedom is such a good bit
Is this not almost exactly what you get on apartments.com or zillow.com by just looking at the listed prices in an area?
I think you might have the problem backwards. Realpage was about buyer collusion, and that wouldn't look any different from the prices naturally just rising in a market with more demand/less supply because even sellers who aren't colluding would still raise their prices if they saw that that was the going rate in the area.
When there are multiple competing factors all influencing price simultaneously it's very hard to accurately determine how much any particular factor contributed, or what the "actual price" would have been without them.
This is actually essentially the problem that justifies markets as an efficient way to arrive at fair prices - it's computationally too expensive to calculate the precise supply/demand ratios at any given moment, and demand can change much faster than supply can adjust (and nobody could ever really know how elastic demand is for things like local housing markets anyway).
So sellers want to respond to changes in demand by raising prices, because the business model of housing rentals is matching short term demand/pricing/risk to long term costs/costs/risk. But every buyer has their own demand preferences and every supplier has a different product with different fixed costs, and everybody knows their own demand preference and ability to provide supply, so the aggregate price a market settles at "collapses" all that information without explicit coordination: https://en.wikipedia.org/wiki/Economic_calculation_problem
If there truly is an increase in demand, as a buyer you probably do want rents to increase, because otherwise you get shortages like in Berlin where there is nothing to rent. So that's why coordinating to withold inventory with other sellers is bad, it creates a shortage anyway and only a small number of participants need to do it to move the entire market
Those sources are tainted. There is an epidemic of fake listings on websites where once you call to inquire, it turns to a bait and switch where they say the fake apartment is no longer available and tell you "what else" they have instead.
It's not only fakes - there is always a very large gap between what is available and what is listed online in honest buildings. Humans not marking move-outs or lease signings in realtime always creates a gap as do move-in dates. Buildings tend to only list what's available until the end of the month not 60 or 90 days out when you may actually want to move.
The best solution is to contact the building but this is time intensive and you get a lot of spammy followup which is why we created https://fless.io to automate this process and help you find what is actually available and not just what zillow or the management company's website lists. It's still the best way to know what is truly available.
No, those are advertised prices, not actual prices.
Look at the difference in prices between recent home sales and listed home prices, it's exactly the sort of information differential I'm talking about.
The US protects its homeowners above all, which is why there are these public databases of true sale prices of real estate. Renters should have the same protections and information too.
But, those... are the actual bid and asks for the home that you were able to verify yourself online, because it's public data?
It's not very common for residential rental agreements to differ substantially from the listed price in the US. It is quite common for long time tenants to pay a different (usually much lower) rate than new listings (often as a result of government regulation or just people being nice to each other).
What realpage did that was illegal was suggest coordinated pricing/inventory management to their customers through their software.
What exactly are you expecting to uncover by knowing what people are paying for rent? I actually have nothing against that in principle. I just don't understand how that establishes any kind of evidence that somebody is doing something wrong.
How many of the most talented people will jump straight in to manufacturing because of policy/macro incentives and shifts in economic policy?
People are much more likely to try something if they see peers and role models doing it. Even better if it’s something fun and exciting that they want to be a part of.
I think to convince someone to run a factory instead of trying to become MTS @ lab, they should know 1. it’s not a binary “make it or break it” where failure means doing some boring, poorly paid job (the downside is good but not so guaranteed that it’s abused/attracts the wrong people ) 2. it’s interesting and challenging and enjoyable at times 3. it’s meaningful at a societal or personal level. That's what made tech/AI/finance work and it's the competing pitch.
Why should someone with other options want to work in or operate a factory?
Yep. It's actually kind of mind blowing how well "reasoning" works at de-biasing and pushing out of global minima, in hindsight, when you see how jagged things get again without.
These are the results of a little performance tuning/permutation testing run against context format and question wording we did. Obviously there is a lot of noise here but I was actually kinda surprised that there was a clear "best way to ask the question" even for relatively low N and low complexity/ambiguity of the task.
(This is a ~30s Ai-driven gif presentation of the results, the full grid shows up about 15s in): https://imgur.com/a/wGFZvGw
These models in particular have some pretty dubiously generalized and diverse training datasets. You can see this for yourself BTW by looking at the datasets SOTA Jev-like models are being trained against and evaluated on. No knock against the teams btw, I just think it's rather demystifying and makes me quite optimistic at how much better these models are going to get over the next few years: https://labs.baseten.co/articles/mammoth-1-and-elephant-1-fr...
I was working on metaparsing earlier this year (specifically over grpc because of its better support for types and better serialization format).
I think most people who use JSON don't want strong typing or to use schemas. If you do, you just use a different serialization format: JSON is designed to be a generic, human-readable way to basically represent any kind of data structure (since it deserializes to JS objects). So everything about JSON is working against you if you do try to enforce type/schemas on it.
A grpc-like protocol with more prescriptive type registries/discovery (over the network) and better interop with http (like grpc-gateway) would be the best approach IMO. Definitely not JSON schema
> I think most people who use JSON don't want strong typing or to use schemas.
Not necessarily. It's biggest advantage is probably that it has very good interoperability. Basically every language has a readily accessible library for json, and even if you don't, it isn't that hard to write a parser and/or generator for it. And being human readable isn't something to sneeze at either.
> think most people who use JSON don't want strong typing or to use schemas. If you do, you just use a different serialization format: JSON is designed to be a generic, human-readable way to basically represent any kind of data structure (since it deserializes to JS objects). So everything about JSON is working against you if you do try to enforce type/schemas on it.
I have been using serde without issues, and never resorted to `serde::Value`[0], the untyped option, so far.
I have yet to experience anything working against me.
I think it may be fairer to say, “most people pick up JSON because of the flexibility.” Those who continue to use it for anything where there’s a consumer of your API probably do come to want types. In my day job I am starting to enforce end-to-end typing as best I can (given it’s Python and JSON) because our payloads are partially content from agents and I want to be able to flag up weird shit if we can. Certainly not the only gate that we have for looking for prompt injection and not even a great one, but it provides some piece of mind.
> I think most people who use JSON don't want strong typing or to use schemas.
Pretty much anywhere I've come across JSON (and xml before that,) everyone expected strong typing. The fact that JSON (and xml) can represent different data than they anticipated "did not compute" in their heads.
In many cases, they were treating JSON (and xml) as dumb serializers and not even paying attention to the output and corner cases.
I definitely want jsonschema, it's a standard and i can use it for many tools.
openapi spec is also a standard and built on top of jsonschema. I can use jsonschema to generate models, types, servers, client sdks, automate forms etc.
I think it's better than grpc for some of these things, plus protobufs and grpc have bunch of tooling that i can pretend to understand but in depth i don't really.
I think the game theory of relying on open source infrastructure is more complicated and ambiguous than most people have considered.
Using open source source software lets you share responsibility and oversight with a large number of people. But it brings with it a much larger attack surface than you'd have if you only implemented the part of that software that you need, and a much more complicated threat model for supply chain risk.
If a large number of people collaborate on open source software for something, especially if it's security or infrastructure related, that makes the project itself a much higher value target than any individual company's home grown mail server or http proxy client would be. Participation makes your vulnerabilities more public, since interacting with the public open source project, making blog posts or hiring ads mentioning it, hosting it (and thus serving traffic in a way that signals or directly tells clients what implementation it's using), bundling it with your site or binaries, etc. tells prospective hackers 1. how to find potential exploit targets for a general open source vulnerability 2. where to look for or introduce vulnerabilities to pwn a particular target.
AI auditing isn't really a silver bullet because it costs a non-trivial amount of money for each commit or PR, and scales with the number of contributors to a project and the project's size. Normally you want more of those with a software project, but in this case it makes AI auditing more expensive unless it's shared across the project and basically part of its CICD (and I don't think that's really been fully adopted yet). But then that introduces other risks like adversarial payloads where the attacker verifies that the AI security checks in place for a project don't trip when they actually send the malicious code for review, because they can run the same checks offline and tweak the payload until it passes.
Personally I think we're headed toward an outcome where only very challenging, well-resourced, and critical open source software is worth using for developers. For smaller things it makes more sense to just use AI to implement your own version of it, or fork/take inspiration from a project and mold it to fit your needs.
Didn't see alignment padding mentioned anywhere so I'll drop it here: did you know that the order of a table's columns affects how much space a record uses?
But wait! There is the per-row overhead of ~30bytes. Your 18 byte row actually takes 54bytes of space. Well, multiples of 54 depending on how often you update/vacuum it. But don't make your rows too big either or you're TOAST
This happens in most systems programming languages by default, but it's cool to know it happens in postgres too. Iirc wasn't it zig or some compiler that had some speedup or optimization just by arranging fields around? I may be wrong
TANGENT WARNING: What bothers me is that unless you are directly plumbing data on disk to the wire, there is literally no benefit to serializing data this way. (I originally realized all this when trying to add varint and byte types to postgres to make storage more efficient, and then finding it was almost impossible to actually serialize them in a way that saved space)
At runtime, if you've allocated a boolean or want to store a byte somewhere, you've either done it on the stack (it's temporary and you know it will need to be accessed at least once as an independent unit of data, and packing it together with other small data structures will make you use an extra instruction to extract it into its own register anyway, so there is not really any benefit to packing them tighter) or heap (you might actually gain something by reducing memory usage here, but packing data together binds the lifecycle and structure of everything at the same address and either requires additional lookups to check the interior structure, or a fancy compiler/build process to bake in the instruction to extract packed data without knowing what other data is packed with it).
When you read serialized data for a record from the disk, while running a typed database, the lifecycle/structure within the record is already shared. Most times you load the record you probably won't be accessing any particular packed data structure (eg if you have 5 bool columns in a table, most queries won't use all or any of them). You already have a global way to handle internal types/optimized reads, because that's what databases do.
So it would actually be feasible to load packed data and efficiently access or calculate with it eg XOR against 0x00..00 to use a bool, or bit shift to load a subword into a register. It would be at worst 1 instruction per read slower if implemented efficiently (the query planner can handle the type lookup/deciding how to do the optimized read, which amortizes and isn't the query bottleneck or even on the critical path).
BUT denser data = more cache coherency and higher read throughput (more rows/s). And if you're doing fancy bit operations and arithmetic to extract and perform calculations on the packed data, it might actually be easier to batch operations with SIMD. So you could get arguably higher performance + much less passive disk usage (saving actual money) by packing data better probably. I'm about 30% of the way towards convincing myself to try this
I wrote a comment explaining what in my mind distinguishes "high reliability" (defensive programming and making invariants/error cases/intended use explicit) C++ from regular C++. IMO it basically boils down to contemporary "Google/fintech style C++", which is a different development culture and ecosystem from defense/automotive
note that this also applies to ironic LLM-assisted shitposts
I think there should maybe be a little more leeway/amnesty for accounts that aren’t new or don’t have a high rate of LLM tells. IMO if you could self-declare the AI usage and wrap them in tags to handle the verbosity and attribution you could integrate it reaosnably
Ironic speech is the main way people make jokes. Sure, ironic violence or something like that isn't a thing outside of WWE, but you shouldn't equate all "bad" behaviors.
In the past we could have said that we shouldn't expect an internet forum filter made of regex patterns to detect irony, but with LLM's as viable modding tools, I'm not sure that we shouldn't raise our standards...
It's irrelevant and I even explained why, just in case you'd be extra slow - yet here you are... Do you hate all LLMs? Do you hate technology? Do you fear change? Answer me. I'm like building a really strong case here!!
they ask how you've managed to avoid this problem so far, and it turns out that you've been battling it nonstop for years
How do you justify that as a lawyer on the basis of "user freedom"?
Honestly your best defense is probably true ignorance or bad decision making that led you to choose something that, to non-developers, really only works as a way to save $100/yr or do some crazy new thing that didn't work. But that's still pretty bad.
Even if you're some crazy unix hacker wizard who for some reason works as a lawyer, how does never using Word help your client?
reply