DEV Community: Aaron Saikovski

Daleks - in Go and Ebitengine and Webassembly

Aaron Saikovski — Fri, 08 Aug 2025 00:47:58 +0000

Ive tried to recreate a faithful version of the 1984 Classic Mac game Daleks.
I loved his game as a kid and wanted to try to create it using Webassembly, Go and Ebitengine.

The source code is here: https://github.com/AaronSaikovski/godaleks
A playable version is available here: https://aaronsaikovski.github.io/godaleks

All rights to their respective owners.

Please be gentle as its very much an alpha version.
keen to hear your feedback!

How to query your GoodWe Solar inverter API using GoLang.

Aaron Saikovski — Mon, 19 Feb 2024 04:25:46 +0000

Over the past few months I have been doing more and more GoLang development for my side projects and and I have come to the conclusion that Go strikes a very nice balance of productivity and performance.
The binaries that Go produces eliminates the need for JVMs or runtime frameworks that need to be shipped with your application. Everything you need to run your application is in a single native compiled binary.
As a side note I did have a quick look at Rust as an option too but decided to settle on Go for this project. (I am not a Rust developer and might look at it in the future).

Project Background
Late 2023 I was thinking of a cool project to stretch my Go development skills a bit and came across this article.
I thought that I could come up with good solution written in Go to query my solar inverter API and present some meaningful
reporting data.
People asked me why? Because its a good way to learn how to query APIs and manipulate JSON results in Go. Thats why!
After lots of extensive research and looking at other open source projects I found on Github here, most of which were in Python and were overly complex and required lots of external dependencies. I settled on writing this in Go.

So after some trial and error and a few iterations I managed to come up with a Go based, command line utility to query my Goodwe/SEMs Solar inverter to query the APIs and return a JSON result of the measured inverter metrics. Sweet!
One thing to note was the lack of any solid API documentation from the GooodWe APIs and as such a lot of trial and error was involved to get this to work. If you have any updated API documentation on how their APIs work please let me know. I couldn't find anything. :-(

The solution
To achieve the desirted outcome, required two separate API calls and passing objects (structs in Go):
1) Obtain a login token - Login to the SEMS Portal API - 'https://www.semsportal.com/api/v1/Common/CrossLogin'.
The Go function signature looks something like this:

func Login(LoginCredentials *types.LoginCredentials) (*types.LoginResponse, error) {

2) Then using the login response struct from Step 1 (represented as a JSON Go struct) pass to the inverter API GetMonitorDetailByPowerstationId API here - 'v2/PowerStation/GetMonitorDetailByPowerstationId'.
The Go function signature looks something like this:

func FetchData(Account string, Password string, PowerStationID string, DailySummary bool) error {

3) Then from the 'FetchData()' Go function a JSON object is returned.
The internal Go function uses a 'interfaces.ISemsDataConstraint' interface constraint to restrict the datatypes to the two structs I defined in the types package:

type ISemsDataConstraint interface {
    types.InverterData | types.DailySummaryData
}

The Internal Go function signature to get the monitor data is as follows - note the interface type constraint:

func getMonitorData[T interfaces.ISemsDataConstraint](LoginCredentials *types.LoginCredentials, LoginApiResponse *types.LoginResponse, InverterOutput *T) error {

There are two output options - Detailed output and a daily summary view. Use the '--dailysummary' flag to produce a daily summary.

The struct for the daily summary data is as follows:

package types

type DailySummaryData struct {
    Language string `json:"language"`
    HasError bool   `json:"hasError"`
    Msg      string `json:"msg"`
    Code     string `json:"code"`
    Data     struct {
        Kpi struct {
            MonthGeneration float64 `json:"month_generation"`
            Power           float64 `json:"power"`
            TotalPower      float64 `json:"total_power"`
            DayIncome       float64 `json:"day_income"`
            TotalIncome     float64 `json:"total_income"`
            Currency        string  `json:"currency"`
        } `json:"kpi"`
        Inverter []struct {
            TotalGeneration string `json:"total_generation"`
            DailyGeneration string `json:"daily_generation"`
        } `json:"inverter"`
    } `json:"data"`
}

The main struct 'inverterdata' is too large to list here but its in the 'types' package here.

The resulting output has had any sensitive data removed from the underlying structs so hopefully no usernames, addresses will be exposed.

The Go project layout has gone through a few refactors as well and I think I have settled on a sensible project and package layout. Hit me up if you agree/disagree.

Some of the big benefits and lessons learned during writing this are
1) Go is awesome at building cross platform/single native binaries with no external runtimes.
2) Produces really clean and easy to read code.
3) Go has really fast performance from compile to runtime.
4) Using some of the advanced Go features such as structs, JSON marshalling, Interfaces and constraints was a learning curve but I think I managed to get my head around these.
5) Pointers in Go are awesome! I used them a lot in this project to pass memory references to structs around and update them by marhalling to JSON.
6) Don't be afraid to refactor your folder and package layouts a few times. I think I did it about five times before I settled on the current layout.
7) Use interfaces and constraints to reduce the amount of code you need to write.

I hope you enjoy exploring this this tool as much as I enjoyed writing it.
Please feel free to provide any feedback and suggestions on how I can make the code better, or if there are any bugs, please report them here.

The code itself can be found here.

Thanks for reading!

Its 2024 and its time for a look at your Web API Tech Stack.

Aaron Saikovski — Mon, 08 Jan 2024 06:00:09 +0000

Hello everyone, this is my first post for 2024 and I hope you all had a great break.
Over the break I was thinking about some of the technologies I wanted to sink my teeth into in 2024.
The main two I will be focussing on are .Net Core 8 and Go.
For a full stack platform .Net/.Net Core is hard to beat and for pure backend API development you really can't beat Go.
When I was looking at some key features for any API development in .Net Core and Go I came up with this list that I thought I would share:
I have broken this down into a .Net Core Web API Vs. Go list with supporting links.

Native compilation or as close to native compiled - Go Wins here. Although .Net 8 has AOT (Ahead of Time) compilation but not all libraries are supported. More info can be found here.
Boilerplate/Starter templates - I have two projects to help get you started here :-). Go API Starter and .Net Minimal API Starter.
Web Framework - Both support a rich web framework, but .Net core wins here from a full stack perspective. But from a pure speed and performance perspective GoLang wins, using the Fibre framework is unbeatable.
Clean architecture - Both support this.
Clean Architecture In ASP.NET Core Web API
Go Backend Clean Architecture
Logging - Both support this but its important to ensure that any logging framework supports a zero allocation model. For .Net use Serilog and for GoLang use Zerolog.
gRPC - Both support this.
Overview for gRPC on .NET
gRPC-Go
Docker/Containers - Both support this. Although .Net 8 has a much richer Docker integration (you can remove Docker files altogether) but the .Net docker image size is about 4 times larger. From a size and speed perspective GoLang wins here.
Creating a Minimal API with Docker
Containerize a .NET app with dotnet publish (new way..No Docker file)
Containerize the go language REST API using Docker
Rate Limiting - Both support this but can be tricky to implement and depends on the algorithm used.
Rate limiting middleware in ASP.NET Core
Rate Limiting API Calls in Go
Profiling - Both support this.
How to Use Mini Profiler in ASP.NET Core Web API
Golang Profiling: The Basics and a Quick Tutorial
Github Actions - Both support this.
How To Build a CI/CD Pipeline With GitHub Actions And .NET
GitHub Actions workflow for Go Continuous Integration
Databases/ORM- Both support this but have different implementations.
API Development Using Dapper and Microsoft Asp.NET Core Web API
Entity Framework
GORM (ORM library for Golang)
SQLBoiler (database-first ORM)
XORM (Simple and Powerful ORM for Go)
Tracing - Both support this.
Tracing in ASP.Net Web API
Tracing runtime activities in Go.
Exceptions - .Net has the more traditional exception handling approach whereas Go has error return/nil types.
How to handle errors in Minimal API apps
Error Handling in Go REST APIs
Health Checks - Both support this.
Health Checks In ASP.NET Core For Monitoring Your Applications
Healthcheck (RESTful Healthcheck API implementation for Go services)
Unit tests - Both support this.
How to test your C# Web API
Testify
Testing REST APIs in Go
Endpoint Grouping - Both support this.
Minimal APIs quick reference (Route Groups)
EndPoint Grouping .Net
Go Fiber – Route Groups
Fiber Framework in Golang
API Key security - Both support this and have very similar implementations.
Implement API Key Authentication in ASP.NET Core
KeyAuth in Go Fiber
API Versioning - Both support this.
.Net MinimalApiExample
Go Fiber Versioning Boilerplate
Authentication & Authorization (JWT) - Both support this but depends on your use case and what you are authenticating against. JWT links are provided here:
How to implement JWT authentication in ASP.NET Core
jwt-go

So from the comparison above hopefully this will guide you in your decision. For pure speed and lightweight APIS with no startup delays, I recommend Go.
But .Net 8 isnt no slouch either and is a very close second. Very close. If you are after a rich and mature ecosystem and really amazing tooling, go with ASP.Net 8 Core.
thanks!

Welcome !

Aaron Saikovski — Thu, 07 Dec 2023 20:58:39 +0000

If you made it this far, welcome.
I am back to blogging once again and hopefully you enjoy reading these articles as much as I enjoy writing them.
2024 is going to be a big year and I have lots of articles and topics to cover and other random tech shenanigans as well.
Watch this space and lots to come.