Record Patterns in Java 21 - A Deep Dive
Dive into Java 21's Record Pattern feature through a comprehensive exploration of its functionality, error scenarios, and practical applications for enhanced programming efficiency.
Implementing Domain-Specific Languages with Java Imports in TypeScript - EclipseCon 2023
Discover how to develop Domain-Specific Languages in TypeScript while leveraging Java libraries, exploring integration challenges and solutions using Eclipse Langium framework for seamless development.
Profile Guided Offline Optimization of Hidden Class Graphs for JavaScript VMs in Embedded Systems
Optimize JavaScript VMs for IoT devices by reducing hidden classes, improving memory usage and execution speed through offline graph optimization and profile-guided techniques.
The 4 Horsemen of Unsoundness in Object-Oriented Languages
Explore 4 subtle issues challenging OO verification: termination, leaky partial verification, ill-founded contracts, and reduction to primitive operations.
A History of Subtyping
Explore the evolution and significance of subtyping in programming languages with Benjamin C. Pierce's comprehensive historical overview.
Layout Polymorphism: Using Static Computation for Efficient Polymorphism Over Variable Representations
Explore layout polymorphism in OCaml, enabling efficient unboxed types while preserving parametric polymorphism. Learn about type-system design and implementation challenges in managing specializations.
Is Wasm Becoming Garbage? - WebAssembly and Garbage Collection
Explore WebAssembly's new garbage collection feature, its design rationale, and implications for compilers targeting object-oriented and functional languages.
Latte: Lightweight Aliasing Tracking for Java
Explore Latte, a lightweight system for tracking aliasing and uniqueness in Java, minimizing annotations and complexity while supporting destructive reads and practical applications.
Object Capabilities - Principles and Applications
Explore object capabilities in programming languages, focusing on security, encapsulation, and access control mechanisms for robust software design.
Design Patterns in Elixir: Exploring the Gang of Four - Keynote
Explore classical design patterns in Elixir, deconstructing objects and examining their impact on large system design with José Valim's insightful analysis.
Variable Monitoring with Declarative Interfaces - Lecture
Explore a scalable framework for monitoring industrial signals using declarative APIs and builder patterns, enhancing readability and extensibility in control software.
Class Layout in C++ - Memory Structure and Compiler Optimization
Explore class layout in C++, including compiler behavior, memory representation, and performance impact. Learn key concepts with examples suitable for beginners and experienced programmers alike.
Taming Lambdas' Uniqueness in C++ - Techniques and Workarounds
Explore techniques to overcome lambda expression limitations in C++, including creating multiple lambdas of the same type and using them with standard containers while maintaining readability and performance.
New Features in Java 11 and 17 - Records and Sealed Classes
Explore key enhancements in Java 11 and 17, including HTTP client API, lambda syntax, sealed classes, and records for improved functionality and development.
The Complexity of Satisfiable CSPs
Explore the complexity of satisfiable CSPs, examining dichotomy theorems and their connections to Fourier analysis, product testing, and linearity testing in this mathematical lecture.
From Diamonds to Mixins: Demystifying Multiple Inheritance in Python
Explore Python's multiple inheritance, from the diamond problem to mixins. Understand Method Resolution Order, super() function, and real-world applications. Learn effective implementation and alternatives.
Immutable Classes in Java Libraries - Are They Ready?
Explore immutable class design in Java, dispelling myths and demonstrating compatibility with popular libraries for persistence, serialization, and mocking.
Data-Oriented Programming in Java - Recent Language Additions and Principles
Explore data-oriented programming in Java, its principles, and recent language additions like records and pattern matching. Convert an OOP application to showcase advantages in microservices.
Are Immortal Libraries Ready for Immutable Classes?
Explore the concept of immortal libraries and their compatibility with immutable classes in modern software development.
Side Effects: The Hidden Complexity in Software Development
Explore how side effects impact software complexity and learn industry solutions. Discover connections between microservices, immutable data, functional languages, and event streaming in tackling this fundamental problem.
Inheritance in C# OOP - Part 5
Explore inheritance in C# OOP through practical examples. Learn implementation techniques, benefits, and code organization for enhanced reusability in programming.