I wish I had have that kind of career path, but my mind works a little bit differently. In my late teens the last thing I wanted to do was to work with computers, I wanted to play music, skateboard and just do all the things that you do when you are young and have a brain constantly chasing dopamine. In a weird way tough, I was always drawn to computers and was the go to guy for fixing computers among friends, but beeing a developer, that sounded boring and absolutley something I would never perceive myself doing.
A few years later while zapping through the channels on TV i stumbled upon a documentary about the Magnum photographer Robert Capa. From that moment on I knew I was going to be a photographer. The only problem was that I didn’t have a camera and I didnt really know how to use one. For my birthday that year, both problems were solved, I got an Canon EOS 300 (yeah it was film back then), a couple of rolls of black and white and color positive film and a book about photography. From that point I shot everything, everyday and it didn’t take that long before I was starting to get some small assignments. Around the same time I started university and got a degree in litterature and theater (theory). I met some really cool people who was involved in free theather groups and started to shot their performances and events and I also started to review books and plays for different magazines. So I did the shooting and the writing, It became a job, it was odd hours, it was long days and it was a bit strange to work when everyone else got home from their 9-5 jobs. It didnt really feel like the thing I wanted to spend the rest of my life doing. Around this time was the first time I started to think about working with computers as a profession, maybe it would be cool to build stuff and be creative in a different way? But I still had a pretty negative (boring) image of what a developer were but I applied for a computer science course at the university and got in.
The summer went, I was almost to old to go to school (or at least I told myself that), all my friends where establishing themself in their careers and I was still a photographer, but out of blue came an oppertunity to work as a photography teacher for a semester at a school for kids age 12-16. I thought about going to school for another four years or start earning money and have “a real” job and landed on the teaching job. Teaching kids was ok, but I found out that I the kids I worked best with where the ones that where in special class because they had a hard time with attention and impulse control. Those were the kids I could connect with and I found it rewarding and the highs and lows were often extreme and could change during the same day. The next semester I was offered a position as a full time teacher so I took it and later started to study for a teachers degree while I was working. I felt after a couple of years that teaching wasn’t really my thing (I had never really felt that It was…) and that I couldn’t keep doing it much longer. I thought about what I really liked about the job and the one thing that stood out was my 10% (or 15%, dont really remeber) of my time that I had for fixing the school computers.
The good thing about beeing really impulsive and beeing really bad at consecquences is that I make shit happen (all other parts are just bad…). I quit my teaching job and went back to school for a 2-year developer bootcamp. So whitout a real income and with two kids I was back in school and started to learn how to code. I was a bit older than the other students, I didn’t know the difference between backend or frontend, but choose to learn backend development, because my cousin is a backend developer so I went for the same path. I took me two, maybe three days to realize that I had hit jackpot with this decision. I found out that I really liked backend development, I liked the problem solving, the logic and the fact that I could be creative in a different way. It was really the perfect blend of what I had learned from 30 years of skateboarding and from photography. Skateboarding isn’t really about making tricks, it’s more about wanting to do something, failing, trying again, failing again, trying until it sticks. Pretty much like learning to code. Photography is about seeing the world in a different way, finding the right angle, the right light and the right moment. It have some similarities with designing a system or a feature, thinking about a problem, seeing it from different angles before acting on it. The fact that I had spent some years teching and studying on how to learn didn’t hurt either. Coding became a gift that kept on giving. I later found the whole open source community which had such resemblence to the skateboarding and punk DIY community and got even more hooked.
This is my fourth year as a develper and I don’t think I ever felt this passionate about a job before. In a way it’s weird because I work with my hobby. The downside of that, beeing that in periods I’m having a hard time doing other stuff (which always bite you in the end), but I guess that’s more of a me problem than a job problem.
Finally some similiraties and dissemblies between the different fields:
Douche comment in software development: “I use arch btw”
Douche comment in photography: “I use a Leica btw”
Douche comment in teaching: “I used to teach at university btw”
Reality in software development: “These requirements are really unclear!?”
Reality in photography: “These requirements are fucking impossible to meet without a proper budget!!”
Reality in teaching: “These requirements are impossible to meet regardless of budget!!”
Perk of beeing in software development: “I can work from home, I can work from anywhere in the world”
Perk of beeing in photography: “Nobody excpets anything from me, I’m a creative…”
Perk of beeing in teaching: “June, July and August…”
Downside of beeing in software development: “Hey, you work with computers, can you have a look at my printer?”
Downside of beeing in photography: “Hey, you’re a photographer, which camera should I buy?”
Downside of beeing in teaching: “Hey, you’re a teacher, let me tell you everything that’s wrong with the education system even tough I haven’t set foot in a school in twenty years?”
layout: post title: “Optimizing Rider on Wayland” date: 2026-07-29 21:00:00 +0200 categories: Dotnet, Linux, Wayland, Ubuntu, Gnome
Beeing a .NET developer on Linux is an awesome experiece, the days of .NET beeing a Windows only thing is long gone. For Linux (and Mac) users the go to places for writing .NET code is JetBrains Rider, Visual Studio Code and NeoVim. NeoVim and Visual Studio Code beeing more general and needing some tweaking for going from an texteditor to an actual IDE, the obivious choice for those of us seeking and IDE is therefore Rider. I’ve been using it on Linux for the last 4 years and it worked like a charm. But that said, there are of course ways in how we can make it even better.
First thing first, Rider is a hybrid consisting of two different procceses where the UI runs on a modfied version on the JVM (Java virtual machine) called the JBR, JetBrains Runtime. The analytic motor, ReSharper which is the motor that interprent and understands your code runs as a separate background process on .NET. These two procceses work together when you type something the JVM process receives the input, draws the charatchers on screen and sends an IPC (inter-process communication) to the .NET proccese that does the syntax validation and other compiler related jobs and then sends it back to the JVM proccese to it to act on the result.
If curious check active proccesses with pgrep -fa rider and you will see the these two procceses running along with helper processes.
Since the JVM is a virtual machine and works as a sandbox on your maching we can configure the JVM for better perforomance. To do this we need to go to Help -> Edit Custom VM Options.
The most appearant thing we can do is increasing the amount of memory Rider can consume. Depending on your machine you can set this to whatever see fit, the default value is 2048 MB. On my machine with 32 GB I have bumped it up to 6144 MB.
On a modern machine you can swap the garbage collector to G1GC. G1GC is optimized for doing the cleanup in shorter bursts, giving you a bit softer writing and scrolling experience under heavy load. The trade off beeing that it uses a bit more CPU, so again this is depending on the machine you have.
-Xmx6144m
For us running Wayland, make sure the JVM uses Wayland and not X11 or else Rider will run a compability layer called Xwayland which translates X11 calls to Wayland.
-Dcom.jetbrains.use.wayland.toolkit=true
Instead of having the CPU drawing every UI element we can send it directly to the graphics card.
-Dsun.java2d.opengl=true
So these simple changes can make Rider even better runing on Linxu with Wayland. My complete config looks like:
-Dide.managed.by.toolbox=Path to toolbox
-Dtoolbox.notification.token=Toobox token
-Dtoolbox.notification.portFile= Even more toolbox shit...
-Xmx6144m
-Dcom.jetbrains.use.wayland.toolkit=true
-XX:+UseG1GC
-Dsun.java2d.opengl=true
To make sure everything is working as expected you can check your settings in Help -> About and close and copy (yes, weird I know…) and paste it into a texteditor and check that the settings are there. If you have any other tips for optimizing Rider on Linux please let me know!
layout: post title: “Railway oriented programming with Java” date: 2026-02-16 22:00:00 +0100 categories: Java, Patterns
The term railway oriented programming have been around a while and you can (and should) check it out since there’s a lot of great resources out there. But many of these examples are written in functional languages so I thought it would be fun to give some examples in Java.
First thing first, what is railway oriented programming? In short it’s a way of handling the control flow in a more functional matter, think - less hard to follow control flow and a more conveyor belt like way of handling your applications flow. The railroad part is a great way of building a mental model, instead of having our control flow like a busy main street with intersections and roundabouts we can think of it as a train track where we have our track (our happy path) but it can be derailed leading to an exception. A close relative to this thought is a monad but lets not go there now ;)
In the heart of our Java implementation we’re going to start with a interface that will look like this
public sealed interface Result<T> permits Success, Failure {
}
Here we have a sealed interface that only permits Success and Failure. As you’ve probably guessed Success and Failure will be the two types that carries our result.
public record Success<T>(T value) implements Result<T> {
}
Our Success record holds a value of T (bare with me if you’re allergic to Generics, you can implement a type but as you will see, there are huge benefits with sticking to Generics).
public record Failure<T>(String error) implements Result<T> {
}
Our Failure record only hold a error message. So this far it’s really straight forward, but now we’re going to add some functionality to our Result
We start of with some static helpers so we can return success or failure, this is nice to haves and we could live without it, but it will come quite handy as you will see.
static <T> Result<T> success(T value) {
return new Success<>(value);
}
static <T> Result<T> failure(String error) {
return new Failure<>(error);
}
The next step is to implement a fold method whose only job is to say:
To make it do this we create a method with a really shitty(or at least hard to read - sorry this was the best I could come up with) method signature.
<R> R fold(Function<? super T, ? extends R> onSuccess,
Function<? super String, ? extends R> onFailure)
It basically takes two functions, one for success and one for failure and they both return the same type R. With that reading pain out of the way we can look at the whole function:
default <R> R fold(Function<? super T, ? extends R> onSuccess,
Function<? super String, ? extends R> onFailure) {
if (this instanceof Success<?> s) {
T value = (T) s.value();
return onSuccess.apply(value);
}
Failure<?> f = (Failure<?>) this;
return onFailure.apply(f.error());
}
Here we check if it’s an instanceof Success (remember the record), then run the onSuccess function. Otherwise run the onFailure function.
I don’t blame you if you’re confused now, but when we combine this with a bind function (sometimes called a flatMap) then it gets useful
default <U> Result<U> bind(Function<? super T, ? extends Result<U>> next) {
return fold(
next,
Result::failure
);
}
So bind takes a success value (T) and returns another result with the help of fold. This makes it possible to chain methods together to create a chain (or a track).
Our complete Result
public sealed interface Result<T> permits Success, Failure {
static <T> Result<T> success(T value) {
return new Success<>(value);
}
static <T> Result<T> failure(String error) {
return new Failure<>(error);
}
default <R> R fold(Function<? super T, ? extends R> onSuccess,
Function<? super String, ? extends R> onFailure) {
if (this instanceof Success<?> s) {
T value = (T) s.value();
return onSuccess.apply(value);
}
Failure<?> f = (Failure<?>) this;
return onFailure.apply(f.error());
}
default <U> Result<U> bind(Function<? super T, ? extends Result<U>> next) {
return fold(
next,
Result::failure
);
}
}
Sorry for my extremly bad imagination but lets say we have a really weird utility class that we use for checking if an Integer is positive. Instead of having a lot of if-checks we can simply use our Result
public class PositiveIntegerUtil {
public static Result<Integer> validate(Integer candidate){
return isNull(candidate)
.bind(PositiveIntegerUtil::isPositive);
}
private static Result<Integer> isNull(Integer candidate){
return candidate == null
? Result.failure("Number cannot be null")
: Result.success(candidate);
}
private static Result<Integer> isPositive(Integer candidate){
return candidate < 0
? Result.failure("Number must be positive")
: Result.success(candidate);
}
}
It’s a stupid example but lets pretend that we had more checks to do, it’s not that hard to see how this could be really useful to chain all the validation logic together with an easy short-circut if something breaks.
Just to get a clear sense of the usage we can write some tests to see
package util;
import org.example.result.Failure;
import org.example.result.Success;
import org.example.util.PositiveIntegerUtil;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
public class PositiveIntegerUtilTest {
@Test
public void givenANegativeInteger_whenValidating_thenFailure() {
var result = PositiveIntegerUtil.validate(-1);
assertInstanceOf(Failure.class, result);
var failure = (Failure<Integer>) result;
assert(failure.error().contains("must be positive"));
}
@Test
public void givenANullInteger_whenValidating_thenFailure() {
var result = PositiveIntegerUtil.validate(null);
assertInstanceOf(Failure.class, result);
var failure = (Failure<Integer>) result;
assert(failure.error().contains("Number cannot be null"));
}
@Test
public void givenAPositiveInteger_whenValidating_thenSuccess() {
var result = PositiveIntegerUtil.validate(1);
assertInstanceOf(result.getClass(), result);
var success = (Success<Integer>) result;
assert(success.value() == 1);
}
}
A real win we get from having our Result
package org.example.util;
import org.example.result.Failure;
import org.example.result.Result;
import org.example.result.Success;
public class StringUtil {
public static Result<String> validate(String candidate){
return isNull(candidate)
.bind(StringUtil::isEmpty);
}
private static Result<String> isEmpty(String candidate){
return candidate.isEmpty()
? new Failure<>("String cannot be empty")
: new Success<>(candidate);
}
private static Result<String> isNull(String candidate){
return candidate == null
? new Failure<>("String cannot be null")
: new Success<>(candidate);
}
}
package util;
import org.example.result.Failure;
import org.example.result.Success;
import org.example.util.StringUtil;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
public class StringUtilTest {
@Test
public void givenAString_whenValidating_thenSuccess() {
var result = StringUtil.validate("racecar");
assertInstanceOf(Success.class, result);
var success = (Success<String>) result;
assertEquals("racecar", success.value());
}
@Test
void givenNull_whenValidating_thenFailureWithMessage() {
var result = StringUtil.validate(null);
assertInstanceOf(Failure.class, result);
var failure = (Failure<String>) result;
assertEquals("String cannot be null", failure.error());
}
@Test
void givenEmptyString_whenValidating_thenFailureWithMessage() {
var result = StringUtil.validate("");
assertInstanceOf(Failure.class, result);
var failure = (Failure<String>) result;
assertEquals("String cannot be empty", failure.error());
}
}
So should I never write a if statement again? Yes you probably should but this pattern can come really handy when the control flow starts to get a bit to nested and the logic get hard to follow. That’s all for this time, hope you found something useful!
]]>There are of course patterns to deal with this but what if you could just stop worrying alltogether? Well now we got a big step on the way towards that can 🎉
With Spring Boot 4 we get an implementation of JSpecify we can now say thats it’s not null by default with @NullMarked annotation.
So how do you get this sweetness into your life?
It’s actualy pretty straight forward, add a new (or update your old) package-info.java file like:
@NullMarked
package com.your.path.here;
import org.jspecify.annotations.NullMarked;
Something to remember here tough is that sub-packages doesn’t inherit the package-info file so they need to be declared per package.
Then if you need stuff to still possible return null
@NullMarked
@Service
public class CanReturnNullService{
@Nullable
public Todo findById(Long id) {
return todoRepository.findById(id).orElse(null);
}
}
You can even use this for input parameters and mark them with @Nullable.
By now you’re probably wondering why you just can’t use Optional everywhere instad. In my opinion it’s not an either or, have them both in your toolbelt but I think @NullMarked is specially good in those cases where you don’t want to brake an existing contract. Changing a return type breaks it.
@Service
public class CanReturnNullService{
// Doesn't break any contract
@Nullable
public Todo findById(Long id) {
return todoRepository.findById(id).orElse(null);
}
// Breaks contract
// if existing contract is
// public Todo findById(Long id)
public Optional<Todo> findById(Long id) {
return todoRepository.findById(id);
}
}
So use them both, they both have there place, on a new service/api/project I would probably use Optional but since reality often involves existing contracts I think @NullMarked is a really good tool.
]]> var response = await chatClient.GetResponseAsync<MealPlan>(chatHistory);
In my particular use case a MealPlan is a model that holds recipes and are tied to a user. The recipe in it’s turn has a list of ingredients. Some off the issues i had was that the LLM (gpt-5-mini in my case) had a hard time with the nesting so I ended up with a graph tree that Entity Framework couldn’t save.
First thing I realized that I screwed up was that I allowed the LLM to create GUIDs which resulted in me getting faulty GUIDs for some properties. So I hade to let Entity Framework be in charge of that and use decorations to make shure it was database generated and ignored when parsing on all my Id properties that were affected.
[JsonIgnore]
[Required]
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public Guid Id { get; init; }
The second issue I had was with the relations where I would sometimes get meal plans without recipes and other times I would get loops of mealplans with recipes that had the mealplan inside them that had the recipe inside and so on resulting in a huge json payload (glad I hade the [NotMapped] decorator on affected entities in Entity Framework). And as first step I tried to be more precise in the prompt rules
new(ChatRole.System, """
You are a friendly assistant that plans meals for a family. You give them:
1. The recipes that they can cook
2. The ingredients that they can use
Your goal is to always bring a mix of easy to cook meals, that are affordable and also nutritious.
Output a single JSON object that matches the MealPlan schema expected by the app.
Rules:
- Do NOT include any properties named "id" or ending with "Id" (they will be generated/assigned server-side).
- Do NOT include navigation objects (e.g., do not embed Recipe inside Ingredient).
- Make sure that recipes and ingredients are created and unique.
"""),
This made the output a lot better and I got it working pretty sweet. But I would still say that fixing issues like his can be pretty cumbersome since the LLM outputs are non determinitic by nature which makes it a lot harder to predict the outcome. With that said beeing able to cast the output is a huge help.
]]>So the situation is that I recently bought a some new plants for indoor use and planted some seeds in my garden. All of this is great but whats the point of buying something if I can’t build something to go along with it 😉
I’ve previously built a small soil moisture sensor that I use to monitor the soil moisture for indoor plants. It works but now I needed something that I could leave outside and survive the weather. I could of course have but a ESP-32 in a waterproof box but I already know how to do that so whats the fun in that?
The most obvious solution and probably the best one would be to set an alarm on my phone or use a calendar app to remind me to water the plants. But again, where is the fun in that?
Instead I decided to use Azure Functions and a timer trigger to send me an email every day at 8:00 AM reminding me to water the plants. This is of course a very bad idea since I will get an email every day even if I don’t need to water the plants. But hey, I had never used Azure Functions before so why not?
I created a new Azure Function project and added a timer trigger function that runs every day at 8:00 AM. The code looks something like this:
public class TimeFunc(ILoggerFactory loggerFactory)
{
private readonly ILogger _logger = loggerFactory.CreateLogger<WateringTimeFunc>();
[Function("WateringTimeFunc")]
public void Run([TimerTrigger("0 0 20 * * *")] TimerInfo myTimer)
{
_logger.LogInformation("C# Timer trigger function executed at: {executionTime}", DateTime.Now);
}
}
The next step was sending a reminder email (I now this is so stupid, there are a hundred ways to do this better…), I previously used SendGrid to send emails so I decided to go with that. BUT…. Appearantly SendGrid didn’t have a free option (apart from a 60 day trial) so that went to shit. After some searching I found out that Azure has a service called Azure Communication Services that includes email capabilities and has a free tier. So I decided to give that a try.
I created a new Azure Communication Services resource in the Azure portal and obtained the connection string. Then I updated my Azure Function to use the Azure Communication Services SDK to send the email. The updated code looks like this:
public class TimeFunc(ILoggerFactory loggerFactory)
{
private readonly ILogger _logger = loggerFactory.CreateLogger<WateringTimeFunc>();
[Function("TimeFunc")]
public void Run([TimerTrigger("0 0 20 * * *")] TimerInfo myTimer)
{
_logger.LogInformation("C# Timer trigger function executed at: {executionTime}", DateTime.Now);
var connectionString = Environment.GetEnvironmentVariable("EmailPrimary");
if (string.IsNullOrEmpty(connectionString))
{
throw new InvalidOperationException("Cant access connection string.");
}
var senderAddress = Environment.GetEnvironmentVariable("SenderEmailAddress");
var recipientAddress = Environment.GetEnvironmentVariable("RecipientEmailAddress");
var emailClient = new EmailClient(connectionString);
try
{
var emailSendOperation = await emailClient.SendAsync(
wait: WaitUntil.Completed,
senderAddress: senderAddress,
recipientAddress: recipientAddress,
subject: "Dags att vattna blommorna",
htmlContent: "<html><body>Vattna blommorna!</body></html>");
_logger.LogInformation("Email sent successfully with operation ID: {operationId}", emailSendOperation.Id);
}
catch (RequestFailedException ex)
{
_logger.LogError($"Email send operation failed with error code: {ex.ErrorCode}, message: {ex.Message}");
}
}
}
Everything was smooth sailing from here, I deployed the function to Azure and set up the necessary environment variables for the connection string and email addresses. Now, every day at 8:00 AM, I receive an email reminding me to water my plants. I will probably be annoyed after a week or so and just turn it off, but hey, I learned something new and had some fun along the way!
]]>@FunctionalInterface
interface CheckTwoObjects {
boolean check(Object o1, Object o2);
}
In C# we can use Func<T, T, T>, Action
public static bool CompareTwoComparableObjects<T1, T2> (T1 t1, T2 t2, Func<object, object, bool> comparison, Func<object, object, bool> typeCheck) => comparison(t1, t2) && typeCheck(t1, t2);
public static bool AreEqual(object o1, object o2) => o1.Equals(o2);
public static bool AreIntegers(object o1, object o2) => o1 is int && o2 is int;
Here we have three methods. The first one takes two generic objects and two functions that both takes two objects and return boleans. As you probably guessed we are going to put the last two methods in the first one like this:
var result = CompareTwoComparableObjects("someValue", "someOtherValue", AreEqual, AreIntegers);
This simple method makes it possible for us to create something very similar to Javas functional interfaces and we can use the method like:
var a = "x";
var b = 5;
var checkTheseTwo = CompareTwoComparableObjects(a, b, AreEqual, AreIntegers);
Console.WriteLine($"{a} and {b} have the same value and are numbers : {checkTheseTwo}");
You can of course write any combination of methods, I choose simple predicates just to keep it simple in this example but hey, go wild :)
]]>For someone coming from a different background this might be a bit confusing so lets have a look and see whats going on.
In our example we are creating something that can help us sort tarantulas in case they are poisonous or not. We start of with a class called Tarantulas that looks like this:
public sealed class Tarantula
{
public string Name { get; set; }
public bool IsNewWorld { get; set; }
public bool IsPoisonous { get; set; }
}
If we then create a list of various tarantulas, and filter out the non venomous ones before printing the result we get something like this:
List<Tarantula> tarantulas =
[
new Tarantula
{
Name = "Poecilotheria regalis",
IsNewWorld = false,
IsPoisonous = true
},
new Tarantula()
{
Name = "Aphonopelma chalcodes",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Brachypelma hamorii",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Tliltocatl albopilosus",
IsNewWorld = true,
IsPoisonous = false
}
];
var poisoniusTarantulas = tarantulas.Where(spider => spider.IsPoisonous);
Console.WriteLine("Dont pet: ");
foreach (var tarantula in poisoniusTarantulas)
{
Console.WriteLine(tarantula.Name);
}
So far it’s all pretty straight forward. But what if we add a new tarantula to the list after we have filtered out the non venomous ones?
List<Tarantula> tarantulas =
[
new Tarantula
{
Name = "Poecilotheria regalis",
IsNewWorld = false,
IsPoisonous = true
},
new Tarantula()
{
Name = "Aphonopelma chalcodes",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Brachypelma hamorii",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Tliltocatl albopilosus",
IsNewWorld = true,
IsPoisonous = false
}
];
var poisoniusTarantulas = tarantulas.Where(spider => spider.IsPoisonous);
var poisonius = tarantulas.GetPoisonousTarantulas();
tarantulas.Add(
new Tarantula
{
Name = "Pelinobius muticus",
IsNewWorld = false,
IsPoisonous = true
});
Console.WriteLine("Dont pet: ");
foreach (var tarantula in poisoniusTarantulas)
{
Console.WriteLine(tarantula.Name);
}
This will print
Dont pet:
Poecilotheria regalis
Pelinobius muticus
This is because the query is not executed until we actually need the result. If we want to execute the query immediately we can use the ToList() method.
var poisoniusTarantulas = tarantulas.Where(spider => spider.IsPoisonous).ToList();
and then our output will be
Dont pet:
Poecilotheria regalis
Strange? Not really, just remember that LINQ uses deferred execution, think of it as lazy loading, query will not be called until needed.
To make it even more clear we can create an extension method that prints the name and then yield returns the poisonous tarantulas.
public static class SpiderExtensions
{
public static IEnumerable<Tarantula> GetPoisonousTarantulas(this IEnumerable<Tarantula> tarantulas)
{
foreach (var tarantula in tarantulas)
{
Console.WriteLine($"{tarantula.Name} is sorted here");
if (tarantula.IsPoisonous)
{
yield return tarantula;
}
}
}
}
And then we can call it like this:
var poisonius = tarantulas.GetPoisonousTarantulas();
this will print
Aphonopelma chalcodes
Brachypelma hamorii is sorted here
Brachypelma hamorii
Tliltocatl albopilosus is sorted here
Tliltocatl albopilosus
Pelinobius muticus is sorted here
Pelinobius muticus
If we change it to use the ToList() method to execute the query immediately.
var poisonius = tarantulas.GetPoisonousTarantulas().ToList();
this will output
Poecilotheria regalis is sorted here
Aphonopelma chalcodes is sorted here
Brachypelma hamorii is sorted here
Tliltocatl albopilosus is sorted here
Dont pet:
Poecilotheria regalis
Finally we can use the both sorting methods but only call the list that didn’t use the extension method. We see that the extension method is never called since it doesn’t print anything.
public sealed class Tarantula
{
public string Name { get; set; }
public bool IsNewWorld { get; set; }
public bool IsPoisonous { get; set; }
}
public static class SpiderExtensions
{
public static IEnumerable<Tarantula> GetPoisonousTarantulas(this IEnumerable<Tarantula> tarantulas)
{
foreach (var tarantula in tarantulas)
{
Console.WriteLine($"{tarantula.Name} is sorted here");
if (tarantula.IsPoisonous)
{
yield return tarantula;
}
}
}
}
List<Tarantula> tarantulas =
[
new Tarantula
{
Name = "Poecilotheria regalis",
IsNewWorld = false,
IsPoisonous = true
},
new Tarantula()
{
Name = "Aphonopelma chalcodes",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Brachypelma hamorii",
IsNewWorld = true,
IsPoisonous = false
},
new Tarantula
{
Name = "Tliltocatl albopilosus",
IsNewWorld = true,
IsPoisonous = false
}
];
var poisoniusTarantulas = tarantulas.Where(spider => spider.IsPoisonous);
var poisonius = tarantulas.GetPoisonousTarantulas();
tarantulas.Add(
new Tarantula
{
Name = "Pelinobius muticus",
IsNewWorld = false,
IsPoisonous = true
});
Console.WriteLine("Dont pet: ");
foreach (var tarantula in poisoniusTarantulas)
{
Console.WriteLine(tarantula.Name);
}
Which will output
Dont pet:
Poecilotheria regalis
Pelinobius muticus
Hope use had some use of this post and just for the record, Pelinobius muticus isn’t that poisonous, but really defensive (and big) and I couldn’t think of any other tarantula that was poisonous :D
]]>If we imagine a stack of records (not a C# record but a vinyl record) and we have three vinyl records: at the bottom we have Miles Davis - Kind of blue, in the middle we have Nas - Illmatic and at the top we have Toots and the Maytals - In the dark. So far so good, but now we want to listen to Illamtic. Since it’s in the middle we first have to remove In the dark to access Illmatic. If we instead want to listen to Kind of blue we have to remove both In the dark and Illmatic since it’s at the bottom. This is the core principle of the stack! We can also put it as first in - first out FILO. Lets say we got a stack of numbers. Like 1, 2, 3, 4 and 5 and we want to access 3. Then we have to remove 5 and 4. so our new stack is 1, 2 and 3. The process of removing from a stack is called poping and if we add to the stack we call that pushing.
If we return to our stack of three vinyl records, lets say that we have built ourself some kind of vinyl record storage. Since we only had three records and we’re out of money we only build or storage for three records. One day a friend comes and gives us a fourth vinyl record. We try and put it in the storage but remember, we only built it for three vinyl records so when we add the fourht theres no room for it. Now we got a stack overflow.
If we instead would sell all of our vinyl records and then forgets about it and we go to our storage to get a vinyl record but it’s empty, then we got a stack underflow.
For this example I worked with a linked list. A linked list is a list of nodes where each node has a value and a reference to the next node. If we have a linked list of three letters A, B and C.
The first node A has the value of A and a reference to B.
The second node has the value of B and a reference to C.
The third node has the value of C and a null reference.
public class StackLinkedList
{
private static LinkedListNode<int>? _first = null;
public static LinkedList<int> List = [];
}
as you can see our stack class consists of a linked list and a linked list node called _first that will serve as our reference to where we are in the stack. Lets add methods for pop and push operations on the stack
// our Push method takes a value
public void Push(int value)
{
// we create a new node to hold our value
var newNode = new LinkedListNode<int>(value);
// we assign our _first node the value
_first = newNode;
// and finally adds it to the stack
List.AddLast(newNode);
}
public void Pop()
{
// we create a temporary node to print we value we remove (this is not neccessary if you dont care what is removed)
var temp = _first;
// if _first is null and we try to remove we get a stack underflow
if (_first is not null)
{
// we make the node behind first node the new first node (ideally we would like to check so there's an actual node behind too but I tried to make it as concise as possible )
_first = _first.Previous;
// them we remove the last element of the stack
List.RemoveLast();
}
// this is just for visualisation later on
if (_first != null)
{
Console.WriteLine($"Removed element {temp.Value});
};
}
Now we have implemented pop and push operations and our stack is pretty much complete. To make it easier to follow I will add a method to print our stack to the console.
public void PrintStack()
{
var currentNode = _first;
while (currentNode != null)
{
Console.WriteLine(currentNode?.Value);
currentNode = currentNode?.Previous;
}
}
So lets look at our stack class
public class StackLinkedList
{
private static LinkedListNode<int>? _first = null;
public static LinkedList<int> List = [];
public void Push(int value)
{
var newNode = new LinkedListNode<int>(value);
_first = newNode;
List.AddLast(newNode);
}
public void Pop()
{
var temp = _first;
if (_first is not null)
{
_first = _first.Previous;
List.RemoveLast();
}
if (_first != null) Console.WriteLine($"Removed element {temp.Value}");
}
public void PrintStack()
{
var currentNode = _first;
while (currentNode != null)
{
Console.WriteLine(currentNode?.Value);
currentNode = currentNode?.Previous;
}
}
}
We have a list that we can add (pop) and remove (push) from. Let’s see it in action.
var stackLinkedList = new StackLinkedList();
stackLinkedList.Push(1);
stackLinkedList.Push(2);
stackLinkedList.Push(3);
stackLinkedList.PrintStack();
stackLinkedList.Pop();
stackLinkedList.PrintStack();
This will print
3
2
1
Removed element 3
2
1
As we see we always travel from front to back (or top to bottom). First in -> Last out. This is the FILO principle.
What if we rather would like to have a first in -> first out order FIFO? Then we can use the queue structure. We can imagine a regular queue of people in a store. The first person in line will be the first to be served. If we have a queue of five people: Anna, Mohammed, Lisa, Shawn and Aila. For Lisa to be served we have to serve Anna and Mohammed first. If we add another person to our queue the we are doing an enqueue and if Anna has gotten served and is removed from the queue then have done a dequeue. Remember first in - first out. Just as the stack if our queue are full and we try to add another element then we get an overflow. If our queue are empty and we try to remove another item then we get an underflow.
Once again we will work with a linked list to make it easy to follow.
public class QueueLinkedList
{
private static LinkedListNode<int>? _first = null;
private static LinkedListNode<int>? _last = null;
public static LinkedList<int> List = [];
}
The difference here comapared to the stack is that we now has two references. The first and the last node of the queue.
To peform enqueue and dequeue operations we add two methods.
// we input the value we want to add
public void Enqueue(int value)
{
// we create a new node to hold our value
var newNode = new LinkedListNode<int>(value);
// if the first node is empty both first and last node will hold the same value
_first ??= newNode;
_last = newNode;
// we add the node at the end of our list
List.AddLast(newNode);
}
public void Dequeue()
{
// we create a temporary node for printing only so this isn't anything you need to do
var temp = _first;
if (_first is not null)
{
// here we also should check that we have a node second to first but to make it easier to follow I skiped that step instead we assign the second node as first
_first = _first.Next;
// we remove the first node
List.RemoveFirst();
}
// we print out the result
Console.WriteLine($"Removed element {temp.Value}");
}
Finally we create a method to print out que.
public void PrintQueue()
{
var currentNode = _first;
while (currentNode != null)
{
Console.WriteLine(currentNode?.Value);
currentNode = currentNode?.Next;
}
}
So our complete class will look like:
public class QueueLinkedList
{
private static LinkedListNode<int>? _first = null;
private static LinkedListNode<int>? _last = null;
public static LinkedList<int> List = [];
public void Enqueue(int value)
{
var newNode = new LinkedListNode<int>(value);
_first ??= newNode;
_last = newNode;
List.AddLast(newNode);
}
public void Dequeue()
{
var temp = _first;
if (_first is not null)
{
_first = _first.Next;
List.RemoveFirst();
}
Console.WriteLine($"Removed element {temp.Value}");
}
public void PrintQueue()
{
var currentNode = _first;
while (currentNode != null)
{
Console.WriteLine(currentNode?.Value);
currentNode = currentNode?.Next;
}
}
}
Lets see it in action!
var queueLinkedList = new QueueLinkedList();
queueLinkedList.Enqueue(1);
queueLinkedList.Enqueue(2);
queueLinkedList.Enqueue(3);
queueLinkedList.PrintQueue();
queueLinkedList.Dequeue();
queueLinkedList.PrintQueue();
We set it up the same way as we did with the stack but now it will print
1
2
3
Removed element 1
2
3
So this was the stack and the queue structures. To summarize:
The stack works with FILO -> first in, last out.
The Queue works with FIFO -> first in, first out!
If we add to add stack we are pushing.
If we remove from the stack we are popping.
If we add to the queue we are doing an enqueue.
If we remove the from the queue we are doing an dequeue.
Until next time, tack care!
]]>The second disclaimer is that some of the nuget packages I use in this post are in alpha or release-candidates so when you are reading this there may be newer releases with added functionality or breaking changes. With that said, lets jump in to how to create a multi agent system with Semantic Kernel.
If we are going to work with AI agents the first thing to do is to define what an AI agnent is in the Semantic Kernel context. Microsoft describes it pretty straigh forward as “Agents are software based entities that leverage AI models to do works for you. They are built to perform a wide range of tasks and called different names based on the jobs they do.” in their documentation. They go on to list different examples like chatbots and copilots. But what does the agent consist of? An agent in Semantic Kernel is made up of three building blocks: plugins, planners and persona. A plugin is essentially a function and planners are execution plans for these functions. If you haven’t read my previous post about creating planners in Semantic Kernel it may be a good idea to do that if you haven’t worked with planners, prompts or kernel functions before. Given an agent a persona sounds kind of creepy but it’s more in the lines of context. The persona is the part that communicate with the end user. Think of the chatGPT interface where you can have a conversational style of interacting with the model. This is the persona. Here we give the agent a context of what role it has and what we wish to achive.
Now that we now the lingo it’s time for some coding! I’ve made a simple demo project where the main idea is to build a photography helper that can help us create photo trips depending on what we want to shoot. Maybe not the most original idea but I needed something for this demo so it will do for this purpose.
First thing first let’s download the following nuget packages
dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI --version 1.19.0
dotnet add package Microsoft.SemanticKernel.Agents.Core --version 1.19.0-alpha
dotnet add package Microsoft.SemanticKernel.Agents.Abstractions --version 1.19.0-alpha
dotnet add package Microsoft.SemanticKernel.Agents.OpenAI --version 1.19.0-alpha
As you can see the packages for working with agents are still in alpha so please keep in mind that this is pretty unstable and likely to change, it’s not something yoy want to take to production. For testing these packages at home, remeber to disable the warnings from Rozlyn with:
#pragma warning disable SKEXP0110, SKEXP0001
Once we downloaded all the nuget packages and disabled the warning it’s time to set up Semantic Kernel.
var kernel = Kernel.CreateBuilder()
.AddOpenAIChatCompletion(
modelId: "gpt-4o",
apiKey: "your-api-key-here"
)
.Build();
Try out the model you like, I went with 4o but maybe you can go for a cheaper model.
Now it’s time for us to create some agents. I decided to go with three agent (you can go with as many or as few you like just remember that more agents often leads to a higher cost since every agent integrates with the LLM). In this example we are going to create three agents:
The location scout will scout photography locations for us based on our requrements and give us recommendatinos on where to shoot and also create a plan of how to get there with public transportation.
The idea suggestor, the location scout will pass on the locations to the idea suggestor who will create ideas for photo shoots based on the locations given by the location scout.
The manager, the idea suggestor will pass on the ideas and location to the manager who will review them and ensure our requirements are met. If they are met hte manager will approve this by just responding “approve”.
To create our agents we create a new agent and give them instructions and a kernel. In this example we use the same kernel for all of our agents but you can use diferent kernels for different agents if you want to. It’s perfectly fine to use OpenAi for some and maybe AzureOpenAi or Llama for others.
// Create instructions for each of the agents
var locationScout = """
You are a photography location scout which will take the requirement and create a plan for suggesting photography locations in Skåne, Sweden.
Location scout understands the requirements and form the location documents with a plan on were to photograph and how to get there by public transportation from Lund
""";
var ideaSuggester = "You are a idea suggester and your goal is to suggest ideas for photography shoots by taking into consideration all the requirements given by the location scout.";
var manager = """
You are the manager that will review photographic ideas given by the idea suggester and make sure all client requirements are completed.
Once all client requirements are completed you can approve the request by just responding "approve".
""";
// Create a new agent
ChatCompletionAgent managerAgent =
new()
{
Instructions = manager, // Give it the instruction from above
Name = "ManagerAgent", // Give it a name, this can be whatever
Kernel = kernel // Point to a kernel
};
ChatCompletionAgent locationScoutAgent =
new()
{
Instructions = locationScout,
Name = "LocationScout",
Kernel = kernel
};
ChatCompletionAgent ideaSuggesterAgent =
new()
{
Instructions = ideaSuggester,
Name = "IdeaSuggester",
Kernel = kernel
};
If you look in the instructions for the manager the line below may seem a bit odd
"Once all client requirements are completed you can approve the request by just responding "approve".
This is the termination strategy it’s purpose is to define a definiton of done for our agents. To create a termination strategy we create a new class that inherits from the TerminationStrategy class.
using System.Diagnostics.CodeAnalysis;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.Agents.Chat;
namespace PhotographyHelpers;
[Experimental("SKEXP0110")] // Since it's in alpha this is an experimental feature so keep it out of production environments
public class ApprovalTerminationStrategy : TerminationStrategy
{
protected override Task<bool> ShouldAgentTerminateAsync(
Agent agent,
IReadOnlyList<ChatMessageContent> history,
CancellationToken ct
) => Task.FromResult(history[^1]
.Content?.Contains("approve", StringComparison.OrdinalIgnoreCase)
?? false);
}
This nothing fancy, the method is inherited from the TerminiationStrategy class and it evalutes the input messages from our chat to see if it meets our definition of done (our completion criteria). In this perticual case it takes the last message (first from the end) and check for the word “approve” since that is what we are looking for. If it’s found then true is returned.
Now it’s time to link everything together and we do that by creating a AgentGroupChat. The name is pretty selfexplanatory and what you do is you give your agents as input and sets the termination strategy.
AgentGroupChat chat = new(managerAgent, locationScoutAgent, ideaSuggesterAgent)
{
ExecutionSettings = new()
{
TerminationStrategy = new ApprovalTerminationStrategy()
{
Agents = [ managerAgent ],
MaximumIterations = 6
}
}
};
Here we give it the termination strategy we created earlier and explicitly say that it’s our managerAgent that can determine if the approval strategy has been fulfilled. I’ve set the maximum iterations to 6, you can set it to whatever you want and maybe 6 is a bit high in this case since it rarely needs all six attempts. The group chat holds our agents chat conversation and our conversation with the agents. All that’s left now is to tie it all together and create a really simple user interface so that we can interact with our agents.
Now we are going to create a simple command line interface so that we can interact with our agents and print the response from our agents.
Console.WriteLine("Specify what and when you want to photography");
while (true)
{
var input = Console.ReadLine();
chat.AddChatMessage(new ChatMessageContent(AuthorRole.User, input));
await foreach (var content in chat.InvokeAsync())
{
Console.WriteLine($"# {content.Role} - {content.AuthorName ?? "*"}: {content.Content}");
}
}
Here we start by presenting the user with a prompt to give the agents something to work with. Once we have a proimpt we add it as a chat message to the agents with the author role set to user. Our agents set of to work and we print each response by calling chat.InvokeAsync() and prinnting the response. Here you can alaborate freely to get the content that’s relevant for you.
Lets try it out by asking it to create a plan for a street photography shoot in Helsingborg for tomorrow! This is what we get:
Specify what and when you want to photography
I want to do some street photography tomorrow morning in Helsingborg
Assistant - ManagerAgent: That's a great idea! Could you provide any specific requirements or objectives you have in mind for your street photography session in Helsingborg? For instance, are there any particular subjects or themes you want to focus on, special locations you want to visit, or specific times you're aiming to capture? This will help in ensuring all your requirements are met.
Assistant - LocationScout: Excellent choice! Helsingborg offers diverse scenes for street photography, ranging from bustling city streets to tranquil harbor views. Here's a detailed plan for your street photography session tomorrow morning, including suggestions on where to photograph and how to get there by public transportation from Lund.
### Suggested Locations in Helsingborg
1. **Kärnan Tower and Surrounding Area**
- **Description:** Begin your day here for a panoramic view of the city and peaceful early-morning scenes in the nearby park. The medieval tower and its surrounding gardens offer excellent vantage points and interesting human activity.
- **Photography Subjects:** Historic architecture, early-morning light, people walking their dogs, joggers, and tourists.
2. **Stortorget (The Great Square)**
- **Description:** This is the heart of the city with vibrant street life, cafes, and historic buildings. It's perfect for capturing local life and urban architecture.
- **Photography Subjects:** Street performers, locals, and visitors interacting, architectural details.
3. **Kullagatan**
- **Description:** One of Sweden's oldest pedestrian streets, filled with shops, cafes, and colorful facades. It's a fantastic spot for candid street photography.
- **Photography Subjects:** Shoppers, street vendors, interesting shop windows, and pedestrians.
4. **Helsingborg Central Station Area**
- **Description:** A modern hub with a mix of contemporary and classic design. It's busy in the mornings with commuters.
- **Photography Subjects:** Commuters, travelers, reflections, and architectural contrasts.
5. **North Harbor (Norra Hamnen)**
- **Description:** A modern waterfront area with boats, modern residential buildings, and walking paths. It's usually quieter in the morning with potential for serene and reflective compositions.
- **Photography Subjects:** Boats, waterfront activities, reflections, and modern architecture.
### How to Get There by Public Transportation from Lund
1. **Lund to Helsingborg**
- Take the Öresundståg train from **Lund Central Station** to **Helsingborg Central Station**. The journey takes about 40-45 minutes with frequent departures, especially in the mornings.
2. **Getting Around Helsingborg**
- Most of the highlighted locations are within walking distance of each other and the Helsingborg Central Station, making it convenient to explore on foot.
### Detailed Itinerary
**06:00 AM - Departure from Lund**
- Arrive at Lund Central Station by 6:00 AM and catch the Öresundståg train to Helsingborg.
**07:00 AM - Arrive in Helsingborg**
- Arrive in Helsingborg Central Station by around 7:00 AM.
**07:15 AM - Kärnan Tower**
- Walk to Kärnan Tower, about a 10-minute walk from the Central Station.
- Spend around 45 minutes capturing the sunrise light and the serene morning atmosphere.
**08:15 AM - Stortorget**
- Head towards Stortorget, a 5-minute walk from Kärnan.
- Spend about an hour in Stortorget photographing the early bird locals, street performers, and architectural elements.
**09:15 AM - Kullagatan**
- Move to Kullagatan for some busy pedestrian street scenes.
- Spend around an hour photographing here.
**10:15 AM - Helsingborg Central Station Area**
- Circle back to the Central Station area to focus on commuter activities.
- Spend around 30-45 minutes here.
**11:00 AM - North Harbor (Norra Hamnen)**
- Walk to North Harbor (around 10-15 minutes from the Central Station).
- End your morning session capturing the tranquil scenes by the water and the unique modern architecture.
**12:00 PM - Conclusion**
- Option to grab lunch and review your photos, or head back to Lund by catching the Öresundståg train from Helsingborg Central Station.
### Tips for a Successful Street Photography Session
- **Early Start:** Early mornings provide soft light and fewer crowds.
- **Blend In:** Dress casually to avoid drawing too much attention.
- **Mind the Weather:** Check the forecast and dress accordingly.
- **Gear:** Bring a versatile lens (e.g., 35mm or 50mm) for varied shots.
- **Stay Safe:** Keep an eye on your surroundings and your gear.
Enjoy your street photography adventure in Helsingborg!
Assistant - IdeaSuggester: Sounds fantastic! Helsingborg has a lot to offer for a morning street photography session. Here's a well-rounded plan to capture the essence of the city:
### Suggested Locations in Helsingborg
1. **Kärnan Tower and Surrounding Area**
- **Description:** Start with the iconic Kärnan Tower, a medieval tower offering panoramic views. The surrounding park is perfect for catching the early morning light.
- **Photography Subjects:** Historic architecture, morning joggers, and the serene ambiance of the park.
2. **Stortorget (The Great Square)**
- **Description:** A lively square in the heart of Helsingborg. It's a great place to capture the hustle and bustle of city life.
- **Photography Subjects:** Early morning vendors, commuters, and cafes setting up for the day.
3. **Kullagatan**
- **Description:** One of Sweden's oldest pedestrian streets. It's lined with shops, cafes, and colorful facades.
- **Photography Subjects:** Shoppers, street vendors, interesting shop windows, and pedestrians.
4. **Sofiero Castle Gardens**
- **Description:** A bit of a walk or a short bus ride, but the gardens are splendid in the morning light.
- **Photography Subjects:** Garden landscapes, flowers in bloom, and the castle's architectural details.
5. **Helsingborg Central Station Area**
- **Description:** Modern design mixed with classic elements, a busy hub especially during morning rush hours.
- **Photography Subjects:** Travelers, architectural details, and the movement of trains.
### Detailed Itinerary
**06:00 AM - Departure from Lund**
- Arrive at Lund Central Station by 6:00 AM and catch an early Öresundståg train to Helsingborg.
- Travel Time: Approximately 40 minutes.
**07:00 AM - Arrive in Helsingborg**
- Arrive at Helsingborg Central Station.
**07:15 AM - Kärnan Tower**
- Walk to Kärnan Tower, roughly a 10-minute walk from the station.
- Spend around 45 minutes capturing the morning light and the tower's surroundings.
**08:00 AM - Stortorget**
- Head to Stortorget, about a 5-minute walk from Kärnan.
- Spend about an hour capturing the early city life and architectural splendor.
**09:00 AM - Kullagatan**
- Move to Kullagatan for some vibrant street scenes.
- Spend about an hour photographing here.
**10:00 AM - Helsingborg Central Station**
- Circle back to capture the bustling station area.
- Spend around 30-45 minutes.
**10:45 AM - North Harbor (Norra Hamnen)**
- Walk to North Harbor, approximately a 10-15 minute walk from the Central Station.
- Capture waterfront activities and modern architecture.
**11:30 AM - Sofiero Castle Gardens (Optional)**
- If you're up for it, take a short bus ride or drive to Sofiero Castle Gardens.
- Spend about an hour capturing the peaceful garden scenes.
**12:30 PM - Conclusion**
- Head back towards the central area for lunch and review your shots.
- Return to Lund by catching the Öresundståg train from Helsingborg Central Station.
### Tips for Success
- **Check the Weather:** Dress accordingly and be prepared for potential changes in conditions.
- **Blend In:** Dress in a way that helps you blend into the environment, avoiding attracting unwanted attention.
- **Keep Gear Light:** A versatile zoom lens and a lightweight tripod can be very handy.
- **Stay Safe:** Be aware of your surroundings, especially in busy areas.
Enjoy capturing the charm and vibrancy of Helsingborg!
Assistant - ManagerAgent: Your plan covers a great mix of locations that showcase Helsingborg's diverse scenes and atmospheres. All client requirements have been considered: starting early, capturing a blend of historic and modern settings, focusing on street life and architectural details, and incorporating a picturesque garden.
approve
As you can see the location scout start by giving us locations in Helsingborg and passing them on to the idea suggestor who gives us plans for what to photograph on the given locations. Finaly the manager looks at the plan and approves it. We have some tweaks we could do like telling the ideasuggestor not to repeat everything the location scout has said but instead just add to it. Our manager could instead respond with the whole plan before approving or we could introduce a fourth agent between the idea suggestor and manager that handels the packaging of the end user message so that everything we see would be the final plan. But that would require finetuning our loop with the Console.WriteLine so that it only printed the message from the agent that presents the finished plan.
So this was a quick introduction introduction on bulding multi agents systems in Semantic Kernel. I hope it can be a stepping stone and inspiration for you to do your own experiments with Semantic Kernel. Until next time, take care!
]]>