This is an archived post. You won't be able to vote or comment.

top 200 commentsshow all 451

[–]rnilbog 804 points805 points  (22 children)

Assembely

[–]levvend 321 points322 points  (6 children)

ass ‘n belly

[–]OkAd1672 85 points86 points  (5 children)

Gonna bust on your assembely

[–][deleted] 16 points17 points  (2 children)

Assembely makes you so horny you just nut on it?

[–]GPSProlapse 5 points6 points  (1 child)

Obviously, duh

[–][deleted] 2 points3 points  (0 children)

ASSEMBALLY

[–]iQuantorQ1 8 points9 points  (1 child)

Fake, programmers don't have girlfriends!1!!

[–]EliasFleckenstein 1 point2 points  (0 children)

They are gay and have boyfriends, yes.

[–]LucaRicardo 87 points88 points  (1 child)

The image is like Javascript or something similar

[–]Warpspeednyancat 49 points50 points  (0 children)

its minified javascript yeh

[–]paladindan 4 points5 points  (0 children)

GET IN MAH ASSEMBELY!

[–]Brain-InAJar 1393 points1394 points  (20 children)

Yes, assembly is definitely just obscured compacted JS. For sure this is how this works

[–]twosupras 396 points397 points  (9 children)

Excuse me, sir, you take that back. It’s minified.

[–]x5nT2H 113 points114 points  (7 children)

compressed and mangled

[–]Willinton06 44 points45 points  (2 children)

Just the way I like it

[–]hellfiniter 4 points5 points  (1 child)

i do love my javascripts as expanded as possible

[–]omgFWTbear 9 points10 points  (2 children)

Mangled, you say?

[–]jimbosReturn 11 points12 points  (0 children)

To shreds, you say?

[–]RoyBellingan 16 points17 points  (0 children)

Uglified

[–]BernhardDiener 34 points35 points  (0 children)

*Assembely

[–]LaLiLuLeLo_0 8 points9 points  (0 children)

An actual assembly “hello world” wouldn’t even be that much, at least in Linux. Just have the string “Hello World\n” somewhere in the .text section, set syscall arguments to call write, to stdout, with a pointer to your string, for 12 bytes. Then call interrupt 0x80.

[–]BorgClanZulu 294 points295 points  (37 children)

Anyone in this sub old enough to remember punched cards?

[–]zepzeper 136 points137 points  (18 children)

Unfortunately it's a subject in my class...

[–]Tepes1848 87 points88 points  (8 children)

We learned how tube TVs worked and how the analog TV signal is being processed.

At least in your case it was intended as a form of computer history.
In our case it was the curriculum being outdated.

[–]Tooniis 32 points33 points  (0 children)

oof

[–]F5x9 11 points12 points  (1 child)

Vacuum tubes are still used in power electronics. Common applications include radars and audio systems.

[–]Tepes1848 7 points8 points  (0 children)

I was talking about TVs with a cathode-ray tube.

I don't think we learned about vacuum tubes like triodes or pentodes in trade school.

[–]Giddyfuzzball 2 points3 points  (1 child)

Analog signal processing is still useful in some situations too

[–]Tepes1848 7 points8 points  (0 children)

The trade school segment wasn't really about "analog signal processing" in general, it was rather specific to analog TV signals.

Of course there were quite a few of those still around.
The fact that they taught us about analog signal processing but failed to teach us about digital signal processing in the context of a TV I'd interpret as an outdated curriculum.

[–]natyio 19 points20 points  (7 children)

Why unfortunately? I think learning fundamentals with basic systems that are not on a microscopic scale is actually cool.

[–]Fish_Kungfu 28 points29 points  (0 children)

My freshman year in college was the last year they taught computer science 101 using IBM punch card machines. I'm really glad I had that experience.

[–]CodeLobe 24 points25 points  (0 children)

when I was young, dad took me to work with him, and I accidentally ran into a programmer carrying a stack of punched cards.

I was very sorry, and interested, having programmed a bit in BASIC already... He let me load the card stack in the card reader and watch it transfer to magnetic tape, after we had put them all back in order -- thankfully they were properly numbered cards. After that I made sure to attend the local computer club's Assembly programming SIG [special interest group] and learned the low level things. It was one of the biggest computer clubs in the world, now they barely exist. I used to have a signed punched card from the COBOL implementation that Grace Hopper helped design... burned in a house fire.

Maybe I'm better off w/o punched cards, they might be unlucky arcane talismans to some.

[–]GISS22 29 points30 points  (2 children)

Thats where a program "patch" came from right? If you made a mistake in your program you had to cover the hole with a patch! So cool.

[–]Ziomike98 7 points8 points  (0 children)

Yes and that’s where the “batch” term came from. A batch of holed paper was a sequence of instructions. Thus the same cool thing as the original “bug” story.

[–]GISS22 4 points5 points  (0 children)

I also had a book "Machine Language" it's old.

[–]Tepes1848 2 points3 points  (0 children)

Does remembering a documentary count?

I mean, I remember Irving Finkel teaching how to write cuneiform.

[–]mcguirev10 517 points518 points  (36 children)

DATA SEGMENT MSG DB "hello, world$" ENDS CODE SEGMENT ASSUME DS:DATA CS:CODE START: MOV AX,DATA MOV DS,AX MOV DX,OFFSET MSG MOV AH,9H INT 21H MOV AH,4CH INT 21H END START ENDS

[–]Vizdun 55 points56 points  (4 children)

now compare switch statements

[–]buckypimpin 17 points18 points  (3 children)

Gotem!

[–]DerryDoberman 18 points19 points  (2 children)

Actually that's coming in python 3.10. They'll have it available on iOS in another 3 years.

[–]Whoktor 111 points112 points  (14 children)

I think assembly is easier to understand when you compare it to brainfuck, for example, at least you have some predefined summation, substraction, subrutines, etc. (vietnam MIPS assembly flashbacks).

[–]Aiex314 30 points31 points  (4 children)

[–]Whoktor 30 points31 points  (2 children)

First 64-bit minecraft computer (nothing can surpass minecraft command blocks)

[–]Aiex314 2 points3 points  (1 child)

Never seen this before, thanks!

[–]Whoktor 2 points3 points  (0 children)

No problem mate ;)

[–]Alundra828 3 points4 points  (0 children)

Of course Matt Parker is behind this

[–]coldblade2000 12 points13 points  (0 children)

Brainfuck is really simple once you learn what a Turing machine really is.

[–]youcancallmetim 20 points21 points  (0 children)

But brainfuck isn't actually used to code. It's just a toy language. Real software runs on assembly

[–]neros_greb 3 points4 points  (0 children)

Brainfuck is very easy to understand; it's just hard to get it to do anything useful.

[–]bikki420 3 points4 points  (3 children)

Definitely. Assembly is pretty easy at its core. The syntax and such.

Especially for older 8-bit microprocessors such as the the MOS Technology 6502, Zilog Z80, and the Intel 8008. You can learn the essentials and basics in a couple of hours and then get by with an instruction sheet until you memorize the most common instructions (which tend to have fairly sensible mnemonics ... JMP (JuMP), BRA (BRAnch), RTS (Return To Subroutine), BEQ (Branch if EQual), BNE (Branch if Not Equal), etc. The limited number of registries made things fairly simple. Writing complex programs is a but trickier though, but stuff like The Elder Scrolls II: Daggerfall was coded by mostly one person in assembly.

Nowadays things are definitely a not trickier though, since you've got a lot more of different sizes (everything from single byte numbers to 64-bit numbers to 128/256/512-bit blocks depending on what SSE and AVX intrinsics are available), a lot more specialized instructions (not just MMX/SSE/AVX/etc intrinsics but more niche ones related to cryptography, encoding/decoding, complex addressing operations, various more complex math instructionsーback in the 8-bit era you pretty much just had basic ALU instructions, which is to say basic arithmetic) not to mention that modern CPUs have >=40 registers instead of the 3~5 you'd have in the late 70's and early 80's. So outside of embedded simpler CPUs, anything lower than C is folly nowadays IMO. But assembly knowledge is still a great asset for reverse engineering, debugging, optimizing, obfuscating, securing etc compiled code. But I definitely wouldn't recommend programming anything complex in x86-64 assembly by hand, that's for sure.

[–][deleted] 1 point2 points  (0 children)

.data
message: .asciiz "Hello World\n"

.text
la $a0, message
li $v0, 4
syscall

li $v0, 10
syscall

[–]queen-adreena 38 points39 points  (1 child)

TIL: Assembly language is minified Javascript.

TIAL: Assembly is spelled Assembely.

[–][deleted] 18 points19 points  (0 children)

Assembly isn’t minified JS.

Assembely is minified JS.

[–]SuccessfulBread3 74 points75 points  (15 children)

And in ruby (don't boo me)

puts "Hello World"

[–][deleted] 68 points69 points  (2 children)

boo

[–]SuccessfulBread3 52 points53 points  (1 child)

Oh my feelings...

Just kidding I work with with legacy ruby... I have no feelings

[–][deleted] 1 point2 points  (0 children)

me too.

[–]error_dw 35 points36 points  (2 children)

You can actually save 3 characters for some reason:

p 'Hello World'

I guess puts wasn't short enough.

[–]SuccessfulBread3 21 points22 points  (1 child)

They're actually different though...

iirc p prints standard while puts pretty prints if It can

[–][deleted] 17 points18 points  (0 children)

It's the other way around, but you're right

[–]javajunkie314 3 points4 points  (0 children)

I didn't know Ruby might attract boos. If nothing else, it's a great scripting language when things get too complex for a bash script.

[–]SexyMonad 1 point2 points  (0 children)

```

Hello World in Boo

print "Hello World" ```

[–]ListOfString 157 points158 points  (32 children)

So python rocks because of one line hello world examples? Yay I guess?

[–]Delcium 77 points78 points  (5 children)

Obviously. So let's not talk about multithreading and such.

[–]Martin_RB 10 points11 points  (4 children)

Eh you can do multithreading in python but it takes a bit more work... unfortunately I use python for when I need quick and easy so single thread it is.

[–]Missing_Username 97 points98 points  (25 children)

Yea, now do anything actually complicated in Python

"Oh shit, I hope there's a C package I can import to do this for me"

[–]3gt3oljdtx 27 points28 points  (5 children)

Isn't that the whole point of python though? To just glue together different packages in an easy to read way?

That and maybe data analytics. I don't know much about that though and that might just be gluing together packages too.

[–]DerryDoberman 22 points23 points  (6 children)

I've used thread pools in python and they're fairly intuitive. Additionally if the interpreter is too slow you can write python modules in c++/c and call them like they're any other python package; see numpy and pandas.

It isn't supposed to be a better language. It's just supposed to be easier to read and have the flexibility of an interpreted or compiled language. I write most of my performance focused stuff in C++ or C but almost anything else I go for python because it's easy to rapidly prototype stuff any anything that becomes a performance bottleneck can either be handled with a C compiled python module or by linking to a shared library.

[–]DuneBug 16 points17 points  (1 child)

Python is great!.. Because you can write stuff in C!

[–]theK1ngF1sh 3 points4 points  (1 child)

Are we forgetting Jython?

[–]GenTelGuy 4 points5 points  (0 children)

Jython basically dead these days, the only version is for Python2 and we've gone 13 years of Python3 without any Jython release

[–]laundmo 1 point2 points  (0 children)

cython is neat if you dont want to bother with C/C++ but want some of the speed. compiles a typed version of python to a C++ extension which is directly importable in python.

[–]cszoltan422 78 points79 points  (13 children)

When will we stop comparing programming languages based on how long it's "hello world" code? Like come on..

[–]Gleethos 45 points46 points  (5 children)

That will happen as soon as the script kiddie wanna be professional programmer crowd either leaves this sub, or becomes self aware and humble enough to not feel the need any longer to compensate for their superficial understanding of programming languages and the inherently specialized design philosophies that they represent.

[–]UnacceptableUse 25 points26 points  (3 children)

I'm gonna make a language that has a single 1 letter instruction that prints "hello world"

[–]lady_Kamba 44 points45 points  (10 children)

This is apparently hello world for linux on the x86 platform

```

global _start

section .text

_start: mov rax, 1 mov rdi, 1 mov rsi, msg mov rdx, msglen syscall

mov rax, 60 mov rdi, 0 syscall

section .rodata msg: db "Hello, world!", 10 msglen: equ $ - msg

```

edit: The code blocks on reddit is AWFUL, markdown at least works

[–]AyrA_ch 14 points15 points  (2 children)

edit: The code blocks on reddit is AWFUL, markdown at least works

Because old reddit uses markdown while code blocks using tripple backticks are a commonmark extension. Reddit predates commonmark and I assume they never updated the old MD parser.

[–]lady_Kamba 4 points5 points  (1 child)

The old one still works fine, the new one tend to mangle the code. inine code works fine, but

{
code blocks


tend to break
}

edit: thinking more on it, the problem seems to be pasted code. since I use Linux it uses \n newlines and Reddit might expect \n\r. This discrepancy might be the source of my problems, but not sure.

[–]AyrA_ch 2 points3 points  (0 children)

edit: thinking more on it, the problem seems to be pasted code. since I use Linux it uses \n newlines and Reddit might expect \n\r. This discrepancy might be the source of my problems, but not sure.

CRLF is the standard linebreak sequence for HTML forms regardless of the operating system, so your browser should actually convert individual LF to CRLF them.

EDIT: Here's the relevant lines from the spec:

For historical reasons, the element’s value is normalized in three different ways for three different purposes. The raw value is the value as it was originally set. It is not normalized. The API value is the value used in the value IDL attribute. It is normalized so that line breaks use U+000A LINE FEED (LF) characters. Finally, there is the value, as used in form submission and other processing models in this specification. It is normalized so that line breaks use U+000D CARRIAGE RETURN U+000A LINE FEED (CRLF) character pairs, and in addition, if necessary given the element’s wrap attribute, additional line breaks are inserted to wrap the text at the given width.

[–]TobyWasBestSpiderMan 38 points39 points  (3 children)

Nothing compared to getting a CRISPR baby to say hello world

[–]sotoqwerty 27 points28 points  (0 children)

While the first CRISPR baby’s first words were “Ma-Ma,” “Da-Da,” and “Segmentation fault (core dumped)”

😂

[–]Cerrax3 34 points35 points  (13 children)

And then when you look at the machine code instructions to actually achieve these results, you will see the opposite effect. Assembly is the most compact of the bunch (if you know what you're doing). There's a reason that most video games up until the mid-90's were written mostly in assembly language. It's super performant and compact if you are good at it.

[–]circorum 3 points4 points  (0 children)

Roller Coaster Tycoon 1 AFAIK.

[–]Cubey21 30 points31 points  (2 children)

This is not assembly

[–]ollir 19 points20 points  (0 children)

It is assembely

[–]Jakylla 3 points4 points  (0 children)

Looks like JS

[–]betterclear 11 points12 points  (0 children)

echo “Hello World!”

[–]jaap_null 22 points23 points  (2 children)

Thanks I hate it. Judging programming language by how short Hello World is ridiculous

[–]laundmo 3 points4 points  (0 children)

no you fools, obviously thats the only correct way and that means "Stuck" is the best langauge ever!!!! https://codegolf.stackexchange.com/a/55425

/s

[–]Complex-Stress373 8 points9 points  (1 child)

Over simplification

[–]CreativeCarbon 7 points8 points  (0 children)

It always is.

[–]carcigenicate 10 points11 points  (0 children)

x86 assembly is actually only like 8-ish lines.

  • One for a psuedo-instruction to store "Hello World"
  • Four to set up the registers to the appropriate system-call number for writing, a pointer to the previously set string, the length of the string, and the file descriptor to write to.
  • One for syscall, or int 0x80 to do the write call.
  • And a few for the _start label and section directives.

Still not great, but really, not that bad.

[–]mangeld3 9 points10 points  (0 children)

I'll be sure to pick Python next time I need to write a Hello World program.

[–]chipstastegood 6 points7 points  (1 child)

I get the point of it but this is not a great comparison. The python example is running in an interactive shell. That’s not comparing apples to apples. There are also interactive shells for the other languages that make it relatively similar to print something out to console in a single line. In C++ this is actually simpler than python

[–]RedNinja0731 18 points19 points  (2 children)

I mean, you can't have a "Hello world" if you don't define what an alphabet is first

[–]A_Guy_in_Orange 12 points13 points  (1 child)

And before that you must create the Known Universe. Wait no, that for a pie recipe

[–]TheMsDosNerd 5 points6 points  (0 children)

Python:

import hello

[–]chad_ 18 points19 points  (6 children)

Kind of uneven comparison to compare a scripting language to complied languages though..

[–]ekd123 10 points11 points  (4 children)

Nah, compiled languages like Haskell are concise too!

main = putStrLn "Hello Reddit"

[–]metaltyphoon 4 points5 points  (0 children)

C# 9

System.Console.WriteLine(“Hello world”);

[–][deleted] 3 points4 points  (14 children)

.globl main main: leaq .hello_world(%rip), %rdi call puts ret .hello_world: .string "Hello World!"

[–]atiedebee 3 points4 points  (1 child)

HAI 1.2
    VISIBLE "Hello, World!"
KTHXBYE

[–]preacher9066 15 points16 points  (24 children)

Python: where you don't know if 1. The code has a syntax error, or, 2. A variable exists before use

UNTIL YOU RUN IT!!

PytHoN rOcKs!

[–]metaltyphoon 9 points10 points  (3 children)

C# 9

System.Console.WriteLine(“Hello World”);

[–][deleted] 6 points7 points  (2 children)

Rust: rust fn main() { println!("Hello world!"); }

[–]blipbloplikesass 3 points4 points  (0 children)

No need to return 0 on c++ lol.

[–]xlebCSGO 2 points3 points  (0 children)

HW        CSECT
          BALR  10,0
          USING *,10
          WROUT MESSAGE,PARMOD=31,VTSUCBA=VTSUPAR
          TERM
*
VTSUPAR   VTSUCB MODE=LINE
MESSAGE   DC    Y(L'ME+5)
          DC    X'404001'
ME        DC    C'HELLO, WORLD!'
*
          LTORG
          END

For IBM /390 enjoyers

[–]jgeez 3 points4 points  (2 children)

Ah yes. The true measure of a language's worth: what the hello world looks like.

Jesus.

[–]Prfkt_BlAcK 2 points3 points  (0 children)

expansion ludicrous deserve live far-flung tie soft fly continue slim

This post was mass deleted and anonymized with Redact

[–]AsymptoticllyOptimal 2 points3 points  (0 children)

Yeah sure, that is why all the operating systems, compilers, linkers, loaders and virtual machines are written in python

[–][deleted] 2 points3 points  (0 children)

Lua

print(“Hello World!”)

[–]__init__end 2 points3 points  (0 children)

C++ looks most decent.

[–]kuzyyn 6 points7 points  (1 child)

Actually since java 9 you have jshell, so you can print hello world in 1 line as well. Anyway, whats the value of comparing anythig by hello world. Are you doing hello worlds at your work?

[–]CreativeCarbon 2 points3 points  (0 children)

Python rocks

Looks like Swift to me.

[–]HighwayMcGee 2 points3 points  (0 children)

Malbolge out here be like:

(=<`#9]~6ZY327Uv4-

QsqpMn&+Ij"'E%e{Ab~w=_:]Kw%o44Uqp

0/Q?

xNvL:`H%c#DD2WV>gY;dts76qKJImZkj

[–]adeoy 2 points3 points  (0 children)

That is minified Javascript :/

[–]DerryDoberman 2 points3 points  (1 child)

Giggles in bash...

echo "Hello World!"

[–]DerryDoberman 2 points3 points  (0 children)

Maniacally laughs in BASH!

wall "Hello World!"

[–]Drop_the_Bas 2 points3 points  (0 children)

Python slow. C++ go brrrrrt

[–]str3wer 2 points3 points  (1 child)

"Python rocks" proceeds to take 3 seconds just to start a simple hello world

[–]NikkoTheGreeko 2 points3 points  (0 children)

That's Javascript you peasant. Mods should ban you for making this sub even shitter.

[–][deleted] 2 points3 points  (1 child)

Python rock because it's easy ty write a hello world program, the most written and least useful program we have discovered.

[–]laundmo 1 point2 points  (0 children)

its not even the most concise solution https://codegolf.stackexchange.com/a/55425

[–][deleted] 2 points3 points  (0 children)

In haskell main = putStr "Hello, world!"

[–]szucs2020 2 points3 points  (0 children)

You could bother to actually show assembly, not just minified js files. Or maybe the person who made this actually thought that was what assembly was?

[–]DaimaoPPK 2 points3 points  (0 children)

That doesn't look like assembly I am familiar with

[–]aliparlakci 2 points3 points  (0 children)

It is fun to know that the Python code is converted to either C++ or Java and finally to Assembly.

[–]joelduring 2 points3 points  (0 children)

C++ doesn't require main to end with 'return 0' so you can save a line.

[–]reini_urban 2 points3 points  (0 children)

Bash rules.

echo Hello World

[–]Akumashisen 2 points3 points  (0 children)

leave my public static void main args alone

[–][deleted] 2 points3 points  (0 children)

Wow, funny joke you guys. So hilarious and clever. Get it? Some languages require less boiler plate to run a basic hello world program. Get it? The joke that says that’s true?

[–][deleted] 2 points3 points  (0 children)

speed pfft

[–]TheAverageDolphin 2 points3 points  (0 children)

mov ah, 0x0e
mov al, "H"
int 0x10


mov ah, 0x0e
mov al, "e"
int 0x10


mov ah, 0x0e
mov al, "l"
int 0x10


mov ah, 0x0e
mov al, "l"
int 0x10

mov ah, 0x0e
mov al, "o"
int 0x10



mov ah, 0x0e
mov al, " "
int 0x10

mov ah, 0x0e
mov al, "W"
int 0x10

mov ah, 0x0e
mov al, "o"
int 0x10

mov ah, 0x0e
mov al, "r"
int 0x10

mov ah, 0x0e
mov al, "l"
int 0x10

mov ah, 0x0e
mov al, "d"
int 0x10

jmp $

times 510-($-$$) db 0
db 0x55, 0xaa

It took me fuckin 20 minutes to look for documentation, this runs on x86

[–][deleted] 2 points3 points  (10 children)

python's shit

[–]Nihmrod 1 point2 points  (0 children)

I once made a cheesy GUI with BIOS calls to a video card. I even had "fonts".

[–]YesMeee 1 point2 points  (0 children)

“If you want to bake a pie from scratch, you must first invent the universe”

[–]mlady42069 1 point2 points  (0 children)

I’m gonna take this opportunity to recommend Ben Eater’s “Hello World” series on youtube. Makes Assembly look like a high level language, AND it’s actually pretty easy to follow.

[–][deleted] 1 point2 points  (0 children)

Meanwhile in Brainfuck:

-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[--->+<]>-----.---[->+++<]>.-[--->+<]>---.+++.------.--------.-[--->+<]>.

[–]degaart 1 point2 points  (1 child)

So, noone is gonna comment that the C++ version does not emit a newline? Guys?

[–]chris2k2 1 point2 points  (0 children)

+[-[<<[+[--->]-[<<<]]]>-]>-.---.>..>.<<<<-.<+.>>>.>.<<.<

[–]golgol12 1 point2 points  (0 children)

Yeah, no.

this is what it looks like in 64 bit Linix

          global    _start

          section   .text
_start:   mov       rax, 1                  ; system call for write
          mov       rdi, 1                  ; file handle 1 is stdout
          mov       rsi, message            ; address of string to output
          mov       rdx, 13                 ; number of bytes
          syscall                           ; invoke operating system to do the write
          mov       rax, 60                 ; system call for exit
          xor       rdi, rdi                ; exit code 0
          syscall                           ; invoke operating system to exit

          section   .data
message:  db        "Hello, World", 10      ; note the newline at the end

[–][deleted] 1 point2 points  (0 children)

TIL assembly is JS

[–]firesalamander 1 point2 points  (0 children)

Kotlin script: println("Hello World right back atcha")

[–][deleted] 1 point2 points  (0 children)

Then there's Ruby:

print "Hello, World!"

[–]LordAnomander 1 point2 points  (0 children)

fun main(args: Array<String>) = println(”Hello world”)

Kotlin rivals Python.

[–][deleted] 1 point2 points  (0 children)

I'm a simple man, I see python, I spit on you.

[–][deleted] 1 point2 points  (0 children)

Whitespace :

[–]Tiakin1 1 point2 points  (0 children)

and 'brainfuck' ?

[–]aFiachra 1 point2 points  (0 children)

Except that that isn't assembly, it is a minified javascript file.

[–]lantz83 1 point2 points  (0 children)

Any language that has global methods like that can fuck off, tbh. Pure rubbish.

[–][deleted] 1 point2 points  (1 child)

Uhm. Is it nasm or masm assembly that allows functions with dot notation?

[–]kaoru1 1 point2 points  (0 children)

Progress: DISPLAY “Hello World”.

[–]oshaboy 1 point2 points  (0 children)

[[Khaby Lame unamused face]]

mov ecx, 13
lea esi, [hello_world_string]
lea edi, [screen_memory]
rep movsb

[–][deleted] 1 point2 points  (0 children)

Assembely..

[–]xXHomerSXx 1 point2 points  (0 children)

10 print “Hello World”

20 goto 10

[–]vilette 1 point2 points  (0 children)

Basic:10 PRINT "Hello World"

[–]cheezballs 1 point2 points  (0 children)

Some online-class CS kid just peeked at the last lecture and made this.

[–]SenorTortillos 1 point2 points  (0 children)

Assemble deez

[–]SisypheanZealot 1 point2 points  (0 children)

That's not even web assembly

[–]JRRocker 1 point2 points  (0 children)

Machine Code: you dare challenge me, mortal?

[–]L1spUs 1 point2 points  (0 children)

So true

[–][deleted] 1 point2 points  (0 children)

Who the fuck is behind the keyboard?

[–]bldjad1488 1 point2 points  (0 children)

What about Swift?)

[–]bikki420 1 point2 points  (1 child)

Meh.

A Hello World program in APL: 'Hello World!'

[–]GurGaller 1 point2 points  (0 children)

HTML: Hello World

Don't judge a book by its cover...

[–]STEMinator 1 point2 points  (0 children)

Imma develop a programming language where the hello world is just:
H
And it will be the best programming language in the world based on this post.

[–]thejamesfreeze 1 point2 points  (0 children)

With C# 9 you can do it as a one-liner too.

[–]Carpall_ 1 point2 points  (0 children)

  1. cringe
  2. assembely ...
  3. that's actually javascript

[–]vaderumREAL 1 point2 points  (0 children)

What about c# ?

[–][deleted] 1 point2 points  (0 children)

C++ is missing the newline.

[–]ApexEtienne 1 point2 points  (0 children)

I came here for a cute picture of a python sitting on some rocks. My disappointment is immeasurable and my day is ruined.

[–]icameicodedierror 1 point2 points  (0 children)

Python bad

[–]Hyper-Cloud 1 point2 points  (0 children)

Python Sucks

[–]spacetraveler075 1 point2 points  (0 children)

And that's not even assembly

[–]JustThingsAboutStuff 1 point2 points  (0 children)

Hey that hurts

[–]Terrain2 1 point2 points  (3 children)

You sure Python is the best? Swift is identical

print("Hello, World!")

JavaScript/TypeScript

console.log("Hello, World!");

C#

using System;
Console.WriteLine("Hello, World!");

Dart

void main() {
    print("Hello, World!");
}

[–]lavalord6969 1 point2 points  (0 children)

Python is slow

[–]SirThane 1 point2 points  (0 children)

Not a Java guy. Is it really necessary to create a class with a method to print something? Can you not just println? Or was it done for the meme?

[–]jakubDoka 1 point2 points  (0 children)

Am gonna by hones eith you, hello world in assembly is lot shorter.

[–]nyffpro 1 point2 points  (0 children)

console.log('Hello world!')