Of course things are simpler if you restrict yourself to 10% of the functionality.
4,317 karma · joined October 31, 2019
Of course things are simpler if you restrict yourself to 10% of the functionality.
I wish that were true. Maven is terrible at this, e.g. here's a bug report that's been open for 12 years: https://issues.apache.org/jira/browse/MCOMPILER-209
Even just doing things like "please predownload any dependencies in this one job and cache them, so they can be reused in these 5 other jobs" don't work reliably with maven because certain plugins like surefire download dependencies on the fly.
> Nor everyone is building Google sized monorepos.
Nor is everyone building "small-ish codebases". You don't have to be Google, I worked at a company with maybe 10 developers in total, but the codebase was over 10 years old and had a gazillion features (plus a lot of tech debt, obviously) and the build times were atrocious. It wasn't all maven's fault, of course (we had really badly written tests, for example), but the broken incremental compilation easily added 5-10 more minutes to each build.
Python is a purely interpreted language that runs in the context of your file system. Java code needs to be compiled and packaged, you have to write a manifest, you have to decide whether to include dependencies (fat jar) or not, or maybe you want to create a war (if you're stuck in the 2000s)... then what about maybe distributing the sources too?
Also, Maven works. Gradle works. Mill probably works too. The reason uv is a success is that everything Python had before was a broken mess. When people complain about JVM build tools, they come from a different position, not from one of "stuff is completely broken".
https://docs.gradle.org/current/userguide/dependency_constra...
In a sense I feel that part of the microservice craze is due to the fact that many of our build systems are not good enough to allow us to work with huge monoliths efficiently. Gradle is a bit better (definitely faster), but comes with additional complexity. Haven't tried Mill.
Which is not the same thing as being able to judge a study design.
You mean the same Hacker News where everyone was suddenly an expert in epidemiology a few years ago and now can speak with authority to geopolitics?
You can find some kind of objective metric, e.g. bug count or time spent developing new features. That alone is super hard to get right, but even if you could, it wouldn't necessarily tell you which techniques lead to a better result. People have tried studying such things (e.g. do static types help) and the studies rarely come up with any effect.
I don't think that's necessarily because these things don't have an individual effect, but because there are humans involved and so, personal ways of thinking probably play an outsized role, so technique X might be a very good fit for person A, but not for person B.
Often, we've worked on codebases that were nearly collapsing under their own weight, where adding even small features would take an inordinate amount of time, where most changes would have unintended consequences, where onboarding was incredibly hard, etc. And we've worked on other codebases where changing things was easy, so we know the difference.
Often, the business has no clue how to fix this because a) they're non-technical, b) we unfortunately have no consensus in the industry about what "good code" is, c) humans are much better at short-term than long-term thinking.
I also went to places like Beppu or Kagoshima where I barely saw any tourists.
I'm operating under the assumption that most tech giants (and in particular Meta) are doing everything in their power to keep violating people's privacy as long as they can get away with it.
Since it's impossible to audit everything such a huge corporation is doing and since cases can take a very long time to resolve (after which the damage is often already done), the huge fines are for scaring companies into submission. I am perfectly fine with that, no actually: I wish the fines were so big that they were actually threatening the business's survival.
> I'm not sure where the right balance is, tbh.
I'm probably the wrong person to ask because I think that Facebook simply shouldn't exist.
HN is sometimes incredibly biased towards consumer tech.
I find the worst part to be when it doesn't correct flaws in my assumptions.
For example, yesterday I asked it "what is the difference between these two Datadog queries"? And it replied something that was semi-correct, but it didn't discover the fundamental flaw - that the first one wasn't a valid query because of unbalanced parens. In fact, it turns out that the two strings (+ another one) would get concatenated and only then would it be a valid query.
A simple "the first string is not a valid query because of a missing closing paren" would have saved a lot of time in trying to understand this, and I suspect that's what I would have received if I had prompted it with "what's the problem with this query" but LLMs are just too sycophantic to help with these things.
Cost of living is increasing in the US too (in large part due to geopolitical reasons), and social contributions are rising because of demographic factors. I'm not sure how market liberalism is magically going to fix that latter issue.
In addition to them there are also countless small to medium sized companies that nobody's ever heard of, that don't experience hypergrowth but have slow and steady growth - especially in the B2B sector. I've worked at some such companies.
But in terms of pure statistical validity, I don't think it matters.
Partying in someone's apartment is a thing in probably every reasonably sized city in Europe, not just Berlin. Although you should probably alert your neighbours.
Maybe for LOB applications, it would be better if languages defaulted to arbitrary precision arithmetic. But scientific computing is also a huge field that often uses the same languages and there, arbitrary precision is often the completely wrong tool, e.g. it would make certain key algorithms (like Gaussian elimination) exponential.
I feel like this is just one of these things that developers should know about so they can make the correct choice, just like DB indices.
Language log has been writing about this for so long it's not even funny: https://languagelog.ldc.upenn.edu/nll/?cat=54
Although the best place to start is probably here: https://languagelog.ldc.upenn.edu/nll/?p=2922
That's what Swift does fwiw. But there are downsides to that too (although they're also related to Swift not having a good fault recovery mechanism).
In practice, whenever you know you're going to use large enough numbers in Java, you probably want to use BigInteger or BigDecimal (e.g. in banking). Unfortunately, Java doesn't allow you to use the + operator with it.