The 1st rule of Javascript is: You don't admit you program Javascript.

The 1st rule of Rust is: You tell everyone you program Rust and how it is better than basically any programming language that existed or will exist.

The 1st rule of C++ is: There are no rules because everyone was too busy debugging templates to think of any rules.

The 1st rule of Java is: You must have excessive numbers of classes and boilerplate. The more boilerplate the better.

The 1st rule of Haskell is: It is great to learn, but you will never see it again once you leave college.

The 1st rule of Python is: you have to complain about all code being "non pythonic" without ever saying how you could make it so.

The 1st rule of Ruby is: You have to try to explain to people that "Ruby" exists without "on Rails". You will always fail at it tho.

The 1st rule of C is: actually... You're probably doing something complex and important. Carry on.

The 1st rule of Go is: Don’t panic. It’s all normal.

The 1st rule of Swift is: The same as Rust’s 1st rule.

The 1st rule of TypeScript is: It’s not just a safety belt and a helmet for JavaScript. (It is, but don’t you dare admitting it!)

The 1st rule of programming in general is:
Never say that you program or else you will need to install 30 printers

@jonas-w and fix the wifi 24/7

The first rule of brainfuck is.. wait, why? Are you nuts? Of course you are.

The first rule of SonicPi is: make it headbangy!

The second rule of MATLAB is… did I get my indexes wrong again? Damn.

So what is the first rule for PHP? Are the rules unique or may different languages share a first rule?

@Oktokolo I am just glad people added their own rules. This has been a really fun post because of the interaction.

@Oktokolo The first rule of PHP is that you must keep telling everyone including yourself that it's actually not that bad, while forgetting that you are (probably) interacting with some framework, as opposed to actual raw php, otherwise you'll go insane.

@Midnight-shcode True, i wraped _everything_ because the standard lib is so unbelievably bad 'n quirky.

I use Rust on Arch Linux by the way

The 1st rule of c# is don't talk about time limits
The 2nd rule of c# is don't talk about time limits !

@hjk101 you're a special kind of Nazi in pink combat boots aren't you ?

@AvatarOfKaine it's all about the cape

@AvatarOfKaine my main is c# and i don't understand those two rules. could you explain, please?

@Midnight-shcode everything takes a longer time because it's strongly typed and everyone wants precise time estimates which you avoid giving yeah i know its vague and sucks

@Midnight-shcode I really feel ashamed at the lack of wit now

@AvatarOfKaine "everything takes a longer time because it’s strongly typed"
Wtf?! It makes no sense at all.

@Lensflare c# is incredibly class centric

You type everything

In Js and python you just throw shit together and can get to work quickly

C# is structured

And honestly it does take longer to get something moving in c#

It really does

@Lensflare I had to be meticulous in c# excepting things like console utilities and design everything to specific uses with the plan being for utilize things like polymorphism in the future and inheritance to cut back on the amount of coding and implementation and to define things by markers and interafces

Alot of files
Alot of structure

So yeah it takes longer

@Lensflare example

By design
Someone changes an assembly updating it's version

Side by side error
Instant crapout

Or in the way things tend to be design Ed someone removes a database column dies on query not possibly lines later when the field is referenced

Or ... Sigh it's been awhile
Look it's just a more careful technology that's meant to fuck up if you're using it correctly to prevent unforeseen issues ok !

@Lensflare why are you always so mean to me :(

@Lensflare how about when you implement base classes and interfaces and the like requiring strict rules ? That structuring adds dev time.

@Lensflare or hey how about that abomination wcf
And all the attribute classes a person has to use and the like

@Lensflare or the old way of making web requests or implementing web clients and the like

Takes longer
More setup
More explicit things
Used to anyway

Or the threading classes
Or semaphores
Or event handling considering threads
Defining delegates instead of just "pass me whatever"

Grrr you make me mad having to think about the love hate !

@Lensflare say something!

@AvatarOfKaine nothing that you have mentioned has to do strong typing. Some of your points are about OOP and others are frameworks and standard lib.

I was a big fan of C# myself years ago. But now i find it too verbose and as you say, some things are just too complicated and take too long. So, I kinda agree. But strong typing is definitely not the problem 😄

@AvatarOfKaine I have no idea why you think that I am always mean to you 🤔
I don’t remember a single instance where I was.

@Lensflare well that is how I always understood the difference as being very very explicit about everything
... But ok .
Verbosity is how you define what I said yes it takes a long goddamn time because of that

I feel Microsoft is murdering c#

@Lensflare I should make a gif slideshow of you calling me a crazy bastard over the past two years

@AvatarOfKaine explicitness is one part of verbosity, yes. But there are many more. One example is that the lack of a standard multipurpose collection type forces you to be very verbose when passing around inline or literal collections.
Another example is the myriads of different interfaces for collections to work around the dangerous reference semantics of collections.

But the strictness of types has really nothing to do with being explicit. Take type inference for example. In C# using var is being very strict about types, but it is implicit.

I think that it is really important to differentiate those things.
Misunderstandings like this for example is why many JS users think of it as a good language. They compare it to C++ or C#. Then they see type strictness as the main difference. And they feel like JS is easier. They conclude that it easier because of the lack of strict types. But there are many more things to compare.

@AvatarOfKaine
…

In fact you could use C# with dynamic to behave like JS in that regard. But what wouldn’t make it the same as JS because there are many more differences.

@Lensflare var actually does define a type at compile time
The type resolves and is added to an anonymous class list prior to execution not during

@Lensflare so actually not the same I can open a node she'll and work with data on the fly or in the debug console and the engine allows it

@AvatarOfKaine to be honest I think that you are a bit crazy, based on your recent rants and comments. Sry 😅

But I can’t remember ever mentioning it. Maybe you have some crazy mind reading superpowers.

@Lensflare I personally don't think JS is a good language for anything heavy hitting

I regret using it to make a Google photos incremental downloader to this day and that's not even an incredibly involved task

@AvatarOfKaine about var: yes, I know. That’s what type inference is.

@Lensflare well it's ok
I think you're likely morally insane and a liar pretending not to remember all thisthat is spinning computer jargon together to seem extra intelligent so we're even lol

Amusingly while that would seem to point out which of us is crazy it really doesn't when you start looking at the people speaking in person and how old they say they are after a certain set of events can't but help remind them

@Lensflare the first rule of typescript is: you are bound to vscode.

If theres a lightweight non-obtuse way go compile it, I wouldnt know.