I fucking love you.

Dynamic typers: learning the debug tool is too hard.

Loose typers: can't we all just be friends?

TypeScript says why not both?

As usual, you got to the correct words before I did.

hi putt

Right. Shortcuts often don't solve problems, they only make them more difficult to understand.

I just like the fact this image seems to shit on them both equally, as a critique of the absolutism some people have. I found it in a slide deck from a talk given by the author of Lua.

I disagree. Anything more than a 1-liner benefits from static types. Untyped code should be static generic. Type inference can make this as convenient to write as dynamic types.

If it looks like a tail and acts like a tail -- it must be a tree.

Explained here: https://voat.co/v/programming/3347536/19860217

(For anyone reading, feel free to correct me or add more to it)

Programming languages are either Static Type or Dynamic Type.

Static Type means to declare the data type of the variable that you want to define. Example:

int a = 5;
string b = "Hello World";
bool c = true;

In the above, the data types are int, string, and bool.

In Dynamic Type programming languages, you do not declare the data type. Instead, the programming can deduce what type of data it is by what you put in. Example:

a = 5;
b = "Hello World";
c = true;

Pros and Cons:

• Dynamic Type is generally easier for beginners, is faster to write code, and the compiler is less likely to give errors when you attempt to run the program. However, you still have to be careful as you might not get the result you were expecting.
• Static Type forces you to cross your "i"s and dot your "t"s. The compiler will give you errors if what you're trying to define doesn't match with the data type you declared. However, it's a bit slower to write code.

And for the meme: the Dynamic Type guy finishes faster but gets unexpected results, while the Static Type guy is really far behind.

NIGGERKIKEFAGGOT

I’ll tell you this, all these static typing people are a bunch of nerdy faggots that can’t handle dynamism, are scared of eval(), have never used a lisp, and think that JavaScript is somehow a good example of a dynamic interpreted language.

Goddamned children. If I want a “static type” I’ll use a fucking class for it and have done with.

Niggas be like:

def BuyKfc (DwumStickz, Wingz): ...

And then the Jew hired to clean up after the Affirmative Action hires be like:

`` typedef unsigned int t_kfc_drumstick; typedef unsigned int t_kfc_wings;

bool purchase_kentucky_fried_chicken (t_kfc_drumstick drumstick_qty, t_kfc_wings wings_qty) { ... } ``

So Python is like JS? I never tried, I don't like the crowd, they are all poor and depressed, why is that?

Use Nim - Pythonic syntax with types at the speed of C.

Node conquered the attention of soyboy programmers....but not much else.