Tag Archives: Azure

Azure

ZoneForge for Azure: a new name, and a lot more capability

Gallery Leave a comment

If you’ve used Azure Canvas before, you’ll notice it’s had a rebrand — it’s now ZoneForge for Azure, and it’s moved to zoneforge.cloud. Everything else about it is the same free, in-browser tool; the name is the main thing that’s changed. (azure-canvas.com still redirects, and all your existing share links keep working.)

Why the rename? Microsoft recently shipped a feature called “Azure Canvases”, which started crowding out the tool in search results and causing confusion. Rather than fight Microsoft’s own product for the name — and to keep on the right side of the “Azure” trademark, which asks third-party tools to use a “X for Azure” pattern — I’ve rebranded. “ZoneForge” felt right: the tool is increasingly about defining and forging the zones (subscriptions, regions, resource groups, networks) of an architecture.

It’s grown well beyond a diagram tool. What started as “drag some Azure shapes and generate Bicep” is now closer to a proper Azure-aware architecture designer. Since the original post it’s added:

  • Import from Azure — point it at a subscription and pull in an entire resource group (or a single VNet and what’s connected to it) to diagram what you already run.
  • Architecture-aware placement — it understands Azure, so resources snap into the right containers: subnets inside VNets, VMs/NSGs inside subnets, gateways/firewalls/bastion in their reserved subnets.
  • Validate, Review & Well-Architected score — check the design against a live subscription, plus best-practice review and a WAF pillar score.
  • Live cost estimate — real Azure retail pricing straight on the canvas, no sign-in needed.
  • Boundaries & views — Management Group / Subscription / Region / Resource Group boundaries, plus separate Network, Infrastructure and Identity views.
  • More ways to get the design out — Bicep, ARM JSON and Terraform, plus Visio (.vsdx), SVG, and clean A4 printing.
  • Quality of life — a File menu (save/load/import/export), one-click Share links, draggable dialogs, and dark mode.

Under the hood the rename touches everything you’d expect — new domain, updated metadata, new export filenames (zoneforge.bicep, zoneforge.arm.json, etc.) — but it’s deliberately backwards-compatible. Old Azure Canvas JSON exports still import, the #d= share-link format is unchanged, and your saved diagrams survive.

There’s also now a feedback box in the About dialog (a 5-star rating and a comment field) — if you’ve tried it, I’d genuinely love a rating and a line on what worked or what broke. Just click the ‘Z’ in the top right corner.

It’s still free, still runs entirely in your browser, and still at the stage where I want people to poke at it. Give it a go and tell me what you think.

👉 zoneforge.cloud

If you work with Azure, try to break it — that’s the most useful feedback there is. 😄

Azure, Cloud Computing, Developer Tools, DevOps / Infrastructure as Code, Web Tools

Azure Canvas Update: It’s an Architecture Designer, Not just a Drawing App

Gallery Leave a comment

When I first wrote about Azure Canvas, the easy pitch was “draggable Azure icons in your browser.” That was never the point, and the gap between the two has widened considerably since. Azure Canvas is not a diagramming tool that happens to use Azure shapes — it is an architecture designer that understands what those shapes mean, what they are allowed to do, and whether Azure will actually accept them.

The distinction matters, because anyone can push coloured rectangles around a canvas. The hard part is a canvas that pushes back.

As ever, the tool is free and runs entirely in the browser.

Try it: https://azure-canvas.com/

A canvas that understands Azure

Every object in Azure Canvas carries the rules of the real service behind it, and the canvas enforces them as you design:

– VNets contain subnets; VMs, NSGs, route tables, NAT gateways, private endpoints, and Application Gateways live inside subnets rather than floating in space.

– VPN Gateway, Azure Bastion, and Azure Firewall claim their required reserved subnets automatically, because Azure insists on them and so should the diagram.

– Peerings, VPN connections, public IP associations, identities, monitoring links, and application dependencies are modelled as real relationships, not decorative arrows.

– Service‑specific obligations are handled for you — an NSG sharing a subnet with Application Gateway v2 gets its GatewayManager rule without you needing to remember it at 11pm.

The result is a design that is structurally correct by construction. You are not drawing a picture of an architecture; you are building the architecture, and the picture is a side effect.

From design to validated to deployed

The reason the modelling matters is that the diagram is the start of a pipeline, not the end of one:

– Import reconstructs an existing resource group or VNet and its connected resources directly from Azure Resource Manager, read‑only, with subscription and region boundaries intact.

– Validate Design combines local structural checks with live Azure checks — provider registration, region and VM‑size availability, storage name availability, CIDR overlap, required relationships, and service constraints — so problems surface before deployment, not during it.

– Generate produces deployable Bicep, ARM JSON, and a Terraform starter from the same model.

– Deploy submits the generated template straight to Azure Resource Manager, no local CLI or compiler required, and monitors progress with the timing warnings that gateways and Bastion have taught it to give.

Each stage reads from one architecture‑aware model. That is what separates this from a drawing app: the boxes are not the artifact, they are the source of truth that everything else is derived from.

Taking the design elsewhere

Because the model is real, the outputs are too. Alongside JSON import/export and browser‑local saving, Azure Canvas can now hand your design to the places architectures tend to end up — exporting to native Visio for design packs that have to live in someone else’s document, and printing a design that crops, scales, and fits itself to the page instead of fighting you. Useful, unglamorous, and firmly in service of the design rather than the headline.

Who it’s for

Azure Canvas is for architects, network and security teams, engineers, and students — anyone who prefers to understand an environment visually before committing it to code, and who wants the visual to be more than a pretty guess.

It is free, actively evolving, and shaped by people designing and operating real Azure environments. Suggestions are welcome in the comments; I read them, and Azure remains an enthusiastic reviewer of the rest.

Try Azure Canvas: https://azure-canvas.com/

C#, Programming and Scripting, RetroComputing

Space Invaders Part I

Gallery Leave a comment

I am not a developer by trade and any experience I have is of using C# and various iterations of Visual Basic in the distant (7+ years) past. I use PowerShell in my day-to-day but this can’t really be described as a genuine programming language. One of my ‘bucket list’ items for 2025 was to figure out how to write a Space Invaders game and something I have been procrastinating over for months. This was mainly a project in how do I write it but also served as a great way to learn or at least re-acquaint myself with a programming language I’d lost touch with. Since this was to be a fairly steep learning curve, I figured I should give myself a fighting chance by choosing a language that :

  1. I am somewhat familiar with
  2. Is suitable for such a project.

So for part 1, C# it was. I say part 1 because now I have a good idea of how to put the game together, I would like to take this further and write a version in another language and possibly even a recognizable version in PowerShell. This should give me some exposure to other languages I currently have little to no knowledge of (I’m looking at you, C++ and Python).

But you can get AI to write the whole thing, surely? Well, yes, true and I’m not going to lie, to some extent, using AI is almost unavoidable. When starting on a particular subroutine it would basically read my mind about what I wanted to do next. Really. It’s not like I’m new to this (AI in general or looking for fixes to programming issues) but I’d start to type the name of a routine to make the saucer fly across the screen and it would largely write the thing for me before I’d finished typing the name of the sub. Blown away. That said, not everything was quite right and many times its assumptions weren’t what I wanted so going through the code to fix these issues wasn’t just ‘satisfying’ but necessary.

Then there were annoyances which I genuinely wanted AI to solve but try as it might, it just couldn’t. First versions occasionally left artifacts of the laser fire on the screen that wouldn’t go away. Co-Pilot kept making suggestions but either these didn’t work or worse still, broke the code. And it was during these frustrating times that my free access ran out and I was left to fend for myself (more or less). Back to Stack Overflow for fixes (in the end this solved itself when I was forced to adopt the OnPaint method for sprites – more on this later).

Eventually I had a working game on my desktop development machine which I was quite proud of. It looked just like the real thing and although I’d furnished it with a few more flourishes than I’d originally planned (my starting goal was to make a very basic game that could be ported easily from language to language) I was happy with it. Then I tried it on my laptop. Oh dear. Every time I fired a laser it slowed the game down. Sound was also hogging the UI thread too…my God, this computer must be several million times the speed (and memory) of my old Beeb that used to run this game, so why is it having such a hard time?

This called for a re-write to some extent. Quite a large extent, in fact. I had to put the main game loop on a background thread; the sound had to be pushed out onto a background thread too (this helped a lot but still isn’t perfect by any stretch). However the really big change was to replace the way the sprites were presented. My initial version had all graphics as a separate PictureBox – this was ideal as it was simple and would potentially make future versions eas(ier) to write. Unfortunately this proved incredibly resource-intensive and although it ran OK on my desktop machine, it really struggled on my laptop. Begrudgingly I had to bite the bullet and swap this for the OnPaint Method. Although the learning curve for this increased (dramatically in fact), this did have two main advantages:

  1. The OnPaint method is significantly more performant. Each PictureBox is a full windowed control, which means it has its own window handle (HWND) and processes system messages. For a game with lots of objects like aliens, bullets, and lasers, creating and managing a PictureBox for each one consumes substantial system resources and this led to poor performance and noticeable lag, esp on my laptop. In contrast, OnPaint performs a single, highly optimized drawing operation directly onto the form.
  2. Smooth Animation (Double Buffering): The OnPaint method works seamlessly with the form’s DoubleBuffered property. By setting this.DoubleBuffered = true;, all drawing operations within OnPaint are first rendered to an off-screen buffer and then drawn to the screen in a single operation. This improved animation noticeably.

There are other benefits to this too which I’ll leave out here for brevity’s sake and ultimately it was worth the effort to get the game working with this method instead. The PictureBox version can be found here and the OnPaint version here. Links to the full project are also at the end. I still think there is value in the PictureBox (and single threaded) version if only as the academic exercise of creating the game in it’s simplest* form.

*It’s not in it’s simplest form. I could have made it a lot simpler. As I said, I got a little carried away.

GAME FLOW

Although I won’t pretend I started out with a ‘design’ in mind, this is something that kind of presented itself as I got further into the project. I have used VS2022’s Mermaid Editor extension to help create a flow diagram of how the whole thing works:

Flowchart illustrating the game loop and events for a Space Invaders game, including game setup, player actions, collision checks, and game over sequences.

I have, somewhat lazily, embedded the flying saucer as a project resource and this is the only graphic in the project that remains as a PictureBox. So in short, this is on the form and not ‘created’ in code. The same can be said for the hi-score form which I have designed in the editor rather than created in code. I make no apologies for this and feel free to change and use what you like for your own project, should you wish to. All the graphic and sound files will, as a result, need to be in the same directory as the exe file (“EalingAttack.exe“). Oh yes and on that subject, I had various names for it throughout the project. It started with a reference to my road (BirkbeckInvaders) before eventually settling for EalingAttack (my borough in London). As such you’ll see references to these and they could do with cleaning up in an ideal world. Finally, I have added descriptions of what everything does throughout the code for anyone who’s interested.

I haven’t decided when the next installment will be yet but don’t hold your breath. Ideally I need to start spending some time with the family again :-). I promised a follow-up article on 6502 assembly as well which I still haven’t got round to yet. I’ll probably tackle that first though as it will be a shorter project but again, in my own time which could be whenever.

CONTROLS:

Oh and I forgot to add a controls screen so it’s:

Left/Right arrow for the turret movement and spacebar to fire. As alluded to above, sound is still an issue on some machines, particularly the background sound. If this noticeably affects gameplay, you can toggle it by pressing ‘S‘.

Finally – feel free to create your own upgrades and leave links in the comments.

GITHUB :

bondy666/Space-Invaders: Learn to program Space Invaders in multiple languages

Either clone it or for those who just want to play the game go to Code > Download zip, unpack and run the exe. I promise, there are no nasty surprises (apart from the bad coding).

Late edit – found one or two bugs which could do with fixing (should be easy enough!). Get to level 6 and see what I mean. High score table needs some finessing too.

_______________________________________________________________________________

EDIT JAN ’26

Quick and dirty web version. This is notable only for the fact it runs in an Azure Container Instance. If the link doesn’t work then I’ve probably deactivated the CI.

http://spaceinvaders.ahhmehcbc3e3cybu.ukwest.azurecontainer.io

GitHub:

https://github.com/bondy666/Space-Invaders/tree/896f13f0366b25fc5bc8eed8c7ae74a13a5b0df9/WebInvaders