Python History

Optional Reading to know Python history.

The history of Python is a fascinating journey of a “hobby project” that evolved into one of the world’s most dominant programming languages. It spans over three decades, characterized by a philosophy of code readability and open-source collaboration.

Here is the complete history of Python, broken down by eras and major milestones.

1. The Origins (Late 1980s)

The inception of Python dates back to the late 1980s at CWI (Centrum Wiskunde & Informatica) in the Netherlands.

• The Creator: Guido van Rossum, a Dutch programmer, began working on Python as a hobby project to keep himself occupied during the Christmas week of 1989.
• The Inspiration: Guido was working on the ABC programming language at the time. While he liked ABC’s elegance, he found it too rigid for real-world production. He wanted to create a language that possessed the clean syntax of ABC but with the extensibility of C and the error handling of Modula-3.
• The Name: Contrary to popular belief, the name does not come from the snake. Guido was a big fan of the British comedy group Monty Python’s Flying Circus. He needed a name that was short, unique, and slightly mysterious.

2. Early Releases (1991–1994)

Guido published the first version of the code (version 0.9.0) to the USENET newsgroup alt.sources in February 1991.

• Key Features of 0.9.0: Even this early version included classes with inheritance, exception handling, functions, and the core datatypes (list, dict, str) that are still used today.
• Modula-3 Influence: The module system was a major feature borrowed from Modula-3, allowing Python to be modular and organized.

3. Python 1.0 (January 1994)

This was the first major release, marking Python’s maturity as a standalone language.

• Functional Tools: It introduced functional programming tools like lambda, map, filter, and reduce.
• CNRI: During this period, Guido moved to the Corporation for National Research Initiatives (CNRI) in Virginia, USA, where development continued.
• Keyword Arguments: Python 1.4 introduced keyword arguments (e.g., func(a=1)), a feature inspired by Modula-3.

4. Python 2.0 (October 2000)

Python 2.0 was a significant leap forward and introduced a more open development process.

• “BeOpen” and Open Source: The development team moved to BeOpen.com, and the Python code was transitioned to SourceForge, solidifying its open-source nature.
• List Comprehensions: Borrowed from the functional language Haskell, this feature allowed for concise creation of lists (e.g., [x*2 for x in list]).
• Garbage Collection: It introduced a cycle-detecting garbage collector, which improved memory management for reference cycles.
• Unicode Support: Better support for Unicode characters was added to standardize text processing.

5. Python 3.0: “Py3k” (December 2008)

This is arguably the most critical moment in Python’s history. Python 3.0 was designed to rectify fundamental design flaws in the language.

• The Goal: To clean up the codebase and remove redundancy (adhering to the Zen of Python: “There should be one– and preferably only one –obvious way to do it”).
• Backward Incompatibility: Unlike previous updates, Python 3 was not backward compatible with Python 2. Code written for Python 2.x would not run on Python 3.x without modification.
• Key Changes:
  • print became a function: print("Hello") instead of print "Hello".
  • Integer division: 5 / 2 returned 2.5 (float) instead of 2 (integer).
  • Unicode by default: All strings became Unicode strings.

6. The “2 vs 3” Era (2008–2020)

Following the release of Python 3, the community entered a long transitional period.

• The Split: Many companies and libraries were stuck on Python 2.7 (the last release of the 2.x series) because porting code to Python 3 was difficult.
• Coexistence: For over a decade, Python 2 and Python 3 co-existed. Developers had to choose which version to support.
• The End of Python 2: Python 2.7 officially reached its “End of Life” (EOL) on January 1, 2020. No further security patches or bug fixes are released for it.

7. Modern Era & The Steering Council (2018–Present)

• Guido Steps Down: In July 2018, Guido van Rossum stepped down from his role as the “Benevolent Dictator For Life” (BDFL), a title the community gave him, after a contentious debate over “Assignment Expressions” (the Walrus operator :=).
• Steering Council: Python is now governed by a five-member Steering Council elected by active core developers.
• Annual Releases: The language has moved to a predictable annual release cycle (e.g., 3.9, 3.10, 3.11), focusing on speed improvements (the “Shannon Plan”) and better error messages.

–

Summary of Major Versions

–

Why is Python Popular Today?

While it started as a scripting language, Python’s history paved the way for its dominance in three modern fields:

1. Web Development: Frameworks like Django and Flask (mid-2000s) made it a web powerhouse.
2. Data Science & AI: The release of libraries like NumPy (2006) and Pandas (2008) turned Python into the default language for data analysis, replacing R and MATLAB in many sectors.
3. DevOps & Automation: Its readability made it the preferred choice for scripting, infrastructure as code (Ansible, SaltStack), and cloud automation.

Python 2 vs. Python 3: The Technical Evolution

Think as: Old Currency vs. New Currency (Demonetization) or Typewriter vs. Word Processor.

Imagine Python 2 is like a classic Typewriter. It works great, built many legendary stories, and is robust. But, if you make a mistake, fixing it is hard (handling text encodings was messy), and it lacks modern features like spell-check (type safety hints).

Python 3 is like a modern Word Processor. It looks similar, but under the hood, it handles text differently (Unicode by default), calculates math more naturally, and has powerful tools to automate boring tasks. Just as you wouldn’t write a new book on a typewriter today, you shouldn’t start a new project in Python 2.

The biggest friction point for beginners moving from Python 2 to 3 is the Print statement and Integer Division.

• Print: In Python 2, print was a statement (like a command). In Python 3, it is a function (needs brackets).
• Division: In Python 2, dividing two integers (e.g., 5/2) dropped the decimal, giving 2. Python 3 does “True Division,” giving 2.5.

For an architect, the critical difference is Text Processing (Unicode) and Iterators.

• Byte-handling: Python 2 treated text as bytes by default (ASCII). This caused massive “UnicodeDecodeError” headaches in global applications. Python 3 treats all strings as Unicode by default.
• Memory Efficiency: Functions like range(), map(), and zip() in Python 2 created full lists in memory immediately. In Python 3, they return iterators (lazy evaluation), which saves massive amounts of RAM when processing large datasets or logs in a DevSecOps pipeline.
• Tool: To automatically convert Python 2 code to 3, we use the 2to3 library.
  • Official 2to3 Documentation

Key Characteristics

Benefits of Python 3

1. Global Language Support: Native Unicode means you can process Hindi, Emoji, or Mandarin text without complex encoding/decoding logic.
2. Safety: Stricter types prevent bugs (e.g., you cannot strictly compare “1” < 2 in Python 3; it raises an error, whereas Python 2 allowed it).
3. Performance: Modern versions (3.11+) are significantly faster due to optimizations unavailable in the 2.x architecture.

Types of Python: Implementations & Distributions

Imagine “Python” is a Recipe written in a book. It’s just a set of instructions on how the language should behave. Now, different chefs can cook this recipe.

• CPython (The Standard Chef): This is the original chef who wrote the recipe. 95% of people go to this chef.
• Jython (The Java Chef): A chef who cooks the Python recipe but uses a Java kitchen.
• PyPy (The Fast Chef): A chef who cooks the same recipe but uses super-fast automated tools (JIT) to finish quicker.

In technical terms: “Python” is the Interface/Language Specification, and these “Types” are the Interpreters/Implementations written in different underlying languages (C, Java, C#, etc.).

When you download Python from python.org, you are actually downloading CPython. It is called CPython because it is written in the C programming language. It is the default and standard version. If someone just says “Python,” they mean CPython.

As an Architect, you choose the implementation based on the environment:

• CPython: The reference implementation. Uses the Global Interpreter Lock (GIL), which limits threads to one CPU core at a time (a bottleneck for CPU-heavy tasks).
• PyPy: Uses Just-In-Time (JIT) compilation. Instead of interpreting line-by-line, it compiles hot code spots into machine code at runtime. Great for long-running scripts but uses more memory.
• Jython/IronPython: Allows seamless integration with legacy enterprise stacks (Java JVM or .NET CLR). You can import Java classes directly into your Python script.
• MicroPython: Optimized to run on microcontrollers (ESP32, Arduino) with just kilobytes of RAM.

–

Key Characteristics

Use Cases

• CPython: You are building a Django website, a DevOps automation script, or training an AI model with TensorFlow.
• PyPy: You have a pure Python script doing heavy math that takes 10 hours to run. Switching to PyPy might cut it down to 2-3 hours without changing code.
• Jython: You need to write a script that tests a Java Application Server and needs to access Java objects natively.
• MicroPython: You are building a Smart Home sensor that reads temperature and sends it to AWS IoT Core.

Benefits

• CPython: enormous ecosystem. All C-extension libraries (NumPy, Pandas) work perfectly here.
• PyPy: Speed. It is generally 4.4x faster than CPython for pure Python code.
• Jython: Portability. If you have a JVM installed, Jython runs there. No need to install a separate Python environment.

Limitations

• C-Extensions (The Big One): Libraries like NumPy or Pandas rely heavily on C code. CPython handles them easily. PyPy, Jython, and IronPython often fail or are very slow with these libraries because they cannot easily talk to the C-backend.
• Startup Time: PyPy takes longer to start up than CPython (because of the JIT warm-up). Not good for tiny, quick scripts.

Common Issues & Solutions

Problem: “I installed PyPy for speed, but my Pandas script crashed.” Solution: Do not use PyPy for Data Science libraries. Stick to CPython (or the Anaconda distribution) for anything involving NumPy/Pandas.

• CPython (Official Python Site)
• PyPy (The Fast Python)
• Jython (Python for Java)
• MicroPython (Python for IoT)

–

Cheat Sheet

–

Run this simple script to see which implementation you are currently running.

import sys
import platform

print("Implementation:", platform.python_implementation())
print("Version:", sys.version)
print("Compiler:", platform.python_compiler())

# Output on Standard Python:
# Implementation: CPython
# Version: 3.10.x ...
# Compiler: GCC ...