2024 on Funky Si's Test

Reflecting on 2024, goals for 2025

funkysi1701@gmail.com (funkysi1701) — Mon, 30 Dec 2024 20:00:00 +0000

It is that time of year again, time to reflect on the year that has passed and look forward to the year ahead. As with many years 2024 has been a mixed bag, some good stuff, and some not so good stuff. I did not make any goals at the start of 2024, but I am going to fix that for 2025.

Goals for 2025

Blog Posts
More Learning
Drink More Water and Do More Walks
Attend Conferences and User Groups

Blog Posts

For most of the year, I have not been writing blog posts. However, the Scottish Summit conference reignited my blogging spark, and I have written seven posts since then. My goal is to write one post a week. I am sure I will miss the odd week, but the important thing is not to miss two in a row.

More Learning

Being a developer is a constant journey of learning, and I have not done enough of that this year. During December, I completed a few challenges from Advent of Code , and I hope to do more of them. I have also discovered Exercism and started working through the C# track. I am sure there will be more opportunities to learn new things in 2025.

Health

2024 took an unusual turn. In June, I walked a half marathon across the Peak District , and since then, I have been doing lots of walks. Walking is good for my physical and mental health, so I intend to do more of it in 2025. I have a 5k scheduled for January, which should be lots of fun as it is around the wildlife park. On the same topic, I want to drink more water. Not sure how I am going to accomplish this as I am easily distracted by the current developer problem, instead of thinking about my health.

Conferences and User Groups

I want to attend a conference or user group once a month in 2025. Conferences and user groups are great places to meet people, learn new things, and be encouraged by the community. I have signed up as a volunteer for NDC London in January, and DDD North is back in February. I am sure I will be able to fill the other months with events soon enough as well.

What Happened in 2024

I did something in 2024 that I thought I would never do. I signed up for a half marathon hike across the Peak District for charity. This was an amazing achievement for me, involving lots of training walks and raising over £600 for charity.

My attendance at conferences and user groups has been a bit light this year. However, I did attend the Scottish Summit in October, which rekindled my blogging. I also attended DDD North with a couple of my work colleagues, which was great as usual.

Family life has kept me busy this year and has been my focus for much of the year. Next year, I want the focus to shift more to my work and career. I attended a couple of code club sessions with my eldest son, and it was great to see his skills develop. Like me, he wanted to help others with the coding exercise.

Automate develop to main pull requests

funkysi1701@gmail.com (funkysi1701) — Mon, 16 Dec 2024 20:00:00 +0000

Creating pull requests is part of day-to-day Git work: you propose changes, review them, and merge. Long-lived integration branches make that tedious if someone has to open the release PR by hand every time.

Automatic pull requests keep a develop → main (or master) PR open and refreshed when develop moves. Below are two patterns I use: GitHub Actions with the GitHub CLI, and Azure DevOps with a PowerShell script against the REST API.

GitHub

GitHub Actions can run whenever code is pushed to develop. Prefer create or update so a second push does not fail when the PR already exists — the same idea this site uses in .github/workflows/auto-pr.yml :

name: Auto PR
on:
 push:
 branches:
 - develop
 workflow_dispatch:

permissions:
 contents: read
 pull-requests: write

jobs:
 create-pr:
 runs-on: ubuntu-latest
 steps:
 - name: Check out repository code
 uses: actions/checkout@v4
 with:
 fetch-depth: 0
 ref: develop
 - name: Create or update pull request
 env:
 GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 run: |
 TITLE='Merge develop into main'
 BODY='Created by GitHub Actions.'
 if gh pr create -B main -H develop --title "$TITLE" --body "$BODY"; then
 exit 0
 fi
 PR=$(gh pr list --head develop --base main --state open --json number -q '.[0].number')
 if [ -n "$PR" ] && [ "$PR" != "null" ]; then
 gh pr edit "$PR" --title "$TITLE" --body "$BODY"
 else
 echo "No open PR found to update."
 exit 1
 fi

This runs on push to develop, checks out that branch, then creates a PR into main or edits the existing open develop → main PR. Pin actions/checkout to a major tag (or a full commit SHA in production workflows) and grant pull-requests: write.

The workflow uses the GitHub CLI . gh pr create opens the PR; gh pr edit refreshes title and body when create fails because one already exists. You can also fold create-or-edit into a one-liner if you prefer:

run: gh pr create -B main -H develop --title 'Merge develop into main' --body 'Created by GitHub action' || gh pr edit -B main --title "Merge develop into main" --body 'Created by GitHub action'

Azure DevOps

Azure DevOps has a similar feature to GitHub Actions called Azure Pipelines. You can create pipelines that run on specific triggers, such as when code is pushed to a specific branch. For Azure DevOps I have a PowerShell script that does most of the work; let’s have a look at it:

param (
 [Parameter(Mandatory=$true)][string]$repoName,
 [Parameter(Mandatory=$true)][string]$sourceBranch,
 [Parameter(Mandatory=$true)][string]$targetBranch,
 [Parameter(Mandatory=$true)][string]$prTitle,
 [Parameter(Mandatory=$true)][string]$prDescription
)

# Construct base URLs
$collectionUri = $env:SYSTEM_TEAMFOUNDATIONCOLLECTIONURI.TrimEnd('/')
$projectName = $env:SYSTEM_TEAMPROJECT
$apisUrl = "$collectionUri/$projectName/_apis"
$apiVersionQs = "?api-version=7.0"

# Create common headers
$headers = @{
 "Authorization" = "Bearer $env:SYSTEM_ACCESSTOKEN"
 "Content-Type" = "application/json"
}

# Step 1: Fetch the repository GUID using its name
$repositoryUrl = "$apisUrl/git/repositories/$repoName$apiVersionQs"
$repositoryResponse = Invoke-RestMethod -Uri $repositoryUrl -Method GET -Headers $headers
$repoGuid = $repositoryResponse.id # Extract the repository GUID

if (-not $repoGuid) {
 throw "Failed to retrieve repository GUID for repository '$repoName'"
}

# Now construct the project URL using the repository GUID
$projectUrl = "$apisUrl/git/repositories/$repoGuid"

# Construct full ref names
$sourceBranchRef = "refs/heads/$sourceBranch"
$targetBranchRef = "refs/heads/$targetBranch"

# Step 2: Prepare the body for the commit comparison using GetCommitsBatch API
$body = @{
 "itemVersion" = @{
 "version" = "$targetBranch"
 "versionType" = "branch"
 }
 "compareVersion" = @{
 "version" = "$sourceBranch"
 "versionType" = "branch"
 }
} | ConvertTo-Json

# Step 3: Call the Azure DevOps API to compare the branches using GetCommitsBatch
$diffUrl = "$projectUrl/commitsBatch$apiVersionQs"
$commitResponse = Invoke-RestMethod -Uri $diffUrl -Method POST -Headers $headers -Body $body

# Step 4: Check if there are any changes between the branches
if ($commitResponse.count -gt 0) {
 Write-Output "There are changes between $sourceBranch and $targetBranch."
} else {
 Write-Output "No changes between $sourceBranch and $targetBranch."
 return
}

# Check for existing active pull requests between source and target branches
$encodedSourceBranchRef = [System.Web.HttpUtility]::UrlEncode($sourceBranchRef)
$encodedTargetBranchRef = [System.Web.HttpUtility]::UrlEncode($targetBranchRef)
$checkPrUrl = "$projectUrl/pullrequests$apiVersionQs&searchCriteria.sourceRefName=$encodedSourceBranchRef&searchCriteria.targetRefName=$encodedTargetBranchRef&searchCriteria.status=active"
Write-Output "Checking for existing active pull requests between $sourceBranch and $targetBranch"
$existingPrs = Invoke-RestMethod -Method GET -Headers $headers -Uri $checkPrUrl
if ($existingPrs.count -gt 0) {
 # An active pull request already exists
 $existingPr = $existingPrs.value[0] # Assuming we take the first one if multiple exist
 $pullRequestId = $existingPr.pullRequestId
 Write-Output "An active pull request already exists between $sourceBranch and $targetBranch."
 Write-Output "Pull Request ID: $pullRequestId"
 Write-Output "##vso[task.setvariable variable=prId]$pullRequestId"
 return
}

# Create a Pull Request
$pullRequestUrl = "$projectUrl/pullrequests$apiVersionQs"
$pullRequest = @{
 "sourceRefName" = "$sourceBranchRef"
 "targetRefName" = "$targetBranchRef"
 "title" = "$prTitle"
 "description" = "$prDescription"
}

$pullRequestJson = ($pullRequest | ConvertTo-Json -Depth 5)

Write-Output "Sending a REST call to create a new pull request from $sourceBranch to $targetBranch"

# REST call to create a Pull Request
$pullRequestResult = Invoke-RestMethod -Method POST -Headers $headers -Body $pullRequestJson -Uri $pullRequestUrl

# Ensure the pull request ID exists
if (-not $pullRequestResult.pullRequestId) {
 throw "Pull request creation failed. No pull request ID returned."
}

$pullRequestId = $pullRequestResult.pullRequestId
Write-Output "Pull request created. Pull Request Id: $pullRequestId"
Write-Output "##vso[task.setvariable variable=prId]$pullRequestId"

This uses the Azure DevOps REST API to create a PR. The script takes the repository name, source branch, target branch, PR title, and PR description. It compares the branches, creates a PR when there are commits to merge, and reuses an existing active PR when one is already open. Run it as a pipeline step.

My pipeline has a step that looks a bit like:

 - task: PowerShell@2
 displayName: Create PR
 condition: eq(variables['Build.SourceBranch'], 'refs/heads/develop')
 inputs:
 targetType: 'inline'
 script: 'build/CreatePR.ps1 -repoName ProjectX -sourceBranch develop -targetBranch main -prTitle "Release $(Build.Number.Major).$(Build.Number.Minor).x" -prDescription "Dev to Prod"'
 env:
 SYSTEM_ACCESSTOKEN: $(System.AccessToken)

I only run this step on the develop branch, and you can see I supply all the parameters that are defined in my PowerShell script. I include the System.AccessToken so the step can call the REST APIs for the project.

For combining repositories before you automate promotion, see merge two projects into one . For a broader GitHub Actions walkthrough, start with using GitHub Actions .

If you have enjoyed this article and want to get a monthly email with all my latest articles, please sign up for my newsletter . If you have any questions or comments, please feel free to reach out or leave a comment below.

Common AI and Copilot Terms

funkysi1701@gmail.com (funkysi1701) — Mon, 09 Dec 2024 20:00:00 +0000

AI is everywhere at the moment, from chatbots to code completion tools like GitHub Copilot. Here are some common AI and Copilot terms with explanations.

Common AI and Copilot Terms

Artificial Intelligence (AI)

Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think and learn like humans. AI can be used for various applications, including natural language processing, image recognition, and decision-making. AI systems are designed to perform tasks that typically require human intelligence, such as visual perception, speech recognition, decision-making, and language translation.

Wikipedia: Artificial Intelligence

Machine Learning (ML)

Machine Learning (ML) is a subset of AI that involves the use of algorithms and statistical models to enable machines to improve their performance on a specific task through experience. ML algorithms learn from data and make predictions or decisions without being explicitly programmed. Machine learning is used in a variety of applications, such as email filtering, fraud detection, and recommendation systems.

Wikipedia: Machine Learning

Natural Language Processing (NLP)

Natural Language Processing (NLP) is a field of AI that focuses on the interaction between computers and humans through natural language. NLP enables machines to understand, interpret, and generate human language, making it possible for AI systems to communicate with users in a more natural way.

Wikipedia: Natural Language Processing

GitHub Copilot

Copilot is an AI-powered code completion tool developed by GitHub in collaboration with OpenAI. It uses machine learning models to provide code suggestions and autocompletions based on the context of the code being written. Copilot helps developers write code faster and with fewer errors by offering relevant code snippets and completing lines of code as they type. It supports a wide range of programming languages and can be integrated into popular code editors like Visual Studio Code.

Retrieval-Augmented Generation (RAG)

Retrieval-Augmented Generation (RAG) is a technique that combines retrieval-based and generation-based approaches to improve the performance of AI models in tasks such as question answering and text generation. RAG involves retrieving relevant documents or information from a large corpus and using that information to generate more accurate and contextually relevant responses.

Large Language Models (LLM)

Large Language Models (LLM) are a type of AI model that is trained on vast amounts of text data to understand and generate human language. These models, such as GPT-3, are capable of performing a wide range of language tasks, including translation, summarization, and question answering. LLMs leverage deep learning techniques to capture the nuances of language and provide highly accurate and contextually relevant outputs.

Wikipedia: Language Models

Generative Pre-trained Transformer (GPT)

Generative Pre-trained Transformer (GPT) is a type of large language model developed by OpenAI. GPT models, such as GPT-3, are pre-trained on a diverse range of internet text and fine-tuned for specific tasks. GPT models are known for their ability to generate coherent and contextually relevant text, making them useful for applications such as chatbots, content creation, and code generation.

Deep Learning

Deep Learning is a subset of machine learning that involves the use of neural networks with many layers (deep neural networks) to model complex patterns in data. Deep learning has been particularly successful in tasks such as image and speech recognition, natural language processing, and game playing.

Neural Networks

Neural Networks are a series of algorithms that attempt to recognize underlying relationships in a set of data through a process that mimics the way the human brain operates. Neural networks consist of layers of interconnected nodes (neurons) that process input data and generate output.

Reinforcement Learning (RL)

Reinforcement Learning (RL) is a type of machine learning where an agent learns to make decisions by taking actions in an environment to maximize a cumulative reward. RL is commonly used in applications such as robotics, game playing, and autonomous systems.

Computer Vision

Computer Vision is a field of AI that enables machines to interpret and understand visual information from the world, such as images and videos. Computer vision techniques are used in applications such as facial recognition, object detection, and image classification.

Generative Adversarial Networks (GANs)

Generative Adversarial Networks (GANs) are a class of neural networks used for generating new data samples that are similar to a given training dataset. GANs consist of two networks: a generator that creates new data samples and a discriminator that evaluates the authenticity of the generated samples. GANs are used in applications such as image synthesis, data augmentation, and style transfer.

Positronic Brain

The Positronic Brain is a fictional technological concept created by science fiction writer Isaac Asimov. It is a highly advanced artificial brain used in robots, enabling them to process information, make decisions, and exhibit behaviors similar to human intelligence. The concept of the Positronic Brain is central to Asimov’s Robot series, where it serves as the foundation for the robots’ cognitive functions and adherence to the Three Laws of Robotics. Star Trek’s Commander Data had a positronic brain as well.

For more information on the Positronic Brain, you can refer to the following sources:

Top electricity-consuming devices

funkysi1701@gmail.com (funkysi1701) — Mon, 02 Dec 2024 20:00:00 +0000

I have been wondering what devices in my house use the most electricity. I have a smart meter which tells me how much electricity I am using, but it doesn’t tell me what devices are using the most electricity.

Recently I purchased 12 of these ANTELA Smart Plugs (they come in packs of 4 so it hasn’t broken the bank). They are straightforward to set up, you plug them into your power socket and plug your device you want to monitor into them, after that you connect to the wifi and can turn the device off/on and see how much power/current/voltage they are using. I have integrated them into Home Assistant and after about a day of usage I can reveal the following findings:

2 x Monitors attached to my Laptop. As I write this they are only using about 30W of power between them.
Microwave - I cooked a potato and it used 1.2kWh of power.
Washing Machine - Peaks at about 2kW of power, plus the cycle takes some time to complete.
Laptop - Laptop charger, looks to be using about 37W of power.
Kettle - A massive electricity hog, only runs for a short time but reaches 2.9kW of power.
My Routers/Switches/Servers - My home network has a few devices on it like Raspberry Pi’s, a linux and windows server and a network switch etc. Between them they are using about 32W of power. Not a lot but it is on 24-7.
Fridge - I have a fridge freezer, it uses about 72W of power.
TV (and firestick) - This is a surprisingly large amount of power. TV is on quite a lot and is using 110W of power. There are other devices which contribute to this value, however when off the TV is still using 10W of power. I am assuming its age is a big factor.
Tumble Dryer - Again no surprises that this is a big electricity user, it peaks at 2.3kW of power and as it runs for a good couple of hours or so, is a big contributor to my electricity.
Dishwasher - I have put the dishwasher on a few times today and it peaks at 2.2kW of power.

I am not able to monitor 100% of my electricity usage, things like lights, my boiler and anything else wired directly in, won’t have a plug and I can’t monitor in this way. However over the last month or so I can see what is using the most electricity.

Octopus Energy who supply my energy have an agile tariff, which means the price of electricity changes every half hour depending on demand. I want to move the heavy usage of electricity to cheaper parts of the day, so I can save money.

If you want to support me do check out my referral links we could both get £50 if you sign up with Octopus Energy to supply your energy.

Now how did I get this all setup?

1 - Plug a smart plug into a power socket and start measuring power. The app “Smart Life” is used to connect to the smart plug and get the power readings and is available in the Android store.

2 - Integrate each smart plug into Home Assistant. The integration you need is the Tuya integration. A User Code from the Smart Life app is needed to add to Home Assistant.

3 - The Voltage, Power and Current sensors are all defaulted to off in Home Assistant, so you need to go and enable these, once that is done you can see the power usage in Home Assistant.

4 - Now you have Watts, Amps and Volts in Home Assistant but the Energy section of Home Assistant requires Wh or KWh. To get this you need to use the Integral helper to get the amount of time that the device is on for. Go to Add Integration and search for Integral (helper)

Name is the user friendly name of the device.
Metric prefix is the unit of measurement, in this case KWh.
Time of Unit is Hours
Entity is the sensor that is measuring the power usage.
Integration method use Left Riemann sum
Precision is the number of decimal places, so fine to use 0 here.
Max Sub Interval is 5 minutes

This gives you an extra sensor in Home Assistant which is the energy usage of the device. In my case in kWh.

5 - Go to your Energy Dashboard in Home Assistant and go to Energy Configuration. Add the new sensor to the Individual Devices section and you can see the energy usage of the device over time.

The accuracy is not brilliant, sometimes it looks like I have used more energy in my devices than my smart meter says I have used in total. However it is a good indicator of what is using the most electricity in your house. Leave it running for a few days, you may have to tweak the Integral helper settings to get the best results.

The Home Assistant Forums are great for getting this sort of thing setup, I have found a lot of useful information on there.

Getting started with .Net Aspire

funkysi1701@gmail.com (funkysi1701) — Mon, 25 Nov 2024 20:00:00 +0000

What is .Net Aspire?

.Net Aspire is a comprehensive set of tools, templates, and packages designed to simplify the development of cloud-native applications using .Net. It focuses on building observable, production-ready apps by providing a consistent and opinionated set of tools and patterns .

The key features of .Net Aspire:

Orchestration: Enhances the local development experience by simplifying the management of your app’s configuration and interconnections. It helps with app composition, service discovery, and connection string management.
Integrations: Offers NuGet packages for commonly used services like Redis and Postgres, ensuring they connect consistently and seamlessly with your app.
Tooling: Comes with project templates and tooling experiences for Visual Studio, Visual Studio Code, and the .Net CLI to help you create and interact with .Net Aspire projects.

Overall, .Net Aspire aims to improve the experience of building .Net cloud-native apps by providing a robust framework for developing distributed applications.

Getting started with .Net Aspire

I touched on .Net Aspire last week, when I talked about what was new in dotnet 9 , but let’s walk through an example.

Lets say you have a simple application. It has a Blazor web front end, it communicates with a .Net API and that API retrieves data from a SQL Server database. Before Aspire came along I would create a docker compose file and configure ports so the FE could call the API, and add connection strings so the API could access the database.

services:
 Api:
 image: ${DOCKER_REGISTRY-}api
 container_name: api
 ports:
 - 12345:80
 - 44338:443
 networks:
 - my-network
 build:
 context: .
 dockerfile: API/Dockerfile
 depends_on:
 - sqlserver

 Ui:
 image: ${DOCKER_REGISTRY-}ui
 container_name: ui
 ports:
 - 44330:443
 networks:
 - my-network
 build:
 context: .
 dockerfile: UI/Dockerfile
 environment:
 - APIPath=http://Api:80

 sqlserver:
 image: ${DOCKER_REGISTRY-}sql
 container_name: sql
 volumes:
 - sqlvol:/var/opt/mssql
 ports:
 - "5432:1433"
 networks:
 - my-network
 build:
 context: .
 dockerfile: Database/Dockerfile

As you can see from this docker compose file, there is a lot of specifying ports and other plumbing to get these three parts of my system to work together.

Now in Visual Studio, right-click on the API project and select add .Net Aspire Orchestrator Support this will add two new Visual Studio projects to the solution, AppHost and ServiceDefaults.

AppHost is where you configure what service depends on what, you can configure all sorts of different dependencies, like databases (sql server, mysql, postgres etc), rabbitmq, redis and many others.
ServiceDefaults is where you configure the defaults for your services, like how opentelemetry should be configured, or how logging should work.

Now right click on the Blazor project and select the same option to get that wired up as well.

var builder = DistributedApplication.CreateBuilder(args);

builder.AddProject<Projects.UI>("ui");

builder.AddProject<Projects.API>("api");

builder.Build().Run();

Your Program.cs file inside your AppHost project will look something like this now, with both your API and UI/Blazor projects referenced.

There is one more component we need to wire up, but we don’t have a project to right click on for the database. It is fairly straightforward to do, update it to look like the following:

var builder = DistributedApplication.CreateBuilder(args);

var sqldb = builder.AddSqlServer("sql")
 .WithDataVolume("sql-data")
 .AddDatabase("Context", "Project");

var api = builder.AddProject<Projects.API>("api")
 .WaitFor(sqldb)
 .WithReference(sqldb);

builder.AddProject<Projects.UI>("ui")
 .WaitFor(api)
 .WithReference(api);

await builder.Build().RunAsync();

You also need to install a couple of nuget packages. Aspire.Hosting.SqlServer and Aspire.Microsoft.EntityFrameworkCore.SqlServer the second one is because my project is using Entity Framework. Lets look at what we have, we are defining a SQL Server called sql, with a data volume called sql-data, and a database called Project, which we can refer to as Context. We then configure API to reference the sql server we have just configured, and wait for sql server to be ready before starting the API. Next the Blazor project depends on the API and will wait for that to be ready before starting. Pretty powerful stuff.

OK lets look at the API project, what do I need to configure in my connectionstrings? Not much, Aspire will fill all of this in for you.

 "ConnectionStrings": {
 "Context": ""
 }

In your API project, your Program.cs will need a nuget package Aspire.Microsoft.EntityFrameworkCore.SqlServer and the following line, and no need for any pulling config and passing in connection strings.

builder.AddSqlServerDbContext<Context>("Context");

One more clever thing we can do with Aspire is seed some data into my database before starting the project. Update the code that sets up your database in the AppHost project as follows.

var sqldb = builder.AddSqlServer("sql")
 .WithBindMount("./sqlserverconfig", "/usr/config")
 .WithBindMount("../API/data/sqlserver", "/docker-entrypoint-initdb.d")
 .WithEntrypoint("/usr/config/entrypoint.sh")
 .WithDataVolume("sql-data")
 .AddDatabase("Context", "Project")

Add a sqlserverconfig folder inside your AppHost project and add the following two files. I have found entrypoint.sh being a bit picky with its line endings (windows vs linux)

#!/bin/bash

# Adapted from: https://github.com/microsoft/mssql-docker/blob/80e2a51d0eb1693f2de014fb26d4a414f5a5add5/linux/preview/examples/mssql-customize/entrypoint.sh

# Start the script to create the DB and user
/usr/config/configure-db.sh &

# Start SQL Server
/opt/mssql/bin/sqlservr

#!/bin/bash

# set -x

# Adapted from: https://github.com/microsoft/mssql-docker/blob/80e2a51d0eb1693f2de014fb26d4a414f5a5add5/linux/preview/examples/mssql-customize/configure-db.sh

# Wait 60 seconds for SQL Server to start up by ensuring that
# calling SQLCMD does not return an error code, which will ensure that sqlcmd is accessible
# and that system and user databases return "0" which means all databases are in an "online" state
# https://docs.microsoft.com/en-us/sql/relational-databases/system-catalog-views/sys-databases-transact-sql?view=sql-server-2017

dbstatus=1
errcode=1
start_time=$SECONDS
end_by=$((start_time + 60))

echo "Starting check for SQL Server start-up at $start_time, will end at $end_by"

while [[ $SECONDS -lt $end_by && ( $errcode -ne 0 || ( -z "$dbstatus" || $dbstatus -ne 0 ) ) ]]; do
 dbstatus="$(/opt/mssql-tools18/bin/sqlcmd -h -1 -t 1 -U sa -P "$MSSQL_SA_PASSWORD" -C -Q "SET NOCOUNT ON; Select SUM(state) from sys.databases")"
 errcode=$?
 sleep 1
done

elapsed_time=$((SECONDS - start_time))
echo "Stopped checking for SQL Server start-up after $elapsed_time seconds (dbstatus=$dbstatus,errcode=$errcode,seconds=$SECONDS)"

if [[ $dbstatus -ne 0 ]] || [[ $errcode -ne 0 ]]; then
 echo "SQL Server took more than 60 seconds to start up or one or more databases are not in an ONLINE state"
 echo "dbstatus = $dbstatus"
 echo "errcode = $errcode"
 exit 1
fi

# Loop through the .sql files in the /docker-entrypoint-initdb.d and execute them with sqlcmd
for f in /docker-entrypoint-initdb.d/*.sql
do
 echo "Processing $f file..."
 /opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P "$MSSQL_SA_PASSWORD" -C -d master -i "$f"
done

The second BindMount line mounts a folder inside your API project, so add a data folder with a subfolder called sqlserver. Inside that add a sql script called init.sql. Put all your CREATE DATABASE and CREATE TABLES sql commands inside this. And if everything works you will have a seeded DB ready to test your application with.

Conclusion

This is just a few things I have done with Aspire. Go check out the docs on MS learn or the some of the sessions from dotnet conf .

Version 9 of .Net is here

funkysi1701@gmail.com (funkysi1701) — Mon, 18 Nov 2024 20:00:00 +0000

Every November it is like Christmas for .NET developers, as Microsoft releases the next version of .NET. This year is no different, and we have version 9 of .NET to play with. This release is packed with new features and improvements across the board.

If you haven’t already head on over to the dotnet website and download the latest version.

Also we get a brand new version of Visual Studio, which is always a good thing, so head on over to the Visual Studio website and download the latest version (or the Preview version if you want to test what is coming out next).

Back when .Net 7 came out I wrote a post about what you needed to fix to get the latest version working with your existing code. However this time around the upgrade is really smooth.

NuGet Audit

Back in .Net 8 NuGet Audit was introduced which told you if any of your packages had security vulnerabilities. This has been improved in .Net 9, and now defaults to tell you about transitive dependencies. This is a great feature, but if you would prefer to keep .Net 8’s functionality you can add the following to your project (*.csproj) file.

 <NuGetAuditMode>direct</NuGetAuditMode>

.Net Aspire

Released just after .Net 8 .Net Aspire is a suite of tools to help develop microservices. Gone are the days of specifying ports and connection strings for your services, Aspire can handle this all programmatically.

Aspire adds two new projects to your solution. AppHost and ServiceDefaults.

AppHost is where you configure what service depends on what, you can configure all sorts of different dependencies, like databases (sql server, mysql, postgres etc), rabbitmq, redis and many others. It is open source so the community are busy adding everything you could possibly need.
ServiceDefaults is where you configure the defaults for your services, like how opentelemetry should be configured, or how logging should work. Microsoft have thought hard about this and come up with some opinionated defaults, but you can change these to suit your needs.

Starting the AppHost project will start up the Aspire Dashboard where you can start/stop containers, view logs and see the health of your services. This is primarily a devlopment tool, but there are some deployment tools, however I have not explored these much yet. More details about Aspire can be found here

Blazor

I have been using Blazor since the first previews in the .Net 3.1 days. It has come a long way since then, and now with .Net 9 it is even better.

There has been some optimization of the delivery of static assets. To take advantage of this improvement, replace the following line in your Program.cs file.

 app.MapStaticAssets(); //Add this line
 app.UseStaticFiles(); //Remove this line

.Net 9 will then cache your static assets ang give them a unique filename. This will allow the browser to cache the files for longer, and only download them when they have changed. This will speed up your site and reduce the amount of data transferred.

In your razor pages use code similar to this:

<link rel="stylesheet" href="@Assets["bootstrap/bootstrap.min.css"]" />
<link rel="stylesheet" href="@Assets["app.css"]" />
<link rel="stylesheet" href="@Assets["BlazorSample.styles.css"]" />

AI

It will have not escaped your notice that AI is everywhere, and it is no different with .Net. I saw some very impressive demos at the .Net Conf online conference. I encourage you to check our the videos. But to summarize Microsoft have added a bunch of abstractions to make it easier to write code to talk to the different AI models, I haven’t played about with AI much yet, but I am tempted to give it a go.

SQL Management Studio

I have not used SQL Management Studio for a while as I have trying out Azure Data Studio. However a new Preview of SQL Server Management Studio is now avaliable . This version is 64bit and is based on Visual Studio engine, it even shares the same installer.

Conclusion

This is only a small taste of the new features in .Net 9. Go check out .Net Conf to learn more or check out some of the links I have shared above.

Strategy Design Pattern

funkysi1701@gmail.com (funkysi1701) — Mon, 11 Nov 2024 20:00:00 +0000

Understanding the Strategy Design Pattern.

In the world of software development, design patterns are essential tools that help developers solve common problems in a standardized way. One such pattern is the Strategy Design Pattern. This pattern is particularly useful when you need to define a family of algorithms, encapsulate each one, and make them interchangeable. Let’s dive into what the Strategy Design Pattern is, why it’s useful, and how you can implement it in your projects.

What is the Strategy Design Pattern?

The Strategy Design Pattern falls under the category of behavioural design patterns. It enables an algorithm’s behaviour to be selected at runtime. Instead of implementing a single algorithm directly, code receives run-time instructions as to which in a family of algorithms to use.

Why Use the Strategy Design Pattern?

The primary benefits of using the Strategy Design Pattern include:

Flexibility: It allows you to change the algorithm or strategy being used without altering the code that uses the algorithm.
Reusability: By encapsulating algorithms separately, you can reuse them across different parts of your application.
Maintainability: It promotes cleaner code by adhering to the Single Responsibility Principle, making your code easier to maintain and extend.

How to Implement the Strategy Design Pattern

Let’s break down the implementation of the Strategy Design Pattern with a simple example. Suppose we are developing a flight simulator that supports multiple flying methods (e.g., Flapping like a bird, Jet Engine powered, and Warp Speed).

Step 1: Define the Strategy Interface

First, we define an interface that all payment strategies will implement.

public interface IFlyingStrategy
{
 void Fly();
}

Step 2: Implement Concrete Strategies

Next, we create concrete classes that implement the IPaymentStrategy interface.

public class Bird : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying like a bird");
 }
}

public class Plane : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying using 21st century aviation fuel");
 }
}

public class StarShip : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying using warp engines");
 }
}

Step 3: Create the Context Class

The context class uses a IFlyingStrategy to perform the payment.

public class FlyContext
{
 private IFlyingStrategy _flyingStrategy;

 public void SetPaymentStrategy(IFlyingStrategy flyingStrategy)
 {
 _flyingStrategy = flyingStrategy;
 }

 public void Fly()
 {
 _flyingStrategy.Fly();
 }
}

Step 4: Use the Strategy Pattern

Finally, we use the FlyContext to fly with different strategies.

class Program
{
 static void Main(string[] args)
 {
 FlyContext context = new FlyContext();

 context.SetPaymentStrategy(new StarShip());
 context.Fly();

 context.SetPaymentStrategy(new Plane());
 context.Fly();

 context.SetPaymentStrategy(new Bird());
 context.Fly();
 }
}

Conclusion

The Strategy Design Pattern is a powerful tool that promotes flexibility, reusability, and maintainability in your code. By encapsulating algorithms and making them interchangeable, you can easily extend and modify your application without disrupting existing functionality. Whether you’re dealing with payment processing, flying machines, sorting algorithms, or any other scenario requiring dynamic behaviour, the Strategy Design Pattern can help you write cleaner and more efficient code.

How to start a code club for kids

funkysi1701@gmail.com (funkysi1701) — Sat, 02 Nov 2024 18:00:45 +0000

Code Clubs are free, welcoming spaces designed to introduce young people to the exciting world of programming and digital skills. Today, I had the pleasure of taking my son—an absolute coding enthusiast—to one of these sessions, held at Leeds Central Library.

The club was hosted in a cozy room on the top floor of the library. Walking in, I expected rows of computers set up for traditional coding exercises. Instead, we found mysterious white lines taped onto the floor. Curious to find out what they were for, we soon learned they were meant to guide robots that the children would be programming. The instructor handed out iPads and small spherical robots known as Spheros, and the children were tasked with programming the robots to follow the lines.

The iPads were preloaded with easy-to-use software that felt familiar to those who’ve used Scratch, a popular block-based coding language. By simply dragging and dropping blocks of code, the kids controlled the robots’ movements. Each “move” block had three variables—direction, speed, and duration—that the children could adjust to guide the robot along the lines.

It was a great hands-on learning experience. My son and I faced a bit of trial and error to figure out which way the robot saw as “forward,” but soon enough, our Sphero was gliding smoothly along the first line. As we went along, we added “pause” blocks between movements, which made the robot stop before changing direction, adding a nice rhythm to its journey along the lines.

Once the main task was completed, there was time for the kids to explore other features. We experimented with different commands, making a smile or frown appear on the robot’s LED display, while others programmed their Spheros to zip around the room, flashing lights and making playful noises.

The club meets every two weeks, and both my son and I left feeling thrilled with the experience. We’re already looking forward to the next session!

If you’re interested in finding a Code Club near you check out https://codeclub.org/en/find , alternatively, https://codeclub.org has lots of resources to explain what code clubs are all about.

Scottish Summit 2024

funkysi1701@gmail.com (funkysi1701) — Mon, 28 Oct 2024 18:00:45 +0000

Scottish Summit 2024 took place in Aberdeen on October 18th and 19th at the P&J Live Arena, and I was fortunate enough to attend.

Friday

The first full day of the conference, Friday the 18th, began with the unmistakable sound of bagpipers welcoming attendees at the venue—an echo of the 2022 event that reminded us all of the conference’s Scottish roots. Registration was quick and seamless; all I needed was my QR code ticket to receive a unique lanyard made of seed paper—perfect for planting flowers in the spring.

Scott Hanselman was the keynote speaker, and I spotted him mingling with other attendees. I almost asked him for a selfie but decided against it. His keynote, titled “AI: Hero or Villain,” was compelling. He demystified ChatGPT, explaining that it’s not magic but rather a product of machine learning, using mathematics to predict the next word in a sentence.

Next, MVP Vesa Nopanen delivered his talk on “Supercharge Your Teams Meetings.” I picked up some valuable tips, particularly the importance of adding notes and agendas to enhance meeting effectiveness.

Following that, a couple of the Scottish Summit organizers discussed the technology behind the event. They explained how they used Stripe for payments, integrating it with Power Automate and Power Pages. I found this particularly interesting for a charity event; it demonstrated a commitment to learning while keeping costs manageable.

The next session explored what it means to be a modern full-stack software developer, focusing on integrating Power Apps with traditional web development. As someone new to Power Apps, I learned that starting with it can be beneficial, filling gaps with .NET or conventional web development as needed.

I then attended a session on public speaking. Although I’ve never given a talk at a conference, hearing about others’ journeys was encouraging and prompted me to consider my own potential in this area.

The final session of Friday featured Microsoft’s Sarah Lean, who shared how her hobbies—specifically curling—have influenced her work life. This talk made me reflect on my own hobbies and their impact on my professional journey.

The evening wrapped up with a drag cabaret, which exceeded my expectations. Several brave community members dressed up and participated in the show, all in support of the conference’s charity, TIE.

Saturday

Saturday kicked off with a dive into the world of wizards and D&D in a session titled “Securing the Realm: DM-less D&D with Azure AI.” This practical talk demonstrated how AI can be utilized in running D&D games, discussing essential guardrails and effective AI prompts.

Another engaging talk, “Community - It Just Makes Sense,” highlighted the tech community’s role in career development. I realized that I’ve only just scratched the surface of community involvement, and I’m eager to explore it further.

Sarah Lean returned to discuss KQL (Kusto Query Language), which Application Insights uses for querying data. Although I’ve encountered KQL before, learning more about it was fascinating.

The “Ask the Azure Experts” panel featured four Azure MVPs and Sarah Lean, who answered questions about Azure migration and cost management, sharing numerous helpful insights.

“Who’s Afraid of a Little Ole Copilot?” presented by Dona Sarkar and her colleagues, was a captivating exploration of how Copilots function within the Microsoft ecosystem. It featured various speakers I had encountered throughout the conference, demonstrating the interactivity of Microsoft’s services, from Purview to Responsible AI. It was a fun and enlightening way to close the conference.

Saturday evening featured a pub quiz and the UK Community Awards ceremony, where dedicated community members were recognized for their hard work. Our quiz team, led by MVP Vesa Nopanen and humorously named “Vogon Poets,” finished 14th—complete with silly hats. It was a delightful opportunity to socialize with teammates and was one of the highlights of the conference.

Conclusion

In summary, Scottish Summit 2024 was an exceptionally well-organized conference. As a .NET developer, I found a limited number of directly relevant sessions, but the true value lay in the community. I reconnected with familiar faces and met new friends, especially during the pub quiz.

I left feeling inspired to become more involved in the community and participate in future events. The sessions on public speaking, community engagement, and hobbies underscored the importance of soft skills in the tech world.

And yes, I caught a glimpse of Scott Hanselman, which was quite a thrill!

Funky Si walks a half marathon

funkysi1701@gmail.com (funkysi1701) — Sun, 18 Feb 2024 11:00:00 +0000

On June 8th I will walk 13 miles near Bakewell in the Peak District to raise £250 (or more) for Cancer Research. To sponsor me click fundraise.cancerresearchuk.org/page/funkysi1701 , to find out more about the event go www.cancerresearchuk.org/get-involved/find-an-event/big-hike/big-hike-peak-district

So why am I doing this?

I am a Software Developer in my day to day life, which does not involve a lot of physical activity. I have become very lazy. Doing a half marathon is completely outside of my comfort zone and is not at all a me thing to do.

However last year I realised my mental health was starting to degrade. I have a family which keeps me very busy, I am facing lots of challenges with this, other members of my family have mental health issues which is starting to have a knock on affect on me.

I mentioned some of these challenges to a friend who suggested I join a walking group which was helping people with mental health problems. I went along and to my surprise I really enjoyed myself, the people were friendly and I enjoyed the walk in the countryside. After this I went out and bought some proper walking shoes

I went to the next one, and the next one and each time I enjoyed myself. I must admit that after these walks it tired me out due to my unfit nature, but it was worth it as for a few hours I wasn’t thinking about the 101 problems that I had no solutions for.

Fast forward to about a week ago, an advert for this charity walk popped up on facebook. I took a look at it and I started thinking. The 10k was a similar distance I had done on one of my walks, so I could easily do that. What if I could raise some money for a charity and go for a fun walk? For the next few days I kept thinking about it. Eventually I booked it. My thinking was if I am going to do something for charity I need to push myself outside of my comfort zone. I would never manage a full marathon, but what about a half marathon?

So tomorrow I start training, every day or so I walk for about 40 minutes, I will probably post some updates on my charity page as no doubt I will struggle to keep going.

Please if you can think about donating, and give me some encouragement I think I am going to need it.

TrekRanks #174

funkysi1701@gmail.com (funkysi1701) — Fri, 05 Jan 2024 20:00:00 +0000

Trek Ranks #174: Top 5 Ensemble Episodes

I was recently invited onto the TrekRanks podcast. I had a great time talking Trek with Jim Moorhouse and fellow guest Anika Dane. If Trek is your thing, do take a listen.

Everyone contributes in this episode of TrekRanks as we break down the “Top 5 Ensemble Episodes.” Our panel highlight those episodes in which the entire cast play important roles and help portray the group as a whole, rather than as individuals. From heavy hitters to deep cuts and everything in between, this one quite appropriately covers it all.

Listen here

2024 on Funky Si's Test

Reflecting on 2024, goals for 2025

Blog Posts

More Learning

Health

Conferences and User Groups

What Happened in 2024

Automate develop to main pull requests

GitHub

Azure DevOps

Related on this blog

Common AI and Copilot Terms

Common AI and Copilot Terms

Artificial Intelligence (AI)

Machine Learning (ML)

Natural Language Processing (NLP)

GitHub Copilot

Retrieval-Augmented Generation (RAG)

Large Language Models (LLM)

Generative Pre-trained Transformer (GPT)

Deep Learning

Neural Networks

Reinforcement Learning (RL)

Computer Vision

Generative Adversarial Networks (GANs)

Positronic Brain

Top electricity-consuming devices

Now how did I get this all setup?

Getting started with .Net Aspire

What is .Net Aspire?

Getting started with .Net Aspire

Conclusion

Version 9 of .Net is here

NuGet Audit

.Net Aspire

Blazor

AI

SQL Management Studio

Conclusion

Strategy Design Pattern

Understanding the Strategy Design Pattern.

What is the Strategy Design Pattern?

Why Use the Strategy Design Pattern?

How to Implement the Strategy Design Pattern

Step 1: Define the Strategy Interface

Step 2: Implement Concrete Strategies

Step 3: Create the Context Class

Step 4: Use the Strategy Pattern

Conclusion

How to start a code club for kids

Scottish Summit 2024

Friday

Saturday

Conclusion

Funky Si walks a half marathon

So why am I doing this?

TrekRanks #174

Trek Ranks #174: Top 5 Ensemble Episodes