Developers' Dream Features: Bridging Language Gaps and Customizing Syntax

Developers frequently choose a pair of programming languages that complement each other, leveraging their individual strengths across different aspects of software development. This often leads to interesting discussions about which features from one language would enhance the other, and how these choices impact project selection.

Popular Pairings and Feature Wishlists

Several common pairings emerged, showcasing a range of development philosophies:

• Lisp and Python: Lisp, particularly Common Lisp, is often lauded for its powerful macro capabilities and s-expression-based syntax, which allows for highly programmable editing environments. Python, on the other hand, is cherished for its "batteries included" standard library, offering a vast array of readily available modules. A recurring desire is for Lisp to have a more comprehensive standard library akin to Python's, reducing reliance on external package managers for fundamental tasks. Conversely, some Python users expressed a desire for s-expressions to improve code manipulation and consistency, advocating for a popular Lisp-like language with a rich ecosystem.
• C and PHP: This pairing highlights the contrast between low-level control and high-level scripting. C developers sometimes wish for PHP's convenient "associative array as junk drawer" data structure, simplifying data handling. PHP, designed for short-lived web requests, could benefit from better support for long-running tasks, which C excels at.
• J and Lisp: J is admired for its concise, powerful array programming capabilities, ideal for "number crunching." Lisp, in this context, serves as the general-purpose language for everything else. The wish here isn't necessarily to merge features but to see J-like computational tools, with elegant syntax, integrated into other languages similar to how regular expressions are.
• TypeScript and Ruby: This duo represents the static vs. dynamic typing debate. Ruby developers desire TypeScript's "elegant typings" native to the language for improved code robustness and maintainability, while TypeScript users might seek Ruby's "syntax flexibility" for a more fluid coding experience.
• Python and C++: This pairing is classic for performance versus development speed. C++ users might appreciate Python's significant indentation for visual structure, while Python users often wish for the performance and compile-time guarantees of C++. The choice between them typically boils down to "ease of coding" for Python versus "performance" for C++.
• JavaScript and Python: These two popular dynamic languages bring their own sets of ergonomic preferences. Wishes include JavaScript's looser type handling and more concise dictionary syntax (e.g., obj.prop instead of obj['prop']) for Python. Conversely, Python's comprehensions and less verbose syntax are desired in JavaScript.

The Quest for Ideal Syntax and Language Ergonomics

A significant portion of the discussion revolved around syntax and developer ergonomics. The detailed proposal for "Pith," a hypothetical language or preprocessor, exemplifies this quest. "Pith" aims to streamline Python and JavaScript syntax by:

• Removing colons and parentheses from control flow statements (e.g., if bool: becomes if bool).
• Enabling dot-access for dictionary properties (e.g., a_dict.prop instead of a_dict['prop']), with optional None/undefined return for missing keys.
• Simplifying dictionary literal creation (e.g., {name: 'value'}).
• Eliminating boilerplate like if __name__ == '__main__': by automatically calling a main() function if present.
• Adopting C-style ternary operators (e.g., this ? a : b) and else if for clarity.
• Using backticks for string interpolation (e.g., `{huh}`) akin to JavaScript.
• Standardizing property access for length (e.g., a_string.length).
• Allowing function hoisting (calling functions before definition).
• Integrating multi-line comments and JS-style regex literals.

This concept of a language preprocessor that converts preferred "Pith" syntax into standard Python or JavaScript highlights a powerful approach to customizing developer experience without reinventing entire languages. It underscores the desire for developers to shape their tools to fit their unique preferences and workflow, rather than being strictly bound by original design choices.

Decision-Making for New Projects

The choice between favorite languages for a new project is often pragmatic, driven by:

• Problem Domain: Specialization for numerical tasks (J), web development (PHP, Smalltalk's Seaside), or client-side interfaces (Newspeak).
• Performance Requirements: C++ for speed-critical applications versus Python for rapid prototyping.
• Collaboration and Ecosystem: Python's widespread adoption and extensive libraries make it suitable for collaborative projects, while more niche languages like Common Lisp might be preferred for personal exploration.
• Existing Constraints: Often, the language choice is pre-determined by team standards, existing infrastructure, or client requirements.

Ultimately, developers seek languages that offer a robust "batteries included" ecosystem, flexible and intuitive syntax, and powerful tooling, all while catering to specific project needs and individual preferences.