2024-12 on Funky Si's Blog (Dev)

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.

2024-12 on Funky Si's Blog (Dev)

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?