I'VE HAD ENOUGH!!!

Summary

This rant delves into the quirks and frustrations of programming languages like Golang, JavaScript, and Lua. The speaker vents about Golang's enforcement of unexpected new lines in the formatter, its restrictive syntax errors, and how programming languages make the simple act of coding feel more complicated. Criticism also targets language design decisions, such as JavaScript's lambda functions, which ironically add more keystrokes, and Lua's confusing combination of `else` and `if`. The speaker humorously expresses their dismay at these design flaws, blending comedy with critical insights about the coding world.

Takeaways

• 😀 Golang promises no enforcement of new lines, but the formatter sometimes imposes them unexpectedly.
• 😀 The speaker expresses frustration over Golang's handling of new lines, which contradicts the initial agreement about whitespace.
• 😀 A gentleman's handshake is broken when Golang imposes new lines in code where they were not intended.
• 😀 Golang's switch statement handling creates frustration, as it unexpectedly enforces formatting decisions.
• 😀 The speaker finds it frustrating when coding languages, like Golang, impose formatting decisions that limit customization.
• 😀 There's a significant issue with enforcing certain code formatting in programming languages, particularly in Golang and its switch statements.
• 😀 The speaker criticizes how certain programming languages, like Lua, combine 'else' and 'if' into a single word, which is seen as an error in language design.
• 😀 JavaScript’s behavior with `parseInt` returning zero for multiple different values is called out as illogical and confusing.
• 😀 The speaker criticizes scientific notation in JavaScript, expressing disdain for it, especially in the context of six zeros.
• 😀 The excessive use of lambdas in modern coding practices is questioned, as the speaker argues that they lead to more typing and unnecessary complexity.
• 😀 The speaker expresses disappointment with modern coding trends, such as lambdas and temporary function assignments, which they see as inefficient and counterproductive.

Q & A

What is the main issue the speaker has with Golang's handling of new lines?

The speaker expresses frustration with Golang's formatting, claiming that despite Golang's promise not to enforce new lines, the formatter still inserts new lines, particularly when using switch statements. This breaks their agreement with the language's formatting philosophy.

How does the speaker feel about Golang's approach to whitespace?

The speaker seems to accept Golang's handling of whitespace, agreeing that the language allows for user-controlled new lines while enforcing white space, but their frustration grows when the formatter inserts unexpected new lines, violating their understanding of how it should behave.

What issue does the speaker have with the 'else if' syntax in certain programming languages?

The speaker dislikes languages like Lua that combine 'else' and 'if' into one word, considering it a mistake. They feel this is a confusing and wrong approach, especially when other languages handle them as separate entities.

Why is the speaker critical of JavaScript's handling of zero values?

The speaker criticizes JavaScript's behavior when parsing integers, noting that even when a value is given multiple times, it may return unexpected results, such as returning zero when it shouldn't. This inconsistency is highlighted as a major flaw.

What is the speaker's opinion on the use of lambdas in JavaScript?

The speaker criticizes the use of lambdas, calling them an inefficient choice. They argue that defining a function in a lambda expression, which is lexically bound, actually requires more characters to type compared to traditional function declarations, making it less efficient.

What is the speaker's reaction to Golang's use of switch statements?

The speaker is frustrated by the fact that when using switch statements in Golang, the language inserts new lines despite promising not to enforce them. This contradicts their initial understanding of how Golang's formatter works.

What does the speaker think of scientific notation in JavaScript?

The speaker is strongly opposed to JavaScript's use of scientific notation for zero values, stating that it is an absurdity and an example of poor design, humorously emphasizing their distaste for it.

What is the speaker's perspective on the design of programming languages?

The speaker appears to be a stickler for consistency and logic in programming language design. They are critical of languages that introduce unnecessary complexity or deviate from common sense, such as combining keywords like 'else' and 'if' or making unexpected formatting decisions.

How does the speaker feel about the error caused by new lines in Golang?

The speaker feels betrayed by Golang when a seemingly innocent formatting choice results in an error, particularly when a new line causes an issue with the 'else if' statement. This is portrayed as a significant problem in the language's design.

What are the speaker’s overall feelings about programming languages in general?

The speaker acknowledges that no programming language is perfect but seems to express frustration with the inconsistencies, quirks, and unexpected behaviors they encounter in languages like Golang, JavaScript, and Lua. Despite these grievances, they still continue to use these languages.