TL;DR

JSON is a lightweight data interchange format used for data transmission between servers and web applications. Specified by Douglas Crockford in the early 2000s, JSON supports various data types and simplifies data transfer. It is human-readable, compact, and cross-platform, making JSON suitable for diverse systems.

ArjanCodes (8 mentions) highlights JSON in video titles such as "This Design Pattern Scares Me To Death" and "Stop Hardcoding Everything: Use Dependency Injection", using it as a configuration format and standard report output.

neutral

// ArjanCodes
The Specification Pattern: Bridging Ancient Logic and Modern Python Architecture
In modern software architecture, business rules often become fragmented across APIs and reports, leading to logic drift and maintenance nightmares. The Specification Design Pattern solves this by transforming messy if-statements into reusable, composable predicates. By leveraging Python's operator overloading and generics, we can turn complex logic into a dormant data structure that can even be configured via JSON, though the resulting abstraction borders on the eldritch.
4 min read
// ArjanCodes
Unearthing Structural Integrity: A Guide to Dependency Injection in Python
Are your Python classes suffocating under the weight of hardcoded dependencies? Many developers realize too late that tightly coupled code is nearly impossible to test or extend without a complete rewrite. By shifting to Dependency Injection, you can transform rigid scripts into modular systems where components are swapped as easily as artifacts in a museum display.
4 min read
// ArjanCodes
Modern SOLID Implementation: Refactoring Python for Clarity and Scale
Legacy code often resembles a crumbling ruin, but modern design principles offer a path to restoration. We examine how refactoring messy Python scripts through SOLID principles can transform rigid systems into modular masterpieces. Whether you prefer class-based structures or lean functional approaches, these techniques ensure your software survives the test of time.
3 min read
// ArjanCodes
Beyond Error Checking: The Architectural Power of Python Type Hints
Are your Python type hints merely documentation, or are they actively improving your architecture? Most developers use types to catch bugs, but the real power lies in forcing a design shift toward contravariant inputs and covariant outputs. Discover why being generic with what you receive and specific with what you return is the secret to clean, maintainable code.
2 min read
// ArjanCodes
Ancient Architecture of Logic: A Guide to Python's Built-in Foundations
Most developers barely scratch the surface of Python's 60+ built-in functions, often reinventing the wheel with complex loops. There is a hidden architectural logic in tools like zip, map, and vars that can drastically reduce boilerplate code. This deep dive reveals how to use these native foundations to write more expressive, professional software without ever reaching for an external library.
4 min read
neutral

// ArjanCodes
Ancient Speed and Modern Simplicity: A Go and Python Comparison
The architectural debate between Python's flexibility and Go's rigorous structure is more than just syntax—it's about the longevity of your digital monuments. While Python allows for rapid, almost artistic prototyping, its dynamic nature often conceals structural weaknesses that only appear under heavy load. Go offers a different path, enforcing strict typing and explicit error handling that forces developers to confront potential failures before they happen. This shift in perspective transforms the way we build backend systems, moving away from complex class hierarchies toward lean, composed structures that scale effortlessly.
4 min read
neutral

// ArjanCodes
Beyond the Notebook: Engineering Robust Data Science Architectures
Data science projects often fail not because of poor math, but because of fragile, 'throwaway' code structures. By shifting from messy scripts to engineered pipelines, you can ensure your research survives the transition from experiment to production.
2 min read
neutral

// ArjanCodes
Architecting Ancient Connections: A Pythonic Journey Through REST and GraphQL
In the quest for efficient data transfer, developers often find themselves torn between the rigid structures of REST and the fluid queries of GraphQL. While REST offers the stability of resource-oriented endpoints, GraphQL provides a powerful query language that allows clients to fetch exactly what they need—and nothing more. This guide uncovers the implementation details of both, revealing how field resolvers can either streamline your architecture or lead you into the trap of the N+1 performance crisis.
4 min read

Often Mentioned Together

Sources

last updated Jan 23, 2026