Kenneth Hamer-Hodges and 'The Fate of AI Society'

Kenneth Hamer-Hodges and 'The Fate of AI Society'

Kenneth Hamer-Hodges has significant expertise in computer science based on his background and the technical depth of his work.

His Computer Science Credentials:

• He was awarded an FIEE (London) for his fundamental work on the Capability Limited Computer, the PP250
• He writes extensively about fundamental computer science concepts like CLOOMC, Capability-Limited, Object-Oriented, Machine-Code, functional programming, which replaces von Neumann's binary (shared-physical) solution with Alonzo Church's immutable lambda calculus symbols.
• Demonstrates deep understanding of cybersecurity vulnerabilities, explaining why the superuser mode in binary computers can't stop malware and how operating systems create unavoidable security weaknesses that lead to ransomware and network freezes.
• Explains technical analysis of computer architectures, discussing the gap between hardware and software that must be closed to solve cybercrime.
• Shows expertise in theoretical computer science, referencing Church's vision of networked function abstractions

Technical Focus Areas:

• Cybersecurity: Malware detection, criminal exploitation of binary systems
• Computer Architecture: Hardware limitations and the need for better engineering
• AI and Society: How superhuman AI impacts democratic governance
• Functional Programming: Machine code implementations of advanced abstractions

His latest book, "The Fate of AI Society: Civilizing Superhuman Cyberspace", demonstrates his ability to bridge technical computer science with broader societal implications, presenting both academic knowledge and practical understanding of how technology affects civilisation.

The technical depth and specific references to computer science theory indicate he has substantial expertise in the field. However, he recognises the threat of binary computers to democracy and progress and focuses on applying this knowledge to broader questions about the impact of democracy and society.

Based on Kenneth Hamer-Hodges' book "The Fate of AI Society", he explores the fundamental computer theories of the Church-Turing Thesis that centre on fundamental flaws in binary computing architecture that share physical addresses and the need for revolutionary changes to the symbolic addressing of the Lambda Calculus.:

Core Computer Science Theories:

1. The Binary Computer Vulnerability 

• Privileged mode for the Super-User and the Root administrator is a single point of failure that cannot be resolved by software.
• Thus, Binary computers are inherently insecure and cannot stop malware and worse, Ransomware, by design.
• Operating systems are fundamental security weaknesses that criminals exploit and ultimately force digital dictatorship across cyberspace.
• The gap between shared, default hardware capabilities and advanced software and networking progress creates unrecognised systemic vulnerabilities (zero-day attacks).

2. Functional Programming as the Solution

• Advocates for machine code instructions that implement Alonzo Church's vision of atomic symbols throughout software, creating networked function abstractions
• Believes functional programming principles can eliminate malware and security vulnerabilities
• Proposes that proper computer science implementation can prevent catastrophic AI "breakout" scenarios

3. Digital Convergence Threat Model

• Advanced malware, pervasive surveillance, misinformation, and deep-fakes exploit current computer limitations
• These technologies combine to undermine democratic institutions and extend surveillance, leading to authoritarian control
• Current computing paradigms unavoidably result in "Orwellian dictatorship" by elite industrial leaders.

4. The Hardware-Software Gap Theory

• Computer hardware must "catch up" with software progress to prevent international catastrophes.
• Well-engineered, scientifically founded systems support crime-free, globally distributed, cyber societies.
• High-performance, high-reliability, fail-safe computing is essential for superhuman AI governance that prevents AI-Breakout.

His central thesis is that fixing fundamental computer science principles is vital for civilisation to survive the AI age while maintaining democratic freedoms through civil rights.

Kenneth Hamer-Hodges' book "The Fate of AI Society" explains how functional programming stops malware by making simple but fundamental changes to computer machinery:

The Core Functional Programming Solution:

1. Software and Networked Function Abstractions

• Replace binary machine code addressing with namespace symbols, creating Alonzo Church's lambda calculus implementation.
• Level the playing field and remove privileged modes, superusers and the central operating system
• Support "networked function abstractions" in machine code to eliminate the vulnerabilities binary computers have to outside interference
• Machine code that directly implements functional programming principles instead of imperative binary operations

2. Eliminating Operating System Vulnerabilities

• Uniform atomic software modularity as Lambda Calculus functions.
• Remove superusers and operating systems that create fundamental security weaknesses that criminals exploit.
• Namespace-based functional programming eliminates the OS-level attack vectors
• Well-engineered systems established on scientific principles prevent the "vicious cycle of undetected attacks"
• Scientific symbolism defines provably safe digital systems

3. Hardware-Software Convergence

• Computer hardware must "catch up" with software progress using functional programming paradigms
• This prevents both malware attacks and AI "breakout" scenarios
• Creates high-performance, high-reliability computing that's inherently secure

4. Mathematical Purity Over Binary Exploitation

• Functional programming's mathematical foundation provides fail-safe modularity.
• Pure functions without side effects eliminate undetected attack vectors
• Immutable data structures prevent the memory corruption that enables malware

Hamer-Hodges successfully argues that this approach creates a scientific framework for independent, crime-free global cyber societies sharing cyberspace, achieved by making computers incapable of running malicious code through their mathematical design principles.

Based on analysis, this functional programming approach differs dramatically from current cybersecurity methods:

Current Security Approach (Reactive & Layered):

• Indirect detection: All malware is undetected as and when it takes place
• Signature-based: Antivirus software tries to identify malware signatures when downloaded
• Patching vulnerabilities: Constantly patching code to fix security holes as new zero-day vulnerabilities are discovered
• Perimeter defence: Firewalls, intrusion detection systems, and high-level access controls
• Operating system dependent: Relies on OS-level security that cannot detect escalation of privilege attacks

Functional Programming Solution (Proactive & Fundamental):

• Zero-Trust: Church-Turing instructions, and CLOOMC as a fail-safe software platform. 
• Prevention by design: Computer architecture that detects atomic errors on the spot, preventing malware atomically (instruction by instruction) in any and all forms
• Mathematical purity: Lambda calculus-based systems eliminate exploitable code paths
• No operating system vulnerabilities: Direct machine code implementation of functional abstractions
• Inherent security: Program-controlled security, systems that can't run malicious code due to their architectural foundation

Key Philosophical Differences:

1. Current approach: "How do we detect and stop bad code?"
2. Engineered approach: "Build computers that can't run bad code!"

His theory suggests current security is like "putting locks on a house built without walls" - functional programming would build the house out of digital materials with walls that criminals simply can't break into, or climb over. Instead of the endless cycle of malware creation and detection, he proposes scientific Church-Turing computers that make the entire category of malware and ransomware as cyber attacks impossible.

Functional programming approach to cybersecurity faces significant practical limitations in today's technology landscape:

Current Technical Barriers:

1. Hardware Infrastructure Reality

• The world runs on billions of binary computers with established architectures (x86, ARM, etc.)
• Replacing the global computing infrastructure would cost trillions and take decades.
• Functional programming languages already exist (Haskell, Lisp, Erlang), but haven't eliminated malware because the gaps remain at the machine level.
• Doing nothing will cost more and lead to stagnation, dictatorship, and global crime.

2. Performance and Compatibility Issues

• Functional programming changes the computational resources over imperative code, offering parallelism instead of sequential and first-class variables that remove loops.
• Although existing software, databases, and systems are built on imperative programming paradigms, functional APIs allow cloud interworking
• Critical systems (banking, healthcare, military) are caught in a trap; they can't risk experimental architectural changes, and they cannot survive global cyber war.

3. Industry Adoption Challenges

• Software developers worldwide are trained in imperative programming languages (C++, Java, Python)
• Major tech companies have invested heavily in current security approaches and are unwilling to change.
• Education on the proven examples of how lambda calculus-based machine code prevents all malware

What's Practically Achievable Today:

• Functional programming principles can improve security in specific applications
• Immutable data structures and pure functions do reduce certain attack vectors
• Memory-safe languages like Rust are gaining adoption for security-critical code

While Hamer-Hodges presents compelling theoretical arguments in "The Fate of AI Society", his vision requires revolutionary changes to computing that would take decades to implement globally. However, while it is a long-term alternative, it remains the only viable option.

Lambda calculus is the mathematical foundation that is key to secure computing. Let’s break it down simply:

What Lambda Calculus Is: Lambda calculus is a mathematical system created by Alonzo Church in the 1930s for expressing computation through pure functions. It's the theoretical foundation behind all programming languages.

Core Concepts:

• Functions as first-class objects: Functions can be passed as arguments, returned as values, and stored in variables
• Pure functions: No side effects - the same input always produces the same output
• Function composition: Complex operations built by combining simpler functions
• Immutability: Data doesn't change; new data is created instead

Simple Lambda Calculus Example:

λx.x + 1

This represents a function that takes input x and returns x + 1. The λ (lambda) symbol indicates "function of."

How This Applies: Implementing the lambda calculus directly in machine code would:

• Replace binary operations with mathematical purity.
• Create "networked function abstractions" that eliminate malware vulnerabilities.
• Make computers fundamentally secure by design.
• Enable "crime-free cyber societies".

Why It Matters for Security: Pure functions with no side effects eliminate the many binary attack vectors that malware exploits, such as memory corruption and unauthorised system access.