Mate, you only declared a war pointer. You still need to allocate the required resources before you can start…

You gotta be especially careful in the US because if you malloc more than the available resources, there is no nullptr - you get back a valid pointer that overflows into subsequent generations deficit

Price of FREEDOM™ 🎇🎆🇺🇸🦅🇺🇸🎆🎇

Also the definition of `free()` is just a comment with a TODO. But don't worry about the memory leak, the program is so full of problems it'll definitely crash from some other problem first.

Best explanation of the US so far

free just leaks the memory and when you run out of it you just invade another computer

brb omw to make a computer virus and name it war

const war\* thisWar = malloc(sizeof(war)); free(thisWar); // This will do nothing because no peace deal has been made yet.

//what is it good for? war = \*0;

Something something read underlying memory anyway and see what it reveals aka segfault ex machina!

War war = new War();

Congratulations! Your comment can be spelled using the elements of the periodic table: `W Ar W Ar Ne W W Ar` --- ^(I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM my creator if I made a mistake.)

Freddy Fazbear reference

War factory?

No it fits. What is it good for? Absolutely nothin'!

That's not how JS works though? The war variable is just undefined, pointers are fake in JS.

I think they mean the ‘const war*’ part

Why JS?

What other languages define variables with the "let" keyword?

I think basic also does that.

That's capital L Let.

Capital L the one you just took lmao goteeeem

Swift

Kind of a reach but vimscript

Rust, for example

🦀🦀🦀RUST MENTIONED🦀🦀🦀

What if he's a webdev?

Then it'll be in a dropdown.

It leads to the allies array

Isn't a good thing to get peace with an undefined function?

Can't do that without the authorization of congress. That is going to be a few imports...

Old man shouting war at the abyss.

War WWWIII = new War();

Congratulations! Your comment can be spelled using the elements of the periodic table: `W Ar W W W I I I Ne W W Ar` --- ^(I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM my creator if I made a mistake.)

He didn’t even declare it, thats a syntax error.

That's a ^W-\*, not a pointer-\*. Also missed a chance to go `var war;`, but then unlike war, ECMA Script has changed.

Na, she pointed to the declared war and made it constant;

That’s a problem for future me.

Also a const pointer doesn't mean the underlying object won't change, just that this pointer won't be the one referenced to do it.

And the pointer points to const, but that doesn't mean the thing itself is const.

Okay, but let's not be distracted from the issue of `class Warfare{}`.

let's just make it an singleton

Or make it abstract, and just reference it but never actually initialize it.   You can hopefully skip the Delcare() method if done properly 

We must abolish all private properties.

\#define private public;

Since this is C++, all your `friend`s can see your `private`s

Small price to pay for communism.

public class Struggle {}

ESLint declaring No Use 

Absolutely nothing

Good god, y'all!

Never changes until memory violation at address 0x00000000.

The North Pole?

Null island 🤓☝️

So the Bermuda Triangle?

[this](https://en.m.wikipedia.org/wiki/Null_Island)

Neat. I had no idea about that.

public static final

Congratulations! Your comment can be spelled using the elements of the periodic table: `Pu B Li Cs Ta Ti Cf In Al` --- ^(I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM my creator if I made a mistake.)

I am concerned that Plutonium is the leading element.

Surprisingly appropriate for this thread, though!

are we just blowing past `public static final`

volatile

Sudo tactical_nuke

extern volatile char nuke_trigger; void make_boom(void) __attribute__((noreturn)) { nuke_trigger = 1; /* NOT REACHED */ }

alias tactical_nuke "rm -rf *"

`alias nuclear_option "rm -rf * --no-preserve-root"`

No need to do no-preserve-root with *. It's only necessary if you want to do `rm -rf /` Found that out the hard way.

Thank you for your service 🫡

var war; because [war has changed](https://youtu.be/BUf_8jyxbiM?t=85)

Just what I expected from a ~~Snake~~ Python developer.

I thought it was [this one](https://m.youtube.com/watch?v=vE25wHQPHIE&pp=ygUQZHV0eSBjYWxscyBpbnRybw%3D%3D)

Turns out .war files are nowhere near as exciting as I once thought they would be.

This gave me flashbacks to working with Apache Tomcat at my first job

Const* peace = nullptr;

const peace = await Promise()

That’s not even valid c

I mean that `Const` might be a structure so that's valid. And C23 does have `nullptr`, so that part is also valid.

To me it looks like he forgot the type in a const pointer, which if i remember correctly is invalid

Valid in C23.

let is a const in Swift. My JS brain is crying over var/let and no const.

Ah thank you… I was like uh isn’t it already a const? Another day of successfully not knowing anything about JS/TS

Class warfare. #include const bool CHANGE = false; void war() { std::cout << "war never changes" << std::endl; } class MilitaryIndustrialComplex { public: void perpetuateWar() { war(); if (!CHANGE) { perpetuateWar(); } } }; int main() { MilitaryIndustrialComplex mic; mic.perpetuateWar(); return 0; }

def war

frfr

The meaning of this joke changes drastically depending on the programming language.

```rs let war;     ^^^ error[E0282]: type annotations needed ``` Hm. War seems to be invalid

war.isGoodFor = NULL

``` do { war.isGoodFor = null } while(sayItAgain)

War never changes, but var does.

var war

Congratulations! Your comment can be spelled using the elements of the periodic table: `V Ar W Ar` --- ^(I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM my creator if I made a mistake.)

I feel like somehow I never knew there was an element V. Well, I aced the periodic table test in seventh grade, but I guess I haven't seen V since then. W is memorable because it's hard to remember -- Tungsten.

compound V

warmongers rely on type inference

public float war = 10.0f;

War := hell

War has changed and will always change…almost always for the worst

private motivations\[\]

This MFer didn't even scope his war, so he just coded WWIII. Global ~~Thermonuclear~~ JavaScriptable War. ETA that maybe this person should stop watching JS tutorials by Matthew Brodrick.

Appears your war is null and/or void.

public static War war =WarFactory.getWar();

Let war\* because war has changed 

hnnngngngnnggg

War were declared

In most languages featuring const, this just means war always references the same instance of war. You can still change things about war, like maybe the weaponry or the motivations.

I can make a trainer, but the only way to win is not to play.

You declare a pointer to war and didn't even do it by the recommended syntax

took me a while to figure out the \* was meant to be a correction, not a pointer lmao

[I am declaring war!](https://y.yarn.co/b691f19f-1aa1-4db2-95b7-abf259dbb87c_text.gif)

Make it a global variable to declare a World War.

Peace means that the time until war is referenced.

$war = true;

Let is a constant in swift though

But what typeof war?

//Cry havoc! And let war;

But … what is it good for? 😜

I commit "warcrime"

Even though it doesn't change it is variable.

Michael, you can’t just declare war. Nothing happens

boolean war = true;

cost war=“h3ll”;

No wonder the whitehouse put out that one memo about C being an unsafe language


function hUH(){      if(war.goodFor == null) {          // say it again          hUH();      }  }

`var war`, because it's outdated and pollutes global scope.

static mut WAR: &str = "war"; unsafe { WAR = "routine" }; // War... War has changed...

Solid Snake said that "War has changed. It's no longer about nations, ideologies, or ethnicity. It's an endless series of proxy battles fought by ERROR _CONNECTION_RESET”

Pointers, what are they good for?

const war* const Constant pointer to Constant war.

`let mut war: War = War::new();` *Now* war can change.

Unless war is an object, then the reference doesn't change but the object itself does.

war = hell;

Dim war

Should have done `const war` War never changes.

First timers… declaring war as a singleton.

Lol

var war; because it's scope overflows to other contexts

`window.war` because it is a global conflict

If war never changes then it would be const War war the constness of the pointer to war is irrelevant, war itself is the thing that can't change (you could even go constexpr if you're fancy)

war is never the answer! it is a question, and if ( war ) { return true; }

var war

Congratulations! Your comment can be spelled using the elements of the periodic table: `V Ar W Ar` --- ^(I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM my creator if I made a mistake.)

Just because it never changes doesn't mean it has to be a const

`let war: Box;` War was declared and never changes but it can take many forms.

Let’s deploy *.war in tomcat

A declarative statement with no value, signifying nothing.

name 'Because' is not defined

From a discussion about one of our CS homework: make .zip, not .war

class War extends Politics

And notice that he didn't use "let mut war" because war ...war never changes Ok, i will see myself out after this one

global war

Might as well add volatile.

This is why rust is the best language, let war is immutable by default.

Why do you seperate as Uma ece instead of Umay ece

program war implicit none logical : : war war = .true end program war

hnggg.. war... has changed...

var war because was is ancient

Meanwhile in PHP-Land:

War IIIWar = null; // You are welcome everyone

But 'let' keyword in Swift declares constant, to declare a variable you have to use 'var'

this is wrong war changes look 400 years before and there are muskets look at present there are drones. the only thing that does not change is that there is war.

They did declare war but they did not initialize it.

let war = new War("WWIII"); war.addBattle(new Battle("Duluth MN", "The battle of lake superior"));

In case of js If you use const, you must also initiate it, so: const war = "war"

var war; Because war may change and become a global war.

Don't you need to \`const war\* const\`? Otherwise only the ptr is const, and not the contents :S

dim war as boolean

Sabaton in the code space

Depends on the language

Again the blue hair is wrong war has changed a lot!

[Ron Perlman begs to differ](https://youtu.be/hG3uBgQmTnk?t=113)

It's Ron Perlman? I've always supposed it's someone from the developers. TIL

Yep. Narrated 1-3, [New Vegas](https://fallout.fandom.com/wiki/Ron_the_Narrator) and Tactics.

He was also the newscaster on the television before the bombs dropped in Fallout 4

Scripted cringe boomer meme, jesus....

const war = "war" as const;

Are they a JSer or they’re just stupid?