Objectivism-oriented programming

Objectivism-oriented programming is a software development methodology originally created by members of Ayn Rand's Church of Objectivism, and should not be confused with Object Oriented Programming. While considered by many to be extreme, it is also not in itself a form of Extreme Programming, although extreme programmers might make use of its techniques from time to time.

The fundamental tenet of Objectivism-oriented programming is that all computation can be performed by a single operation of the form

```A=A
```

While computer scientists insist that this accomplishes nothing (making it merely a form of nonfunctional programming) and that Objectivism-oriented programmers are performing massive computational hand waving behind the scenes to obtain the intended value of A, Objectivism-oriented programming has become incredibly popular in the software industry.

A similar topic in computer engineering is known as the RAND Gate which returns whatever value it is given as an input.

A schematic diagram of a RAND gate.

One of the deep problems within Objectivism-oriented programming involves the transition of the state-machine from loaded to running. Because the initial state of the machine at load time cannot be known, there exists (for a while) the state where A is unknown, making A=A highly suspect. So far, the only Objective way out of this mess is to divide Logic by Zero (see HowTo:Divide by Zero). And you wondered why Microsoft software has memory leaks. Objectivism-oriented programming may also be abject-oriented.

Other contributions

In C, the rand() function returns a random number between 0 and 32767. The aynrand() function, by contrast, returns a random number between 1 and 1.

Rules Of Objectivism-oriented programming

1. any object programmed with an objectivism-oriented programming language, can access any amount of resources without regulation from the host Operating System

Examples of Objectivism-oriented programming

The language of choice for this methodology is Objectivist C. However, you can still do objectivist-oriented programming in less rational languages:

4th

```A @ A !
```

BASIC

```10 LET A=A
```

``` CLA
DCA A
```

C

```main()
{
int a;
a = a;
}
```

C#

```main()
{
int a;
a = a;
}
```

generates error: Use of unassigned local variable 'a'

Java

```public class ObjectivistObject extends java.lang.Object {
private int a;
public static void main(String[] args) {
ObjectivistObject objectivist_object = new ObjectivistObject();
}
protected ObjectivistObject() {
a = a;
}
}
```

Malbolge

```('OscarWilde:MalbolgeIsLikeDatingAGerman')
```

Perl

``` my \$a = (@{{ 'a' => ['a']}->{'a'}})[0];
```

```A=\$A
```

Lisp

```(setq a a)
```

Scheme

```(define 'a
((((lambda (l) l)
(lambda (a) a))
'a)))
```

Arc

```; using special internal variables known to be
; equal to each other
(= pg i-rule-you-suck-wanna-start-a-startup?)
```

PHP

``` <?php \$a = \$a; ?>
```

ENTERPRISE COBOL

```IDENTIFICATION DIVISION.
CLASS-ID. AYN INHERITS RAND.
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
REPOSITORY.
CLASS RAND IS "java.lang.OBJECTIVISM".
IDENTIFICATION DIVISION.
FACTORY.
DATA DIVISION.
WORKING STORAGE SECTION.
01 A PIC 9(6) VALUE ZERO.
PROCEDURE DIVISION.
IDENTIFICATION DIVISION.
METHOD-ID. OBJECTIVISM.
PROCEDURE DIVISION.
METHOD OBJECTIVISM.
MOVE A TO A.
END METHOD OBJECTIVISM.
END OBJECT.
END CLASS.
```

```L 1,A
ST 1,A
```

IBM z/Architecture assembler

```LG 1,A
STG 1,A
```

```PX
```

Coq

```Inductive eq (A:Type) (a:A) : A -> Prop :=
refl_equal : a = a :> A

where "a = aa :> A" := (@eq A a aa) : type_scope.

Notation "a = aa" := (a = aa :> _) : type_scope.
```