Developing editing support for \(\mathbf{L}\)
languages in \(\mathbf{E}\) editors is complex and
time-consuming. Some languages do not provide
dedicated editors, while others offer a single
native editor. The \(\textit{language server
protocol}\) (LSP) reduces the language-editor
combinations \(\mathbf{L} \times \mathbf{E}\) to
\(\mathbf{L} + \mathbf{E}\), where a single language
server communicates with editors via LSP plugins.
However, overlapping implementations of linguistic
components remain an issue. Existing language
workbenches struggle with modularity, reusability,
and leveraging type systems for language server
generation. In this work, we propose: (i) Typelang,
a family of domain-specific languages for modular,
composable, and reusable type system implementation,
(ii) a modular language server generation process,
producing servers for languages built in a modular
workbench, (iii) the variant-oriented programming
paradigm and a cross-artifact coordination layer to
manage interdependent software variants, and (iv) an
LSP plugin generator, reducing \(\mathbf{E}\) to
\(\mathbf{1}\) by automating plugin creation for
multiple editors. To simplify editing support for
language families, each language artifact integrates
its own Typelang variant, used to generate language
servers. This reduces combinations to \(\mathbf{T}
\times \mathbf{1}\), where \(\mathbf{T} =
\mathbf{L}\) represents the number of type systems.
Further reuse of language artifacts across languages
lowers this to \(\mathbf{N} \times \mathbf{1}\),
where \(\mathbf{N} << \mathbf{T}\), representing
unique type systems. We implement Typelang in
Neverlang, generating language servers for each
artifact and LSP plugins for three editors.
Empirical evaluation shows a 93.48% reduction in
characters needed for type system implementation and
100% automation of LSP plugin generation,
significantly lowering effort for editing support in
language families, especially when artifacts are
reused.
Abstract
About Me
PhD Candidate in Computer Science at the ADAPT Lab (Università degli Studi di Milano), under the supervision of Prof. W. Cazzola. Programming Languages and Compilers enthusiast. Also, a Sound Engineer and Music Composer.
In addition to this homepage, to know more about me, I suggest you to check my GitHub profile and the Posts section of this website. Feel free to consider downloading my CV.
Personal Info
| Born in Magenta (MI), Italy on 7th of March 2000 | |
| Resident of Via F. Turati 75/F, Arluno (MI), 20004, Italy | |
| Email: | federico.bruzzone.i@gmail.com |
| Email: | federico.bruzzone@unimi.it |
| Phone: | +39 391 7369214 |
Contact Info
| GitHub: | github.com/FedericoBruzzone |
| Telegram: | @federicobruzzone |
| LinkedIn: | in/federico-bruzzone |
| Twitter: | @fedebruzzone7 |
| Reddit: | u/FedericoBruzzone |
Scientific Publications
Research Activities
I served as a Reviewer for the European Conference on Object-Oriented Programming (ECOOP 2026).
I served as a Reviewer for the Journal of Software and System Modeling (SoSyM).
I participated in the <Programming> Conference 2025, which took place in Prague, Czech Republic.
I served as a Committee Member (in Artifact Evaluation Committee) at the 18th ACM SIGPLAN International Conference on Software Language Engineering (SLE 2025). Check here for more details.
I served as a Reviewer for the Journal of Systems and Software (JSS). The review was performed for the special issue Trends in Systems and Software Product Line Engineering.
I served as a Student Volunteer at the 29th ACM SIGPLAN International Conference on Functional Programming (ICFP 2024).
Dissemination Activities
The presentation for the first MuseMI meeting of the
2025/2026 season, held in Milan.
Optimizing compilers exhibit limitations when
handling multiple recursive functions (e.g.,
Fibonacci). While single recursion is optimized via
Tail-Call Optimization into efficient
iteration, multiple recursion often forces the
compiler to retain a partial, performance-limiting
recursive structure. Analyzing the optimized LLVM IR
reveals that even state-of-the-art compilers fail to
achieve complete incrementalization for this
pattern. We argue that the automatic,
general-setting iterative transformation of multiple
recursive functions remains an unsolved and critical
challenge for compiler technology.
Abstract
The presentation for the P4 compiler in Software Defined Networking (SDN).
The presentation about my PhD project, Universal Language Server Protocol and Debugger Adapter Protocol for Modular Language Workbenches, at the University of Milan.
The presentation of my Master's Thesis, Toward a Modular Approach for Type Systems and LSP Generation, at the University of Milan.
Open Source Activities
I am the maintainer of the Tide compiler . Tide aims to be a modular and extensible framework for building compilers and language tools, prioritizing simplicity and ease of use. Region-based memory management provides a middle ground between manual memory management and automatic garbage collection, enabling efficient memory usage without the overhead of tracing GC. Research is ongoing on how to preserve separate compilation without compromising modularity or performance.
Tgt is a TUI (Terminal User Interface) client for Telegram, built using the tdlib-rs library, which provides safe and idiomatic Rust bindings to the official TDLib (Telegram Database Library) C++ library. Thanks to CI/CD pipelines, we ensure (i) that the projects build and work correctly on Linux, macOS, and Windows, (ii) automatic releases on GitHub and crates.io, and (iii) automatic documentation generation.
I am one of the 393 contributors to Rust 1.86.0. You can find the release notes here.
This PR closed the issue #1384 by generalizing the Closeness centrality to weighted networks using the Newman method. It provides both the Rust implementation and the Python bindings.
With this PR, I refactored functions to accept a single type-level constant value ty::Value instead of separate ty::Valtree and ty::Ty parameters.
With this PR, I added the TooGeneric variant to the LayoutError enum to emit the error when a type is too generic to be laid out. The Unknown variant is emitted when the layout of a type is unknown.
I am one of the 396 contributors to Rust 1.83.0. You can find the release notes here.
I am the 56th top Github contributor (for public contributions) in Italy out of 958 according to this classification.
After the study of the rustc-dev-guide, I made my first small contribution to the Rust compiler.