I FUCKING HATE DYNAMIC TYPING

I've spent hours trying to figure out what's wrong and it was because this shit silently accepted a vector in place of a scalar. FUUUUCK FUCKETY FUUUUCK. Static typing should be everywhere, even in math software, even in fucking Python, I want ALL programming to always be strictly and statically typed. Fucking idiots, ARRGGH.

Unless you are actually complaining about weak typing, errors like these are dead obvious. So you are either a retard or a double agent rooting for Haskell. ^{_{That's not an exclusive OR.}}

>>2
Dead obvious? Not when your eyes are red from lack of sleep because of hours in front of a computer and you've read every fucking line of code several times and haven't noticed it.

>>3
Dead obvious as in ``even the shittiest language will tell you immediately what went wrong and where it went wrong''. Unless you are using weak typing, but everyone knows weak typing is the shittest of the shit.

>>4
But it didn't go wrong, it ran all the calculations as if it's alright to stick a fucking 3-vector in place of a scalar.

I'm sorry your retarded.

>>6
What about his retarded?

>>7
It's retarded.

>>1
It's your standard PEBCAK error. Some people design their software on paper to ensure the logic is sound BEFORE touching a keyboard. This way, trivial errors like variable type mismatching do not happen because the programmer is not designing new logic, the programmer is only translating the pseudocode logic into the syntax that the compiler will expect.

>>8
*Its retarded.

>>1

vector in place of a scalar.

Most people want to reuse arithmetic functions for vectors. Especially in graphics. So you are alone here.

>>11
It wasn't an arithmetic operation, it was a call like

foo(x, otherArg, anotherArg)

and x was supposed to be a scalar but I accidentally put a vector like {x, 0, 0} there so the call became

foo(x, 0, 0, ...)

so the fucking thing just ignored my other args without a single warning, making a perfectly wrong calculation and feeling good about it.

>>12
Protip: Dynamic typing has nothing to do with this. It's caused by a mixture of weak typing and retarded language semantics.

Unlike math, physics has static typing

>>13
Weak typing, dynamic typing, homotyping - I don't care. If the compiler doesn't warn me about pushing a square peg in a round hole, then it's shit. SHIT I TELL YA!

>>15
Don't blame dynamic typing then, Haskell nigger. You'd expect type fetishists to know the difference between type systems.

>>16
I do blame and will forever blame anything that isn't STRONGLY STRICTLY STATICALLY VERIFIABLY RIGIDLY RIGOROUSLY typed. For all the pain I've endured and all the time I've lost, I will forever hate everything that has even the slightest tinge of untypedness.

>>16

You'd expect type fetishists to know the difference between type systems.

There is no useful difference between two pieces of degenerate shit. Calling "weak typing" a "type system" is like calling a chimp a novel writer. You're basically saying that a literary critic should know the difference between gibberish typed by monkey A and gibberish typed by monkey B.

chimp nigger

>>17
Typing is aptly named since it involves lots of typing.

>>20
Typing is anything but a bottleneck in software development.

>>17
Make a static typing preprocessor for every dynamic typing language you are using

>>22
You mean a static analyzer.

>>22
Writing a preprocessor and a typecheker for the plebs languages in use today isn't so hard, but rewriting all the libraries is a bitch.

>>23
No, I don't but this would be a good idea too

What about lisp?

>>26
Typed Racket is nice and getting better.

I'm a fucking retard. scheme/common lisp is too hard for me.

It always felt like Haskell faggots have a problem with Lisp because they try to play Haskell with Sexprs™ when using it. Of course this doesn't work, so they get upset, think it's shit and the reason for this has got to be the biggest difference between the two: Type systems.

>>28
No, they're too shit for me.

>>29

they try to play Haskell with Sexprs™ when using it.

Actually, nothing stops you from typing Lisp code. The only major requirement for Lisp is garbage collection. Everything else is optional, including dynamic typing.

>>31
That's playing semantic games about what constitutes a Lisp.

Also, how would you type macros?

>>32

Also, how would you type macros?

A function from (Atom or List of Atoms) to (Atom or List of Atoms)

>>32
Macros only need types insofar as the AST needs types (it doesn't). Which is to say, even though the expanded code must be correctly typed, the method of producing it (whether expanding it from a macro or typing it in by hand) does not.

>>29
Nope. The biggest reason Lishp is shit is because it's just another run-of-the-mill imperative language (or group of languages, whatever) with the usual cancerous set of disadvantages: everything's mutable, concurrency is shit, everything depends on everything and can launch missiles, everything's bug-ridden, there's no type inference, etc. So since Lithp is so unoriginal, we take the one thing in it that's remotely original, and that's Sexprs™. And we test if at least that one thing could be useful in improving Haskell. And it's not, Sexps are overrated and not really useful for Haskell (goodbye Liskell!). And that leaves nil, nada, Nothing that could be useful about Lishp. Therefore, Lithp is shit through and through, and when someone asks why Lighthp is shit, you could name any one of the reasons and the type system often comes off the top of the head. But that doesn't mean Lithp and Scheme are shit only because of their type systems, that's just the tip of the fecal iceberg of Lithp. It is true that Lishshp is shit because of its type system, but it's also shit for a myriad other reasons and one can enumerate any subset of them really.

>>35
C and Lisp are still the only two languages you need and still both better than haskell.

NASA uses LISP.
NASA doesn't use huskel.

If huskel is so good then why didn't the SICP authors use it instead of Scheme? Even academics think huskel is shit for theory.

>>33
Defeats the point of the type system because you introduce a type (atom) that requires either casts or automatic conversion. One defeats the point of macros, the other one is complete shit and might even be unsafe.

You basically introduced Java's Object, try again. But please don't try as hard as >>35-kun, that would be ridiculous.

It is funny that the major drawback of Haskell (lazy evaluation) has nothing to do with typing, static or dynamic. You can add lazy evaluation to Lisp and it will become useless too! IIRC, SICP has an exercise for that.

If huskel was so good then the SICP authors would of used its parent (ML) instead of Scheme but even its parent is too shit.
LISP is seen as a highly abstract intellectually demanding language built by and used by Wizards. And NASA uses it for mission critical space robots. Who built huskel, who uses it, and what about it again?