Its not wrong though

Open source ≠ Source availiable
Example of non open source programs with source code https://en.m.wikipedia.org/wiki/List_of_proprietary_source-available_software
- Open source ≠ free software
  
  Open source inherently means you can compile the code locally, for free. You can’t necessarily redistribute it, depending on the license, but I’m not aware of a “you can compile this source for testing and code changes only but if you use it as your actual copy you are infringing” license.
  I am very much open to correction here.
  
  According to the Open Source Initiative (the folks who control whether things can be officially certified as "open source"), it basically is the same thing as Free Software. In fact, their definition was copied and pasted from the Debian Free Software guidelines.
- I think InnoSetup belongs on that list as wel.
- You are talking about free softwares there are nonfree licenses which provide source code
  
  There are apps having source public but does not have any developement practice like of open sauce

- Thank you. I almost forgot
- Who downvotes this? Chris Sawyer is the GOAT.

In this thread: Programmers disassembling the joke to try and figure out why it's funny.

Cute. It would be funnier if it was correct.

For people interested in the difference between decompiled machine code and source code I would recommend looking at the Mario 64 Decomp project. They are attempting to turn a Mario 64 rom into source code and then back into that same rom. It's really hard and they've been working on it for a long time. It's come a long way but still isn't done.
https://github.com/n64decomp/sm64
- I thought they were done already?
  
  There is still some stuff that needs documenting, but the original goal of recompiling the created source code into the ROMs has been achieved. People are still actively working on it, so in that sense it's maybe never done.

No, it is wrong. Machine code is not source code.
- And even if you had the source code it may not necessarily qualify as open source.
- well assembly is technically "source code" and can be 1:1 translated to and from binary, excluding "syntactic sugar" stuff like macros and labels added on top.
  
  The code is produced by the compiler but they are not the original source. To qualify as source code it needs to be in the original language it was written in and a one for one copy. Calling compiler produced assembly source code is wrong as it isn't what the author wrote and their could be many versions of it depending on architecture.
  
  But those things you're excluding are the most important parts of the source code...
- Never heard of a decompiler I see.
  
  A decompiler doesnt give you access to the comments, variable names, which is an important part of every source code
  
  A decompiler won't give you the source code. Just some code that might not even necessarily work when compiled back.
  
  Try converting from English to Japanese and back to English.
  
  Still not the actual source code, bucko.

Okay, boomer here, be gentle.
So back in the ‘70s I dabbled in programming (now called “coding”, I hear). I only did higher-level languages like Fortran, Cobol, IBM Basic, but a friend had a job (at age 13!) programming in assembler. Is assembler now called assembly, or are they different?
- It's still called programming, coding is the same thing. Assembler more commonly refers to the utility program that converts the assembly code to machine code while assembly refers to the code itself, but the term assembler code is also valid. It's uncommon to simply call the code assembler because it would be easily confused with the utility program.
- Yep, some call it assembly, others call it assembler
- (at age 13!)
  c/suddenlyfactorial
  
  Easier to say than "at age 6227020800"
- I thought that the assembler is a specific program that translates mnemonics into the corresponding machine code. Perhaps in early computing this was done by hand so a person was the assembler (and worked in assembler), but now that is handled by software (and supports various macros). So programming in assembly would generate a stream of text that must be assembled by an assembler. (Although I have heard people refer to programming in assembler as well, just not often.)
  
  I hear people say "program in assembler" but IMO that's wrong. I'd say you write the code in "assembly language" (or better yet, the actual architecture you're using like "x86 assembly") but you "assemble" it with an "assembler". Kind of like how you could write a program in the "C language" and "compile" it with a "compiler"
- I was too young/poor to afford an assembler for my 6502 so I wore out the assembly long hand on a legal pad and then manually converted each operation to machine code.
  Needless to say my programs done this way were exceptionally simple, but it’s interesting to understand the underlying code.

It just occurred to me that AI in the nearish future will probably/almost certainly be able to do this.
- I can't wait for AI to make a PC port of every console game ever so that we can finally stop using emulators.
  
  This won't happen in our lifetime. Not only because this is more complex than rambling vaguely correlated human speech while hallucinating half the time.
- It was a staple of Asimov's books that while trying to predict decisions of the robot brain, nobody in that world ever understood how they fundamentally worked.
  He said that while the first few generations were programmed by humans, everything since that was programmed by the previous generation of programs.
  This leads us to Asimov's world in which nobody is even remotely capable of creating programs that violate the assumptions built into the first iteration of these systems - are we at that point now?
  
  No. Programs cannot reprogram themselves in a useful way and are very very far from it.
  
  are we at that point now?
  Nope, but we're getting there.
- Do what?

It's honestly remarkable how few people in the comments here seem to get the joke.
Never stop dissecting things, y'all.
- As above so below, the microscopic and the macroscopic

IDA Pro (a disassembler) is closed source but came with a license that allowed disassembly and binary modification. Unfortunately, that's no longer the case.
- Why not use that NSA tool they released
  
  Ghidra is open source even before you run the disassembler 🤯 great anecdote

Joke aside, that's kind of like claiming that any web frontend is open source because you can access the built, minified and often obfuscated source of it.
- So true! I have been "hacking" some chrome extensions recently, do you know of a tool for reverse engineering JS?

What about server site executed code?
- You moved the goal post! No fair!
- Metasploit becomes your "decompiler".

I feel old watching this meme template

If you wanna skip a few inconvenient instructions in X86 assembly, throw a few No Operation instructions in the right places.
NOP = 0x90
- And so you add a hashing check. But then that can be removed.
  So you need one in the OS but that can be removed.
  So you need one in hardware.
  In other words no matter how clever you are there’s always a way to monkey with something unless you have absolute control from silicon on up.
  Here’s a really interesting video the Xbox team did on the challenges of trying to make sure that the content running wasn’t pirated.
  https://youtu.be/U7VwtOrwceo
  While DRM is the bane of everybody there are cases where trust and integrity is important and it’s an intriguing look into how hard it is to manage.
  
  While DRM is the bane of everybody there are cases where trust and integrity is important and it’s an intriguing look into how hard it is to manage.
  Nah, when the user wants to ensure trust and integrity in his own system, it works just fine. The problem comes when the user who needs to be able to access the data is simultaneously the adversary who needs to be stopped from accessing the data.
  In other words, it's one of those situations where the fact that it's hard to manage is a gigantic clue that it's wrongheaded to try to do so in the first place.
  
  Here is an alternative Piped link(s): https://piped.video/U7VwtOrwceo
  Piped is a privacy-respecting open-source alternative frontend to YouTube.
  I'm open-source, check me out at GitHub.
  
  It's called _soft_ware for a reason 😹
  
  Meanwhile, I've been archiving terabytes of software with no DRM, with no account.

OS - obfuscated source

I've wondered: Can you go deeper than assembly and code in straight binary, or does it even really matter because you'd be writing the assembly in binary anyway or what? In probably a less stupid way of putting it: Can you go deeper than assembly in terms of talking to the hardware and possibly just flip the transistors manually?
Even simpler: How do you one up someone who codes in assembly? Can you?
- The first computer I used was a PDP-8 clone, which was a very primitive machine by today's standards - it only had 4k words of RAM (hand-made magnetic core memory !) - you could actually do simple programming tasks (such as short sequences of code to load software from paper tape) by entering machine code directly into memory by flipping mechanical switches on the front panel of the machine for individual bits (for data and memory addresses)
  You could also write assembly code on paper, and then convert it into machine code by hand, and manually punch the resulting code sequence onto paper tape to then load into the machine (we had a manual paper punching device for this purpose)
  Even with only 4k words of RAM, there were actually multiple assemblers and even compilers and interpreters available for the PDP-8 (FOCAL, FORTRAN, PASCAL, BASIC) - we only had a teletype interface (that printed output on paper), no monitor/terminal, so editing code on the machine itself was challenging, although there was a line editor which you could use, generally to enter programs you wrote on paper beforehand.
  Writing assembly code is not actually the same as writing straight machine code - assemblers actually do provide a very useful layer of abstraction, such as function calls, symbolic addressing, variables, etc. - instead of having to always specify memory locations, you could use names to refer to jump points/loops, variables, functions, etc. - the assembler would then convert those into specific addresses as needed, so a small change of code or data structures wouldn't require huge manual process of recalculating all the memory locations as a result, it's all done automatically by the assembler.
  So yeah, writing assembly code is still a lot easier than writing direct machine code - even when assembling by hand, you would generally start with assembly code, and just do the extra work that an assembler would do, but by hand.
- Yes, you can code in machine code. I did it as part of my CS Degree. In our textbook was the manual for the particular ARM processor we coded for, that had every processor-specific command. We did that for a few of the early projects in the course, then moved onto Assembly, then C.
  
  That was a fun class. One of the last ones I took before recursion made me change majors.
- Assembly effectively is coding in binary. Been a long time since I've looked at it, but you'd basically just be recreating the basic assembly commands anyway.
  I guess you could try flipping individual transistors with a magnet or an electron gun or something if you really want to make things difficult.
  If you actually want to one-up assembly coders, then you can try designing your own processor on breadboard and writing your own machine code. Not a lot of easy ways to get into that, but there's a couple of turbo dorks on YouTube. Or you could just try reading the RISC-V specification.
  But even then, you're following in someone else's tracks. I've never seen someone try silicon micro-lithography in the home lab, so there's an idea. Or you could always try to beat the big corps to the punch on quantum computing.
- You can code in binary, but the only thing you'd be doing is frustrating yourself. We did it in the first week of computer science at the university. Assembly is basically just a human readable form of those instructions. Instead of some opcode in binary you can at least write "add", which makes it easier to see what's going on. The binary machine code is not some totally other language than what is written in the assembly code, so writing in binary doesn't really provide any more control or benefit as far as I'm aware.
- All those assembly language instructions are just mnemonics for the actual opcodes. IIRC, on the 6502 processor family, JSR (Jump to SubRoutine) was hex 20, decimal 32. So going deeper would be really limited to not having access to the various amenities provided by assembler software and writing the memory directly. For example:
  I started programming using a VIC-20. It came with BASIC, but you could have larger programs if you used assembly. I couldn't afford the assembler cartridge, so I POKED the decimal values of everything directly to memory. I ended up memorizing some of the more common opcodes. (I don't know why I was working in decimal instead of hex. Maybe the text representation was, on average, smaller because there was no need of a hex symbol. Whatever, it doesn't matter...)
  VIC-BASIC had direct memory access via PEEK (retrieve value) and POKE (set value). It also had READ and DATA statements. READ retrieved values from the comma-delimited list of values following the DATA statement (usually just a big blob of values as the last line of your program).
  I would write my program as a long comma-delimited list of decimal values in a DATA statement, READ and POKE those values in a loop, then execute the resulting program. For small programs, I just saved everything as that BASIC program. For larger programs, I wrote those decimal values to tape, then read them into memory. That let me do a kind of modular programming by loading common functions from tape instead of retyping them.
  I was in the process of writing my own assembler so that I could use the mnemonics directly when I got my Apple //c. More memory and the availability of quite a few high level languages derailed me and I haven't touched assembly since.
- Re: Coding in binary. It makes no difference. Your assembly is binary, just represented in a more human readable form when writing it in assembly.
  Re: Manual interaction. Sure there's plenty of old computers where you can flip switches to input instructions or manipulate registers (memory on the cpu). But this is not much different from using assembly instructions except you're doing it live.
  You can also create purpose built processors which might be what you mean? Generally this isn't too useful but sometimes it is. FPGAs are an example of doing this type of thing but using software to do the programming of the processor.
  
  this isn't too useful
  The point isn't to be good, practical or useful. It's to be cool 😎
  But this silly question still informed me of something I had misunderstood: I had thought assembly and machine code were the same thing.
- You could like make a simple accumulator machine out of logic gates and enter binary instructions expressed in hexadecimal into its register to program it, yeah, but it's not capable of all the operations of a computer. But yes the first programming was just op codes, switches flipped or punch cards, there was no assembly language. But assembly language is pretty much just mnemonics for operations and registers. Like I had to write a couple C programs in school and use GNU C compiler to disassemble them into x86 assembly and see what it was doing on that level, then we "wrote" some x86 assembly by copypasting a lot of instructions but its not that hard to make something that works in like x86 assembly or like Jasmin (Java virtual machine assembly language) if it's simple enough.
- Assembly is binary

You can have the code of any software with a decompiler. Especially with Java and C# for example.

Source available

Yeah but which version of assembly
- Microsoft's Assembly# of course. It's new. It's just different enough to extinguish assembly
- Depends on the CPU. Either way there are cross-compilers and cross-disassmblers.
  And even failing those options, there's always hex editors for those really in the know.
- 6502 assembly.
  
  The last assembly I could understand. Well, pretend to understand.

Open source code refers to the comments and the documentation.
- so, like half (more?) of current 'open source' isn't, then? because it lacks in one or the other.. or both?

All fun and games if you don't value your time.