Tagged articles
static typing
51 articles · Page 1 of 1

ITPUBAug 1, 2026 · Industry Insights
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.
dynamic typinglanguage designperformance vs safety
0 likes · 13 min read


21CTOJun 20, 2026 · Backend Development
The article walks Ruby and Rails developers through why Go’s static typing, explicit error handling, lightweight goroutines, and single‑binary deployment make it a powerful tool for performance‑critical services while recommending Rails for main‑line web development.
GoLanguage comparisonRuby
0 likes · 6 min read

The article explains why Python’s interpreted nature limits performance, introduces MIT’s Codon AOT compiler that translates Python to native machine code, shows benchmark comparisons (e.g., fib(40) runs in 0.28 s vs 18 s), discusses its static‑type checking, lack of GIL, compatibility trade‑offs, and provides installation and usage instructions.
AOT CompilationCodonPython
0 likes · 8 min read


TonyBaiMar 9, 2026 · Industry Insights
A quantitative benchmark by Ruby core contributor Yusuke Endoh uses Claude Code (Opus 4.6) to implement a mini‑Git across 13 programming languages, revealing that dynamic languages like Ruby, Python and JavaScript dominate AI coding speed and cost, while Go lands in a solid second tier with perfect reliability.
AI CodingClaude CodeGo
0 likes · 13 min read

This article explains ArkTS's strict type restrictions, its use of ESObject for unknown JS types, special limits on interfaces, classes, and decorators, as well as its memory model, closure rules, and the differences between Record and Map containers, highlighting how these design choices improve compilation and runtime efficiency.
AOTArkTSConcurrency
0 likes · 7 min read

This article explains how to apply a series of inline optimization strategies—static typing, function inlining, efficient array and string handling, loop refinements, and Opcache preloading—to dramatically improve PHP execution speed and bring its performance close to that of compiled C code.
InlineOPcacheOptimization
0 likes · 8 min read

This comprehensive guide explains why Python type annotations act like a safety net for your code, covering their benefits, basic and advanced syntax, static analysis with mypy, IDE integration, best‑practice strategies, and how to adopt them in existing projects for improved reliability and collaboration.
Best PracticesIDE integrationPython
0 likes · 15 min read

This article explains why many large‑scale frontend projects are switching from JavaScript to TypeScript, highlighting how static typing, early error detection, type inference, better team collaboration, and IDE support improve code safety, development efficiency, and overall developer experience.
IDE integrationJavaScriptTypeScript
0 likes · 7 min read

Python 3.12 introduces PEP‑695, a new generic syntax that streamlines type annotations by allowing direct use of type parameters without extra imports, enabling clearer, more concise code for functions and classes, and aligning Python’s typing capabilities with modern programming languages.
GenericsPEP-695Python
0 likes · 6 min read

This article explains why adding type hints to Python code—despite increasing line count—enhances readability, enables early error detection with IDEs and static checkers, improves maintenance, and ultimately makes development more efficient and reliable.
IDEPythoncode quality
0 likes · 8 min read

This article explains Go’s static type system, introduces custom types and interface types, demonstrates how empty interfaces work, and shows how the reflect package can inspect and modify values at runtime, including struct fields, using concrete code examples.
Reflectioninterfacesprogramming
0 likes · 13 min read

This article introduces Zephir, an open‑source language that lets PHP developers create compiled, type‑safe extensions, compares it with PHP and C, explains static versus dynamic typing, and outlines its compilation workflow and performance considerations.
PHP extensionsZephirlanguage design
0 likes · 8 min read

Mojo, a new language from Modular, combines Python-like ease with C++-level speed through static typing, MLIR integration, and hardware acceleration, enabling AI developers to write high-performance models without learning complex low-level languages, and its open-source release promises rapid ecosystem growth.
AI developmentMLIRMojo
0 likes · 6 min read

This comprehensive guide walks you through initializing a TypeScript project, explains core and advanced type features, shows how to integrate third‑party libraries, and provides real‑world examples for React and Node.js, while offering best‑practice tips to boost code quality and performance.
Best PracticesGenericsNode.js
0 likes · 11 min read

This article examines why TypeScript has become essential for complex web applications, outlining its benefits such as improved maintainability and early error detection, the challenges developers face, and the language's future impact on the web development ecosystem.
JavaScriptTypeScriptfrontend
0 likes · 7 min read


21CTOJun 17, 2024 · Fundamentals
At PyCon 2024, experts demonstrated how static typing, Cython compilation, static‑linked C extensions, and sub‑interpreter architectures can dramatically accelerate Python code, reduce runtime overhead, and mitigate GIL limitations, offering practical pathways for faster, more scalable Python applications.
CythonGILOptimization
0 likes · 11 min read


21CTOJun 12, 2024 · Frontend Development
This article explains the differences between TypeScript’s any, unknown, and never types, shows when each should be used, and provides practical code examples to help developers write safer and more flexible TypeScript code.
TypeScriptanynever
0 likes · 9 min read

This article introduces Python type annotations, covering basic variable and function annotations, type aliases, custom classes, advanced constructs like Union and Optional, class and attribute annotations, protocols, type ignoring, and popular static‑type checking tools, illustrating how they improve code readability and reliability.
best-practicesstatic typingtype-annotations
0 likes · 6 min read

This article explains how Go's generics feature improves type safety by enabling compile‑time checks, reducing the need for type assertions, and making code clearer and more maintainable, illustrated with concrete code examples and comparisons.
GenericsGoprogramming
0 likes · 5 min read

This article explains Go's static type system, introduces custom types and interface definitions, demonstrates how interfaces store concrete values, and shows how the reflect package can inspect and modify values, covering empty interfaces, type assertions, and mutable reflect values with practical code examples.
Reflectionempty interfaceinterfaces
0 likes · 14 min read

This article explains Python type hints, covering their syntax, benefits for readability and debugging, advanced usage with the typing module, and practical code examples that help developers write more robust and maintainable Python applications.
Code ReadabilityPythonmypy
0 likes · 5 min read

This article explains why TypeScript has become a must‑have tool for front‑end engineers, covering its static type system, improved code readability and maintainability, setup steps, configuration options, special types, generics, tooling integrations and best‑practice utilities to help developers write safer, more robust JavaScript applications.
Frontend DevelopmentGenericsTypeScript
0 likes · 30 min read

This article explains the business reasons for introducing TypeScript in a B‑end frontend product, analyzes common runtime type errors, compares TypeScript with plain JavaScript, evaluates costs, risks and benefits, and outlines a practical implementation roadmap.
TypeScriptcode qualitycost benefit
0 likes · 8 min read

The article explains how Python now exists as both a typed and an untyped language, discusses the distinction between infrastructure and business‑logic code, and argues that embracing both approaches—using type hints for business logic while keeping infrastructure code flexible—benefits developers and the community.
Business LogicPythoninfrastructure code
0 likes · 7 min read

This guide explains why large JavaScript codebases are moved to TypeScript, compares mixed and full migration strategies, and provides a step‑by‑step tutorial on using Airbnb's ts‑migrate tool, its plugins, and related commands to automate the conversion.
JavaScriptTypeScriptcode migration
0 likes · 10 min read


21CTOApr 2, 2023 · Backend Development
Codon, a new Python compiler introduced by IEEE Spectrum, uses static type checking to eliminate runtime overhead, delivering C++‑level performance—10 to 100 times faster than CPython—while targeting genomics, big‑data, and other compute‑intensive domains, though it sacrifices some dynamic Python features.
CodonPythongenomics
0 likes · 7 min read


ByteFEFeb 20, 2023 · Fundamentals
This article explains how TypeScript’s type system works, why the any type is unsafe, how to convert any to the top‑level unknown type for safer code, and demonstrates practical patterns such as subtype reasoning, nominal vs structural typing, and type‑safe wrappers using runtime checks.
Type SystemTypeScriptany
0 likes · 25 min read

This comprehensive guide explains the concept of type gymnastics, explores TypeScript's type system, demonstrates key type operations and patterns, and walks through practical implementations of advanced utility types and a custom ParseQueryString type.
TypeScriptadvanced typesgeneric programming
0 likes · 16 min read


21CTOApr 26, 2022 · Fundamentals
Hare is a newly announced system programming language that aims to replace C with a simple, stable, and robust design, offering static typing, manual memory management, a batteries‑included standard library, and support for multiple architectures and operating systems.
C alternativeHare languageSystem Programming
0 likes · 6 min read

This article examines the limitations of ESLint for error detection, the challenges of a non‑smooth coding experience, and how adopting TypeScript can improve productivity, type safety, and tooling while weighing its learning curve and ecosystem alternatives.
ESLintFrontend DevelopmentIDE
0 likes · 11 min read

This article explains what nominal type systems are, why TypeScript uses a structural system, and presents six community‑driven methods—private‑property classes, literal types, enum intersections, unique symbols, brand interfaces, and brand type intersections—to achieve nominal typing in TypeScript with code examples and pros‑cons analysis.
Nominal TypesType Systemprogramming
0 likes · 13 min read


21CTOAug 23, 2021 · Fundamentals
In this interview, Java creator James Gosling discusses the language’s history, the trade‑offs of breaking changes, the benefits of static typing, JIT performance, async/await, pattern matching, and the broader challenges of modern programming language ecosystems.
JITJavalanguage design
0 likes · 23 min read

This article explains Python's static type support, reviews major type‑checking tools such as mypy, pytype, pyre, and pyright, demonstrates practical usage with code examples, and shows how these techniques improve IDE assistance, refactoring safety, and code intelligence in real projects.
ImportLabmypypyright
0 likes · 16 min read

TypeScript’s rapid rise stems from its incremental type system, strategic collaborations, and tooling ecosystem—including DefinitelyTyped, JSX support, and integration with Babel and modern build tools—while its future may involve native type annotations in JavaScript and continued community‑driven evolution.
JavaScriptTypeScriptfrontend
0 likes · 17 min read

This article examines why dynamic‑typed languages such as Perl, PHP, Ruby, and Python are generally slower than compiled or statically‑typed languages, discusses static versus dynamic typing, and emphasizes that performance issues often stem from implementation choices rather than the languages themselves.
PHPPythonRuby
0 likes · 6 min read


政采云技术Jan 5, 2021 · Frontend Development
This article explains why TypeScript was created to overcome JavaScript's shortcomings, compares the two languages, and details essential TypeScript features such as static typing, enums, interfaces, classes, generics, type guards, and practical coding tips to help developers write clean, robust, and maintainable front‑end code.
GenericsTypeScriptstatic typing
0 likes · 16 min read

This article introduces Python type annotations, explains why they improve code consistency and readability in collaborative projects, demonstrates simple and advanced usage with code examples and screenshots, and encourages developers to adopt static typing for better maintenance and fewer runtime errors.
Best Practicescode qualityprogramming
0 likes · 5 min read

This article examines TypeScript—a Microsoft‑backed JavaScript superset—detailing its static‑typing benefits, improved readability, bug reduction, and active ecosystem while also discussing learning costs, slower development speed, library compatibility issues, and the necessity of compilation, helping developers decide whether to adopt it.
Code MaintainabilityFrontend DevelopmentJavaScript
0 likes · 11 min read

An experienced Python engineer shares three indispensable tools—Kite for AI‑powered code completion, Mypy for static type checking, and SonarLint for real‑time linting—explaining their benefits, usage examples, and how they improve coding speed, reliability, and error detection.
Pythoncode completiondevelopment-tools
0 likes · 8 min read

An in‑depth look at TypeScript’s evolution, its core advantages over plain JavaScript, real‑world adoption statistics, and practical guidance for teams on when and how to adopt, migrate, and leverage its tooling to boost productivity, safety, and maintainability in front‑end projects.
ProductivityTypeScriptmigration
0 likes · 17 min read


WecTeamDec 31, 2019 · Frontend Development
This article chronicles a developer's transition from plain JavaScript to TypeScript, illustrating how static typing improves code robustness, debugging, and documentation while also discussing migration steps, common pitfalls, and practical examples across frontend projects.
JavaScriptTypeScriptVue
0 likes · 19 min read

This article recounts Dropbox’s multi‑year effort to adopt static type checking with mypy across millions of Python lines, detailing why type checking is essential for large projects, the performance challenges encountered, and the engineering solutions—including incremental checks, a daemon, and a custom compiler—that enabled successful migration.
dropboxlarge codebasemypy
0 likes · 18 min read

This article compares Go and Node.js from a Node.js developer’s viewpoint, highlighting Go’s static typing, compiled nature, enforced formatting, built‑in libraries, package management, and tooling, and provides resources for learning Go effectively.
Go modulesNode.jscompiled language
0 likes · 7 min read

The article discusses how type mismatches cause runtime errors in JavaScript projects, explains why static typing with TypeScript can catch these issues at compile time, and argues that rigorous type declarations are essential for building and maintaining large‑scale frontend applications.
Code MaintainabilityJavaScriptTypeScript
0 likes · 6 min read

This article explains how Python's dynamic typing can hide bugs when variables change type, demonstrates the pitfalls with examples, and introduces three solutions—Type Hints, Variable Annotations, and docstrings—to make code clearer and safer.
IDEmypystatic typing
0 likes · 6 min read


21CTOMay 22, 2018 · Fundamentals
Drawing from years of experience at startups, Twitter, and Google, the author contrasts dynamic languages like Ruby and JavaScript with static languages such as Java and Haskell, highlighting how type systems affect readability, tooling, and code maintenance in large‑scale software development.
dynamic typingprogramming languagessoftware engineering
0 likes · 8 min read


21CTOAug 29, 2017 · Backend Development
This article explains how Go’s compiled single‑binary output, static type system, superior performance, built‑in libraries, and strong IDE support helped a micro‑service platform replace a Python/Django stack, cutting code by 64% and boosting backend speed by up to 30%.
GoIDE Supportbackend development
0 likes · 7 min read

This article provides a comprehensive overview of Kotlin, covering its basic syntax, key language features such as static typing, type inference, functional and object‑oriented support, its design philosophy of practicality, conciseness and safety, seamless Java interoperability, and its applications in server‑side and Android development together with tooling and compilation details.
AndroidKotlinProgramming Language
0 likes · 26 min read

This article explains how Python’s flexible typing can introduce subtle bugs, demonstrates the pitfalls with examples, and introduces Type Hints, Variable Annotations, docstrings, and Java‑Bean‑style solutions—including static checking with mypy—to improve code readability and reliability.
code-qualitymypystatic typing
0 likes · 5 min read

This article explains how TypeScript extends JavaScript with static typing, improves code safety, integrates with tools like Webpack and TSLint, and provides practical setup, compilation, and type‑definition guidance for building robust front‑end applications.
TSCTSLintTypeScript
0 likes · 10 min read

This article introduces TypeScript as a Microsoft‑created superset of JavaScript that adds static typing, explains its type‑system fundamentals, compares it with lint tools, showcases practical code examples—including interfaces, implementations, and function overloads—and demonstrates how static analysis can catch bugs early and improve documentation for both front‑end and Node.js projects.
JavaScriptTypeScriptinterfaces
0 likes · 14 min read
