What is a programmable programming language? (2019)(hiphish.github.io)

    * (defun adder (x y) (+ x y))
    * (disassemble 'adder)
    ; disassembly for ADDER
    ; Size: 37 bytes. Origin: #x541CEE1B                          ; ADDER
    ; 1B:       498B4510         MOV RAX, [R13+16]                ; thread.binding-stack-pointer
    ; 1F:       488945F8         MOV [RBP-8], RAX
    ; 23:       488BD6           MOV RDX, RSI
    ; 26:       488BFB           MOV RDI, RBX
    ; 29:       FF14250001A052   CALL QWORD PTR [#x52A00100]      ; SB-VM::GENERIC-+
    ; 30:       488B5DE8         MOV RBX, [RBP-24]
    ; 34:       488B75F0         MOV RSI, [RBP-16]
    ; 38:       488BE5           MOV RSP, RBP
    ; 3B:       F8               CLC
    ; 3C:       5D               POP RBP
    ; 3D:       C3               RET
    ; 3E:       CC10             INT3 16                          ; Invalid argument count trap

    * (declaim (ftype (function (fixnum fixnum) fixnum) adder))
    (ADDER)
    * (defun adder (x y) (+ x y))
    WARNING: redefining COMMON-LISP-USER::ADDER in DEFUN
    ADDER
    * (disassemble 'adder)
    ; disassembly for ADDER
    ; Size: 35 bytes. Origin: #x541CE8DC                          ; ADDER
    ; DC:       498B4510         MOV RAX, [R13+16]                ; thread.binding-stack-pointer
    ; E0:       488945F8         MOV [RBP-8], RAX
    ; E4:       488D1C3E         LEA RBX, [RSI+RDI]
    ; E8:       488BD3           MOV RDX, RBX
    ; EB:       48D1E2           SHL RDX, 1
    ; EE:       700A             JO L0
    ; F0:       488D141B         LEA RDX, [RBX+RBX]
    ; F4:       488BE5           MOV RSP, RBP
    ; F7:       F8               CLC
    ; F8:       5D               POP RBP
    ; F9:       C3               RET
    ; FA: L0:   CC52             INT3 82                          ; OBJECT-NOT-FIXNUM-ERROR
    ; FC:       0E               BYTE #X0E                        ; RBX(s)
    ; FD:       CC10             INT3 16                          ; Invalid argument count trap

    * (defun adder (x y)
        (declare (optimize (speed 3) (safety 0) (debug 0)))
        (+ x y))
    WARNING: redefining COMMON-LISP-USER::ADDER in DEFUN
    ADDER
    * (disassemble 'adder)
    ; disassembly for ADDER
    ; Size: 9 bytes. Origin: #x541CEAB6                           ; ADDER
    ; 6:       4801FA           ADD RDX, RDI
    ; 9:       488BE5           MOV RSP, RBP
    ; C:       F8               CLC
    ; D:       5D               POP RBP
    ; E:       C3               RET

    * (defun mistake () (adder 5 "5"))
    ; in: DEFUN MISTAKE
    ;     (ADDER 5 "5")
    ; 
    ; caught WARNING:
    ;   Constant "5" conflicts with its asserted type FIXNUM.
    ;   See also:
    ;     The SBCL Manual, Node "Handling of Types"
    ; 
    ; compilation unit finished
    ;   caught 1 WARNING condition
    MISTAKE

    * (defun mistake2 () (adder 5 (subseq "555" 0 1)))
    ; in: DEFUN MISTAKE2
    ;     (ADDER 5 (SUBSEQ "555" 0 1))
    ; 
    ; caught WARNING:
    ;   Derived type of (SB-KERNEL:VECTOR-SUBSEQ* SB-C::SEQ SB-C::START SB-C::END) is
    ;     (VALUES (SIMPLE-ARRAY CHARACTER (1)) &OPTIONAL),
    ;   conflicting with its asserted type
    ;     FIXNUM.
    ...

    int x[20];
    pfor(i = 0; i < 10; i++) {
        x[2*i] = expensive(2*i);
        x[2*i+1] = expensive(2*i+1);
    }

    void thread_callback(int i){
        x[2*i] = expensive(2*i);
        x[2*i+1] = expensive(2*i+1);
    }

    macro pfor(var = init, cond, incr, body...) {
        symbol callback = generate_random_symbol();
        ```
        void $callback(int $var) {
            $...body;
        }
        vector threads;
        for($var = $init; $cond; $incr) {
            threads.push(make_thread($callback, $var));
        }
        for(t in threads)
            join_thread(t);
        ```
    }

  for i in 1 to 10 do printf("%d\n", i)

  for(int i = 1; i <= 10; i++) { printf("%d\n", i); }

  (hypotehtical-expression-evaluator-macro (complex-computation-that-gets-reused-100-times-but-takes-10-minutes-each-time))

  (loop for i from 1 to 10 do (print i))

    [A x y]

    ᵀA

    [ᵀA x y].