Don't forget the classic film On the Waterfront. Considered one of the greatest movies ever made and adapted from "Crime on the Waterfront," a 24-article series by the New York Sun's Malcolm Johnson that received the second prize ever awarded for Local Reporting, in 1949.
> In a vocation where loss of limb (and even life) was not uncommon, prospective workers — in a field disproportionately comprised of working-class African-Americans and whites of Italian and Irish descent who did not benefit from the upward mobility of the G.I. Bill — were forced to offer kickbacks to syndicate representatives at the daily "shape-up," in which prospective workers were forced to compete against each other to secure work irrespective of union membership. At any time, workers could be virtually blacklisted from subsequent employment for arbitrary purposes in the union's "blue books," their jobs often requisitioned by members of the syndicate who were completing prison sentences.
> Requests has always had modules intended for its use and only its use. At some point, we tried to document them for ourselves and that led to people using them externally and then filing bugs against them. This is a perfect example of 3 adults who did not consent explicitly to the use, but Python says that we must have because we didn't hide them well enough.
I don't understand the problem? It's bad that users reported bugs in internal modules?
A couple years ago I worked on an internal tool for the regulatory division of an agriculture company that involved mapping endangered species boundaries. The Environmental Protection Agency requires the company review potential impact of a proposed herbicide on endangered species inhabiting areas where the herbicide might be used (or drift).
The question of "what is a species" made me go a bit insane. I really wanted a unique identifier for each "species", but kept running into edge cases like species that changed scientific names (so you'd need name + date to resolve it). Occasionally people would refer to species by common name, but a common name can resolve to dozens of different scientific names. I don't think people realize how difficult and awkward it is to build software that deals with ambiguous entities.
This is a tangent, but the US Fish and Wildlife service has a cool tool for exploring endangered species [0]. I had a few issues with the data, but was overall impressed with how easy it was to access and how deep it goes (there are gigabytes of shapefiles representing endangered species boundaries offered in zip files). Preble's meadow jumping mouse [1] had a range so complex that its shapefile was 250 MB, the complete set of shapefiles covering all species' ranges was 2.5 GB--this single species of mouse took up 10% of this! For comparison, the Topeka Shiner's range shapefile was only 147 KB.
This reminds me exactly of how difficult it is to create decent security groups.
I've had a few opportunities to build active directory from the ground up. It always starts nice and clean with Accounting, Sales, Production, etc. Then Directors, Managers, Supervisors etc.
Everything maps out nicely in the beginning but then you run into things like "well Susie is only a supervisor, but she's in account so needs access to X. And Bob is a director but shouldn't have access to Y. And Managers should only be able to access Z but only if they are in Marketing. Etc."
You end up with a bunch of custom groups and the whole idea of a big venn diagram disintegrates.
In theory everyone has a defined role on paper, but it completely falls apart when the rubber meets the road.
Create React App is in a strange, pseudo-death state.
- It is not listed as an option for starting a new project in the React docs[0].
- The last release was April 12, 2022.
- The last time I created a new project with CRA, it printed a console log that claimed CRA was deprecated. However, the message seemed to originate from a dependency rather than CRA itself.
All this was enough to convince me to move to Next.js for future projects; though I find Next.js overcomplicated and full of things I will never use.
If "type bugs are an obvious thing and happen all the time" and "static Typing reduces type related bugs" then it should be easy to demonstrate this empirically. However, "a review of all the available literature (up to 2014), show[s] that the solid research is inconclusive while the conclusive research had methodological issues."
Why would you need an empirical study for this? It’s trivially provable. Runtime exceptions in a language like JavaScript can arise from type mismatches. That’s impossible to do in a language like Java, because the compiler catches it before you ever run the program. This eliminates an entire class of bugs.
What you’re proposing here sounds like somebody saying “How do we know Rust results in less bugs than C++ without an empirical study?”. Even though, we _know_ Rust eliminates an entire class of memory related bugs. I say this as a C++ advocate too. Anytime I run into a memory bug, that’s a bug that would not have happened in Rust. Likewise, any time you run into a runtime exception due to a type mismatch (for example: expected an int not an object), that is a bug that would not have happened with a type safe language.
Edit: I also want to add that the metric is important. Is it number of bugs per line of code? What does that even mean? Assembly programs consist of many more lines of code because it’s more terse, but the number of bugs in assembly will probably be greater than a higher level language. Even though the large number of lines of code would probably push the metric down and make it seem like assembly has a low number of bugs per line of code. Because of this, bugs per line of code isn’t a useful metric.
The only way I could think of measuring this would be to have two feature for feature equivalent projects in two different languages and compare the number of bugs in each. But even that probably has a bunch of flaws.
I think you're right that static typing reduces bugs, but I am not convinced the reduction is significant or meaningful. If static typing has a significant effect, then why is the existing research so weak and inconclusive?
I don't understand your point about metrics and measurement. Are you saying the effect of static typing is so small that it is completely dominated by other confounding factors and thus cannot be measured?
My point about metrics is why I think the research is inconclusive. It’s very difficult to get a metric that’s meaningful in this context. If you said: this code base on average has 1 bug per 100 lines of code, that doesn’t say anything meaningful. If that code is assembly, that’s not very good because of how terse the code is. Whereas, if that code is Python or Ruby, that’s much better because of how concise those languages are.
Because of this, I feel like the only way to truly measure whether or not static typing has a significant effect would be to create two equivalent projects. Say you created stack overflow in Python and in C#. Then you could compare the quantity of bugs and see if it differs. But even this has problems because who knows how many bugs haven’t been caught? Is the code truly equivalent? Did the people who wrote the two codebases have slightly different experience resulting in differing number of bugs?
There’s too many variables in an experiment like this to conclusively determine whether or not static typing reduces the bugs. But, I don’t think that means that we can’t infer that eliminating a whole class of bugs is helpful.
Edit: the more I try to think about my reasoning the more I’m thinking it’s flawed. I think the answer to whether or not static typing reduces bugs is unknowable, but I strongly believe that it helps. Maybe we’ll get a study that isolates this metric one day :)
> In the 1970s/80s, an hour of minimum wage could afford you about 7 big macs. Now, it will not even buy you one.
The cost of a Big Mac in 1986 was $1.6 according to the Economist's Big Mac Index dataset[0]. The minimum wage in 1986 was $3.35[1] according to the US Department of Labor.
So you could afford at most two Big Macs in 1986, not seven. Also you can definitely afford one big mac with an hour of minimum wage today (minimum wage: $7.25, big mac: $5.36).
It's good to keep the facts straight here, which is what you're doing. But it should be noted as well that the broader point being made has not been addressed. Even according to these adjusted figures, the ability to buy Big Macs with an hour of labor has decreased. Shouldn't it be increasing, as technology gets better and productivity increases? Where have the additional profits from productivity gain been going?
I worked in a government office where only unionized IT workers were allowed to move computer equipment. My boss gave me his old monitor after upgrading and I had to wait until after hours to move it. This was around 2018.
So the electrical strip thing seems plausible to me.
This was before my time, but I believe the WS-* series of specifications is an example.
> Like with the original J2EE spec, which sought to complicate the basic mechanics of connecting databases via HTML to the internet, this new avalanche of specifications under the WS-* umbrella sought to complicate the basic mechanics of making applications talk to each other over the internet. With such riveting names as WS-SecurityPolicy, WS-Trust, WS-Federation, WS-SecureConversation, and on and on ad nauseam, this monstrosity of complexity mushroomed into a cloud of impenetrable specifications in no time. All seemingly written by and for the same holders of those advanced degrees in enterprisey gibberish.
That's surprising! Wasn't it Philip Wadler who said "The essence of XML is this: the problem it solves is not hard, and it does not solve the problem well."
You don’t have to use anything for XML, either. The simplest XML document is almost indistinguishable from the simplest JSON document. Nothing in XML requires XML schemas or namespaces or anything else that is usually attributed to the complexities of XML.
> In a vocation where loss of limb (and even life) was not uncommon, prospective workers — in a field disproportionately comprised of working-class African-Americans and whites of Italian and Irish descent who did not benefit from the upward mobility of the G.I. Bill — were forced to offer kickbacks to syndicate representatives at the daily "shape-up," in which prospective workers were forced to compete against each other to secure work irrespective of union membership. At any time, workers could be virtually blacklisted from subsequent employment for arbitrary purposes in the union's "blue books," their jobs often requisitioned by members of the syndicate who were completing prison sentences.
https://www.pulitzer.org/article/underworld-syndicate-malcol...