There are books about Lisp implementations and papers about various Lisp compilers. Actually there is a whole bunch of literature about it.

Personally I find that the article needs a bunch of improvements:

static vs. dynamic vs. statically typed and dynamically typed

These are different things. Either we are talking about runtime behavior (a dynamic language can change itself or the program at runtime) or we are talking about typing.

For example Java is a statically typed language, but it allows the use of class loaders which can reload classes at runtime - which provides some dynamic features. On the other end of the spectrum are many compiled Lisp implementations which allow various changes to the programming language at runtime, for example via an extensive meta-object protocol.

> Attempting to access a value that has not been named in a relevant scope leads to a syntax error issued at compile time.

A syntax error? Really? Syntax?

> So called dynamically typed languages are sometimes referred to as duck-typed or duck languages.

Definitely not. Duck typing is a only a special form of dynamic typing, usually in an object-oriented language. Non object-oriented dynamically typed languages don't provide duck typing, because they lack OOP objects.

Does compiled Lisp look different?

Maybe... Let's look at SBCL on a 64bit Intel processor:

* (defun calc (a b c) (+ (* 2 a) (* 3 b) (* 4 c)))

CALC

* (disassemble #'calc)

; disassembly for CALC
; Size: 118 bytes. Origin: #x1002EC2599
; 599: 48895DE8 MOV [RBP-24], RBX ; no-arg-parsing entry point
; 59D: BF04000000 MOV EDI, 4
; 5A2: 488BD1 MOV RDX, RCX
; 5A5: 41BBD0020020 MOV R11D, 536871632 ; GENERIC-*
; 5AB: 41FFD3 CALL R11
; 5AE: 488BF2 MOV RSI, RDX
; 5B1: 488B5DE8 MOV RBX, [RBP-24]
; 5B5: 488975F0 MOV [RBP-16], RSI
; 5B9: BF06000000 MOV EDI, 6
; 5BE: 488BD3 MOV RDX, RBX
; 5C1: 41BBD0020020 MOV R11D, 536871632 ; GENERIC-*
; 5C7: 41FFD3 CALL R11
; 5CA: 488BFA MOV RDI, RDX
; 5CD: 488B75F0 MOV RSI, [RBP-16]
; 5D1: 488BD6 MOV RDX, RSI
; 5D4: 41BBD0010020 MOV R11D, 536871376 ; GENERIC-+
; 5DA: 41FFD3 CALL R11
; 5DD: 488BDA MOV RBX, RDX
; 5E0: 48895DF0 MOV [RBP-16], RBX
; 5E4: 488B55F8 MOV RDX, [RBP-8]
; 5E8: BF08000000 MOV EDI, 8
; 5ED: 41BBD0020020 MOV R11D, 536871632 ; GENERIC-*
; 5F3: 41FFD3 CALL R11
; 5F6: 488BFA MOV RDI, RDX
; 5F9: 488B5DF0 MOV RBX, [RBP-16]
; 5FD: 488BD3 MOV RDX, RBX
; 600: 41BBD0010020 MOV R11D, 536871376 ; GENERIC-+
; 606: 41FFD3 CALL R11
; 609: 488BE5 MOV RSP, RBP
; 60C: F8 CLC
; 60D: 5D POP RBP
; 60E: C3 RET
NIL

Now we can even define the types in Common Lisp:

* (defun calc (a b c)
(declare (fixnum a b c))
(the fixnum
(+ (the fixnum (* 2 a))
(the fixnum (* 3 b))
(the fixnum (* 4 c)))))
STYLE-WARNING: redefining COMMON-LISP-USER::CALC in DEFUN

CALC
* (disassemble #'calc)

; disassembly for CALC
; Size: 38 bytes. Origin: #x1002F4B802
; 02: 48D1E1 SHL RCX, 1 ; no-arg-parsing entry point
; 05: 488D047F LEA RAX, [RDI+RDI*2]
; 09: 48D1F9 SAR RCX, 1
; 0C: 48D1F8 SAR RAX, 1
; 0F: 4801C1 ADD RCX, RAX
; 12: 48C1E602 SHL RSI, 2
; 16: 48D1FE SAR RSI, 1
; 19: 4801F1 ADD RCX, RSI
; 1C: 48D1E1 SHL RCX, 1
; 1F: 488BD1 MOV RDX, RCX
; 22: 488BE5 MOV RSP, RBP
; 25: F8 CLC
; 26: 5D POP RBP
; 27: C3 RET
NIL
*