Developers, developers, developers, developers

D-Dad I'm sorry please come home! ;-;

Attached: Steve_Sweaty_Balls_Ballmer.jpg (789x937, 93K)

LOVE

Old Micro$oft

THIS

BIG

>
>EXIT_SUCCESS
B L O A T
L
O
A
T

what a retarded bloated pajeet code lmao kys

I have about 60 ballmers, who wants a dump

Attached: 1526599719688.jpg (3333x2157, 909K)

please give me validation, senpai ^_^
#include

int main(void){
for(;;){
printf("DEVELOPERS ");
}
}

Attached: blingee ballmer.gif (400x225, 255K)

With the snap of his fingers, half of the developers in the universe will cease to exist.

Attached: ballmer thanos.jpg (2025x1068, 1.17M)

>int main (void)
Bloat

>printf
>when you can just use puts
still bloat

puts will add an extra \n dumbass
this is fine

And? The first one manually printed out \n too. Or just use fputs, you dodo.

You really don't need them to be on separate lines

int main() {
printf("Developers.\n");
}

Me

based

>Not doing it in 16-bit assembly

>unnecessary printf
kys

What am I suppose to fucking develop exactly?

>the servers belongs to Linux
>the desktop belongs to Windows
>Perfectly balanced, as all things should be.

youtube.com/watch?v=KMU0tzLwhbE

int main() {
getc("dvlpr");
}

bloody pajeets in this thread

#include

int main() {
for(;;) {
std::cout

t. bloated pajeet

>printf
>EXIT_SUCCESS
>stdio.h

fucking indians

>More type-safe: With , the type of object being I/O'd is known statically by the compiler. In contrast, uses "%" fields to figure out the types dynamically.

>Less error prone: With , there are no redundant "%" tokens that have to be consistent with the actual objects being I/O'd. Removing redundancy removes a class of errors.

>Extensible: The C++ mechanism allows new user-defined types to be I/O'd without breaking existing code. Imagine the chaos if everyone was simultaneously adding new incompatible "%" fields to printf() and scanf()?!

>Inheritable: The C++ mechanism is built from real classes such as std::ostream and std::istream. Unlike 's FILE*, these are real classes and hence inheritable. This means you can have other user-defined things that look and act like streams, yet that do whatever strange and wonderful things you want. You automatically get to use the zillions of lines of I/O code written by users you don't even know, and they don't need to know about your "extended stream" class.

++++++++++[>+>+++>+++++++>+++++++++++.+++++++++++++++++.-----------------.+++++++.+++.+.-----------.+++++++++++++.+.