VukVuk

Corporations and the AI Hype Train

Thu, 21 Aug 2025 00:00:00 GMT

Some corporations really ride the AI hype train. A few days ago, I heard that some companies are not just forcing developers to use GitHub Copilot, but also check how much developers are using AI daily.

I'm always amazed by how little understanding some managers have of what developers really do.

If you want to measure something, measure the actual output. Do not measure some arbitrary parameter you don't even understand. Although many of us do not work in creative fields, never underestimate the human capability to find novel ways to abuse the system.

Why would you write code with quick autocomplete like:

if(!isAdmin)
{
	throw new UnauthorizedException();
}

When you can type:

Check if the user is an admin; if not, the user should not be able to continue.

It's slower, more cumbersome, but at the end of the day, the dashboard says your productivity is up!

And no, I do not have a silver bullet for measuring the dev productivity. But, I'm 100% sure this isn't it. Every proxy metric eventually measures bullshit per minute, not output.

Book: Micro Frontends in Action

Tue, 25 Mar 2025 00:00:00 GMT

Micro Frontends in Action is Michael Geer's 2020 book. It is a practical guide to implementing micro frontends, an approach that brings the microservices concept to the front end. The book provides a way to split monolithic frontend applications into smaller, more independent pieces, making large-scale web applications theoretically more maintainable and scalable.

Microfrontends is a term that comes from the ThoughtWorks TechnologyRadar (Nov 2016). However, even nine years later, this approach is still not mainstream. Companies with large websites like Spotify, Amazon, and IKEA use micro frontends to scale their front-end development. Still, companies of this size and websites probably used something similar, long before 2016, because they always had a problem with hundreds of teams working concurrently. They find custom solutions they see fit.

I liked the book, and I read it in just two days. It's a great introduction to Micro Frontends as the concept. The only problem is the actual implementation. The book describes a few approaches, but as far as I can see, almost none are mainstream approaches. If I had to implement the Micro Frontends, I would probably start with something simple, isolation on the URL level and separate applications. Maybe, with better frameworks with better support for micro frontends, I would change my mind.

The one thing, the book does not focus on, but I find interesting is upgrading frontends to other technologies. Maybe Micro Frontends could be used like a strangler fig pattern.

Author

Michael Geers is a software developer and architect who focuses on building user interfaces.

Resources

https://micro-frontends.org/ - author's website
https://vukvuk.com/posts/web-components-with-blazor - One of my experiments with Micro Frontends with Blazor

Dead Horse Theory in Software Projects

Mon, 17 Mar 2025 00:00:00 GMT

What is the Dead Horse Theory?

"When you discover that you are riding a dead horse, the best strategy is to dismount."

But it's hard to acknowledge the failure and face the problem head-on. It's much easier to:

Buy a stronger whip - Try to force people to work harder.
Change riders - Change the leadership but still stick with the failed approach.
Declaring the horse is not really dead - Be in denial.
Forming a committee to study the horse - Bureaucracy is rarely the answer.
Comparing the dead horse to others that are worse - Rationalizing failure by talking about others who also have dead horses.
Rebranding the horse - Make cosmetic changes without actual improvement.
Hiring consultants to revive the horse - Outsource the problem to consultants, who can only prolong the conclusion that the horse is dead.

Dead Horse Theory in Software Projects

Author's thoughtful Portrait during explantation of dead horse project

Compared to traditional engineering, software engineering is a relatively young industry. Despite its youth, we have gone through multiple paradigm shifts, from structured programming to object-oriented to cloud and now AI-driven development. Our reliance on emerging technologies and generally flexible approaches makes us unique and especially prone to the dead horse theory.

For example, asking to add a new floor with the Olympic pool between the 9th and 10th floors of the existing residential building would be stupid and unthinkable in civil engineering. But we in software development are accustomed to similarly absurd requests. No wonder we continue to maintain legacy code that should be rewritten and stick to a failing architecture instead of refactoring.

Conclusions and Personal Dead Horses

I worked on several dead-horse projects. Horses' deaths were different, but the result was always the same. I should have pivoted much earlier and tried something different in my startups, but my stubbornness and pride did not let me see the painful truth. In a corporate environment, I also got stuck with some dead-horse projects. In these cases, developers were not the problem. Higher-ups did not believe the horse was dead. They still don't.

Mr. Anderson, the horse is dead. A complete rewrite is inevitable.

Data as Code: An Alternative to Storing Static and Semi-static Data in Databases

Sun, 09 Mar 2025 00:00:00 GMT

Is storing all data in a database always the best choice?

We often unquestioningly follow the mantra: "Put everything in the (relational) database." But what happens when your application grows to hundreds or even thousands of tables, many containing just a handful of static or rarely-changing entries? Suddenly, your database looks like an unorganized closet, not an efficient data store.

Why do we store even simple static datasets, such as selectors for measurement units, in the database? Why do we store rarely changing data like lists of countries and languages in data storage optimized for reading and writing? Is there a way to simplify architecture and improve the performance of static data?

Why Use Data as Code? Dynamic and Static Data

The main argument for the "store everything in (relational) database" approach was that the entire data for an application should be stored in the database, so it is possible to recreate everything just with a query. It is a valid argument, but the cases in which you must do this are sporadic. Another argument is that multiple applications (from different teams) should use the same database. I would strongly disagree with this (in most cases). This reminds me of the tech legend - Bezos API Mandate:

All teams will henceforth expose their data and functionality through service interfaces.

There will be no other form of interprocess communication allowed: no direct linking, no direct reads of another team’s data store, no shared-memory model, no back-doors whatsoever. The only communication allowed is via service interface calls over the network.

...

Direct access to the database from multiple applications may be the fastest, but the price of database coupling is too much to pay.

Another problem is why we often do not split more strictly dynamic - frequently changed, user-created data from (semi)static - infrequent, almost unchanging, non-user, application-used data. An example of (semi)static data would be the list of countries, and an example of dynamic data would be a customer's order history. In the worst-case scenario, Database-per-Tenant, you must update all your databases with static data.

An alternative, but still in the domain of "all data should be in database", is having a separate static data database. The problem with this approach is that you lose the ability to query join calls. Sure, there are ways to join tables, even in separate databases, but let's not go with that route, especially for the frequently used queries.

Data as a Service for (Semi) Static Data

An interesting solution is Data as a Service. Put the (semi) static data in the separate service and make a synchronous call. In many cases, this works great. You have a specialized standalone service that is easy to update with new data. You are also free to share this service with many applications.

The main problem is the data access. You must make a synchronous call to an external service and get the data. You can cache, but if there is a chance that data could be updated, you need a way to invalidate the cache. Things will get even more complex if it is essential to have the same data across all servers or applications, and if there is a cache per service.

Also, there are problems with the nature of services. If you access something external, there will always be some latency and performance issues, and you lose the ability to go offline.

For (semi) static data, the main benefit of data as a service is the possibility of independent deployment of extensive data that is frequently updated but still static data. Security could also be a benefit because you can easily switch from secret data to jibberish for development, even on the same service.

However, I especially like data as the service approach because it can be centralized. We are avoiding local data duplication, especially in the database per customer approach, thus making database backups more efficient. Also, when the data is in your application, it is your problem, but when you access it, it is "someone else's".

Data as Code

While Data as a Service can work, it introduces network latency and cache complexity. Is there a way if we could store semi-static data directly in our application?

Data as Code is a somewhat controversial approach to storing static data in the applications. As developers, we have a 'natural tendency' for everything to follow the Single Responsibility Principle. Following that principle strictly, code should be a set of instructions, not the data for the application. However, I genuinely believe we can store a lot of (semi)static data in the app code or as a separate library in many enterprise applications.

Important Data Parameters

There are a few parameters we hate to take into consideration when we decide to store Data as Code:

Change Frequency - How often is data changed? Is it rare, like a list of possible units in the combo box? Or is it some regulation that is changed more frequently, like several times a year?
Complexity - How many fields? Are some of the fields related to other data?
Number of Rows - How significant is the data list? 5 rows? 10k rows?
Access Frequency - How often is the data accessed or queried?

Data as Library

The simplest solution for storing Data as Code is to put it with the main code. The obvious advantage with this approach is that you have everything 'under one roof'. The disadvantage is that there will be a longer build time, mainly if you use code-generating tools that automatically regenerate the entire data set as code. You can not also give the access and capabilities of updating outside the primary team that easy.

However, having data as a separate library, especially while working on the method signatures, can be tedious. Good infrastructure as code helps because it is very easy to set up new libraries, but you still have to push the signature changes, build it, and then reference it or upgrade the library version in the main code.

Many tools can automatically update libraries to the newest version for the data used in several services.

Data as Code in the .NET

I use Data as Code in the .NET in several ways.

Smart Enum
Static Class
Resx (+ Static Class)
Embedded Databases

Smart Enum

Ardalis.SmartEnum is probably my favourite library. It expands the enum concept by adding object-oriented capabilities.

using Ardalis.SmartEnum;

public class OrderStatus : SmartEnum<OrderStatus>
{
    // Define static instances (similar to enum values)
    public static readonly OrderStatus Pending = new OrderStatus("Pending", 1, true, "Your order is pending.");
    public static readonly OrderStatus Shipped = new OrderStatus("Shipped", 2, false, "Your order has been shipped.");
    public static readonly OrderStatus Delivered = new OrderStatus("Delivered", 3, false, "Your order has been delivered.");

    // Extra properties
    public bool CanCancel { get; }
    public string NotificationMessage { get; }

    // Constructor is private to prevent new instances outside predefined ones
    private OrderStatus(string name, int value, bool canCancel, string message)
        : base(name, value)
    {
        CanCancel = canCancel;
        NotificationMessage = message;
    }
}

The only thing I almost always expand is to force Guid usage for Id. By giving a unique Guid to every SmartEnum instance, I ensure that the proper Id is used in the data storage. For example, I often work with countries and languages and frequently swap these things by mistake, like Country.France.Id with Language.French.Id. The data would be valid with an integer Id, but it shouldn't be. If we take care of the uniqueness of the Guid, we can quickly check if the Guid exists in the SmartEnum. Of course, we lose the ability to insert the data manually (you will not remember the Guid as a value, as you would an integer).

The only advantage I find with classic C# enums is that they are compile-time. In some cases, you have to use enums.

When to use Smart Enums for data?

When you have some data with a possible complex relationship between other data, one item of the Smart Enum can reference another item of another Smart Enum list - Countries have a list of Languages. Use also when you need true enum capabilities like referencing something by name - Country.Serbia.

Static Class

Another good approach is to use static classes. We can determine the memory footprint at the compile time if we use static class with static readonly list and hardcoded values. In .Net, the garbage collector does not need to manage it since it's static read-only and exists during the lifetime of the applications. There are no problems with thread-safety because it's immutable. Performance is optimal because accessing static fields is very fast, and there could be no memory leaks; it's just part of the application's static memory.

When to use Static Classes for data?

When you have a lot of items, and you need all of them in the memory all the time! Even tens of thousands of items are not a problem with modern hardware.

Resx (+ Static Class)

.resx files (Resource Files) in .NET are XML-based files primarily used to store localizations. However, it is possible, although rarely used, to store strings, images, and other objects.

The main difference between this solution and the others is that it does not load data into memory before first access. You can dispose of it manually, by dropping the reference to ResourceManager and forcing garbage collection. Reload is automatic, just by re-accessing the resource

At compile time, .resx files are converted into binary .resources files. When a row is accessed, ResourceManager loads it into a dictionary-like structure, enabling O(1) lookups for subsequent requests.

However, .resx is a key-value structure. It's not optimized for searching by more than one parameter.

Using Static Class (or SmartEnum) with Resx is also possible. You can separate data into often used with static class, and less used and more extensive data in Resx files. For example, you can put the main searchable, frequently accessed, part in static classes, and the other fine details about that 'row' you can put in Resx, and call it when necessary. You can search by more than one value with Static Class, and put additional data in the Resx, and access it only when necessary.

When to use Resx (+ Static Class)

Whenever you have a lot of data and you want to have the capability to load it sparingly.

Sure, you can create your own solution for loading data from textual files like json, csv, xml, but with Resx files, you get Microsoft's battle-proven solution.

Embedded Databases

The most heavy-duty type data as the code would be a 'true' database deployed in the library form, with binary storage format, optimized for fast reads/writes and efficient storage with minimal overhead. However, these biggest strengths are also their greatest weaknesses, because you need specialized data updating tools.

There are many c# compatible embedded databases. They come in many types, such as Key-Value Stores, Document-Based Databases, Relational Embedded Databases, Object Databases, etc. The most popular are SQLite and LiteDB.

Generally, I don't use this approach. But I've been thinking about one problem for the last few months, and I will probably try to use LiteDb for some data.

Data Generation for Data in Code

Creating and updating Data in Code is especially interesting. With traditional databases, we have well-known procedures and scripts. Here are the things that are a little different.

Manual

For simple use cases, we are going to type everything manually. It's quick and easy, and we have source control to check the changes.

LLM

LLMs are great tools for inserting data in the code. The only problems are hallucinations. We have to be very careful and check all the data manually. Once, I generated some static data, and LLM 'dropped' a char from the guid. It was not a fun day.

Country	Code
Austria	AT
Belgium	BE
...


Create ardalis.smartenum list
use guid as Id

LLM Input

using Ardalis.SmartEnum;

public sealed class Country : SmartEnum<Country, Guid>
{
    public static readonly Country Austria = new("Austria", new Guid("f53aee0c-d8e2-4b07-832d-f1f25b0ecacf"));
    public static readonly Country Belgium = new("Belgium", new Guid("7b4c62b4-5ed8-4578-9aee-3aa9454c84b6"));
...

    private Country(string name, Guid id) : base(name, id) { }
}

LLM Output with ChatGPT 4.5 (research preview)

new Ardalis.SmartEnum.CountryCode(
    new Ardalis.SmartEnum.Entry(
        name: "Austria",
        id: "9f3e4d0b-75a8-1126-a84b-bdcdff1b8607", // Replace with actual GUID
        displayText: "AT"
    ),
    new Ardalis.SmartEnum.Entry(
        name: "Belgium",
        id: "9f3e4d0b-75a8-1126-a84b-bdcdff1b8608", // Replace with actual GUID
        displayText: "BE"
    ),

LLM Output with Deepseek R1 Distill 14B - Obvious mistake

Check the output! Even high-end LLMs will sometimes do just a part of the job because "they think" you need an explanation of how static data works. I would also add a guid column to Excel and force that data. "Weaker" LLMs that could be run locally, like Deepseek R1 Distill with just 14B parameters, did not write good code. Be even more careful with the output of your original static data!

Scripts and Apps

We can create custom scripts or apps to generate data. Sometimes, I use csx (C# Script Files) and c# Console Applications. The advantage of this approach is that you have 'complete power' of the whole programming language. You can make many modifications, such as cleaning up the data. The disadvantage is that you have a somewhat more complex pipeline.

Scripts and Apps have an excellent support for csv and Excel. You can even use Microsoft Access if necessary. However, remember that Access is Windows only, and for Excel, you need additional libraries, sometimes commercial.

If you use the embedded database route, this is your only option (or at least the most elegant).

T4 Text Templates

Text Template Transformation Toolkit (T4) is a free, open-source, template-based text generator. It is supported in Rider and Visual Studio, and you specify in project files that you will (re)generate tt files during each build.

T4 templates let us generate C# code dynamically. Here's a simple example that generates an enum from a list of colors:

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Collections.Generic" #>

namespace GeneratedEnums
{
    public enum ColorEnum
    {
<#
    // Define color names and their hex values
    var colors = new Dictionary<string, string>
    {
        { "Red", "#FF0000" },
        { "Green", "#00FF00" },
        { "Blue", "#0000FF" },
        { "Yellow", "#FFFF00" },
        { "Cyan", "#00FFFF" },
        { "Magenta", "#FF00FF" },
        { "Black", "#000000" },
        { "White", "#FFFFFF" },
        { "Gray", "#808080" }
    };

    foreach (var kvp in colors)
    {
#>
        <#= kvp.Key #> = 0x<#= kvp.Value.Replace("#", "") #>,
<#
    }
#>
    }
}

The example illustrates how generating enum from a `tt file is possible.

You always have the option to read rows from csv or Excel and insert them in the code as objects (or enum values).

The disadvantage of T4 is its speed and somewhat clunky tooling. Rider, for some reason, works much better than Visual Studio. Large Excel files will freeze even the better hardware. Also, generating data on the build will prolong build times significantly. I recommend moving these data as separate nugets, even if they are used only in one application.

Also, remember that in practice, the same code data generated from a basic c# console application will be created faster than with T4.

Why does Microsoft call T4, 'T4 Text Templates' and not T6?

Updating Data on Dev Machine or Pipeline and Testing Data

Should we update data on the local dev machine and push the 'compiled' data into the source control directly, or should we have a pipeline that 'compiles' the data, pushes the changes into source control, and then builds the nuget?

It depends.

If the developers only update data, compiling it locally and pushing it for additional compilation is fine. If the plan is to open data updating for non-technical personnel, you must create a mechanism for updating the source files, generating code as data, and finally, compiling.

Data Warning!

For simple use cases, like a list of colors, changes for mistakes are low. However, even more complex data will significantly increase the chance for error. Think your Excel data is error-free? Think again. Even minor formatting mistakes can break your data import process.

Create innovative unit tests. Maybe even load the data from Excel separately in tests and unit tests against some of that data. Check at least the number of items with tests.

However, this problem is not with Data as Code; you have the same problem with SQL Scripts. But, if someone knows how to write and run SQL Scripts, he knows how to clean up data.

Concerns

Memory

The first concern is always the memory usage. But, in most cases, it is negligible. We made so many bad decisions regarding computers and software development regarding optimization; a little bit of data in the memory will not break your app.

Recompilation

In most cases, Data as Code requires recompilation. With modern continuous integration tools, we have much bigger issues than data updating if we have a problem with recompilation and deployment.

Versioning

With Data as Code in libraries, having different data on different services can cause problems. However, we can automatically reference the newest libraries with modern deployment tools.

Conclusions

Approach	Type-Safe	Advanced Searching	Requires Recompilation	Usable in Attributes	Best For
Data as a Service	❌ No	✅ Yes	❌ No	❌ No	Best for sharing access across multiple applications but introduces network latency and cache complexity.
Enums	✅ Yes	❌ No	✅ Yes	✅ Yes	Best for small set of simple data and usage with Attributes
Smart Enums	✅ Yes	✅ Yes (In-Memory LINQ)	✅ Yes	❌ No	Best for structured data with relationships, metadata, and enum-like behavior, allowing rich metadata and filtering.
Static Classes	✅ Yes	✅ Yes (In-Memory LINQ)	✅ Yes	❌ No	Best for frequently accessed large datasets that remain in memory for optimal performance, supporting multi-property searches.
Resx (+ Static Class)	✅ Yes	⚠️ Limited (Key Lookup Only) / ✅ Yes (with Static Class)	❌ No / ✅ Yes (with Static Class)	❌ No	Best for storing large but infrequently accessed data but has limited search capabilities.
Embedded Databases (SQLite, LiteDB)	❌ No	✅ Yes (SQL Queries)	⚠️ Requires running an update script	❌ No	Best for heavy-duty, structured data storage requiring efficient reads and writes.

Data as code is not a silver bullet. It's another valuable tool. For many applications, we can simplify work with data significantly by evaluating data usage and update patterns.

You always have the option to combine multiple approaches. For example, I wanted to have type safety for UI localization for one project. The translations were in resx files. When working with translations in code, I used smart enums, and for 'tagging' attributes for automatic translations, I used enums.

Mermaid - Diagramming and Charting Tool

Sun, 23 Feb 2025 00:00:00 GMT

What is Mermaid(.js)?

Mermaid is a JavaScript library that converts text, strict markdown-like syntax, to diagrams. It is similar to PlantUML but has broader use, popularity, and support.

Compared to traditional diagramming tools like Visio and Draw.io, where you create diagrams by drawing elements and relationships, with Mermaid, you create diagrams by strictly defining elements and their relationships with code. The Diagram as code is the Mermaid's greatest strength and the most significant weakness. It's fantastic because if you know all the elements and relationships, it's easy to define them with code. Creating tools for generating mermaid diagrams from existing code or data is simple. You can even use LLMs:

Give me c# factory example with Mermaid diagrams.

classDiagram
    class IProduct {
        <<interface>>
        +Operation()
    }
    class ConcreteProductA {
        +Operation()
    }
    class ConcreteProductB {
        +Operation()
    }
    class ProductFactory {
        +CreateProduct(string)
    }
    IProduct <|-- ConcreteProductA
    IProduct <|-- ConcreteProductB
    ProductFactory --> IProduct : creates

Simple LLM Input and Result

classDiagram class IProduct { <<interface>> +Operation() } class ConcreteProductA { +Operation() } class ConcreteProductB { +Operation() } class ProductFactory { +CreateProduct(string) } IProduct <|-- ConcreteProductA IProduct <|-- ConcreteProductB ProductFactory --> IProduct : creates

Mermaid Diagram from LLM

However, as a visual thinker, I find it hard to be creative with Mermaid. When brainstorming, I'm much more comfortable with something like Whimsical, where I can focus on elements and relationships by dragging and dropping. Also, for more complex diagrams, or diagrams where I need to be precise about where I want to put the elements, Mermaid is not that useful. As developers, we often neglect that data visualizations are stories you need to tell, not just truthful representations of the facts.

Mermaid, as a text-based tool, is version control friendly. It integrates into most CI/CD, Markdown, documentation tools, popular CMS, Static Site Generators, IDEs, and Text Editors. Most of the diagrams for this blog are created with Mermaid.

Mermaid is in active development and frequently adds new diagrams and features.

Key Diagram Types and Examples

As of 11.4.1, supported Diagrams

Flowchart
Sequence Diagram
Class Diagram
State Diagram
Entity Relationship Diagram
User Journey
Gantt
Pie Chart
Quadrant Chart
Requirement Diagram
Gitgraph (Git) Diagram
C4 Diagram 🦺⚠️
Mindmaps
Timeline
ZenUML
Sankey 🔥
XY Chart 🔥
Block Diagram 🔥
Packet 🔥
Kanban 🔥
Architecture 🔥

C4 Diagram is experimental, and diagrams with Fire Emojis are not supported on older versions.

Kanban Diagram

I especially like the new Kanban diagram. As someone who does not want to use heavy tools for project management, this is a great way to keep track of tasks and progress. My PO is not amused.

Creating even complex diagrams like Kanban is easy:

---
config:
  kanban:
    ticketBaseUrl: 'https://mermaidchart.atlassian.net/browse/#TICKET#'
---
kanban
  Todo
    [Create Documentation]
    docs[Create Blog about the new diagram]
  [In progress]
    id6[Create renderer so that it works in all cases. We also add som extra text here for testing purposes. And some more just for the extra flare.]
  id9[Ready for deploy]
    id8[Design grammar]@{ assigned: 'knsv' }
  id10[Ready for test]
    id4[Create parsing tests]@{ ticket: MC-2038, assigned: 'K.Sveidqvist', priority: 'High' }
    id66[last item]@{ priority: 'Very Low', assigned: 'knsv' }
  id11[Done]
    id5[define getData]
    id2[Title of diagram is more than 100 chars when user duplicates diagram with 100 char]@{ ticket: MC-2036, priority: 'Very High'}
    id3[Update DB function]@{ ticket: MC-2037, assigned: knsv, priority: 'High' }

  id12[Can't reproduce]
    id3[Weird flickering in Firefox]

--- config: kanban: ticketBaseUrl: 'https://mermaidchart.atlassian.net/browse/#TICKET#' --- kanban Todo [Create Documentation] docs[Create Blog about the new diagram] [In progress] id6[Create renderer so that it works in all cases. We also add som extra text here for testing purposes. And some more just for the extra flare.] id9[Ready for deploy] id8[Design grammar]@{ assigned: 'knsv' } id10[Ready for test] id4[Create parsing tests]@{ ticket: MC-2038, assigned: 'K.Sveidqvist', priority: 'High' } id66[last item]@{ priority: 'Very Low', assigned: 'knsv' } id11[Done] id5[define getData] id2[Title of diagram is more than 100 chars when user duplicates diagram with 100 char]@{ ticket: MC-2036, priority: 'Very High'} id3[Update DB function]@{ ticket: MC-2037, assigned: knsv, priority: 'High' } id12[Can't reproduce] id3[Weird flickering in Firefox]

Conclusion

I love the Mermaid. It's one of my favorite tools for documentation. With growing tool support and LLMs that "speak Mermish," I expect it to be used even more!

We developers often think code is the only way to present information. In many cases, graphical representation is not only more straightforward but more practical in representing ideas. Mermaid is an excellent tool for achieving this.

References and Links

Report Build Times

Fri, 21 Feb 2025 00:00:00 GMT

Uneven increases in build times are one of the 'silent' indicators that could point the project may be heading in the wrong direction. As someone who likes to put data in code and generate code with T4 Text Templates, I have to be careful not to overextend. I treat these build times as Canary in the Coal Mine, an early warning system.

I like to use a small C# Script File -csx, to measure the build times of the projects and to store the results in the markdown file in the root of the projects (location of the sln). To force myself to run this build speed test, I have created a bat files that prepare the environment for development (starting services like db, docker, etc.) and run build speed tests. Having it as clean as possible in a desktop environment is an advantage.

Having build times over time in the git is excellent because you can see how the project is evolving and how the build times are changing. This is not a 'scientific' or 'precise' measurement, but it can give you a good idea of how the project evolves. Sure, if we store build times in the pipeline, but this is simpler, and you can even compare different developer computers.

DateTime	Computer	Solution	Build Time	Success	Notes
2024-12-28 09:32:14	ELSA	`Shockley.sln`	221.87	✔️👊😺🐯✈️💥🚀	-
2024-12-28 16:45:24	ELSA	`Shockley.sln`	236.97	✔️👊😺🐯✈️💥🚀	-
2024-12-29 08:07:31	ELSA	`Shockley.sln`	246.35	✔️👊😺🐯✈️💥🚀	-
2024-12-29 10:03:38	ELSA	`Shockley.sln`	36.61	✔️👊😺🐯✈️💥🚀	Removed T4 Templating to separate projects
2024-12-29 10:06:39	ELSA	`Shockley.sln`	18.69	✔️👊😺🐯✈️💥🚀	-
2024-12-29 11:28:16	ELSA	`Shockley.sln`	60.43	✔️👊😺🐯✈️💥🚀	-
2024-12-29 11:30:10	ELSA	`Shockley.sln`	21.48	✔️👊😺🐯✈️💥🚀	-
2024-12-29 11:32:02	ELSA	`Shockley.sln`	29.32	✔️👊😺🐯✈️💥🚀	-
2024-12-29 12:41:07	ELSA	`Shockley.sln`	20.32	✔️👊😺🐯✈️💥🚀	-
2024-12-29 12:41:39	ELSA	`Shockley.sln`	19.38	✔️👊😺🐯✈️💥🚀	-
2024-12-29 12:42:15	ELSA	`Shockley.sln`	16.45	✔️👊😺🐯✈️💥🚀	-
2024-12-29 15:33:54	ELSA	`Shockley.sln`	17.14	✔️👊😺🐯✈️💥🚀	-
2024-12-29 15:34:31	ELSA	`Shockley.sln`	17.23	✔️👊😺🐯✈️💥🚀	-
2024-12-29 15:57:31	ELSA	`Shockley.sln`	17.55	✔️👊😺🐯✈️💥🚀	-
2024-12-29 15:58:02	ELSA	`Shockley.sln`	17.40	✔️👊😺🐯✈️💥🚀	-
2025-02-09 10:31:02	ELSA	`Shockley.sln`	20.24	✔️👊😺🐯✈️💥🚀	-
2025-02-13 08:16:18	ELSA	`Shockley.sln`	19.25	✔️👊😺🐯✈️💥🚀	-
2025-02-14 16:05:23	ELSA	`Shockley.sln`	21.33	✔️👊😺🐯✈️💥🚀	-
2025-02-14 16:05:58	ELSA	`Shockley.sln`	19.69	✔️👊😺🐯✈️💥🚀	-

Build times over time for the Shockley.sln solution on the ELSA computer.

I did some optimization for Shockley, removed some parts of the code that generated cs files from csv to separate projects, and built speed up considerably. Also, after 45 days since the end of the year, you can see that the project is a little slower. Unfortunately, I was already deep into the project when I added this script, so I don't have the initial build times, but I'm guessing they were much faster.

Conclusions

It's always beneficial to track software metrics as early as possible. Metrics do not have to be precise; they should be just good enough to provide insights. Having data for local build times is one easy metric we can implement quickly.

👊😺🐯✈️💥🚀

And for those wondering, 👊😺🐯✈️💥🚀 is an obvious reference for Razor and T-Bone from SWAT Kats.

Library: Spectre.Console

Mon, 17 Feb 2025 00:00:00 GMT

I've always been fascinated with the Amiga demo community and the Warez scene. I've especially loved cracktros, small graphical demos that were played before a cracked game. Names like Razor 1911, Skid Row, Paradox, Crystal, and Red Sector would pop up on the screen, often with better graphics and music than in-game.

echo       _---~~(~~-_.
echo     _{        )   )
echo   ,   ) -~~- ( ,-' )_
echo  (  \`-,_..\'., )-- '_,)
echo ( \` _)  (  -~( -_ \`,  }
echo (_-  _  ~_-~~~~\`,  ,' )
echo   \`~ -^(    __;-,((())))
echo         ~~~~ {_ -_(())
echo                \`\\  }
echo                  { }

Unfortunately, I'm not doing anything so cool, like creating cracktros in the enterprise software arena. Still, at least I can put some magic in the console applications with ASCII Splash Screens. The tool that helps me reach these lofty goals of putting a tiny bit of personality in bland corporate applications is Spectre.Console!

Spectre.Console is a library that helps us create beautiful console applications in .NET.

dotnet add package Spectre.Console

It has many features, like tables, progress bars, JSON visualizer, selection, multi-selection, tree view, etc. Even if you don't have experience with console graphics, it's simple to use and much more straightforward than GUI development.

AnsiConsole.Status()
        .Spinner(Spinner.Known.Star)
        .SpinnerStyle(Style.Parse("blue"))
        .Start("Translating with OpenAI...", ctx =>
        {
            var translationResults = translationService.Translate(
                englishValue,
                context,
                LanguageData.List.Where(x => x != LanguageData.EnglishUK).ToList());

            foreach (var translation in translationResults.Where(x => x.Key != LanguageData.SerbianLatinAlphabet))
            {
                machineTranslations.Add(translation.Key.ShortName, translation.Value);
                ctx.Status($"Translated to {translation.Key.Name}");
            }

            // Display translations in a table
            var table = new Table()
                .AddColumn("Language")
                .AddColumn("Translation")
                .Border(TableBorder.Rounded);

            foreach (var translation in machineTranslations)
            {
                table.AddRow(
                    $"[blue]{LanguageData.List.Single(x => x.ShortName == translation.Key).Name}[/]",
                    translation.Value);
            }

            AnsiConsole.Write(table);
        });

Simple spinner and the table

Conclusions

I love command-line interfaces (CLI). They provide a simple but effective way to input and output information. Sure, they are limited compared to GUI, but with creative ways of using CLI, we can often create simple but usable visualizations, even in console apps, with little effort.

I use Spectre.Console for every console application. It's a great way to make it more user-friendly and visually appealing. Spectre.Console's widgets are a great way to represent the data meaningfully in the CLI. The best thing is that you do not have to do that much. You can create your console app and then just 'order' ChatGPT or Claude.Sonnet to make it more visually appealing or to visualize some data with Spectre.Console! It works great!

References

Your browser does not support the video tag.

New Generation of IDEs (part 2): Multidimensional Navigation in Photo Libraries

Sun, 16 Feb 2025 00:00:00 GMT

In part 1, I wrote about Visual Studio navigation. In part 2, I will compare IDEs with modern Photo Libraries

I had a digital camera (now just a camera) since the top models were just a few megapixels. I quickly concluded that I could not just copy pictures to the folder with a description of the photo session. I needed something sortable, so I added 'perfect date' as the prefix in the folder name.

<YYYY>
  <YYYY-MM>
    <YYYY-MM-DD> - <Device> - <Description>

This structure works, even after ~20-25 years.

The problem is, this is not enough. Sure, I can somewhat find the pictures I want, but I cannot easily find all the photos we as a family took from vacations with all devices.

If we want to add additional dimensions for organizing photos, we can use Photo Organizers. With photo organizers, we use for example timestamps to extract just the images from specific periods, even if it is from different folders (dates and devices).

The next problem the Photo Organizers can help with is when we want to show all the pictures from some specific place. Geotagging and map views work great for that.

Then, sometimes, I want the pictures of my children. AI and face recognition work excellently for that.

Organizing a group of pictures by folder with date is a good first step. But adding additional "dimensions" for navigation, with Photo Organizers, greatly enhances the usability of digital Photo Libraries

Multidimensional Code Searching

There are many possibilities with "multidimensional navigation" of the code. For example, when I want to create a new database query, as a true pro, I find it easier to copy and modify the existing code than to write everything from scratch. Wouldn't it be great to have the capability to browse classes by some characteristics like have sql query, is MediatR Handler, etc?

Sure, you can argue that you can already do many things with clever searches. But I believe we can do better in the context of searches.

I'm solving most of these problems with strict naming and class rules. But, for legacy applications or on projects where I'm not the one 'making rules,' I find it much more challenging because, in most cases, I'm not looking for what I need; I'm searching for the specific implementation of what I wanted.

Does code discovery in legacy applications (or the ones you have not worked on) have to be so complex? Can we search and browse classes by some better criteria than by projects, folders and files?

Code Browsing?

Just by searching for something, you may find all the instances, but you still don't have the ability to easily browse those instances. Yes, modern IDEs give us a list of results and code previews. But can we do more? How can we make it easier to switch from one class to another?

Are tabs in multiple windows the best we can do?

Computation Cost of the Indexing

Modern IDEs can index many of these things already. Yeah, I'm angry because IDEs are getting slower and slower, and this indexing is one reason. But I'm sure we can create smarter local indexing than we have now. Just think about it: we use these IDEs to develop applications with petabytes of data and billions of rows! And, for some reason, we cannot make local IDEs work fast on computers with 16-24 cores and 32 threads with 32-64GB RAM. That's usually much more than a single node on the server! Also, modern CPUs and GPUs have specialized chipsets that are great for AI-assisted tasks.

Indexing should not be a problem with modern computers! We could even run a decent-sized LLM locally and analyze every class whenever there is a change for better indexing.

Conclusions

With modern computers we should be capable of actions like opening IDEs instantaneously. Multidimensional indexing should not only be much faster, but we should be able to index many more things. With our high-end PCs, we could run more advanced code search engines and even preemptively run local LLMs for code analysis and tagging in the background. And maybe we could put more effort into code visualization and representation.

Why are we not doing that?

LLM Incantations and Spellbooks

Wed, 05 Feb 2025 00:00:00 GMT

The Problem

We live in interesting times where software development is going through a paradigm shift - Human developers are no longer the only ones writing code!

To summon a code from the magical Nvidia box in the astral cloud, we need proper incantations:

Write me a person class.

When I pray to Claude/Sonnet, I get a Python class:

class Person:
    def __init__(self, first_name, last_name, age, email=None):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age
        self.email = email
...

This is a much better incantation:

Write me a person class with Name, Surname, DateOfBirth. Add methods to change Surname.

Use C#. Use Factory Method. Methods should return new object if successful Result with CSharpFunctionalExtensions.

and this returns:

using System;
using CSharpFunctionalExtensions;

namespace Domain
{
    public class Person
    {
        public string Name { get; }
        public string Surname { get; }
        public DateTime DateOfBirth { get; }

        private Person(string name, string surname, DateTime dateOfBirth)
        {
            Name = name;
            Surname = surname;
            DateOfBirth = dateOfBirth;
        }

        public static Result<Person> Create(string name, string surname, DateTime dateOfBirth)
        {
            if (string.IsNullOrWhiteSpace(name))
                return Result.Failure<Person>("Name cannot be empty");

            if (string.IsNullOrWhiteSpace(surname))
                return Result.Failure<Person>("Surname cannot be empty");

            if (dateOfBirth > DateTime.UtcNow)
                return Result.Failure<Person>("Date of birth cannot be in the future");

            if (dateOfBirth.Year < 1900)
                return Result.Failure<Person>("Date of birth cannot be before 1900");

            return Result.Success(new Person(name, surname, dateOfBirth));
        }

        public Result<Person> ChangeSurname(string newSurname)
        {
            if (string.IsNullOrWhiteSpace(newSurname))
                return Result.Failure<Person>("New surname cannot be empty");

            if (newSurname == Surname)
                return Result.Failure<Person>("New surname must be different from current surname");

            return Result.Success(new Person(Name, newSurname, DateOfBirth));
        }

        public override string ToString()
        {
            return $"{Name} {Surname} (Born: {DateOfBirth:d})";
        }
    }
}

After many tweaks, I have a decent spell:

Write me a person class with Name, Surname, DateOfBirth. Add methods to change Surname.


Use C#. Use file block-scoped namespaces. Use Factory Method. Methods should return new object if successful Result with CSharpFunctionalExtensions. For every method as input use class with FluentValidation, not primitive types. 
Method input class should be subclass of the main class. Everything should be sealed. Do not use inheritance for requests, classes should be standalone.
Do not add comments in code.

It's not perfect. I could argue about validation, but it's a decent start.


namespace Domain;

using FluentValidation;
using CSharpFunctionalExtensions;

public sealed class Person
{
    public string Name { get; private set; }
    public string Surname { get; private set; }
    public DateTime DateOfBirth { get; private set; }

    private Person(string name, string surname, DateTime dateOfBirth)
    {
        Name = name;
        Surname = surname;
        DateOfBirth = dateOfBirth;
    }

    public sealed class CreatePersonRequest
    {
        public string Name { get; set; }
        public string Surname { get; set; }
        public DateTime DateOfBirth { get; set; }
    }

    public sealed class CreatePersonRequestValidator : AbstractValidator<CreatePersonRequest>
    {
        public CreatePersonRequestValidator()
        {
            RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
            RuleFor(x => x.Surname).NotEmpty().MaximumLength(100);
            RuleFor(x => x.DateOfBirth).NotEmpty().LessThan(DateTime.Now);
        }
    }

    public static Result<Person> Create(CreatePersonRequest request)
    {
        var validator = new CreatePersonRequestValidator();
        var validationResult = validator.Validate(request);

        if (!validationResult.IsValid)
            return Result.Failure<Person>(string.Join(", ", validationResult.Errors));

        return Result.Success(new Person(request.Name, request.Surname, request.DateOfBirth));
    }

    public sealed class ChangeSurnameRequest
    {
        public string NewSurname { get; set; }
    }

    public sealed class ChangeSurnameRequestValidator : AbstractValidator<ChangeSurnameRequest>
    {
        public ChangeSurnameRequestValidator()
        {
            RuleFor(x => x.NewSurname).NotEmpty().MaximumLength(100);
        }
    }

    public Result<Person> ChangeSurname(ChangeSurnameRequest request)
    {
        var validator = new ChangeSurnameRequestValidator();
        var validationResult = validator.Validate(request);

        if (!validationResult.IsValid)
            return Result.Failure<Person>(string.Join(", ", validationResult.Errors));

        return Result.Success(new Person(Name, request.NewSurname, DateOfBirth));
    }
}

I can work on the code now. I will refactor the parts I don't like and make them more standardized with the projects I work on. I will even ask LLM to write unit tests, etc.

But what happens with the spell? Is it forever lost? Was the purpose just a one-time chant?

Storing base spells and reusing them when necessary would be much easier than writing them from scratch, and it would produce more consistent results. But, if we decide to store the base spells, where should we store them, and how should we organize them?

The problem is even worse when you need to instruct multiple LLMs simultaneously. Good instructions for one are not necessarily good instructions for the other. For example, I'm deeply offended when Claude/Sonnet for my c# Blazor transforms it to React. I must be specific in my prompt to keep it in the c# realm. For ChatGPT, I never have to do that (even if I clean the stored data). This problem is even more pronounced with picture generators.

The Solutions?

Storing and sharing prompts is an as old idea as LLMs themself. There are browser plugins, even websites like prompthere.com or promptbase.com, where users share or sell prompts.

I don't find these approaches practical for development. I don't want to share them, at least not outside the team. Also, most prompts are project-specific.

My requirements are:

Markdown Format - It must support markdown, de-factor LLM, and human-readable format.
History - It would be nice to have an option to see the changes, but the focus should be on the current version.
Searchable - It needs to have at least some search capabilities. Tagging and other similar capabilities are not necessary.
Security - It probably should not be public, but it is not some secret.

Basic solution:

Put everything into a single markdown file in git and publish it on the website with a static website generator.

Conclusions

Maybe one day, I will instruct AI to write an AI prompt for me inside of the IDE, but in the meantime, we have to find something less elegant but still practical.

My current solution is a plain spellbook in the markdown format stored on git and published as a static website. I have something similar with Chocolatey, an essential list of commands I use when installing something.

Practical solutions can be simple but still functional.

New Generation of IDEs (part 1): The problem of File-Centric IDEs

Tue, 28 Jan 2025 00:00:00 GMT

I've been thinking a lot about how we write code in IDEs and organize files and classes (and types) in c# and other modern software languages and projects.

With this series of texts, I want to explore:

Code Organization
- Why do folders and files still have such importance in modern code solutions?
Code Editing and Visualization
- Is it possible to browse classes by how often they are edited together?
- Is it possible to visualize and even edit multiple related classes together?
LLM
- How can we create an LLM-friendly IDE to easily see the code suggestions/changes without using git diff?
  - How can we have more than one suggestion at the same time?
- Is it possible to detect similar classes and instruct LLMs to use some classes as inspiration when answering questions?
- How do we store LLM instructions as part of the solution?
- How can the generation of LLM tests be made easier?
Can we find a solution in other fields?

Solution and Project Organization in .NET

I think we have two types of project organization:

Language organization
File organization

From a language perspective, we have namespaces and classes. We can argue that we have projects (assemblies), too, but is a project more of a file type of organization or a language one?

From a file perspective, we have textual files that can have a single or more classes. We have folders and Projects - specialized file types that somehow group multiple files into one unit. That grouping can be done by folder, like in .NET Core, or by direct file reference, like in .NET (classic).

Of course, c# is multipurpose language, and it does not have to follow this organizational pattern strictly, but in most cases, it does. Most of us work on enterprise projects, where c# has the most significant strengths.

The Problem? - File Centric IDEs

Modern IDEs and Text Editors can only work with files! Why do we not use a different concept to open classes and not worry about how it is stored on our data system? Why are we so focused on the concept of files? Compilers work with classes, not files.

Sure, it made sense decades ago. Just take any text editor and do the work. But, most of us today use powerful IDEs and enhanced Text Editors that use more computing power for LLMs per single call than all the computers in the world in the 60s. Why not use that power differently?

The two most popular ways of navigating the files in software projects are the equivalent of the explorer, where we have a list of projects with a list of folders and files recursively. The second is some type of search, where we type parts of file name, class name, etc., and jump to specific parts of some file.

There are more practical ways, such as a 'go to' declaration, usage, etc. I frequently use source control's 'list of changed files' to jump to edited files. There are ways we can bookmark lines that some may find helpful.

There are options like 'peek definition' in Visual Studio and 'quick definition' in Rider that show small popup windows with details from other classes. It even gives you the option to edit the class. But it still switches your focus from one class to another, but in a popup window. You don't see the relationship.

Perhaps I'm missing something, but is the pinnacle of the environment for code writing tabs and windows?

The problem remains: There is no simple way to open, browse, and show related classes we often edit together. It is always a process to find and open related files.

I am a "visual thinker". I need Trello and Post-It notes; I need some way to visualize entities and relationships.

I like working with C# in Visual Studio and Rider, but I have to "imagine the visual part." I feel there is an opportunity to create some "Class Navigator" where you can visually explore and write code through class relationships, not by file organization.

I still don't know what that would look like, but I believe there is a better way to write code than opening a file and then another file and organizing windows.

I will try to explore this topic by creating a plugin for Rider, with limited capabilities, around a single idea of alternative-related class visualizations.

Part 2 will explore navigation in modern photo libraries and how it enables "multidimensional" navigation.

VukVuk

Corporations and the AI Hype Train

Book: Micro Frontends in Action

Author

Resources

Dead Horse Theory in Software Projects

What is the Dead Horse Theory?

Dead Horse Theory in Software Projects

Conclusions and Personal Dead Horses

Data as Code: An Alternative to Storing Static and Semi-static Data in Databases

Is storing all data in a database always the best choice?

Why Use Data as Code? Dynamic and Static Data

Data as a Service for (Semi) Static Data

Data as Code

Important Data Parameters

Data as Library

Data as Code in the .NET

Smart Enum

Static Class

Resx (+ Static Class)

Embedded Databases

Data Generation for Data in Code

Manual

LLM

Scripts and Apps

T4 Text Templates

Updating Data on Dev Machine or Pipeline and Testing Data

Data Warning!

Concerns

Memory

Recompilation

Versioning

Conclusions

Mermaid - Diagramming and Charting Tool

What is Mermaid(.js)?

Key Diagram Types and Examples

Kanban Diagram

Conclusion

References and Links

Report Build Times

Conclusions

👊😺🐯✈️💥🚀

Library: Spectre.Console

Conclusions

References

New Generation of IDEs (part 2): Multidimensional Navigation in Photo Libraries

New Generation of IDEs (part 2): Multidimensional Navigation in Photo Libraries

Multidimensional Code Searching

Code Browsing?

Computation Cost of the Indexing

Conclusions

LLM Incantations and Spellbooks

The Problem

The Solutions?

Conclusions

New Generation of IDEs (part 1): The problem of File-Centric IDEs

Solution and Project Organization in .NET

The Problem? - File Centric IDEs

Project and File Navigation in Modern IDEs

Relationship-based navigation?