I had been circling this decision for years, in that slow, slightly embarrassing way you circle something that would be nice to have and never quite feels urgent enough to sit down and do. This week I finally registered a domain, my first, and I was lucky enough to get the one I actually wanted: my first name, on Ireland’s country-code TLD. This site now lives at stefano.ie.

Buying the name was much easier than the version of the story I had been telling myself. I pointed it at the same GitHub Pages site that used to live only at sanelli.github.io, with a bit of help from Google Gemini on the DNS side, and both the apex and the www hostnames serve the pages the way I wanted them to. The DNS check in the GitHub repository still fails, even though the site loads; I assume GitHub is looking at one hostname while I configured the other, or both, and the checker has not caught up with that split. Either way, I am not going to lose sleep over a red mark in a settings screen.

With a bit more effort I also wired projects@stefano.ie through to my Gmail account. There are still some wrinkles, mostly mail from that address landing in spam on my side, but it is a real address on a domain that is mine, which already feels like a step forward from hiding behind a Gmail handle.

The older posts are still here, including the one about rebuilding this site. Same pages, same GitHub repository. They just have a shorter name on the door.

— Made withCursor

The only time I took AI seriously was at Politecnico di Milano, at least twenty years ago. The course was Intelligenza Artificiale. It was mostly intelligent agents, search and search algorithms (the A* algorithm, for finding solutions to problems), backtracking, logic, and inference. There was also Soft Computing: genetic algorithms, fuzzy logic, and neural networks.

I still have the book, Intelligenza Artificiale: Un approccio moderno, Volume 1, by Stuart Russell and Peter Norvig. I even remember writing some code, probably in Java, to train a neural network, or a simulation of lions and monkeys: the lions were supposed to catch the monkeys, and the monkeys were supposed to run away. I probably still have that code in my Gmail account; a classmate and I wrote it.

I did not keep up

After that I honestly did not put much effort into following AI, or LLMs. That does not mean nothing happened. In November 2022 OpenAI released ChatGPT, and I was still oblivious to what large language models could do. In my head it was something like: nice tool, but it cannot do anything I cannot do myself. That may even have been true at the time. I also thought LLMs were destined to be useless, or useful only in a very thin niche, like blockchain. For a few months everything was blockchain this and blockchain that. I have never needed to write anything with a blockchain, or use a blockchain library, and I suspect most people barely remember what they were for, even if they are probably useful in their corner.

A few years passed. The next real encounters were in the summer and autumn of 2025. The first was on holiday in Mallorca with a friend. I was mostly using Google; they preferred a conversation with ChatGPT. I was very sceptical of the answers. In my mind the model could only repeat what it had been trained on: stale at best, made up at worst. I was still not convinced.

Later that autumn, or maybe a bit earlier, coding models started showing up everywhere, and at Unity there were more and more discussions about using AI to write code, or about what AI could do for customers. A couple of people who reported to me decided to try LLMs for tests and scaffolding. I did not stop them. My line was:

If you commit that code, you are responsible for that code, no matter whether you, AI, or Stack Overflow wrote it.

I still did not trust AI to produce code I would want in production.

Then I actually used it

In 2026 I left Unity and went back to SIG. The company line on AI was simple: try it, and see if it helps with the day-to-day work. It did.

Some colleagues gave me a proper introduction to Cursor, and I realised I could save a lot of time and mental energy, especially in a legacy codebase, and spend it on the part that matters: architecture and problem solving. Day by day I got more comfortable with it. I learned the modes, Plan and Ask, when to switch models, and when to trust the model versus my own software-engineering instinct. AI can be wrong. That part did not change.

After a couple of months I wanted Cursor at home too, so I bought myself a Cursor Pro subscription and went back to Mappa. Before Cursor, a new feature could take months: not only because there is a lot of code, but because the Roslyn API is poorly documented, and writing tests that cover every case took a huge amount of energy. Since I started using Cursor on Mappa I have shipped three versions: 10.0, 10.1, and 10.2. On top of that I rebuilt this site, and in a single day, while I was also cleaning the apartment windows, I wrote a compiler and interpreter for EML.

A walk, a meal log, and a change of mind

What made me sit down and write this is something I noticed today, while complaining to myself about how hard it is to track what I eat. For my own reasons I am trying to eat a bit healthier, and a big part of that is knowing what I actually consume. I got a Fitbit Air and installed Google Health on my iPhone. Fine, except logging every meal is tedious, the app UI is confusing and overwhelming, and even the “smart” bits are frustrating. I tried to scan the barcode on a pack of mixed nuts; the portion-size screen came up in Korean, which I do not speak.

On a post-lunch walk I thought: what if I write a small program that reads a JSON file and sends a request to the Google Health API? I have had this kind of idea before. I usually get stuck, because turning it into something real means learning a pile of details: how does this API work, how does auth work, what are the valid values for these fields?

Today, after I got home from work, I opened Cursor, described what I wanted, and built a small set of tools: ask Gemini to turn a markdown log of what I ate (and maybe some photos) into JSON in the right shape, then upload it through the Google Health API. All of that in less than a couple of hours, and I was having fun doing it.

AI, used properly, is very good at removing this kind of roadblock. It brought back the fun of writing something new. The tool is called foody. Once I have used it myself for a while I will make it public and write a post about it.

So, did I change my mind?

How do I see the future of software engineering? A slightly easier job than it used to be, especially for senior engineers. AI took away a lot of the hurdles that made writing code a chore, and left more room for the part that is actually the job, and possibly the fun part: problem solving. The work will change. Being a software engineer is still a good career.

I do want to say something to junior engineers, and to people studying computer science. It is more or less what my maths teacher told me in primary school, when I was learning arithmetic: do not use a calculator. In your case: do not use AI to write the code and the projects for you. Learn to code the hard way. Sit with the problems that make you a better engineer. Use AI to check your work, or to reason with. If you skip the fundamentals, you will not get them.

I was wrong about AI.

— Made withCursor

The result is eml, an Ada compiler and interpreter built with Alire. Math goes in, a two-opcode stack IR comes out, and you can run that IR or emit JavaScript and C.

The eml function

A few months ago Andrzej Odrzywołek’s paper All elementary functions from a single operator showed up in my X feed. The claim is simple and a bit wild: one binary operator,

eml(x, y) = exp(x) − ln(y)

together with the constant 1, is enough to rebuild the usual scientific-calculator basis — arithmetic, exp and ln, trig, roots, constants like e, π, and i. Closed programs are a binary tree of identical nodes, and the grammar is just S → 1 | eml(S, S). NAND for continuous math, if you like that analogy.

For example, e = eml(1, 1), exp(x) = eml(x, 1), and ln(z) = eml(1, eml(eml(1, z), 1)). Work happens over complex numbers, principal branch.

I found that idea fascinating: most of the operations I was taught as separate buttons on a calculator can stem from one function and one number. I am also really into compilers, and this looked like a language that was still manageable while still forcing me through the basics.

Why Ada?

In theory I could have used any language I wanted. Cursor wrote the code; I steered. What I noticed along the way is that these models do their best work when they are tightly constrained, and Ada gives you a type system that can enforce some of that out of the box. I also turned on the strictest Alire switches I could: warnings as errors, style checks, contracts, every runtime check, Ada 2022.

There was a second reason. Ada is not C, Python, or JavaScript, and I wanted to see whether a less common language would give Cursor a harder time.

Why no crates?

There are no third-party Ada libraries. Tokenizers need regular expressions, so I had Cursor build a small in-repo compiler from a regex subset to an NFA. I wanted to see whether skipping packages would hurt performance. This is a simple language, but using custom automata for the tokenizers actually worked incredibly well.

Architecture

Everything funnels into one IR: a binary tree of 1 and eml(S, S). Front ends differ by format; backends only see that tree.

preproc, tokenize, and parse stop at their dump (expanded text, tokens, or a tree). compile and run continue from IR_Eml.Node. run flattens to opcodes and evaluates on a complex stack, while the JavaScript and C emitters walk the tree as nested eml(...) calls instead of flattening.

Stack semantics are two instructions: ONE pushes 1; EML pops Y then X and pushes eml(X, Y).

Actions

The executable is one binary, eml. The front end is chosen from the effective input format.

Diagnostics print as [ID] line:column description (five-digit IDs). Unused --var bindings follow --warn (default, none, or error).

Input formats

--input / -i is optional (stdin when omitted). If -i is omitted, --input-format / -if is required. When both are present, -if overrides the file extension.

Output formats

-o / --output is optional on preproc, tokenize, parse, and compile (stdout if omitted). When -o is set, the extension must match -of.

Same-format compile is rejected (eml → eml, beml → beml).

What went well

Instructing Cursor to generate the right code was fairly easy. I just had to keep the tasks bite-sized: create the tokenizer for this format, allow outputting this other format, and so on.

What took some time

When building the Ada interpreter, Cursor got stuck a few times on infinite values that show up as mid-steps. The identities are not free of ±∞ — the paper is explicit about that (ln 0 = −∞, e^(−∞) = 0) — and while Ada and IEEE-754 can live with it, getting the interpreter to live with it took a few rounds.

Also, as usual, JavaScript proved to be a poor language, or maybe I am just not good with it. Ada and the generated C both execute simple expressions such as 1 + 2 * 3, but the JavaScript backend, at least in Safari, comes back with Infinity + Infinityi, which is underwhelming. I am even using an external library for this, math.js, and I do not blame the library so much as the language.

Next

Still on the list:

• Compile to a native binary via LLVM
• Compile to CIL
• Compile to Java bytecode
• Compile to wat, and possibly to wasm
• A VS Code extension for .mxeml / .teml / .eml files

— Made withCursor

The new Travels page sits in the header next to the other media lists. Trips live in _data/travels.yml, with the same card layout, year rail, search, ratings, and month gaps you already get on books or movies. Each entry has a title, dates, a star rating when I remember one, and the places I visited, with Wikipedia links where they exist.

On top of that I added a map. Leaflet loads above the list, with a pin for every place that has coordinates in _data/travel_coords.yml. Dublin is marked as home. Older visits fade a little on the map so recent trips stand out. When you search or filter by rating, the list and the pins stay in sync.

The quiet Stats page now counts trips too, alongside the other yearly totals.

It is the same Jekyll pattern as the rest of the rebuild: YAML, Liquid, a bit of JavaScript, no new stack. I had years of trips scattered in photo folders and memory; now they have a proper home on the site.

— Made withCursor

I have been running this page on the default Minima setup for years. That setup is already more than enough: Markdown, a theme, GitHub Pages, done. I never really looked further. I also do not write Ruby, which is what Jekyll is built on, so I treated the generator as a black box and left it alone.

That was a mistake, or at least a missed chance. Once you start using data files, layouts, and a few plugins, Jekyll is a small static CMS. I was surprised how far it goes without a database or a build toolchain I would normally reach for at work.

What changed:

• The Career page is a proper CV again: roles, product shots, chips for languages and frameworks, education, awards, and links.
• Portfolio items are cards driven from YAML, with the related posts hanging off each one.
• Books, music, movies, and games moved out of hand-written tables into data files. The pages search, filter, and sort in the browser.
• Emoji prefixes are gone. A single SVG sprite covers navigation, projects, and this post.
• Dark is still the default. A footer control cycles dark, light, and system.
• The site builds with GitHub Actions on Jekyll 4, which meant I could add plugins Pages would not run on its own: a sitemap, redirects, cached includes, external links opening in a new tab, and pagination.
• There is a real /posts/ index now. The homepage only keeps the latest few.
• Yearly counts live on a quiet /stats/ page (the “Stats for nerds” link at the bottom of the home page).

None of this needed me to become a Ruby developer. Liquid, YAML, and a bit of CSS were enough. I should have opened the hood years ago. The default site was already good; the rest was sitting there waiting.

— Made withCursor

Mappa 10.2.0 expands mapping control with reference handling and compile-time cycle breaking, IQueryable projection, nested property paths, dependency-injection registrars, inaccessible-member mapping, object factories, before/after hooks, and richer enum / settings options. Benchmarks, coverage tooling, and generator performance also improve. Full changelog: v10.1.0…v10.2.0

Breaking changes

When upgrading from 10.1.0, see the upgrade guide.

Relaxed nullability matching for existing map methods

• Nested mappings may reuse an existing map method when nullability annotations differ slightly (#184, #272)
  • With #nullable enable, nested mappings may now invoke an existing map method on the mapper, a dependency, or a matching polymorphic method when the underlying types match even if nullability annotations differ.
  • Exact nullability matches are still preferred; a relaxed match is used only when no exact match exists.
  • Supported relaxations: nested needs TTarget? → may invoke a method returning TTarget; nested needs TSource → may invoke a method accepting TSource?.
  • Previously, a nullability mismatch caused the generator to skip the existing method and generate inline mapping (or select another strategy). Review nested mappings that relied on the old behaviour.

What’s new

Reference handling

• Circular reference / reference handling (#249, #307) — Reuse mapped reference-type instances for cycles and shared graphs (ReferenceReusing), limit runtime nesting (MaxRuntimeDepth), and guard generator discovery (MaxCompileTimeDepth + compile-time mapping-cycle detection). Not supported on IQueryable projection.
• Per-TTarget reference reuse and codegen polish (#320, #321, #322, #333) — Key reuse by source identity and typeof(TTarget), omit redundant AddReferencePair calls, and cache the reference-manager local.
• BreakCompileTimeCycles (#306, #311) — Optionally break compile-time mapping cycles by synthesizing private map methods; emits MP00078 when a cycle is auto-broken.

New features

• IQueryable projection (ProjectTo-style) (#245, #284) — Map methods with IQueryable<TSource> → IQueryable<TTarget> emit provider-translatable Select projections. Not compatible with Native AOT ([RequiresDynamicCode]).
• Nested (dot-separated) property paths (#120, #274, #275, #278) — Use paths such as "Address.City" on MappaUseProperty, invoke, constant, context, and ignore attributes for flattening/unflattening.
• MappaObjectFactory (#253, #291) — Construct target types via named factory methods instead of new.
• MappaBeforeMap / MappaAfterMap (#250, #281) — Invoke named hooks immediately before and after the generated root mapping body.
• MappaMustMapTargetProperty (#20, #298) — Require listed (or all) non-required target properties to be mapped on the empty-constructor path; otherwise MP00065.
• Inaccessible / private members (#254, #300) — Opt in with MappaAllowInaccessibleSourceMembers / MappaAllowInaccessibleTargetMembers to read/write private or protected members (and invoke inaccessible constructors) via UnsafeAccessor.
• Generic polymorphic type-mapping attributes (#305, #316) — Prefer MappaTypeMapping<TTarget, TSource> and MappaTypeMappingDefault<TDefault> over non-generic forms.

Dependency injection

• MappaDependencyInjection attribute (#299, #302) — Generate IServiceCollection registration methods for [Mappa] mappers; static DI mappers are skipped with MP00073.
• InjectFromAssemblies (#301, #317) — Discover [Mappa] mappers across assemblies for DI registration; Bson and Protobuf DI packages migrate to generated registrars.

MappaSettings and mapping behaviour

• DictionaryAssignment (#34, #273) — Choose indexer or Add insertion for dictionary-to-dictionary mapping.
• PreventEnumerableCount (#108, #285) — Avoid Enumerable.Count for fixed-size targets when the source length is unknown.
• CompatibleMapMethod (#13, #296) — Opt-in reuse of existing map methods when the source is a base/interface type and the method returns a compatible derived type.
• Richer enum mapping configuration (#255, #282) — Configure enum↔integral, enum↔string, and enum↔enum pairings via MappaMapEnumMember, MappaMapEnumIgnore, and MappaMapEnumDefault.
• Relaxed nullability fallback for map method matching (#184, #272) — See Breaking changes.

Projection polish

• Remove unused {MethodName}Element from IQueryable projections (#303, #304) — Stop emitting unused local helpers in projection-generated code.

Generator quality and performance

• Narrow syntax providers and honor CancellationToken (#323, #325, #335) — Attribute-driven incremental discovery via ForAttributeWithMetadataName, and cooperative cancellation on hot paths.
• Reduce ReportGenerator CRAP / cyclomatic complexity (#238, #318) — Refactor hotspot methods and enforce CRAP/CC maxima in the coverage script.
• Branch coverage improvements (#327, #336) — Targeted tests for previously uncovered generator branches; comparison-chart annotation polish.
• Bug fixes (#319, #328, #329, #330) — Null-class continue path, culture typo, and MappaContext documentation corrections.

Benchmarks and CI tooling

• Expanded benchmark suite with SVG charts (#134, #286) — Broader mapper scenarios, competitor/Mappa percentage charts, and gist/history publishing.
• Benchmark display and comparison charts (#295, #297, #309, #315) — Bogus-seeded inputs, refined TIME/MEMORY SVGs, and a winner comparison table.
• Default BenchmarkDotNet job; skip PR benchmarks (#331, #332) — Reduce flakiness and stop running/commenting benchmarks on pull requests.
• Coverage history and PR coverage comments (#250, #276, #280, #281) — PR coverage comments with drop thresholds and improved coverage-history SVGs.
• Gist update retries (#293, #294) — Idempotent history merges with retries on gist updates.

Test infrastructure

• Stronger generator syntax assertions (#277, #279, #290, #292) — Require HasNextSyntaxNode walks and full validation after HaveGeneratedSourceCode().
• Diagnostic assertion rules (#310, #313) — Require HaveDiagnostics(n) or NotHaveDiagnostics() on generator test chains.
• Dump generated sources from generator tests (#308, #312) — Persist successful generation dumps for issue reports.

Maintenance

• Update outdated NuGet package dependencies (#287, #337) — Bump Roslyn, analyzers, test packages, samples, benchmarks, and integration packages.
• Release 10.2.0 (#271, #338) — Promote version from 10.2.0-alpha.* to stable 10.2.0.

What’s next

This is a tentative and non-exhaustive list of issues that I would like to cover in the upcoming version of Mappa:

Mapping / generator features

• #334 — Inline mapping via C# interceptors
• #256 — Collection merge semantics and map into existing collections
• #251 — Conditional mapping, null substitution, and value transformers
• #248 — Generic mapping methods
• #247 — Map into existing target / merge semantics
• #246 — Reverse / bidirectional mapping
• #283 — IQueryable projection follow-ups
• #73 — Support fields, not only properties

Generator performance

• #326 — Optimize hot paths (TypeSymbolExtensions, constructor detection, attribute helpers)
• #324 — Reduce Collect() fan-out and document incremental host behavior
• #314 — Investigate Mapperly/Mapster benchmark wins and FastCollections behaviour

Diagnostics and maintainability

• #141 — Improved debug feature

Mappa 10.1.0 builds on the 10.0.0 foundation with expanded enum mapping, richer parse and format MappaSettings, identity deep-copy and collection buffer options, stronger diagnostics, safer generated code, and a migrated test stack. Documentation now includes a full feature catalog. Full changelog: v10.0.0…v10.1.0

Breaking changes

When upgrading from 10.0.0, see the upgrade guide.

MappaSettings rename

• ForceCaseInsensitivePropertyMap renamed to CaseInsensitivePropertyMap (#257, #260)
  • Update attribute usage: [MappaSettings(CaseInsensitivePropertyMap = BooleanSetting.Enable)]
  • Update .editorconfig: mappa.caseinsensitivepropertymap = enable
  • The legacy .editorconfig key mappa.forcecaseinsensitivepropertymap is no longer supported

Stricter diagnostics

Projects that previously compiled may now fail with new or tightened generator errors:

• MP00042 — ambiguous invoke-method resolution (#233, #266) — When multiple methods match [MappaInvokeMethod] or a polymorphism InvokeMethod default, the generator reports an error instead of silently selecting the first match.
• MP00038 — invalid parse style values (#231, #241) — Arbitrary integer DateTimeStyles / NumberStyles values in [MappaSettings] now produce a generator diagnostic instead of being silently decomposed into known flag bits.

What’s new

Test infrastructure

• Migrate to xUnit v3 (#119, #222) — Test projects now use xUnit v3 and Microsoft Testing Platform.
• Replace FluentAssertions with AwesomeAssertions (#208, #223) — Assertion library updated across all test projects.

New features

• IdentityMapDeepCopy setting (#14, #267) — Control shallow, deep, and nested same-type copying in identity mappings via [MappaSettings].
• EnumerableConcreteType setting (#29, #268) — Prefer T[] over List<T> when mapping to sequence-like interface targets (e.g. IEnumerable<T>).
• DateTimeStyle for parse (#214, #224) — Per-type DateTimeStyles for Parse / ParseExact on DateTime, DateOnly, and TimeOnly.
• NumberStyles for parse (#215, #226) — Per-type NumberStyles for string-to-numeric Parse conversions.
• GlobalDateTimeStyle and GlobalNumberStyle (#225, #228) — Shared parse-style defaults applied across date/time and numeric types.

Enum mapping

• Description attribute support (#15, #16, #265) — Map enums using [Description] for enum-to-string, string-to-enum, and enum-to-enum conversions.
• Case-insensitive string-to-enum (#17, #258) — Optional case-insensitive matching when parsing strings to enums.
• Numeric enum-to-enum mapping (#18, #264) — Map enums by numeric value instead of member name via EnumToEnumMapSetting.
• Partial enum-to-enum warning (MP00039) (#19, #244) — Warn when not all source enum members can be mapped to the target enum.
• CaseInsensitiveEnumMap (#15, #265) — Optional case-insensitive enum member matching.
• Rename ForceCaseInsensitivePropertyMap (#257, #260) — Setting renamed to CaseInsensitivePropertyMap; legacy .editorconfig key removed.

[MappaInvokeMethod] attribute

• Optional SourcePropertyName parameter (#67, #243) — Invoke a method with an explicit source property value instead of the full source object.
• Ambiguous invoke-method diagnostic (MP00042) (#233, #266) — Report a diagnostic when [MappaInvokeMethod] or polymorphism invoke-method resolution is ambiguous.

Diagnostics and quality

• Invalid style values (MP00038) (#231, #241) — Diagnose arbitrary integer DateTimeStyles / NumberStyles values in [MappaSettings].
• Test coverage improvements (#220, #239) — Additional generator, builder, and settings-stack tests for previously uncovered paths.
• Fix .editorconfig CurrentCulture mapping (#229, #235) — Correct global culture resolution in MappaGlobalOptions.
• Rename misleading local in CanMapStringToNumber (#234, #242) — Internal readability fix in string strategy detection.

Generated code safety

• Escape format and culture strings (#230, #236) — User-controlled format and culture strings are safely escaped in generated mapping code.
• Escape attribute string literals (#232, #237) — User-controlled literals from mapping attributes are escaped in generated code.

Documentation and samples

• Feature catalog (Documentation/features.md) (#262, #263) — New page listing all Mappa features with links to tutorial, attributes, algorithm, and samples.
• Generator algorithm documentation alignment (#227, #240) — Algorithm docs and generator README brought in line with the current implementation.
• Suppress MP00039 in EnumToEnumMapper sample (#259, #261) — Intentional partial enum mapping demonstrated with #pragma warning disable.

What’s next

This is a tentative and non-exhaustive list of issues that I would like to cover in the upcoming version of Mappa:

Mapping / generator features

• #255 — Richer enum mapping configuration
• #250 — Before / after map hooks
• #249 — Circular reference / reference handling
• #248 — Generic mapping methods
• #246 — Reverse / bidirectional mapping
• #245 — IQueryable projection (ProjectTo)
• #184 — More relaxed nullability when matching methods
• #120 — Flattening and unflattening
• #108 — Allow preventing Enumerable.Count when targeting arrays, Span, and Memory
• #73 — Support fields, not only properties
• #34 — Allow choosing .Add vs. the indexer for dictionary-to-dictionary mapping

Language / platform

• #174 — Support C# 14 extension blocks in static classes (partial classes assumed)

Diagnostics and maintainability

• #141 — Improved debug feature
• #238 — Reduce ReportGenerator CRAP score and cyclomatic complexity in Mappa.Generator

Favorite song. Una donna non può. “Forse sono pazza / Scontato che mi piaccia / La divinazione come pratica.” Those lines already say everything this album is about, and what I like to hear: something personal, something emotional, and not just love, or the emotions around love. Something about yourself. A masterpiece. It is also a feminist hymn, very vocal about what society does not want women to do. The whole record is a way of telling everyone those assumptions are wrong: what a woman can or cannot do, or should.

Favorite intro. 1484. I am not sure what instrument opens it (probably the harpsichord she has talked about), but it puts me at the court of a king, listening to medieval music, eating roast turkey cooked on an open fire, while jesters sing, dance, and play.

Favorite lyrics. “Servirebbe un incantesimo contro il tecnofeudalesimo,” from Feral Girl. I am not sure what Francesca really wanted to say with that line. I read somewhere that she even thought of calling the album Tecnofeudalesimo. For me it strikes a chord because I am trying to use less technology, mainly to spend less time doomscrolling on the phone. These are the kind of lyrics I find myself humming on the way to work.

Special mention. Litha. The repetitive “Vieni vieni intorno al fuoco / scordati chi eri quando inizia il gioco / vieni vieni intorno al fuoco / mescola anche tu le lacrime all’alloro” makes me feel like a witch jumping around a bonfire, in silky clothes, throwing bay leaves into the fire, under a full moon. This song is very, very evocative.

The only one I cannot vibe with. Weirdly enough, the song that appeals to me the least is Magia bianca, magia nera, the one that gives the album its name. I kind of understand the point of the lyrics, I think: you do not have to sit in the box of what other people call white magic or black magic; you can decide for yourself. Musically, though, it feels less connected to the rest of the album.

Spotify YouTube Music Apple Music

— Made withCursor

Mappa 10.0.0 is a major release. It targets .NET 10, adds polymorphic mapping and richer configuration, and expands MappaInvokeMethod, constructor mapping, and collection support. Documentation and samples were reviewed end-to-end. Full changelog: v1.2.0…v10.0.0

What’s new

Platform

• Migrate to .NET 10 (#178, #188) — Mappa now targets .NET 10; upgrade consuming projects accordingly.

New features

• Polymorphic mapping (#49, #187) — Map base types to derived instances when the runtime type is known.
• MappaAssignToContext attribute (#205, #207) — Assign mapped values into MappaContext during generation.
• MappaSettings property name matching (#98, #211) — Configure how source and target property names are matched (e.g. case sensitivity).
• Constructor strategy: ignore target properties (#3, #204) — Exclude specific target properties from constructor-based mapping via attribute.
• String → Parse(string) mapping (#52, #177) — Map string to any type that exposes static TTarget Parse(string).
• Numeric format and IFormatProvider (#76, #216) — Control culture and format for numeric Parse / ToString conversions.

[MappaInvokeMethod] attribute

• MappaContext parameters (#70, #206) — Invoked methods can accept MappaContext arguments.
• Hierarchy lookup (#179, #199) — Optional fields, properties, and methods are resolved up the class hierarchy.
• Instance member access (#193, #195) — Non-static fields and properties are referenced with this. in generated code.
• Static vs. instance safety (#190, #194) — A static mapping method cannot invoke a non-static method.
• Non-static method dependencies (#185, #191) — Method dependency lookup can use accessible non-static methods where appropriate.

Mapping improvements

• Collection concrete types with capacity constructors (#109, #176) — Support collection types that expose a capacity constructor.
• Read-only collection properties (#110, #202) — Broader support when targeting read-only properties of collection types.
• Inherited mapping methods (#186, #196) — Methods used for mapping are discovered in parent classes.
• MappaDependency in base classes (#183, #197) — Fields and properties marked with MappaDependency are picked up from accessible members in parent classes.

Diagnostics and quality

• Missing attribute warnings (#154, #203) — Additional compiler warnings for misconfigured or incomplete attribute usage.
• EditorConfig integration tests for MappaSettings (#210, #213) — Settings behavior is validated against EditorConfig configuration.

Documentation and samples

• Tutorial and documentation review (#148, #217) — Tutorial advanced topics, attribute reference, error codes, and package READMEs updated and aligned with current behavior.
• MappaInvokeMethod docs for MappaContext (#209, #212) — Documented rules for MappaContext in invoked methods.
• AOT samples coverage (#41, #198) — Mappa.Samples.Aot now runs all sample mappers for native/AOT validation.

Maintenance

• CI and tooling (#200, #201) — GitHub Actions dependencies bumped to current versions.
• TODO hygiene (#182, #189) — Guard against leftover issue TODOs in the codebase.

What’s next

This is a tentative and non-exhaustive list of issues that I would like to cover in the upcoming version of Mappa:

Mapping / generator features

• #215 — Support NumberStyles for Parse on all numeric types
• #214 — Support DateTimeStyle for Parse / ParseExact on DateTime, DateOnly, TimeOnly
• #184 — More relaxed nullability when matching methods
• #181 — Speed up enum mappings with switch expressions
• #175 — Support mapping empty → empty type
• #155 — Add MappaUseConstructor attribute to pick which constructor to use
• #120 — Allow mapping via nested source property chains
• #73 — Support fields, not only properties
• #67 — MappaInvokeMethodAttribute: add SourceProperty parameter
• #29 — Option to prefer arrays over lists in generated code
• #19 — Fail enum→enum maps when not all source values are mappable

Language / platform

• #174 — Support C# 14 extension blocks in static classes (partial classes assumed)

Protobuf

• #89 — Polymorphism via protobuf oneof for both source and target

Testing / benchmarks / CI

• #208 — Migrate away from FluentAssertions
• #119 — Migrate to xUnit v3
• #134 — Improve benchmarks
• #152 — Run benchmarks on CI/CD when merging to main