Declare Victory with Class Macros
Explore metaprogramming in Ruby, from attr_reader to custom class macros, to simplify code and improve readability. Learn techniques for declarative programming and effective use of metaprogramming.
Monkeypatch the Planet
Explore the limits of JavaScript metaprogramming and discover innovative techniques to push boundaries, with insights on raw JS capabilities and advanced tools for extending language functionality.
JavaScript Metaprogramming - ES6 Proxy Use and Abuse
Explore ES6 Proxy's metaprogramming capabilities, from creating custom syntax to redefining undefined. Learn practical applications and creative uses in modern JavaScript development.
C++ Concepts for Developers
Explore C++20 concepts: their capabilities, limitations, and applications in improving code quality. Learn how concepts enhance type safety, metaprogramming, and design patterns in C++ development.
Compile Time Regular Expressions
Explore a novel C++20 library for compile-time regular expressions, examining implementation details, challenges, and performance comparisons with other regex engines.
Python.jl - Seamlessly Blend Python and Julia
Explore seamless Python-Julia integration, featuring demos, capabilities, challenges, and insights into extreme DSL embedding in Julia.
Deriving as a Library - Type Classes and Language Features
Explore implementing type class deriving as a library, enhancing Haskell's extensibility without language extensions.
Those Annotations Can Have Things Other Than Typing - Exploring Function Annotations Beyond Type Hints
Explore innovative uses of Python function annotations beyond typing, uncovering potential applications and their implications for code design and functionality.
Rembus.jl: A Pub/Sub and Remote Procedure Call Middleware for Microservices
Explore Rembus.jl, a middleware for distributed systems. Learn to implement pub/sub and RPC architectures, exchange data between languages, and leverage fault-tolerance features.
Syntax Tree: A Toolkit for Interacting with Ruby Parse Trees
Explore Syntax Tree, a powerful toolkit for analyzing and manipulating Ruby code, and discover its potential applications and future possibilities.
Interfaces.jl: Base and Package Interface Tests for Your Objects
Learn to define and test strict interfaces in Julia using Interfaces.jl. Explore run-time and compile-time constraints, optional components, and traits for improved package interoperability and robust object behavior.
What's the Plan? Task Planning for Robots - JuliaCon 2024
Explore task planning for robots using Julia's features to efficiently handle complex knowledge bases and action sequences in goal-oriented scenarios.
Adventures in Julia IR - Plundering Core.Compiler
Explore Julia's typed intermediate representation (IR) and learn to implement custom optimization passes, extending compiler capabilities beyond conventional metaprogramming techniques.
JavaScript Metaprogramming
Explore JavaScript metaprogramming with ES6's Symbol, Reflect, and Proxy types. Learn practical applications and how these features drive modern language capabilities.
SPy - Static Python Language: Fast as C, Pythonic as Python
Explore SPy, a statically typed Python variant aiming for C-like performance while maintaining Pythonic style. Learn about its design, features, and current status.
Metaprogramming with JavaParser
Explore metaprogramming in Java using JavaParser, focusing on code generation techniques and applications in projects like Drools, with insights on avoiding reflection in Graal VM environments.
SPy: Static Python Language - Fast as C, Pythonic as Python
SPy: A statically typed Python variant aiming for C-like performance while preserving Pythonic feel. Leverages modern Python practices and typing for compile-time optimizations without sacrificing dynamic features.
Beyond LINQ - Using Expression Trees in .NET
Explore advanced uses of expression trees in .NET for metaprogramming, code generation, and automating tasks. Learn to scaffold data grids and web forms, improve performance, and reduce boilerplate code.
MacoCaml - Staging Composable and Compilable Macros
Explore MacoCaml, a novel approach to compile-time code generation in OCaml, combining macros with phase separation and quotation-based staging. Learn about its theoretical foundation and implementation.
TypeCheck - Effortless Runtime Type Checking
Explore runtime type-checking in Elixir with TypeCheck library. Learn its benefits, implementation, and advanced features for improved code clarity and resilience.
C++ Horizons: Reflection, Pattern Matching, and Senders - Future Features
Explore upcoming C++ features: reflection/injection, pattern matching, and senders. Discover how these advancements will transform coding practices and enhance C++ capabilities.