They Landed on the Moon with 72KB. What’s Your Excuse?

Last updated on 
They Landed on the Moon with 72KB. What’s Your Excuse?
Eldon Hall with Apollo Guidance Computer Testing Equipment - Courtesy Draper

🚀 If NASA Could Land Humans on the Moon with 76KB, Why Is Your Code So Wasteful? 🤔

In 1969, NASA sent humans to the Moon using the Apollo Guidance Computer (AGC). It had 72KB of memory—less than a single photo on your smartphone. Yet, it navigated across 380,000 km, landed on the Moon, and brought astronauts home safely.

AGC Memory Specifications

  1. ROM (Read-Only Memory) - 67.6KB:
    • 36,864 words of ROM.
    • Each word = 15 bits.
  2. RAM (Erasable Memory) - 3.75KB:
    • 2,048 words of RAM.
    • Each word = 15 bits.

Source -

  1. https://en.wikipedia.org/wiki/Apollo_Guidance_Computer
  2. A brief Analysis of AGC - https://arxiv.org/pdf/2201.08230

While others might argue, that The Apollo Guidance Computer (AGC) didn’t handle the rocket launch (the Saturn V had its own computer for that) or calculate the complex Moon trajectory on its own (Earth-based mainframes did the heavy lifting).

But what the AGC did was far more badass:

  • It steered the spacecraft in real time with precision.
  • It landed humans on the Moon while ignoring non-critical tasks (like an annoying "1202 alarm").
  • It executed complex maneuvers with a user interface that had just a few buttons and a basic display.

The AGC’s success wasn’t about raw computing power—it was about efficiency, optimization, and precision.

Now let’s talk about today:

  • Apps crash with gigabytes of memory at their disposal.
  • Latency frustrates users and costs businesses millions.
  • Bloated software powers massive data centers that consume 1% of the world’s electricity—just to keep inefficiencies running.

It doesn’t have to be this way.

The Cost of Inefficient Code

Every unoptimized line of code, every redundant query, and every extra millisecond of latency comes at a cost:

  1. Energy: Inefficient code burns through more CPU cycles, consuming unnecessary electricity. This drives up carbon emissions and worsens the climate crisis.
  2. Cost: Latency doesn’t just frustrate users—it increases infrastructure expenses. Companies spend billions scaling resources to compensate for poorly optimized systems.
  3. User Experience: Today’s users expect speed. Every extra second they wait costs you trust, loyalty, and revenue.

The Mindset That Made the Moon Landing Possible

The engineers behind the AGC didn’t have the luxury of wasting memory or processing power. They:

  • Designed a computer that prioritized real-time performance under strict memory constraints.
  • Optimized every bit of code, cutting out redundancy and focusing on essentials.
  • Built a system that could handle critical tasks (like landing on the Moon) while ignoring non-essential ones through interrupt-driven design.

They didn’t rely on “more hardware” or “more memory” because they couldn’t. They had to solve problems with the resources they had.

How We Can Learn From Them Today

As developers and engineers, we have exponentially more resources than those NASA engineers did. Yet, the principles that guided them are more relevant than ever:

  1. Think Latency First:
    Every millisecond matters. Whether it’s an API call, database query, or loading time, small inefficiencies compound at scale. Profile your code, eliminate bottlenecks, and always ask: How can I make this faster?
  2. Optimize for Resources:
    Stop relying on more CPUs, more RAM, or more servers to hide inefficiencies. Write leaner, more efficient code. Optimize database queries. Reduce redundant processing. Smarter code isn’t just faster—it’s cheaper and more sustainable.
  3. Prioritize User Experience:
    Remember, users don’t care about your complex architecture or fancy frameworks—they care about speed and reliability. Cut the fluff and deliver what matters.
  4. Write Future-Proof Code:
    Code isn’t just for today—it will power businesses, systems, and lives for years. Build systems that scale efficiently and adapt to new challenges without wasting resources.

The AGC proved that efficiency isn’t a limitation—it’s a superpower. When we optimize, we save time, energy, and costs, and we build systems that scale without compromise.

Ask yourself:

  • Are you writing fast and lean code or masking inefficiencies with more resources?
  • Are you solving problems in a way that respects the planet’s resources and your users’ time?
  • What would your code look like if 72KB was all you had?

The Future Is in Our Hands

The Moon landing showed us what’s possible when we prioritize efficiency and innovation. Today, as we face challenges like energy crises, climate change, and the need for scalable tech, the responsibility to do better falls on us.

Write code like it matters. Build systems that change the world. Optimize because it’s the right thing to do—for the users, the businesses, and the planet.

The future doesn’t belong to those who use more. It belongs to those who can do more with less.

Let’s code for a better tomorrow. 🌍✨

Next Steps..

  1. AI-Assisted Coding Needs Human Review: While tools like Cursor, GitHub Copilot, and Codeium generate efficient code, human oversight is crucial to refine logic, optimize algorithms, and ensure real-world performance.
  2. Measure Code Performance: Use tools like JMeter, k6, and Postman to conduct load and performance testing, analyze response times, and evaluate system behavior under real-world conditions to ensure seamless scalability.
  3. Take QA Seriously: Build a strong QA team with tools like SonarQube for static analysis, DeepCode for vulnerability detection, and enforce quality gates such as 100% code coverage to ensure efficiency and security in all deployments.
  4. Refactor Regularly: Refactor code periodically to eliminate redundancy and improve maintainability with IDE-integrated tools like IntelliJ IDEA or VS Code refactoring capabilities.
  5. Profile and Monitor Continuously: Profile your code with tools like Pyroscope, Flamegraphs, or VisualVM, and monitor resource usage with Datadog, Prometheus, or AWS CloudWatch to identify inefficiencies and optimize resource consumption.
  6. Optimize Databases: Analyze and refine queries using PgAdmin, SolarWinds, or MySQL Workbench, and implement caching with Redis or Memcached to reduce load and improve responsiveness.
  7. Automate with CI/CD: Use CI/CD tools like GitHub Actions, Jenkins, or CircleCI to integrate automated testing, code analysis, and quality checks, ensuring consistent performance across deployments.
  8. Document and Review Code: Use tools like Confluence, Doxygen, or built-in GitHub wikis for documentation, and conduct peer reviews with platforms like GitLab or Bitbucket to enhance readability and maintainability.
  9. Focus on Scalability: Stress test systems for scalability using tools like Locust or Blazemeter, and ensure they’re designed to handle exponential growth with minimal adjustments.
  10. Stay Ahead of Trends: Continuously learn and experiment with modern optimization tools like Polycoder, AWS CodeWhisperer, and Lighthouse, keeping your skills sharp and projects cutting-edge.

Citation / Sources

  1. Apollo 11 - Source code : https://github.com/chrislgarry/Apollo-11
  2. Good Read : https://www.quora.com/How-could-a-computer-with-64-Kb-memory-launched-Apollo-11-to-the-moon
  3. AGC Wiki - https://en.wikipedia.org/wiki/Apollo_Guidance_Computer
  4. Paper by A Brief Analysis of the Apollo Guidance Computer https://arxiv.org/pdf/2201.08230
  5. Hacker Reactor - https://www.hackreactor.com/resources/todays-computers-vs-the-apollo-11-moon-landing-machine/
  6. Book On Amazon - https://www.amazon.in/Apollo-Guidance-Computer-Architecture-Operation/dp/1441908765
  7. Good Read - https://wehackthemoon.com/tech/apollo-guidance-computer-agc-computer-engineering-breakthrough