Binary representation of an algorithm.

I have prepared a detailed answer as a video on YouTube available here Programming in Practice - Information Computation Fundamentals and submitted it for publication on C# Corner. Unfortunately, it was rejected for reasons not clear to me. Let me know how it works for you.

Best Regards,

Mariusz

@Aman Gupta many thanks for your contribution. Below are a few comments

1. Unfortunately for me "A binary form representing an algorithm is a set of instructions" is just a text but not bitstream especially if it is written down on the paper. How to comment on it?

2. We cannot say "algorithm written in Java" because the algorithm is implemented in a selected programming language, e.g. Java. Again, let me stress that "simplification is not the mother of simplicity"!

3. "disassembled machine code" depends on the target processor but I am looking for a generic statement.

I expect an answer scoped on "binary programming language". It is an important question because I am working on a video publication covering: information versus data and algorithm versus program in the context of binary machines.

Hi Mariusz,

A binary form representing an algorithm is a set of instructions that can be executed directly by a computer's processor. These instructions are written in a binary code, which consists of a series of 0s and 1s that the computer can understand.

In other words, a binary form of an algorithm is a low-level representation of the algorithm that can be directly executed by the computer's processor, without the need for further interpretation or compilation.

Here's an example of a simple algorithm written in Java:

public class AddNumbers {
    public static int add(int a, int b) {
        return a + b;
    }
}

When we compile this Java code, it gets translated into an intermediate form called bytecode, which is stored in a .class file. The bytecode is not yet in binary form, but it's closer to machine code than the original Java source code.

To get the binary form of the algorithm, we need to run the .class file through a just-in-time (JIT) compiler or an ahead-of-time (AOT) compiler, which translates the bytecode into machine code. The resulting machine code is specific to the computer's processor architecture.

For example, on an x86-64 processor, the binary code for the add method might look like this:

; disassembled machine code
0x0000000000000000:  mov     eax, [rsp+0x10]
0x0000000000000004:  add     eax, [rsp+0x18]
0x0000000000000008:  ret

In Java, we can use the javap command to disassemble the bytecode and get a peek at the binary form of the algorithm:

javap -c AddNumbers.class

Thanks