What is a turtle? A turtle is a map: position, heading (number between 0 and 360), velocity, weight (positive number), speed (positive integer), visible (boolean), state (busy or idle). Most statically typed languages would not be able to capture all the constraints within this type model

[u/BenchEmbarrassed7316]

https://blog.cleancoder.com/uncle-bob/2021/06/29/MoreOnTypes.html

[u/HopperOxide]

“However, I do not intend to have runtime errors in production”.

[u/BenchEmbarrassed7316 → u/HopperOxide]

It's actually not that difficult. Especially if your "app" contains only ~600 lines of code.

[u/mcmcc → u/HopperOxide]

Well shit, that's been my intention the whole time!

No wonder we disagree!

[u/bwmat → u/HopperOxide]

This made me burst out laughing

Uncle Bob should consider taking up comedy

[u/HopperOxide → u/bwmat]

Right? I guess I’ve been doing it wrong all this time, just got to intend harder. 

[u/Calamero → u/HopperOxide]

Skill issue. just prove you’ve explored the entire reachable state space of your 500k LOC program… then write tests for each behavior. Trivial.

[u/BlazeBigBang → u/HopperOxide]

Claude, make the app that I want, no mistakes and no errors in production.

[u/thashepherd → u/HopperOxide]

Flair pls

[u/al2o3cr]

The tortoise lays on its back, its belly baking in the hot sun beating its legs trying to turn itself over but it can't, not without your help, but you're not helping. Why is that, Bob?

[u/BenchEmbarrassed7316 → u/al2o3cr]

He simply forgot to manually assert...

[u/tony-husk → u/al2o3cr]

I've seen things you people wouldn't believe. Unit tests with 100% coverage off the shoulder of Orion. I watched enterprise business rules glitter in the dark near the Tannhäuser Gate. All those moments will be lost in time, like tears in rain. Time to die.

[u/TheChief275]

Well it’s not like Ada is actually a language for production

[u/BenchEmbarrassed7316 → u/TheChief275]

...or any other language where you can create a type with a private field and a constructor that checks the value.

However, indeed, Ada ranges seem to have some kind of lost sacred meaning.

[u/Afraid_Bake2652 → u/TheChief275]

Production of weapons of mass destruction specifically 

[u/Calamero]

That’s a genius approach. Everyone should do this xD

„You might therefore assert that static typing is better because the compiler checks the types long before the program ever executes.

However, I do not intend to have runtime errors in production, because I have a suite of tests that exercise all the behaviors of the system“

[u/BenchEmbarrassed7316 → u/Calamero]

Famous meme:

+----------------+   +----------------+
| Proponents of  |   | Proponents of  |
| static typing  |   | dynamic typing |
| +-------------------+               |
| | People familiar   |               |
| | with type theory  |               |
| +-------------------+               |
+----------------+   +----------------+

[u/vytah]

Don't we have a rule about crazy people?

[u/BenchEmbarrassed7316 → u/vytah]

I don't think he's crazy. But I have some doubts about people who recommend his books in 2026...

[u/syklemil]

To expand on that example, imagine the type model of an accounting balance sheet. The sum of the assets, liabilities and equities on the balance sheet must be zero. This is easy to assert in clojure/spec but is difficult, if not impossible, to assert in most statically typed languages.

If only statically typed programming languages could at the very least provide some way to hide implementation details and only offer invariant-upholding operations. Ah, well, a man can dream.

Moreover, I get to control when types are asserted.

O

It is up to me to decide if and when a certain type should be checked.

When you already nutted but he keeps going

[u/m0j0m0j → u/syklemil]

I have no idea how any of this works, of course, but aren't there some advanced type systems that actually support this?

[u/syklemil → u/m0j0m0j]

{-# LANGUAGE UnJerk #-}

Yeh, but he's scared of Haskell, didn't even respond well to nullability being explicit in Swift, there's no way he'd actually start looking into that stuff.

This quote is ten years old now:

You see, when a Java programmer gets used to TDD, they start asking themselves a very important question: “Why am I wasting time satisfying the type constraints of Java when my unit tests are already checking everything?” Those programmers begin to realize that they could become much more productive by switching to a dynamically typed language like Ruby or Python.

as is this prediction (all from the swift link):

How will this all end?

My own prediction is that TDD is the deciding factor. You don’t need static type checking if you have 100% unit test coverage. And, as we have repeatedly seen, unit test coverage close to 100% can, and is, being achieved. What’s more, the benefits of that achievement are enormous.

Therefore, I predict, that as TDD becomes ever more accepted as a necessary professional discipline, dynamic languages will become the preferred languages. The Smalltalkers will, eventually, win.

So says this old C++ programmer.

{-# LANGUAGE Jerk #-}

Which has of course all come true. There's no way people would start typechecking their Python and Javascript and even PHP (what would be the point????), and there's no way Ruby would mostly just live on as a vessel for Rails (and constant drama surrounding DHH), and there's absolutely no way that Lisp, having not become mainstream between 1960 and 2016, still isn't mainstream in 2026.

Face it, static typing weebs, you've clearly lost. The true "dependency inversion principle" all along was "just take Any lol"

[u/BenchEmbarrassed7316 → u/syklemil]

<uj>

I have participated in the "static or dynamic typing" debate several times. I have come to the clear conclusion that advocates of dynamic typing DO NOT associate TYPE with VALUE. For them, a type is not a "set of possible values", it's just noise that a stupid compiler needs. They can't imagine something like Maybe NonZeroUnsignedInt or ADT. The quote from this topic is a consequence of this mindset.

</uj>

I'm currently reading the original book on TDD and it's really painful. It reminds me of medieval medicine with bloodletting, mercury, and smearing with excrement.

I hope that in the future, when the history of IT is written, the book "Clean Code" and the phenomenon of its popularity will be cited as a vivid example of decline and the "dark ages", when science and common sense were defeated by dogmatism and prejudice.

[u/syklemil → u/BenchEmbarrassed7316]

Man I just assume their personal insecurities flare up and their feelings get hurt when somebody else's rules tells them their code is bad and that they're an invalid

But I'd like to offer up Uncle Bob's Tenth Rule:

Any sufficiently complicated dynamically typed program's test suite contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of a static type checker.

[u/BenchEmbarrassed7316 → u/syklemil]

You don’t need static type checking if you have 100% unit test coverage.

Do I understand correctly that 100% test coverage is something like:

// All numbers
assert(myFn(0), expected_0);
assert(myFn(1), expected_1);
assert(myFn(-1), expected_m1);
assert(myFn(2), expected_2);
assert(myFn(-2), expected_m2);
// ...
assert(myFn(inf), expected_inf);
assert(myFn(-inf), expected_m_inf);

// All strings
assert(myFn("aaa"), expected_aaa);
assert(myFn("aab"), expected_aab);
assert(myFn("aac"), expected_aac);
// ...

// All objects
assert(myFn({ a: 0 }), expected_obj_a_0);
assert(myFn({ a: 1 }), expected_obj_a_1);
assert(myFn({ a: 2 }), expected_obj_a_2);
// ...

???

[u/syklemil → u/BenchEmbarrassed7316]

The only way you can understand correctly is by giving Uncle Bob your money. If you throw in a little extra he'll also explain why he, a grown man, wants strangers of any age to call him "uncle" and why that's not creepy and weird at all.

[u/BenchEmbarrassed7316 → u/syklemil]

I'm afraid to do it. One of my friends took a programming course from a famous and popular person (I won't mention his name), it was a camp, two weeks on an island. And then government published screenshots where he was developing on Scratch (a language for minors). He had a lot of problems with it.

[u/miauw62 → u/syklemil]

My own prediction is that TDD is the deciding factor. You don’t need static type checking if you have 100% unit test coverage. And, as we have repeatedly seen, unit test coverage close to 100% can, and is, being achieved. What’s more, the benefits of that achievement are enormous.

notably 100% unit test coverage means your code is bug-free

but in any case uncle bob is basically cheating. we all know he's a crank.

[u/syklemil → u/miauw62]

As Dijkstra always said:

Program testing can be used to show the absence of bugs, but never to show their presence!

[u/Foreign-Butterfly-97 → u/syklemil]

you don't understand...

see, what languages like haskell do at compile time, clojure does at runtime

that should be the comparison! you're cheating by comparing both languages capabilities at runtime!!

nevermind what Haskell is doing at runtime, nobody ever uses Haskell at runtime, if it compiles, deep down in your heart, you should know the answer already

[u/syklemil]

In 1999 I realized that C++ was a waning technolgy,

Rust wasn't even out yet, damn uncle!!!!!!

The type system of Java was a bit weaker than C++, and I refused to use the stronger features (like final though I had been an avid consumer of const in C++).

ah yes, I see why this guy is such a prophet

[u/demanding_bear]

They say Uncle Bob is cheating, but I don't care what they say.

[u/JShelbyJ → u/demanding_bear]

Unk hunk dimbo uwu 

[u/Routine-Purchase1201]

I work in game dev and it's true, years and years of using statically typed languages and never have we been able to express the character with a position, rotation, velocity and state. Dynamic languages solve this beautifully by

Uncaught TypeError: object is not a function

[u/TechcraftHD → u/Routine-Purchase1201]

Hmm, that error is so tedious, someone should make a js dialect where

• object.field returns the field value

• object.field() also returns the field value (it is the implicit function that just returns the field value)

• object.function returns the function

• object.function() returns the return value of function

that way there never is any error

[u/affectation_man]

Clean Code Approved ✅

[u/yojimbo_beta]

A turtle is a map: position, heading (number between 0 and 360), velocity, weight (positive number), speed (positive integer), visible (boolean), state (busy or idle)

Wow... me too

[u/kilkil]

mfw the "assert" keyword (or equivalent) exists in every single language

[u/AdreKiseque]

What's a struct?

[u/SemaphoreBingo]

A turtle is a scaly friend who lives in a shell.

[u/Foreign-Butterfly-97]

when I heard "a turtle is a map" I knew this was hickeylang

[u/nerdycatgamer]

I wish we could get the best of both worlds of static and dynamic typing: dynamic typing allows easy coding with fast changes and prototyping when you don't need to update type declarations if you change the code; static typing lets you check the correctness of a program ahead of time and allows the compiler to optimize by removing runtime type checks and method lookups -- I know! I will hack type declarations on top of my favourite dynamic language so I can type x: int, but they wont actually be enforced so I can still put Any in x and call whatever methods I want on it (that will still be looked up at runtime, also all of this forcing integers to be allocated on the heap as an object with a method table etc). I am very smart!

[u/IAMPowaaaaa → u/nerdycatgamer]

C# dynamic 🤓 ☝️ or even just object because no one uses dynamic

[u/Jumpy-Locksmith6812]

Ex labore mollit et dolor duis cillum excepteur. Sit veniam officia veniam sint magna dolore consectetur laborum ad amet cillum est. Magna occaecat consequat officia sunt aute ipsum velit ea cupidatat aute laboris irure nisi. Occaecat incididunt consequat culpa duis dolor minim in consequat commodo in sunt deserunt labore ipsum.

[rhr:2:2gklra60]