this post was submitted on 28 Nov 2024
452 points (88.2% liked)

Programmer Humor

32692 readers
293 users here now

Post funny things about programming here! (Or just rant about your favourite programming language.)

Rules:

founded 5 years ago
MODERATORS
 
you are viewing a single comment's thread
view the rest of the comments
[–] [email protected] 25 points 2 weeks ago* (last edited 2 weeks ago) (3 children)

I don't mean this insultingly because lots of programming jobs don't require this and for the ones that do we still tend to all start here, but in all honesty this sounds like it's coming from someone who's never worked on a large project maintained by multiple people over time.

First of all, the hysteria over semicolons is ridiculous when JavaScript, Typescript, C#, Java, Go, Swift, etc. etc. wil all automatically highlight missing semicolons, if not automatically insert them for you when paired with an IDE and standard linter. On top of that, JavaScript and Typescript do not require semicolons at all, but they are still used alongside braces, because they make your code more scannable, readable, and moveable.

Secondly, without type safety your code is no longer predictable or maintainable. If you're working to quickly sketch out some new fangled logic for a research paper it's one thing, if you need to write test code so that your codebase can be tested an infinite number of times by other coders and whatever CI/ CD pipelines to make sure that nothing's broken, then all of the sudden you start seeing the value in strict typing.

Honestly, complaining about type safety adding "extra code" is a complaint that almost every coder has when they start out, before you eventually realize that all that "extra code" isn't just boiler plate for no reason but is adding specificity, predictability, reusability, and maintainability to your code base.

When defining types looked like this it was one thing:

String name = new String("Charles Xavier");

But when it looks like this, there's no reason not to use strong typing:

const name = "Charles Xavier";

[–] kameecoding 22 points 2 weeks ago (1 children)

Anyone who thinks a strong type system is a drawback has never worked on any real project where you actually have to collaborate with others.

[–] ChickenLadyLovesLife 3 points 2 weeks ago

I started out with Visual Basic using the Variant type all the time, and even though I was usually just working on one-person projects it was a fucking disaster. You don't even have to collaborate to see the virtues of strong typing.

[–] [email protected] 7 points 2 weeks ago (1 children)

Yeah, the alternative to static typing is to write tons of unit tests, which definitely adds a lot more code to your codebase.

[–] [email protected] 0 points 2 weeks ago (1 children)

That's not an alternative, you always need tests

[–] [email protected] 1 points 2 weeks ago

Right, so this is the part where I get to sound like a smart ass, because I snuck a "tons of" into there.

What you do always need, is tests serving as a specification of the intended behavior, to document it for your team members and your future self.
But the thing that static typing is an alternative to, is integration tests for many code paths. For example, in dynamic languages you have no reassurance that a call to your database library still works, unless you have an integration test which actually calls into the database. Similarly, you hardly know whether the many error-handling code paths are working, unless you write tests for those, too.
In static languages, we don't test this stuff outside of the specification-like integration tests, because the database library and the error handling library are already separately tested, and the type system ensures that we interface with them correctly.

[–] [email protected] 4 points 2 weeks ago (1 children)

without type safety your code is no longer predictable or maintainable

This sounds like someone who's never worked on a large Python project with multiple developers. I've been doing this for almost two decades and we never encounter bugs because of mismatched types.

For reference, the most common bugs we encounter are related to exception handling. Either the code captured the exception and didn't do the right thing (whatever that is) in specific situations or it didn't capture the exception in the right place so it bubbles up waaaaay too high up the chain and we end up with super annoying troubleshooting where it's difficult to reproduce or difficult to track down.

Also, testing is completely orthogonal to types.

[–] [email protected] 10 points 2 weeks ago (1 children)

This sounds like someone who's never worked on a large Python project with multiple developers. I've been doing this for almost two decades and we never encounter bugs because of mismatched types.

Have you worked on major projects in other languages in that time period to be able to compare and contrast?

The last two python projects I had to work on didn't have bugs because of type issues, but it was much harder to come into the codebase and understand what was going on given that you didn't have type information in many many places which forced you to go back and comb through the code instead.

[–] Incblob 2 points 2 weeks ago

So the code did have type hints, just not consistently. Sounds like bad code.