0 views collected around this technical thread.
Guido van Rossum recounts Python’s humble origins, explains how the ‘Worse is Better’ philosophy drove its rapid early adoption, examines its lasting impact on language design, and debates whether this pragmatic approach remains relevant today, even as Python integrates with Rust and evolves.
Recent updates from the Python Steering Council indicate a positive response to PEP 703, which proposes making the Global Interpreter Lock optional in CPython, outlining short‑, medium‑, and long‑term plans for experimental no‑GIL builds, community support, and potential default adoption.
Aliaksandr Valialkin criticizes Go 1.23’s new iterator feature, arguing it adds hidden control‑flow, memory overhead and readability challenges to an already minimalist language, and warns that such complexity undermines Go’s goals of simplicity, productivity, and performance.
This article answers twenty‑seven common Python questions covering why indentation is used for block grouping, the reasons behind surprising floating‑point results, the immutability of strings, the explicit use of self, the absence of assignment in expressions, and many other design choices that shape Python’s core behavior.
This article explains why Zig, with its built‑in build system, package manager, safety features, and modern language design, is emerging as the most compelling replacement for C in system programming, offering high performance, easy C interop, and a promising future for developers.
This article explains why Python uses indentation for block grouping, how floating‑point arithmetic works, why strings are immutable, the purpose of the explicit self parameter, the absence of assignment in expressions, and many other design decisions that shape Python's syntax and runtime behavior.
PEP‑594, approved for Python 3.11‑3.13, removes over‑aged and unmaintained modules from the standard library, revitalizing the language’s “batteries‑included” philosophy by reducing maintenance costs, improving security, and benefiting resource‑constrained platforms while also streamlining future development.
This article explains Python's design choices such as mandatory indentation, floating‑point arithmetic quirks, immutable strings, the absence of switch statements, memory management, and many other language features, providing clear reasoning, code examples, and best‑practice recommendations for Python developers.
Deepin has announced Unilang, a self‑developed, general‑purpose programming language designed to efficiently create desktop applications, offering features such as a C++‑friendly object model, Qt bindings, first‑class functions, dynamic typing, FFI, and a minimal runtime without garbage collection.
Google unveiled Carbon, an experimental open‑source language positioned as a successor to C++, explaining its design goals, key features, roadmap, and community reactions while comparing it to Rust and D and discussing why a new language may be needed beyond evolving C++.
The article argues that Python 3.9’s recent additions—static type checking, variable annotations, extended operators, new string methods, and other syntactic sugar—contradict the language’s original philosophy of simplicity and elegance, turning Python into a heavier, less readable tool for developers.
This article traces Python’s history from Guido van Rossum’s early work on the ABC language and the influence of C and shell scripting, through its 1991 release, community‑driven development, and the language’s design principles that have made it a widely adopted, extensible, open‑source language.
This article surveys how various programming languages implement generic programming, comparing approaches such as boxing, monomorphisation, type erasure, vtables, dictionary passing, and compile‑time code generation, and illustrates each method with code examples from Go, Java, Rust, C++, D, and others.
Bruce Eckel suggested removing the explicit 'self' parameter from Python class methods, but this article explains why keeping 'self' is essential for clear instance referencing, error messages, method types, decorators, and language compatibility, arguing that the proposal would introduce ambiguity and break existing conventions.
The article explains the concept of zero‑cost abstractions, their two core requirements of no global overhead and optimal performance, adds a third focus on developer experience, and illustrates these ideas with Rust’s ownership model, iterators, async/await, and unsafe modules.
This article explores why Python’s for‑loop index variables remain visible after the loop, examines the underlying bytecode and AST handling, and explains why this behavior persists and can be useful in real‑world code.
Over the course of a week, the author explores Elixir’s design and features—covering its pipe operator, sigils, macro quoting, version handling, and differences from Erlang—while reflecting on language ergonomics, code readability, and functional programming concepts illustrated with concrete code examples.
In a series of interviews, the creators of Node.js, Python, Ruby, Kotlin, Scala, C++, Dart, Julia, and Clojure discuss each language's core strengths, design goals, and the contexts in which developers should choose them, offering a panoramic view of modern programming language evolution.
After years of using Ruby, I discovered that Clojure’s carefully designed, concise, and functional nature not only makes prototyping feel natural but also provides instant feedback and encourages thoughtful refactoring, turning development into a smooth, enjoyable flow that has quickly become my favorite language.