BestHub
Sign in
Tagged articles

Language Design

99 articles · Page 1 of 1
Open Source Tech Hub
Open Source Tech Hub
Sep 22, 2026 · Fundamentals

PHP Traits: The Underrated Metaprogramming Tool with Untapped Potential

The article argues that PHP Traits are an underestimated metaprogramming feature offering low cognitive overhead, but their potential is limited by weak composition contracts; it proposes bidirectional contracts allowing traits to require interfaces and implement interfaces, turning traits into predictable compile-time class transformations.

Compile-time TransformationComposition ContractsLanguage Design
0 likes · 8 min read
PHP Traits: The Underrated Metaprogramming Tool with Untapped Potential
TonyBai
TonyBai
Aug 31, 2026 · Fundamentals

‘I Hate Where Go Is Going’ Ignites 200 Reddit Comments on Generics and Iterators

A Reddit post titled ‘I hate where Go is moving’ triggered a heated debate about Go’s recent adoption of generics, iterators, and built‑in collection proposals, exposing a split between those who see these features as natural evolution and those who fear the language is losing its original simplicity.

GoLanguage DesignSoftware Engineering
0 likes · 11 min read
‘I Hate Where Go Is Going’ Ignites 200 Reddit Comments on Generics and Iterators
Radish, Keep Going!
Radish, Keep Going!
Aug 25, 2026 · Backend Development

Go vs Rust vs Zig: Three Value Systems Behind the Language Wars

The author compares Go, Rust, and Zig through hands-on experiments, revealing how each language embodies a distinct value system: Go prioritizes minimalism for team collaboration, Rust maximizes safety and performance via a dense type system, and Zig returns full control to programmers with manual memory management and data-oriented design.

GoLanguage DesignRust
0 likes · 16 min read
Go vs Rust vs Zig: Three Value Systems Behind the Language Wars
TonyBai
TonyBai
Aug 17, 2026 · Fundamentals

The 14‑Year Tug‑of‑War Over Go’s string(int) Conversion Reignited

After 14 years of dormancy, Go’s proposal #3939 to remove the confusing string(int) conversion—originally added for early formatting—has been moved to the regular proposal committee, prompting analysis of its semantics, historical reasons, compatibility concerns, and possible future outcomes.

GoLanguage DesignUnicode
0 likes · 11 min read
The 14‑Year Tug‑of‑War Over Go’s string(int) Conversion Reignited
TonyBai
TonyBai
Aug 3, 2026 · Fundamentals

Is Go Straying from Its Original Simplicity? A Reddit Thread Uncovers the Community’s Deep Divide

A Reddit discussion about Go’s recent generics and iterator additions reveals a split between supporters who see them as necessary pay‑back for early over‑simplicity and opponents who fear they raise complexity, increase entry barriers, and risk turning Go into a more Python‑like language, especially as AI‑generated code struggles to keep up.

AI code generationCommunity DebateGo
0 likes · 18 min read
Is Go Straying from Its Original Simplicity? A Reddit Thread Uncovers the Community’s Deep Divide
ITPUB
ITPUB
Aug 1, 2026 · Industry Insights

Is the Era of Inventing New Programming Languages Over?

The article examines how decades of design trade‑offs, hardware shifts, and evolving developer priorities have turned modern programming languages into cumulative refinements of past ideas, questioning whether truly novel languages can still emerge today.

Language Designdynamic typingperformance vs safety
0 likes · 13 min read
Is the Era of Inventing New Programming Languages Over?
21CTO
21CTO
Aug 1, 2026 · Fundamentals

Why Zig’s Maverick Creator Challenges C, Rust, and Go After 11 Years

The article examines how Andrew Kelley built the Zig language out of frustration with existing tools, outlines Zig’s uncompromising philosophy, independent toolchain, community funding model, anti‑AI stance, and compares its safety and performance advantages against C, Rust, and Go while highlighting real‑world adopters.

Language DesignPerformanceZig
0 likes · 11 min read
Why Zig’s Maverick Creator Challenges C, Rust, and Go After 11 Years
ITPUB
ITPUB
Jul 20, 2026 · R&D Management

How One Engineer’s Pragmatism Built Four Blockbuster Languages Over 40 Years

The article examines Anders Hejlsberg’s four‑decade journey from Turbo Pascal to Go, showing how his focus on cutting developer wait time, embracing platform realities, and minimizing migration cost created lasting language successes rather than relying on pure technical elegance.

Anders HejlsbergC++Delphi
0 likes · 24 min read
How One Engineer’s Pragmatism Built Four Blockbuster Languages Over 40 Years
TonyBai
TonyBai
Jul 14, 2026 · Industry Insights

The 171 Approved Go Proposals Still Unimplemented: A Ten‑Year Technical Debt List

An analysis of the 171 open Go proposals that have been marked Accepted but remain unimplemented, revealing that over half have been pending for more than five years, the categories most affected, the reasons behind the backlog, and recent signs that the Go team is accelerating their resolution.

BacklogGoLanguage Design
0 likes · 16 min read
The 171 Approved Go Proposals Still Unimplemented: A Ten‑Year Technical Debt List
TonyBai
TonyBai
Jul 6, 2026 · Fundamentals

Is Go's Conservative Language Evolution Still Right for the Next 5 Years?

The article examines Go's deliberately cautious evolution—focusing on stability, minimal feature creep, and operational simplicity—by contrasting it with the rapid feature expansion of languages like C++, Rust, and TypeScript, and argues why this approach may remain advantageous over the next five years.

Backward CompatibilityGoLanguage Design
0 likes · 10 min read
Is Go's Conservative Language Evolution Still Right for the Next 5 Years?
TonyBai
TonyBai
Jun 29, 2026 · Fundamentals

Why I Keep Returning to Go After Trying Every Language

The article argues that Go’s batteries‑included standard library eliminates dependency fatigue, its built‑in diagnostics let engineers locate production issues in hours instead of weeks, its uncolored concurrency model avoids async/await pitfalls, and its minimalism reduces cognitive load and boosts team efficiency.

ConcurrencyDiagnosticsGo
0 likes · 10 min read
Why I Keep Returning to Go After Trying Every Language
IT Services Circle
IT Services Circle
Jun 6, 2026 · Fundamentals

Why Modern Languages Are Dropping the C‑Style for Loop

The article explains how C‑style for loops hide many pitfalls, why newer languages like Python, Rust, Swift and Go replace them with safer, more readable constructs, and when the classic C for loop still offers advantages for low‑level and performance‑critical code.

C for loopCode safetyGo
0 likes · 7 min read
Why Modern Languages Are Dropping the C‑Style for Loop
TonyBai
TonyBai
Jun 2, 2026 · Fundamentals

Eliminate Boilerplate: Go’s New Proposal to Convert Functions Directly to Interfaces

The article examines Go’s long‑standing boilerplate adapter pattern, explains the newly accepted Issue #47487 that enables explicit conversion of functions to single‑method interfaces, compares it with the rejected implicit assignability approach, and shows how the compiler generates hidden types to preserve safety and reduce code.

GoLanguage Designboilerplate
0 likes · 11 min read
Eliminate Boilerplate: Go’s New Proposal to Convert Functions Directly to Interfaces
Java Tech Enthusiast
Java Tech Enthusiast
May 27, 2026 · Industry Insights

Why a $5 Million, Five‑Year Language Project Ended Up Switching to TypeScript

After five years and over $5 million invested in developing the Wasp DSL, founder Matija Sosic concluded that creating a new web‑development language was a mistake, and the team pivoted to a TypeScript‑based SDK, citing lower learning curve, better toolchain support, and comparable compile‑time application insights.

DSLLanguage DesignTypeScript
0 likes · 7 min read
Why a $5 Million, Five‑Year Language Project Ended Up Switching to TypeScript
Liangxu Linux
Liangxu Linux
May 24, 2026 · Fundamentals

Why Is C the Most Successful Programming Language?

The article explains that C’s lasting dominance stems from its extreme simplicity with only 32 keywords, low‑level hardware access, and its deep ties to Unix, which together created an ecosystem that outlasted newer languages despite C’s lack of modern features.

C languageLanguage DesignSoftware Engineering
0 likes · 6 min read
Why Is C the Most Successful Programming Language?
Liangxu Linux
Liangxu Linux
May 17, 2026 · Industry Insights

Can MoonBit Support Chinese Keywords? Feasibility, Benefits, and Drawbacks

The article examines MoonBit's proposal to add optional Chinese keywords, discussing technical feasibility through a mapping table, potential advantages for beginners and non‑English speakers, and counterarguments about internationalization, developer workflow, and AI tooling compatibility.

Chinese keywordsLanguage DesignMoonBit
0 likes · 6 min read
Can MoonBit Support Chinese Keywords? Feasibility, Benefits, and Drawbacks
IT Services Circle
IT Services Circle
May 11, 2026 · Fundamentals

Why a Single await Can Turn Half Your Project Red

The article explains how introducing a single async/await call can propagate through an entire codebase, turning many functions "red" and creating hidden performance and maintenance problems, while tracing the historical evolution of async programming, its pitfalls, and emerging alternatives like Java Loom and Zig.

ConcurrencyJava LoomLanguage Design
0 likes · 13 min read
Why a Single await Can Turn Half Your Project Red
TonyBai
TonyBai
Apr 29, 2026 · Fundamentals

Go 1.27 Enables Default SIMD on amd64 and Introduces Portable SIMD Package

Go 1.27 will turn on the simd/archsimd package by default on amd64, while a new portable simd API proposal adds architecture‑independent vector types and operations, offering a two‑layer design that balances low‑level performance with Go’s emphasis on readability and portability.

GoLanguage DesignPerformance
0 likes · 11 min read
Go 1.27 Enables Default SIMD on amd64 and Introduces Portable SIMD Package
TonyBai
TonyBai
Apr 28, 2026 · Fundamentals

Is the Go Ternary Operator War Finally Over? Go Bible Author Proposes a Compromise

After more than a decade of heated debate over adding a ternary conditional operator to Go, core team member Alan Donovan submitted a compromise proposal that blends Go's emphasis on clarity with the expressive power developers crave, sparking fresh discussion in the community.

Alan DonovanGoLanguage Design
0 likes · 10 min read
Is the Go Ternary Operator War Finally Over? Go Bible Author Proposes a Compromise
TonyBai
TonyBai
Apr 15, 2026 · Industry Insights

Modern C++: Productivity Revolution or Added Complexity? Community Deep Dive

A recent r/cpp discussion reveals three distinct C++ developer mindsets—legacy‑code loyalists, modern‑feature enthusiasts, and mixed‑approach pragmatists—debating whether C++20/23 innovations boost productivity or merely pile on complexity, and proposes incremental modernization as a balanced path forward.

C++C++20C++23
0 likes · 11 min read
Modern C++: Productivity Revolution or Added Complexity? Community Deep Dive
Golang Shines
Golang Shines
Apr 9, 2026 · Fundamentals

Why Go’s Error Handling Can’t Use Zig‑Style “try”

The article examines why Go does not adopt Zig’s concise ‘try’ syntax for error handling, analyzing differences in error type design, compiler checks, compatibility constraints, and the trade‑offs between explicit control flow and language ergonomics, and offers practical Go‑centric alternatives.

GoLanguage DesignZig
0 likes · 8 min read
Why Go’s Error Handling Can’t Use Zig‑Style “try”
TonyBai
TonyBai
Apr 9, 2026 · Industry Insights

Rust Developers Petition for a Bigger Standard Library: Should Go Be the Model?

A heated community debate sparked by a Rust forum post questions the language’s minimal std library, arguing that reliance on numerous third‑party crates creates supply‑chain risks, and contrasts Rust’s “small core, strong ecosystem” approach with Go’s comprehensive “batteries‑included” standard library, while exploring possible compromises.

GoLanguage DesignRust
0 likes · 11 min read
Rust Developers Petition for a Bigger Standard Library: Should Go Be the Model?
ITPUB
ITPUB
Mar 29, 2026 · Industry Insights

From Heartbreak to Zig: How a Lost Love Sparked a Modern C Alternative

After a painful breakup in 2015, programmer Andrew Kelly channeled his frustration into creating Zig, a safer, more modern alternative to C, detailing its design goals, community challenges, funding through Patreon, and the language’s growth into a vibrant open‑source project that reshapes how developers think about language design and open‑source life.

ComptimeFundingLanguage Design
0 likes · 10 min read
From Heartbreak to Zig: How a Lost Love Sparked a Modern C Alternative
DevOps Coach
DevOps Coach
Mar 22, 2026 · Fundamentals

Why Rust Still Struggles: Compile Times, Borrow Checker, and Async Pain Points

After five years of daily Rust development, the author outlines persistent challenges such as long compile times, restrictive borrow‑checking, cumbersome async patterns, boilerplate from the orphan rule, and their impact on team productivity, while acknowledging Rust's safety and performance benefits.

@AsyncLanguage DesignRust
0 likes · 7 min read
Why Rust Still Struggles: Compile Times, Borrow Checker, and Async Pain Points
TonyBai
TonyBai
Feb 22, 2026 · Backend Development

Installed Go 1.26 but Can’t Use Its New Features? Inside the go mod init Downgrade Debate

After upgrading to Go 1.26, developers encounter a compile error because go mod init now defaults to the previous major version, sparking a heated debate between the Go core team’s compatibility rationale and the community’s frustration over broken developer experience, with proposed work‑arounds and philosophical reflections on language design.

Community DebateLanguage DesignVersion management
0 likes · 12 min read
Installed Go 1.26 but Can’t Use Its New Features? Inside the go mod init Downgrade Debate
Golang Shines
Golang Shines
Feb 16, 2026 · Fundamentals

Why Go Lacks a Ternary Operator and How It Affects Code Readability

The article explains that, unlike Python, JavaScript, C, and C++, Go does not support the ternary ?: operator because its designers consider it prone to creating unreadable, complex expressions, preferring the clearer if‑else construct, and it discusses alternatives, pros, cons, and a discouraged custom implementation.

Code ReadabilityGoLanguage Design
0 likes · 7 min read
Why Go Lacks a Ternary Operator and How It Affects Code Readability
TonyBai
TonyBai
Feb 9, 2026 · Fundamentals

Is Go Finally Adding Immutable Types After an 8‑Year Dormant Proposal?

The article revisits the eight‑year‑old Go proposal #27975 for an immutable‑type qualifier, explains the defensive‑copy performance problem it aims to solve, details the technical and community challenges—including const‑contamination and io.Writer compatibility—and explores why generics and safety concerns have revived the discussion in 2026.

ConcurrencyGoLanguage Design
0 likes · 11 min read
Is Go Finally Adding Immutable Types After an 8‑Year Dormant Proposal?
TonyBai
TonyBai
Jan 24, 2026 · Fundamentals

After Four Years of Go Generics, Generic Methods Are Finally Arriving

Four years after Go introduced generics, the language’s core team has proposed adding generic methods, a change that resolves the long‑standing asymmetry between generic functions and types, improves API fluency, and reshapes code organization while preserving backward compatibility, though interface support remains limited.

API DesignGoLanguage Design
0 likes · 12 min read
After Four Years of Go Generics, Generic Methods Are Finally Arriving
21CTO
21CTO
Nov 10, 2025 · Fundamentals

The Story Behind Zig: How Andrew Kelley Created a Modern C Successor

This article recounts the origins of the Zig programming language, detailing Andrew Kelley’s background, his motivations to overcome C’s limitations, and the personal experiences that drove him to design a fast, safe, and modern system‑level language.

Andrew KelleyLanguage DesignProgramming Language
0 likes · 6 min read
The Story Behind Zig: How Andrew Kelley Created a Modern C Successor
IT Services Circle
IT Services Circle
Nov 8, 2025 · Fundamentals

From Heartbreak to Innovation: How Zig Became a Safer C Alternative

After a 2015 breakup, programmer Andrew turned his frustration into Zig, a modern, safe, and efficient programming language that challenges C’s shortcomings, grew a vibrant community, secured funding through a nonprofit foundation, and now powers projects like Bun and TigerBeetle.

Compile-time ExecutionLanguage DesignProgramming Language
0 likes · 8 min read
From Heartbreak to Innovation: How Zig Became a Safer C Alternative
21CTO
21CTO
Nov 5, 2025 · Fundamentals

How PEP 810’s Explicit Lazy Imports Can Speed Up Your Python Apps

PEP 810 introduces explicit lazy imports to Python, allowing modules to be loaded only when needed, which can significantly reduce startup time while keeping the feature optional and backward‑compatible, marking a major step forward after years of community debate and earlier failed attempts.

Language DesignPEP 810Startup Performance
0 likes · 3 min read
How PEP 810’s Explicit Lazy Imports Can Speed Up Your Python Apps
Data Party THU
Data Party THU
Oct 24, 2025 · Industry Insights

Python 3.14 Removes GIL: What It Means for Concurrency and AI

Python 3.14 introduces optional no‑GIL support, free‑threading, a concurrent interpreter and performance gains, while Guido van Rossum cautions about over‑hyped expectations, discussing the trade‑offs, impact on AI workloads, and the language’s future in an in‑depth interview.

AIConcurrencyGIL
0 likes · 12 min read
Python 3.14 Removes GIL: What It Means for Concurrency and AI
IT Services Circle
IT Services Circle
Sep 27, 2025 · Fundamentals

Why Google Is Betting on a New C++ Successor for the Next Decade

Google’s ambitious eight‑year roadmap for the experimental Carbon language aims to create a modern, safer, C++‑compatible system language, detailing its tooling, ecosystem, migration strategy via FFI, and why it’s preferred over Rust despite the long development horizon.

C++CarbonGoogle
0 likes · 6 min read
Why Google Is Betting on a New C++ Successor for the Next Decade
21CTO
21CTO
Sep 23, 2025 · Fundamentals

Can Java Become a More Growable Language? Inside Brian Goetz’s Vision

Brian Goetz, Java language architect, outlines his vision for a more growable Java by introducing the “witness” concept, discussing underlying philosophy, potential new features like numeric types, operator overloading, collection expressions, and how these ideas fit into the Valhalla project and Java’s future roadmap.

Brian GoetzJavaLanguage Design
0 likes · 10 min read
Can Java Become a More Growable Language? Inside Brian Goetz’s Vision
21CTO
21CTO
Sep 19, 2025 · Backend Development

Why Go’s Error Handling, Defer, and Nil Design Feel Like Bad Ideas

The article critiques Go’s language design by highlighting unnecessary patterns such as overly broad error‑variable scopes, confusing nil semantics, cumbersome defer usage, hidden memory costs, and a lack of clear ownership, illustrating each point with concrete code examples and comparing alternatives in other languages.

Language Designdefererror handling
0 likes · 11 min read
Why Go’s Error Handling, Defer, and Nil Design Feel Like Bad Ideas
Python Programming Learning Circle
Python Programming Learning Circle
Sep 16, 2025 · Fundamentals

Uncovering Python’s Oddities: Why Indentation, No Switch, and More

This article explains the most frequently asked Python design questions, covering why indentation groups statements, the quirks of floating‑point arithmetic, immutable strings, the absence of a switch statement, memory management, and many other language‑specific decisions that shape Python’s elegant yet unconventional syntax.

FAQLanguage DesignSyntax
0 likes · 28 min read
Uncovering Python’s Oddities: Why Indentation, No Switch, and More
ITPUB
ITPUB
Aug 12, 2025 · Backend Development

Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost

Microsoft’s TypeScript team migrated the compiler from JavaScript to Go, achieving up to ten‑fold performance gains, halving memory usage, and enabling shared‑memory concurrency, while preserving compatibility and exploring future AI‑driven code analysis and language‑service APIs.

ConcurrencyGoLanguage Design
0 likes · 35 min read
Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost
21CTO
21CTO
Jun 21, 2025 · Fundamentals

How to Build a Toy BASIC‑to‑Go Compiler in a Weekend

An experienced programmer shares a weekend project that builds a simplified BASIC variant, toybasic, and a three‑stage compiler written in Go—using Nex for lexical analysis, goyacc for parsing, and custom code generation—to translate BASIC programs into Go code, complete with examples and source links.

BASICLanguage DesignParser
0 likes · 9 min read
How to Build a Toy BASIC‑to‑Go Compiler in a Weekend
Radish, Keep Going!
Radish, Keep Going!
Jun 4, 2025 · Backend Development

Why Go Keeps Rejecting New Error‑Handling Syntax

The Go team repeatedly revisits error‑handling syntax, not to push new proposals immediately, but to reaffirm the language’s core philosophy of explicitness over implicitness, highlighting past failed attempts and the community’s cautious stance on balancing simplicity with clarity.

Language DesignSyntaxcommunity
0 likes · 7 min read
Why Go Keeps Rejecting New Error‑Handling Syntax
JavaScript
JavaScript
Nov 22, 2024 · Fundamentals

Why JavaScript Might Split into Core JS0 and JSSugar: A New Proposal

At a recent Emca TC39 meeting, a Google engineer proposed dividing JavaScript into a minimal core language (JS0) and an advanced variant (JSSugar), arguing that new language features often harm security, performance, and stability, and suggesting that higher‑level capabilities be handled by external tools like TypeScript or Babel.

BabelJS0JSSugar
0 likes · 2 min read
Why JavaScript Might Split into Core JS0 and JSSugar: A New Proposal
21CTO
21CTO
Nov 5, 2024 · Fundamentals

Can Safe C++ Bring Memory Safety Without Dropping the Language?

The article examines the Safe C++ proposal—a collaborative effort by Sean Baxter and Christian Mazakas to add Rust‑inspired ownership and borrowing checks to C++ through a safe standard library—while discussing its 18‑month development timeline, toolchain extensions, community reactions, and broader implications for memory‑safe programming.

C++Language DesignRust
0 likes · 11 min read
Can Safe C++ Bring Memory Safety Without Dropping the Language?
21CTO
21CTO
Oct 16, 2024 · Information Security

Will Safe C++ Extensions Make C++ Memory‑Safe? Insights from Rust and NSA

Amid rising memory‑safety concerns highlighted by Chrome’s vulnerabilities and high‑profile attacks, the C++ community proposes a Safe C++ Extension to add memory‑safety features, while experts compare it to Rust and discuss challenges, adoption pressures, and DARPA’s AI‑driven code‑conversion efforts.

C++Language DesignRust
0 likes · 6 min read
Will Safe C++ Extensions Make C++ Memory‑Safe? Insights from Rust and NSA
21CTO
21CTO
Sep 21, 2024 · Fundamentals

Will Safe C++ Extensions Bring Rust‑Level Memory Safety to C++?

The C++ community has unveiled a groundbreaking “Safe C++ Extensions” proposal that borrows Rust’s borrow‑checking and initialization analysis to add memory‑safety features, sparking debate over its impact on C++’s identity while addressing industry demand for safer code.

C++Language Designmemory safety
0 likes · 3 min read
Will Safe C++ Extensions Bring Rust‑Level Memory Safety to C++?
Tencent Cloud Developer
Tencent Cloud Developer
Aug 28, 2024 · Fundamentals

Uncovering the 50,000‑Line TypeScript checker.ts: Design Choices and Performance Impacts

This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.

ESMLanguage DesignPerformance
0 likes · 13 min read
Uncovering the 50,000‑Line TypeScript checker.ts: Design Choices and Performance Impacts
Liangxu Linux
Liangxu Linux
Jul 1, 2024 · Fundamentals

Huawei Unveils Cangjie (.cj) – A New Programming Language for HarmonyOS NEXT

At the Huawei Developer Conference on June 21, 2024, Huawei announced its self‑developed Cangjie programming language with a .cj file extension, presented a starter "Hello, Cangjie" example, and detailed the language's historical inspiration, core features, and a step‑by‑step introductory tutorial for developers.

CangjieHarmonyOSHuawei
0 likes · 4 min read
Huawei Unveils Cangjie (.cj) – A New Programming Language for HarmonyOS NEXT
Java Tech Enthusiast
Java Tech Enthusiast
Jun 25, 2024 · Fundamentals

Critique of Go 1.23 Iterators and Their Impact on Language Complexity

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.

ComplexityGoLanguage Design
0 likes · 9 min read
Critique of Go 1.23 Iterators and Their Impact on Language Complexity
Python Programming Learning Circle
Python Programming Learning Circle
May 14, 2024 · Fundamentals

Python Frequently Asked Questions: Indentation, Float Precision, Immutability, and Core Language Design

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.

FAQLanguage DesignPython
0 likes · 28 min read
Python Frequently Asked Questions: Indentation, Float Precision, Immutability, and Core Language Design
21CTO
21CTO
Apr 28, 2024 · Fundamentals

Can a Nameless Language Make Coding Simpler? Inside the Experimental Stack Language

A Ukrainian engineer unveils an experimental, nameless programming language built around a single data structure and stack operations, inspired by Forth, APL and PostScript, sparking debate among developers about its practicality, educational value, and the broader challenges of naming in software design.

Language DesignProgramming LanguageSoftware Engineering
0 likes · 8 min read
Can a Nameless Language Make Coding Simpler? Inside the Experimental Stack Language
21CTO
21CTO
Apr 17, 2024 · Fundamentals

Build Your Own DSL in Six Steps with Langium

This guide walks you through creating a domain‑specific language using Langium, covering lexical analysis, parsing, linking, semantic validation, developer experience enhancements, and deployment options, all illustrated with concrete ZModel examples and code snippets.

DSLLangiumLanguage Design
0 likes · 11 min read
Build Your Own DSL in Six Steps with Langium
21CTO
21CTO
Dec 18, 2023 · Fundamentals

What Is Misty? Douglas Crockford’s New Actor‑Oriented Programming Language Explained

Misty, a dynamic and general‑purpose language created by JSON’s inventor Douglas Crockford, targets both students and professional developers with a strict formatting convention, actor‑oriented design, and advanced features like capability security and lexical‑scoped lambdas, sparking debate over its practicality.

Douglas CrockfordLanguage DesignMisty
0 likes · 3 min read
What Is Misty? Douglas Crockford’s New Actor‑Oriented Programming Language Explained
Architect's Guide
Architect's Guide
Dec 5, 2023 · Fundamentals

Why Zig Is the Best C Alternative: Features, Toolchain, and Code Examples

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.

C alternativeLanguage DesignZig
0 likes · 11 min read
Why Zig Is the Best C Alternative: Features, Toolchain, and Code Examples
21CTO
21CTO
Aug 31, 2023 · Backend Development

Why Zig Is Emerging as the Best C Alternative for Modern System Programming

Zig combines a lightweight, C‑compatible syntax with a built‑in build system, package manager, and safety features, positioning it as a compelling, hardware‑friendly successor to C for system programming, cross‑compilation, and modern software development, while offering seamless C interop and robust tooling.

C alternativeCross-compilationLanguage Design
0 likes · 13 min read
Why Zig Is Emerging as the Best C Alternative for Modern System Programming
21CTO
21CTO
Jul 31, 2023 · Fundamentals

What Is VAL? The New System Programming Language Aiming to Rival Rust

VAL is a newly created high‑level programming language designed for system and edge computing, offering near‑Rust performance while avoiding references, and targeting applications like operating systems, games, and image processing that cannot afford virtual machines or garbage collectors.

Language DesignProgramming LanguageRust alternative
0 likes · 6 min read
What Is VAL? The New System Programming Language Aiming to Rival Rust
Python Programming Learning Circle
Python Programming Learning Circle
Apr 10, 2023 · Fundamentals

Common Python Design Questions and Explanations

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.

Data StructuresFAQLanguage Design
0 likes · 27 min read
Common Python Design Questions and Explanations
AI Cyberspace
AI Cyberspace
Feb 23, 2023 · Fundamentals

From ALGOL to C: The Epic Journey That Shaped Modern Computing

This article traces the evolution of the C programming language from its roots in ALGOL 60 through CPL, BCPL, and B, detailing how Ken Thompson and Dennis Ritchie created C, its standard versions, key features, advantages, disadvantages, and its lasting impact on modern software development.

C languageLanguage DesignSoftware Engineering
0 likes · 18 min read
From ALGOL to C: The Epic Journey That Shaped Modern Computing
21CTO
21CTO
Nov 4, 2022 · Fundamentals

Can Google’s Carbon Become the Next Evolution After C++?

The article examines Google’s Carbon language as a modern successor to C++, discussing its goals, design principles, interoperability with existing C++ code, and how it compares to other successor languages like Rust, Kotlin, and TypeScript.

C++CarbonLanguage Design
0 likes · 8 min read
Can Google’s Carbon Become the Next Evolution After C++?
21CTO
21CTO
Oct 13, 2022 · Fundamentals

Why Rust Is Winning Over System Programmers – Pros, Cons, and Real‑World Insights

This article explores Rust's rise in systems programming, detailing its strengths such as safe concurrency, modern language design, and strong compiler feedback, while also highlighting challenges like a steep learning curve, complex async model, and low‑level memory management concerns.

ConcurrencyLanguage DesignRust
0 likes · 10 min read
Why Rust Is Winning Over System Programmers – Pros, Cons, and Real‑World Insights
IT Services Circle
IT Services Circle
Sep 20, 2022 · Fundamentals

Introducing Unilang: Deepin’s New General-Purpose Programming Language

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.

Language DesignQtUnilang
0 likes · 4 min read
Introducing Unilang: Deepin’s New General-Purpose Programming Language
IT Services Circle
IT Services Circle
Aug 1, 2022 · Fundamentals

Google Announces Carbon: An Experimental Successor to C++

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++.

C++ successorCarbonD language
0 likes · 8 min read
Google Announces Carbon: An Experimental Successor to C++
21CTO
21CTO
Jul 20, 2022 · Fundamentals

What Is Google’s New Carbon Language and Why It Could Replace C++?

Google’s newly unveiled Carbon language, positioned as an experimental successor to C++, promises modern language features, seamless C++ interoperability, and a path for developers to write performance‑critical software while avoiding many of Rust’s ownership complexities.

C interoperabilityCarbonGoogle
0 likes · 5 min read
What Is Google’s New Carbon Language and Why It Could Replace C++?
21CTO
21CTO
Mar 24, 2022 · Fundamentals

Discover 5 Quirky New Programming Languages Shaking Up Development

This article introduces five emerging programming languages—Bhai-lang, Peregrine, Flix, Skip, and PolyCoder—detailing their origins, unique syntax rules, core features, and where to find their source code or playgrounds for developers seeking fresh, experimental tools.

AILanguage Designnew languages
0 likes · 9 min read
Discover 5 Quirky New Programming Languages Shaking Up Development
Taobao Frontend Technology
Taobao Frontend Technology
Feb 10, 2022 · Fundamentals

Why JavaScript’s split Loses Data and How the Reversible String Split Proposal Fixes It

The article explains the recent TC39 progress of the reversible‑string‑split proposal, outlines the criteria for advancing to Stage 1, compares JavaScript’s split behavior with other languages, and describes the new splitN method that restores reversibility while preserving existing split semantics.

JavaScriptLanguage DesignReversible
0 likes · 6 min read
Why JavaScript’s split Loses Data and How the Reversible String Split Proposal Fixes It
MaGe Linux Operations
MaGe Linux Operations
Oct 20, 2021 · Fundamentals

Why Rob Pike Opposes Adding Generics to Go 1.18’s Standard Library

Rob Pike, one of Go’s creators, opened a GitHub issue urging the community not to add generics to the Go 1.18 standard library, citing the massive scope of changes and a lack of practical experience, and recommending thorough testing in external libraries before any core updates.

GoLanguage DesignRob Pike
0 likes · 4 min read
Why Rob Pike Opposes Adding Generics to Go 1.18’s Standard Library
21CTO
21CTO
May 28, 2021 · Fundamentals

Will Python 4 Ever Arrive? Guido van Rossum Explains Why It Might Not

Guido van Rossum, the creator of Python, reveals in a recent interview that a Python 4.0 is unlikely, explaining the team’s focus on incremental improvements through versions 3.9 to 3.13, performance boosts, type‑hint evolution, and the challenges of maintaining C compatibility, while also sharing his views on other languages like Rust, Go, and TypeScript.

Guido van RossumLanguage DesignPerformance
0 likes · 6 min read
Will Python 4 Ever Arrive? Guido van Rossum Explains Why It Might Not
Python Programming Learning Circle
Python Programming Learning Circle
Dec 1, 2020 · Fundamentals

The Origin and Evolution of Python: From ABC to a Modern Programming Language

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.

Language DesignProgramming Languagecommunity
0 likes · 13 min read
The Origin and Evolution of Python: From ABC to a Modern Programming Language
High Availability Architecture
High Availability Architecture
Nov 12, 2020 · Fundamentals

A Tour of Metaprogramming Models for Generics

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.

Language DesignType Erasuremetaprogramming
0 likes · 23 min read
A Tour of Metaprogramming Models for Generics
Python Programming Learning Circle
Python Programming Learning Circle
May 13, 2020 · Fundamentals

Why Explicit self Must Remain in Python

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.

Language DesignPythondecorators
0 likes · 8 min read
Why Explicit self Must Remain in Python
Alibaba Cloud Native
Alibaba Cloud Native
Dec 18, 2019 · Backend Development

Why Go (Golang) Really Matters for Modern Server Development – A Complete Guide Overview

This article provides a comprehensive overview of Go, covering its naming history, reasons to choose it for server development, key milestones, garbage collection, error handling, module system, concurrency primitives, context management, engineering practices, and the upcoming Go2 evolution, while highlighting its relevance to cloud-native backend engineering.

GoLanguage DesignModules
0 likes · 15 min read
Why Go (Golang) Really Matters for Modern Server Development – A Complete Guide Overview
21CTO
21CTO
Nov 30, 2018 · Fundamentals

Go 2.0 Is Coming: Inside the New Proposal Evaluation Process

After five years of dormancy, Go 2.0 is finally arriving, and the Go team has unveiled a community‑driven proposal evaluation process that outlines how selected language and library changes—such as generics, error handling, Unicode identifiers, and binary literals—will be reviewed, implemented, and potentially released.

Go 2Language Designerror handling
0 likes · 9 min read
Go 2.0 Is Coming: Inside the New Proposal Evaluation Process
ITPUB
ITPUB
May 8, 2018 · Fundamentals

How Python Was Born: From ABC to a Global Powerhouse

This article traces Python's evolution from Guido van Rossum's early frustrations with C and shell scripting, through the influence and shortcomings of the ABC language, to the creation of Python in 1989 and its rapid growth driven by extensibility, community collaboration, and open‑source momentum.

Guido van RossumLanguage DesignProgramming Language History
0 likes · 14 min read
How Python Was Born: From ABC to a Global Powerhouse
ITPUB
ITPUB
Oct 16, 2017 · Backend Development

Why PHP Is Often Called the Worst Mainstream Language

The article examines why PHP is often labeled the worst mainstream language, highlighting its chaotic function naming, inconsistent APIs, lack of async I/O and multithreading, historical design flaws, community attitudes, and recent improvements like PHP 7, while acknowledging its early deployment advantages.

Language DesignPHPPerformance
0 likes · 9 min read
Why PHP Is Often Called the Worst Mainstream Language
Architecture Digest
Architecture Digest
Oct 31, 2016 · Fundamentals

One Week with Elixir – Language Design Reflections

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.

ElixirLanguage DesignPipe Operator
0 likes · 21 min read
One Week with Elixir – Language Design Reflections
ITPUB
ITPUB
Jun 2, 2016 · Fundamentals

Why Do Languages Keep Null? Exploring the Design Trade‑offs Behind Null References

The article examines why major languages like Java and C# still include null references, presenting expert insights from Eric Lippert and others on the complex trade‑offs—such as orthogonality, compatibility, interop, performance, and semantic consistency—that influence language designers despite known pitfalls.

C#JavaLanguage Design
0 likes · 7 min read
Why Do Languages Keep Null? Exploring the Design Trade‑offs Behind Null References
Qunar Tech Salon
Qunar Tech Salon
Dec 30, 2015 · Fundamentals

Insights from Language Creators: The Future of Programming Languages

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.

Language Designinterviewsprogramming languages
0 likes · 7 min read
Insights from Language Creators: The Future of Programming Languages
21CTO
21CTO
Sep 10, 2015 · Fundamentals

Why Erlang’s BEAM VM Is Unique: Garbage Collection and Async IO

Eric Merritt explains how Erlang’s BEAM VM differs from other VMs with its actor‑based, per‑process garbage collection and efficient asynchronous I/O, discusses the motivations behind Joxa, offers a balanced view on Elixir, explores language laziness, type‑system considerations, and mentions emerging technologies like micro‑kernels and Nix.

BEAMLanguage DesignVM
0 likes · 5 min read
Why Erlang’s BEAM VM Is Unique: Garbage Collection and Async IO
Baidu Tech Salon
Baidu Tech Salon
Jan 15, 2015 · Fundamentals

How Enhanced Generics and Value Types Will Reshape Java’s Type System

The article examines Project Valhalla’s two major prototypes—Enhanced Generics and Value Types—explaining their design goals, runtime specialization, type‑system challenges, and the extensive work still needed before they become part of a future Java release.

JavaLanguage DesignProject Valhalla
0 likes · 5 min read
How Enhanced Generics and Value Types Will Reshape Java’s Type System
Baidu Tech Salon
Baidu Tech Salon
May 22, 2014 · Fundamentals

Reflections on Clojure: Design, Simplicity, and Development Flow

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.

ClojureLanguage DesignSoftware Engineering
0 likes · 8 min read
Reflections on Clojure: Design, Simplicity, and Development Flow