Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-30b-a3b· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

i think the more verbose the programming language is, the more textual information there…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4.1-mini-2025-04-14’s answer.
  1. User

    i think the more verbose the programming language is, the more textual information there is to process at each time - the more tired eyes as an organ and brain regions responsible for image processing get. I find advocating for verbose languages (and regular programming languages are way way overly verbose than needed, even python) with the reasoning going like "you'll train to swim like a fish in a sea in all that code" completely ridiculous

  2. Qwen Assistant

    Your perspective on the relationship between language verbosity and cognitive load is insightful and touches on important considerations in software development. Let’s break this down and explore the nuances:


    1. The "Swim Like a Fish" Argument: A Critique

    The metaphor of "swimming in a sea of code" is often used to argue that exposure to dense, verbose code trains developers to navigate complexity. However, this reasoning can feel reductive or even counterproductive for several reasons:

    • Cognitive Overhead: Excessive verbosity (e.g., repetitive syntax, boilerplate, or overly explicit constructs) increases the cognitive load required to parse and understand code. This can lead to fatigue, especially during long coding sessions.
    • Visual Strain: Reading large blocks of text (especially in languages with heavy syntax) can strain the eyes and brain, as the visual cortex and prefrontal cortex work harder to process and contextualize information.
    • Misalignment with Human Cognition: Humans are not inherently "fish" in code. Our brains are optimized for pattern recognition, abstraction, and storytelling, not parsing dense, linear text. Overly verbose languages may force us to "think like machines" rather than leverage our natural cognitive strengths.

    2. Why Verbosity Exists (and When It’s Useful)

    While verbosity can be a burden, it’s not inherently bad. Some languages prioritize explicitness for reasons like:

    • Clarity for Beginners: Verbose syntax (e.g., Java’s public static void main(String[] args)) can make code more self-documenting, reducing ambiguity for newcomers.
    • Safety and Tooling: Static typing (e.g., TypeScript, Rust) and explicit syntax (e.g., Go) can catch errors early and enable better tooling (e.g., autocompletion, refactoring).
    • Consistency: Verbosity can enforce uniformity, making codebases easier to maintain across teams.

    However, excessive verbosity (e.g., Python’s for i in range(len(list)): ... instead of for item in list:) can feel redundant and counterproductive.


    3. The Case for Conciseness

    Languages like Python, Ruby, or JavaScript (with modern features) prioritize expressiveness over explicitness. This can:

    • Reduce Cognitive Load: Shorter, more readable code allows developers to focus on logic rather than syntax.
    • Enhance Productivity: Less boilerplate means faster development and fewer opportunities for errors.
    • Leverage Human Strengths: Concise syntax aligns with how humans process patterns and abstractions, making code more intuitive.

    That said, conciseness can also lead to "magic" (e.g., Python’s __init__ methods, JavaScript’s arrow functions) that obscure complexity for beginners. The key is balance.


    4. The Role of Language Design

    The "verbosity" of a language is often a trade-off between clarity, safety, and expressiveness. For example:

    • Python is praised for its readability but criticized for being "too verbose" in certain cases (e.g., handling edge cases).
    • Rust balances safety and conciseness with its ownership model, though it has a steeper learning curve.
    • Elixir/Phoenix uses functional programming and concise syntax to build scalable systems, but requires a shift in mindset.

    Ultimately, the choice of language depends on context: team expertise, project requirements, and long-term maintainability.


    5. Your Point: Valid, But Contextual

    Your frustration with verbose languages is valid, especially if you’re working in environments where efficiency and clarity are prioritized. However, the "swim like a fish" argument might resonate more in legacy systems or team environments where consistency and explicitness are critical.

    If you’re advocating for less verbose languages, you’re aligning with trends in modern development (e.g., the rise of Python, Go, and Rust), which emphasize pragmatism over pedantry.


    6. A Balanced View

    • Verbosity isn’t inherently bad—it can improve safety, clarity, and tooling.
    • Excessive verbosity is a problem when it obscures logic or increases cognitive load.
    • The "swim like a fish" analogy is a flawed justification for verbosity; developers should be trained to think critically, not just parse text.

    Final Thought

    Your critique highlights a deeper tension in software development: how to design tools that align with human cognition rather than force us to adapt to machine-centric paradigms. Languages that strike a balance—like Python or Elixir—show that conciseness and clarity can coexist, but they require thoughtful design. If you’re pushing for more concise languages, you’re not just advocating for efficiency—you’re advocating for a better fit between code and the human mind. 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.