I don't want to look at TIOBE, so let's look at the stack overflow survey from 2024. https://survey.stackoverflow.co/2024/technology#admired-and-...

Strong + Static: TypeScript, Java, C#, C++, Go, Rust, Kotlin, Dart, Swift, Visual Basic, Scala

Weak + Static: C

Strong + Dynamic: Python, Lua, Ruby, R, GDScript(*)

Weak + Dynamic: JavaScript, PHP, Matlab, Perl

At this point I'm reaching into the low percentages. I think it's pretty clear that Strongly + Statically typed languages are massively over-represented on the list.

Both Strongly and Weakly Dynamically typed languages are similarly represented.

Note: I'm open to editing the comment to move languages from and to various categories. I haven't used many of them, so correct me if I'm wrong.

not anymore. they were very popular in the industry at one point. very few other languages have so many independent implementations as smalltalk and lisp. a testament to their wide spread use in the past.

Strong + Static: TypeScript; Weak + Dynamic: JavaScript

that doesn't make sense. typescript is javascript with types, it can't be both strong and weak at the same time.

but i believe we have a different definition of weak. just because javascript, php and perl have some implicit type conversions doesn't make them weakly typed. i believe it takes more than that. (in particular that you can't tell the type by looking at a value, and that you can use a value as one or another type without any conversion at all)

C is weakly typed, it was always a major criticism, C++ too i think (less sure about that).

once you correct for that you will notice that all languages in the strong and static category are less than 30 years old and many are much younger. (java being the oldest. but there are older ones like pike which is also strong and static and goes back to 1991)

the strong and dynamic category goes back at least a decade more. (if you include smalltalk and lisp)

what this does show is that static typing has experienced a renaissance in the last two decades, and also the worst is really using any form of weak typing.

i still don't get what makes strong and dynamic a bad combination, other than it's bad because it is not static.

I know that there are discussion about what strong vs weak even means, but I think most people would place the weak distinction way above yours on a possible weak-strong spectrum.

C can certainly be argued to be weak. My understanding is that it's mostly due to pointers (and void* especially). C++ is much better in this regard. I mostly just did not want to add a Weak + Static category just for one language.

Well, now that you've defined Strong to also include all of the languages I consider Weak, then yeah, no issues at all.

but the interesting question is really the one posed at the beginning. what makes strong but dynamic a bad combination?

i think we agree that weak is bad. implicit type conversions like 1+"2" range from the annoying to problematic and dangerous. if we eliminate weak that only leaves strong and static vs strong and dynamic.

i agree that strong and static is better in most cases, type declarations help, and pike the language i use the most myself which is somewhere between python and go, has powerful types that are a joy to work with, but for comparison in typescript types come across as more annoying (in part because they are somewhat optional, and because they get lost at runtime, so they don't help as much as in truly typed languages) but strong and dynamic has shown to be a solid combination, especially with python and ruby. so i don't feel the combination is as bad as you seem to suggest.

Sure, Smalltalk isn't, but Lisp is a different story. In this context I assume we all mean to say "Lisp" and not "Common Lisp" specifically.

Lisp (as the entire family of PLs) is quite massively popular.

Standard rankings have major blind spots for Lisp measurement, they miss things like, for example, Emacs Lisp is everywhere. There's tons of Elisp on GitHub alone, and let me remind you, it's not a "general-purpose" language, its sole function is to be used to configure a text editor and there's mind-boggling amount of it out there. AutoLISP is heavily used in CAD/engineering but rarely discussed online. Many Lisp codebases are proprietary/internal. Also, dialect fragmentation artificially deflates numbers when measured separately - many rankings consider them different languages.

If you count all Lisp dialects together and include: Emacs Lisp codebases, AutoLISP scripts in engineering, Research/academic usage, Embedded Lisps in applications, Clojure on JVM and other platforms - babashka scripts, Flutter apps, Clojurescript web apps, etc;

...Lisp would likely rank much higher than typical surveys suggest - possibly in the top ten by actual lines of code in active use.

Log lines are whatever, but a system that goes into a crash loop or fails on most requests isn't great.

I never did track down the last spot where we screwed that up. This was a system we shifted from statsd, so the offending callers were either working by accident or only killing some data points for one stat and nobody noticed.

So then OpenTelemetry.js had to start sanitizing its inputs and not assuming the compiler should catch it. I still think it odd that something called “.js” was actually “.ts” under the hood.

Getting an error on "Value: " + 2 is very annoying if that's what you wanted to do.

The solution here is Static typing, not Strong/Weak typing.