DEV Community: Krzysztof Koziarski

NuPhy Air75 V2 - firmware upgrade & troubleshooting

Krzysztof Koziarski — Sun, 22 Dec 2024 15:19:08 +0000

I recently wanted to upgrade the firmware on my Nuphy Air75 V2 keyboard to version 2.1.0 and have encountered all sorts of problems.... Therefore, I would like to briefly describe how to deal with them.

Upgrade instructions

Important notes

You need to update all, the keyboard firmware (QMK), the dongle firmware and the RF firmware, otherwise they will not connect.

Instruction

The official instruction can be found on NuPhy's site

The basic instructions for upgrading the firmware are as follows:

1. Download QMK Toolbox

Download QMK Toolbox from https://github.com/qmk/qmk_toolbox/releases and install it.

2. Upgrade QMK firmware

Follow the official instructions.

In short:

The following steps must be done in the exact order and manner as instructed, if your keyboard is already connected, unplug it before starting the process.

Download the firmware from NuPhy's firmware page: QMK_firmware_nuphy_air75_v2.1_ansi_v2.1.0.bin.
Start QMK Toolbox and locate the firmware file (ending with .bin) using the Open dialog in the File menu.
Set the keyboard to wired mode.
Unplug the keyboard
Press and hold the Esc key while connecting your keyboard to the PC using the cable that came with your keyboard.
Release the Esc key when you see the yellow text in the QMK Toolbox
If you have installed all required drivers and they are up-to-date, there are no warnings in QMK Toolbox and the Flash button is enabled, you can press the Flash button to start the firmware upgrade.
If you encounter any problems, see the Troubleshooting section below.

3. Upgrade Dongle Firmware

Follow the official instructions.

In short:

Download the file dongle_52820_upgrade_v2.1.0.exe.
Make sure the USB dongle is connected to your computer,
Run the exe as administrator.
Click the Start button
When finished, click the Finish button
Done.

4. Upgrade RF Firmware

You need iPhone or Android phone.

Follow the official instructions

In short:

Download the nRF Connect for Mobile App.
Save the compressed firmware NUPHY_RF_OTA_Vx.x.x.zip to your phone.
Power up the keyboard in wired mode (make sure the connection mode switch is set to WIRED). Press FN+[ to reset the keyboard to factory defaults.
Refresh the device list in the nRF Connect application until you find the DfuTarg device.
Connect to the DfuTarg device.
Tap the Open Document Picker button, locate the NUPHY_RF_OTA_Vx.x.x.zip file saved in step 2, once the file is loaded
Touch Start.
When the upgrade has finished successfully, power the keyboard off and on again to complete the upgrade.

Troubleshooting

These are the problems I've had and was able to fix with the provided solutions I had to google and found on forums.

Step 2 - Missing WinUSB driver

Problem: In Step 2 you are using Windows and QMK Toolbox displays the following warning message:

STM32 DFU device has NO DRIVER assigned but should be WinUSB. Flashing may not succeed.

Solution: You need to install the driver installer from https://zadig.akeo.ie/ and then install the driver.
Start the Step 2 again

Step 2 - Can't connect to USB dongle

Problem: The Step 2 has finished successfully, but your keyboard can't connect to the USB dongle (but it can connect via Bluetooth) - it has stopped pairing with your USB dongle.
Solution: You need to update all, keyboard firmware (QMK), dongle firmware and RF firmware, otherwise they will not connect.

Step 4 - Unstable connection to dongle (typing characters repeats)

Problem: All steps have been completed successfully, but after connecting to the USB dongle, the keyboard can connect, but typing characters is delayed or repeated several times.
Solution: Re-pair all wireless connections after the update: Once the firmware update is complete, it's important to force re-pair your wireless devices. To do this, hold down Fn+4 until you see the green light blink quickly, then insert the dongle.
Make sure you press the buttons first and then insert the dongle for the pairing to work correctly.

Step 2 - Flashing failed - keyboard is dead

Problem: In Step 2 the flashing failed and the keyboard is dead, no lights on the keyboard, PC doesn't recognize it anymore, nothing happens.

Solution: There is a reset button under the CAPS key. If you press it and reconnect the USB-C cable, it will go into bootloader mode. Then open QMK Toolbox and flash the new firmware from the Nuphy website.

Simplifying Git Worktrees with PowerShell

Krzysztof Koziarski — Sun, 07 Apr 2024 20:21:52 +0000

Git Worktree

One useful but often overlooked feature of Git is git worktree.

This feature allows you to maintain separate working directories for different branches of your Git repository at the same time.
This can help keep your development environment organized and efficient, particularly when working on multiple features or projects simultaneously.
With git worktree, you no longer need to stash or commit your current changes before switching branches. However, managing multiple worktrees can be cumbersome. This is where my PowerShell script, inspired by Bill Mill's approach to using git worktrees, comes into play.

What the script does

The PowerShell script, named Git-Worktree simplifies working with git worktree by automating the creation, deletion, and navigation of worktrees directly from your PowerShell terminal. The tool simplifies the process of setting up worktrees by providing easy-to-use commands.

For your convenience, aliases worktree and gw are also set up to call the Git-Worktree function

Here's a breakdown of its capabilities:

Listing worktrees: Running worktree list provides a list of all existing worktrees within your Git repository.
Creating worktrees: Running worktree mybranch, the script allows you to create new worktrees for specific branches. The first parameter should specify the branch name. If the branch does not exist it will be created. If the branch already exists, a worktree will be created for it. If both the branch and worktree already exist, you will be switched to that worktree. All worktrees will be created inside .worktrees repository for keeping your project directory clean.
Deleting worktrees: The script can delete existing worktrees. The -Delete parameter is used to initiate the deletion process.
Switching to the master branch: Using worktree master switches you to the root directory of the repository for working with the master branch.

Using the script

Here are some examples of how you can leverage the script in your workflow:

1. Creating/switching a worktree for a branch

To create a new worktree for a branch or switch to existing, run:

worktree bugfix-header-typo
worktree task-123

By default every new branch is checked-out from master branch, not current. If you want to checkout from current branch, you need to add -Current parameter:

worktree task-123 -Current

2. Deleting a worktree

To delete a worktree when you're done with the branch:

worktree bugfix-header-typo -Delete
worktree task-123 -Delete

3. Switching to the root directory (master)

To navigate back to the main repo worktree for the master branch:

worktree master

4. Listing existing worktrees

To list all your current worktrees:

worktree list

Summary

By using this script, you simplify the context-switching process that typically hampers productivity when you need to work on multiple branches. The script also helps you maintain a clean work environment by organizing worktrees systematically.

The Git-Worktree script handles the boilerplate of worktree management, so you can retain your focus on what really matters: coding and contributing valuable features to your projects.

To get started, integrate the script into your PowerShell $profile file (run notepad $profile) and use the aliased commands worktree or gw to take your branch management to the next level. Enjoy seamless multitasking across your Git repositories and say goodbye to the old hassles of branch switching.

The script

function Git-Worktree {
   [CmdletBinding()] 
    Param(
        [Parameter(Mandatory=$true)]
        [string]$BranchName,        
        [Parameter(Mandatory=$false)]
        [switch]$Delete,
        [Parameter(Mandatory=$false)]
        [switch]$Current
    )

    function Resolve-GitRoot {
        $dotGitpath = git rev-parse --path-format=absolute --git-common-dir #includes '.git' at the end
        $gitTopLevel = Split-Path -Path $dotGitpath -Parent
        if ($LASTEXITCODE -eq 0 -and $gitTopLevel) {
            return $gitTopLevel
        } else {
            Write-Error "Not inside a git repository or unable to find the git repository root."
            throw "Not a git repository (or any of the parent directories)"
        }
    }

    try {
        $gitRoot = Resolve-GitRoot
    }
    catch {
        Write-Error "Error: $($_.Exception.Message)"
    }

    if ($BranchName -eq 'list') {
        git worktree list
        return;
    }

    if($BranchName -eq 'master') {
        Write-Output "Switching to the root of the repository for main branch 'master' at '$gitRoot'"
        Set-Location -Path $gitRoot
        return
    }

    function Get-GitWorktrees {
        $worktrees = git worktree list --porcelain | Where-Object { $_ -match '^worktree (.+)' } | ForEach-Object {
            $Matches[1].Replace('\', '/')
        }
        return $worktrees
    }

    $existingWorktreePaths = Get-GitWorktrees
    $worktreePath = Join-Path $gitRoot '.worktrees' $BranchName
    if ($Delete) {
        if (Test-Path -Path $worktreePath) {
            try {
                Write-Output "Switching to root"
                Set-Location -Path $gitRoot
                git worktree remove $worktreePath
                if ($LASTEXITCODE -ne 0) {
                    throw "Could not remove worktree"
                }
                if (Test-Path -Path $worktreePath){
                    Remove-Item $worktreePath -Recurse
                    Write-Host "'$worktreePath' folder removed successfully."
                }
                Write-Output "Worktree for branch '$BranchName' has been removed."
            } catch {
                Write-Error "Error: Failed to remove worktree for branch '$BranchName' at '$worktreePath'."
            }
        } else {
            Write-Output "No worktree for branch '$BranchName' at '$worktreePath' exists to remove."
        }
        return
    } 

    $normalizedWorktreePath = $worktreePath.Replace('\', '/')
    if ($existingWorktreePaths -like "*$normalizedWorktreePath*") {
        Write-Output "Worktree for branch '$BranchName' already exists at '$worktreePath'. Switching to that directory."
        Set-Location -Path $worktreePath
        return
    }

    function Create-GitWorktree {
        param (
            [string]$BranchName,
            [string]$WorktreePath,
            [switch]$Current
        )

        git show-ref --quiet -- "refs/heads/$BranchName"
        $branchExists = $LASTEXITCODE -eq 0

        if (-not $branchExists) {
            git ls-remote --quiet --exit-code origin "refs/heads/$BranchName" > $null
            $branchExists = $LASTEXITCODE -eq 0
        }

        if ($branchExists) {
            git worktree add $worktreePath $branchName
        } else {
            $checkoutBranch = $Current ? $null : ($branchExists ? $BranchName : 'master')
            git worktree add -b $branchName $worktreePath $checkoutBranch
        }

        if ($LASTEXITCODE -ne 0) {
            throw "Could not add new worktree for branch '$BranchName' at '$worktreePath'."
        }
    }

    try {
        Create-GitWorktree -BranchName $BranchName -WorktreePath $worktreePath -Current $Current

        Write-Output "Worktree for branch '$BranchName' successfully created at '$worktreePath'."
        Set-Location -Path $worktreePath
    }
    catch {
        Write-Error "Error: Failed to create worktree for branch '$BranchName' and path '$worktreePath'."
    }
}
Set-Alias worktree Git-Worktree
Set-Alias gw Git-Worktree

How to edit any text on any page

Krzysztof Koziarski — Fri, 13 Oct 2023 19:45:55 +0000

Did you know that you can edit any text on any page?

You can put any page into edit mode, which allows you to edit any text as if it were a text editor.

There is a document.designMode property that controls whether the entire document is editable.

It can be useful for creating mockups and taking screenshots by any non-technical people to suggest some changes based on existing functionality.

You can use it to create mems and take screenshot 😁.

Simple (bookmarklet) version

You can create a bookmarklet to toggle edit mode on any page:

Right click on the bookmark bar -> 'Add this page to favorites'
Edit this bookmark -> right click and select 'Edit'
Update name & URL - copy and paste the following code into the URL field:



javascript:(function() { document.designMode = document.designMode === 'off' ? 'on' : 'off'; })();

Developer version

Right click on any page -> Inspect (open Dev Tools) -> Console -> document.designMode = document.designMode === 'off' ? 'on' : 'off'

Both methods should work in all major browsers.

Documentation on MDN

For non-technical users: this only changes the page on your computer and all changes disappear when you refresh the page.

Running Azurite emulator in the background on Windows startup

Krzysztof Koziarski — Fri, 21 Apr 2023 19:55:41 +0000

Azurite is an open-source emulator that enables you to test your applications using Azure Blob, Queue Storage, and Table Storage in a local environment without any cost.
Azurite replaces the Azure Storage Emulator and is regularly updated to ensure support for the latest versions of the Azure Storage APIs.

However, Azurite has one significant drawback compared to the outdated Azure Storage Emulator - it cannot be run in the background without keeping a console/terminal window open at all times.
The obsolete Azure Storage Emulator could be run in the background without opening a new window by running it from the command line:



"C:\Program Files (x86)\Microsoft SDKs\Azure\Storage Emulator\AzureStorageEmulator.exe" start

You could create a start-azure-storage-emulator.cmd script and put the command inside that script, then copy/move it to the Windows Startup folder and voila - the emulator was running in the background and you could forget about it.
Unfortunately this is not possible for Azurite 😥

Options for starting the Azurite emulator

Option 1 - use Docker

One way is to use Docker and run Azurite inside docker:



docker run -d --restart always --name azurite -p 127.0.0.1:10000:10000 -p 127.0.0.1:10001:10001 -p 127.0.0.1:10002:10002 -v c:/dev/data/Azurite:/workspace mcr.microsoft.com/azure-storage/azurite azurite -l /workspace --blobHost 0.0.0.0 --blobPort 10000 --queueHost 0.0.0.0 --queuePort 10001 --tableHost 0.0.0.0 --tablePort 10002

The important thing here is to bind the volume: -v c:/dev/data/Azurite:/workspace where the data is stored, so that it is not lost when the container or Docker is stopped.

But sometimes you can't or don't want to use Docker... What options do you have then?

Option 2 - Run Azurite manually

Run Azurite whenever you need it and keep the console window open all the time.



azurite -l "C:\dev\data\Azurite" --blobHost 0.0.0.0 --blobPort 10000 --queueHost 0.0.0.0 --queuePort 10001 --tableHost 0.0.0.0 --tablePort 10002

Option 3 - Adding Azurite to the Windows startup

This is the option I want to focus on in this article.

Installation



npm install -g azurite

Create batch script

Create a C:\dev\scripts\azurite-startup.cmd file, open it in notepad and paste the following content:



start /B /MIN azurite -l "C:\dev\data\Azurite" --blobHost 0.0.0.0 --blobPort 10000 --queueHost 0.0.0.0 --queuePort 10001 --tableHost 0.0.0.0 --tablePort 10002 > "C:\dev\data\Azurite\azurite.log" 2>&1

The -l, --location option is important here - this is the location of the workspace, where Azurite will store all data.

> "C:\dev\data\Azurite\azurite.log" 2>&1 means you want to redirect standard output and errors to the specified file.

You don't need to specify the *Host and *Port parameters if you don't want to change the default hosts and ports.

Create VBScript

Create a C:\dev\scripts\azurite-win-autostart.vbs file, open it in notepad and paste the following content:



Set WshShell = CreateObject("WScript.Shell")
WshShell.Run chr(34) & "C:\dev\scripts\azurite-startup.cmd" & Chr(34), 0
Set WshShell = Nothing

Windows auto-startup

To run the VBScript file on startup, place it (or it's shortcut right click -> Create shortcut) in the Windows Startup folder. To do this, follow these steps:

Press the Win + R to open the Run dialog box
Type shell:startup and press Enter
Copy the VBScript file you created earlier into the Startup folder.

Restart your computer and the batch script should start without a console window.

Find running Azurite process(es)

If Azurite is running in the background, you won't be able to find or stop the process easily.

You can find it using a PowerShell command:



Get-Process -name "cmd","node" -ErrorAction Ignore | Where-Object { $_.CommandLine -like '*azurite*' -and $_.CommandLine -like '*--blobPort*' }

An even better way is to create functions and/or aliases.

Open the PowerShell $PROFILE file in Notepad: notepad $PROFILE and paste the following content at the end:



function get-azurite-processes { Get-Process -name "cmd","node" -ErrorAction Ignore | Where-Object { $_.CommandLine -like '*azurite*' -and $_.CommandLine -like '*--blobPort*' } }

Set-Alias -Name azp -Value get-azurite-processes -Description "Get Azurite background processess (node and cmd)"

function stop-azurite-processes { get-azurite-processes | Stop-Process }

This will find the cmd and node processes responsible for running Azurite.

To stop Azurite, you can run the function you created in the previous step:



stop-azurite-processes

React + Vite + GitHub Codespaces

Krzysztof Koziarski — Thu, 16 Mar 2023 21:50:12 +0000

In this article, I will show you how to create a React application with Vite and configure dev container to run it in GitHub Codespaces.

According to the official site:

A codespace is a development environment that's hosted in the cloud. You can customise your project for GitHub Codespaces by committing configuration files to your repository, which creates a repeatable codespace configuration for all users of your project.

Currently GitHub Codespaces are available for everyone and you get up to 60 hours per month for free, which should be enough for experiments and pet projects.

Building a React application with Vite.js

In this post, I'll be using React with Typescript, but the same would work for React with a raw javascript template.

1. Build the application - run one of these commands



# npm 6.x
npm create vite@latest devc-react-app --template react-ts

# npm 7+, extra double-dash is needed:
npm create vite@latest devc-react-app -- --template react-ts

# yarn
yarn create vite devc-react-app --template react-ts

2. Install & run



cd devc-react-app

npm install
npm run dev

Your application should run on a random port.

3. Change running port

Open vite.config.ts and change default export to this:



export default defineConfig({
  plugins: [react()],
  server: {
    port: 3000
  }
})

4. Installing extensions

You need to open the project directory in VS Code and install the Dev Containers extensions.

5. Create Dev Container

Once installed, run the Create Dev Container... command and select the universal template

VS Code will add the dev container configuration file to your project: .devcontainer/devcontainer.json.

Once the file is added, you may be prompted by VS Code to open the folder in a dev container.

Let's skip this for now and focus on configuring the dev container first.

Detailed instructions can be found here: Get started with development Containers in Visual Studio Code and here:
Developing inside a Container using Visual Studio Code Remote Development

6. Configuring the dev container

Now, open .devcontainer/devcontainer.json and configure a few things:

forwardPorts - the same as in step 3
portAttributes - this is optional, but allows you to assign a name to the port
updateContentCommand - install dependencies when container is created
postAttachCommand - run application when container is ready

You can also configure a file to open automatically in codespaces customizations.codespaces.openFiles or VS Code extensions to be installed in codespaces and dev container customizations.vscode.extensions.

There are many more configuration options, but I will not focus on them here.



  "forwardPorts": [3000],
  "portsAttributes": {
    "3000": {
      "label": "React App",
      "onAutoForward": "openPreview"
    }
  },
  "updateContentCommand": "npm install",
  "postAttachCommand": "npm run dev",

  // Configure tool-specific properties.
  "customizations": {
    "codespaces": {
      "openFiles": ["src/App.tsx"]
    },
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
      ]
    },
//...

Port attributes

7. Configure start command

By default, Vite doesn't work in codespaces - even though the application is running, you can't see any page content in a browser.

To fix this, you need to modify package.json and change the scripts.dev by adding the --host parameter:



"scripts": {
  "dev": "vite --host"
}

This is the trick I couldn't find anywhere and spent a lot of time looking for.

Remainder: this is the command that the dev container runs as "postAttachCommand": "npm run dev" on startup.

8. Push to GitHub

Now you can push the repository to GitHub and open it in Codespaces:

You will see the green text 'codespaces' in the bottom left corner of your browser.

Extras

Open in local Dev Container

To open a project in a local dev container, you need to:

Have Docker installed and running
Open the project folder in VS Code, then you will be asked if you want to open it in the dev container. You can open it or clone to the dev container
- Reopen in dev container - files stay where they are and you work on them directly from the linked Docker volume
- Clone in volume - preferred for Windows users with WSL2. It clones a copy of the project into a Docker container and volume. This option is much faster on Windows.

Detailed instructions can be found here: Get started with development Containers in Visual Studio Code and here:
Developing inside a Container using Visual Studio Code Remote Development

If you don't have your repository locally and want to clone it directly from GitHub into a local dev container, you can do this from within VS Code:
> Dev containers: Clone repository in Container Volume

Running CRA in Codespaces

To run a React application created with CRA (create-react-app) you need to change start command in package.json:



  "scripts": {
    "start": "BROWSER=none WDS_SOCKET_PORT=0 react-scripts start"
    //...
  },

This is needed to fix the hot reload after each change.

You can find the GitHub repository for this article here

Practicing algorithms using Polyglot Notebooks - part 3 - helpers

Krzysztof Koziarski — Wed, 28 Dec 2022 22:01:36 +0000

In the previous post Practicing algorithms using Polyglot Notebooks - part 2 - introduction the execution and assert part was a bit messy with a lot of code repeating for each algorithm. We can reduce this part by using short extension methods instead.

Instead of writing:

foreach (var (targetSum, numbers, output) in testCases) {
    var result = HowSum(targetSum, numbers);
    var numbersStr = Newtonsoft.Json.JsonConvert.SerializeObject(numbers);
    var resultStr = Newtonsoft.Json.JsonConvert.SerializeObject(result);
    var outputStr = Newtonsoft.Json.JsonConvert.SerializeObject(output);
    Console.WriteLine($"f({targetSum}, {numbersStr}) => {outputStr}, actual: {resultStr}{ (resultStr == outputStr ? " ✔" : " | WRONG!!! ❌") }");
}

we will be able to make it more concise:

foreach (var (targetSum, numbers, output) in testCases) {
    var result = HowSum(targetSum, numbers, new());
    Log($"f({targetSum}, {numbers.Str()})", result?.Str(), output?.Str());
}
Asrt.Flush();

Helpers

We need a set of methods that will help us to prepare, execute, assert and write results.

In the last example above, you can notice three new methods:

Log(...)
.Str()
Asrt.Flush()

Those are helper methods that were added as first code cell in the notebook and should be executed at beginning (first action after the notebook is open).

Reminder - reusing previous cells

You can access methods and variables from previous cells in next cells, but only if you execute the previous cells first.

Methods and variables from previous cells will not be available in next cells until you execute those previous cells first. Similarly, if you change values or method implementation in previous cells without executing those cells then only old values will be available in next cells.

Helper methods

Every algorithm is (and should be) independent and does not depend on any other cell except helpers cell.

`Asrt` class

This is a simple static helper class to assert condition, collect errors and write summary line at the end of cell.

public static class Asrt {
    private static bool hasErrors;
    public static string T(bool condition) {
        if (!condition) {
            hasErrors = true;
        }
        return condition ? "" : " | WRONG!!! ❌";
    }

    public static void Flush() {
        if (hasErrors) {
            hasErrors = false;
            Console.WriteLine("\n❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌");
            // throw new System.Data.DataException("Invalid result");
        } else {
            Console.WriteLine("\n✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅");
        }
    }
}

The T(bool condition) method is used inside Log(...) method to print assert results.
The Flush() method must be called at the end of each cell to write summary line and reset hasErrors flag. It is very important to always call it at the end if you use Log() method in a cell, otherwise you will get an incorrect result in a next cell.

`Log(...)` method

This is a helper method that prints the result for each test case. It accepts function description (funcDefStr) as first argument, result as current return value from algorithm function and expected as expected value. The last parameter is optional and allows you to override default comparison logic.

public static void Log<T>(string funcDefStr, T result, T expected, bool? condition = null) {
    condition = condition ?? EqualityComparer<T>.Default.Equals(result, expected);
    Console.Write($"{funcDefStr} => ");
    Console.Write($"{(result == null ? "<null>" : result)}");
    if (condition == false) {
        Console.Write($" expected: {expected}");
    } else {
        Console.Write(" ✔");
    }
    Console.WriteLine(Asrt.T(condition == true));
}

`.Str()` method

This is an extension method which converts IEnumerable to JSON string array new int[] { 1, 2, 3 } => [1,2,3] or new List<string> { "aa", "bb", "cc" } => [aa, bb, cc].

public static string Str(this IEnumerable<int> arr, int? size = null) => { ... }

public static string Str(this IEnumerable<object> arr, int? size = null) { ... }

Example algorithms

Here are some algorithms which are returning different result types - primitives (int), array (int[]) and array of arrays (string[][]) to demonstrate different usages of helper methods.

Fib

"✅Fibonacci memoization".Display();
public int Fib(int n, Dictionary<int, int> memo = null) {
    if (n <= 2) return 1;
    if (memo.ContainsKey(n)) return memo[n];

    int result = Fib(n-1, memo) + Fib(n-2, memo);
    memo[n] = result;
    return result;
}

(int intput, int output)[] testCases = {
    (6, 8),
    (7, 13),
    (8, 21),
    (45, 1134903170),
};

foreach (var (input, output) in testCases) {
    var result = Fib(input, memo: new());
    Log($"f({input})", result, output);
}
Asrt.Flush();

HowSum

For IEnumerable<T> results use .Str() method to convert result into JSON string. This is an extension method for IEnumerable<T>.
If you want to sort result first, use .SortNStr() to sort elements firts and then convert sequence to JSON string.

"✅HowSum memoization".Display();

public int[] HowSum(int targetSum, int[] numbers, Dictionary<int, int[]> memo) {
    if (targetSum < 0) return null;
    if (targetSum == 0) return new int[0];
    if (memo.ContainsKey(targetSum)) return memo[targetSum];

    foreach (int n in numbers) {
        int remainder = targetSum - n;

        var result = HowSum(remainder, numbers, memo);
        if (result != null) {
            result = result.Append(n).ToArray();
            memo[targetSum] = result;
            return result;
        }
    }

    memo[targetSum] = null;
    return null;
}

(int targetSum, int[] numbers, int[] output)[] testCases = {
    (7, new int[] { 2,3 }, new int[] { 3,2,2 }),
    (7, new int[] { 5,3,4,7 }, new int[] { 4,3 }),
    (7, new int[] { 2,4 }, null),
    (8, new int[] { 2,3,5 }, new int[] { 2,2,2,2 }),
    (300, new int[] { 7,14 }, null),
};

foreach (var (targetSum, numbers, output) in testCases) {
    var result = HowSum(targetSum, numbers, new());
    Log($"f({targetSum}, {numbers.Str()})", result?.SortNStr(), output?.SortNStr());
}
Asrt.Flush();

AllConstruct

For two dimensional results use .Str2() instead. This is an extension method for IEnumerable<IEnumerable<object>> or int[][].

"✅AllConstruct memoization".Display();

public List<List<string>> AllConstruct(string target, string[] wordBank, Dictionary<string, List<List<string>>> memo) {
    if (target == string.Empty) return new() { new List<string>() };
    if (memo.ContainsKey(target)) return memo[target];

    List<List<string>> result = new();

    foreach (string word in wordBank) {
        if (target.StartsWith(word)) {
            string suffix = target.Substring(word.Length);

            var suffixWays = AllConstruct(suffix, wordBank, memo);

            foreach (var way in suffixWays) {
                List<string> targetWay = new();
                targetWay.Add(word);
                targetWay.AddRange(way);
                result.Add(targetWay);
            }
        }
    }

    memo[target] = result;
    return result;
}

(string target, string[] wordBank, string[][] output)[] testCases = {
    ("purple", FromJson<string[]>("[ 'purp', 'p', 'ur', 'le', 'purpl' ]"), FromJson<string[][]>(@"
     [
        [ 'purp', 'le' ],
        [ 'p', 'ur', 'p', 'le' ],
     ]")),
     ("abcdef", FromJson<string[]>("[ 'ab', 'abc', 'cd', 'def', 'abcd', 'ef', 'c' ]"), FromJson<string[][]>(@"
     [
        [ 'ab', 'cd', 'ef' ],
        [ 'ab', 'c', 'def' ],
        [ 'abc', 'def' ],
        [ 'abcd', 'ef' ],
     ]")),
    ("skateboard", FromJson<string[]>(" ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar' ]"), FromJson<string[][]>("[]")),
    ("eeeeeeeeeeeeeeeeeeeeeeeeeeeef", FromJson<string[]>(" [ 'e', 'ee', 'eee', 'eeee', 'eeeee', 'eeeeee' ]"), FromJson<string[][]>("[]")),
};

foreach (var (target, wordBank, output) in testCases) {
    var result = AllConstruct(target, wordBank, new());
    Log($"f('{target}', '{wordBank.Str()}')", result?.Str2(), output?.Str2());
}
Asrt.Flush();

Navigation

For easier navigation between cells, you can use breadcrumbs

or press CTRL+SHIFT+O to find cell by title

All C# algorithms notebook from the dynamic programming course can be found here

Practicing algorithms using Polyglot Notebooks - part 2 - introduction

Krzysztof Koziarski — Wed, 28 Dec 2022 22:00:56 +0000

In the previous post: Practicing algorithms using Polyglot Notebooks - part 1 (setup) I've described how to install and configure Polyglot Notebooks (formerly .NET Interactive notebooks).

In this post I will show you how to start practicing algorithms in C# using Polyglot Notebooks.

I will implement some test cases from the best dynamic programming course in the world:
Dynamic Programming - Learn to Solve Algorithmic Problems & Coding Challenges

The course from freeCodeCamp.org uses JavaScript but I will show you how to do that in C# and Polyglot Notebooks (you can also use JavaScript in Polyglot Notebooks)

First algorithm

Structure

One algorithm will consist of three parts:

Description - a markdown cell with problem description
Practice - a code cell - placeholder - contains empty method and test cases
- this is the main cell you should work in and once completed, remove its content for next time
Solution - a code cell with solution - marked with ✅
- it should be collapsed by default and used only when you stuck and need a reminder

Create algorithm

1. Problem description - Fib

Create a markdown cell and type the description:

## Fibonacci memorization

Write a function `fib(n)` that takes in a number as an argument.
The function should return the `n-th` number of the Fibonacci sequence.

The 0th number of the sequence is 0.
The 1th number of the sequence is 1.

2. Practice - Fib

Below the problem description create a code cell - with method placeholder and test cases, as well execution and assert part.

"Fibonacci memoization".Display();
public int Fib(int n, Dictionary<int, int> memo = null) {
    return -1;
}

// test cases
(int intput, int output)[] testCases = {
    (7, 13),
    (8, 21),
};

// execution
foreach (var (input, output) in testCases) {
    var result = Fib(input, memo: new());

    // assert
    Console.WriteLine($"f({input}) => {output}, actual: {result}{ (result == output ? " ✔" : " | WRONG!!! ❌") }");
}

3. Solution - Fib

Create a new code cell with full implementation. This is a copy of the previous cell but the Fib method has actual implementation.
Solution cell is marked with ✅ so it's easier to recognize.

"✅Fibonacci memoization".Display();
public int Fib(int n, Dictionary<int, int> memo = null) {
    if (n <= 2) return 1;
    if (memo.ContainsKey(n)) return memo[n];

    int result = Fib(n-1, memo) + Fib(n-2, memo);
    memo[n] = result;
    return result;
}

// test cases
(int intput, int output)[] testCases = {
    (7, 13),
    (8, 21),
};

// execution
foreach (var (input, output) in testCases) {
    var result = Fib(input, memo: new());

    // assert
    Console.WriteLine($"f({input}) => {output}, actual: {result}{ (result == output ? " ✔" : " | WRONG!!! ❌") }");
}

Output

Solution cells should be committed to git. Methods in practice cells should be committed empty so you can go back to it at any time - with fresh start and without a need to remove its implementation before starting practice.

More complex results

What if we have a method that returns a non-primitive type? Let's look at method:

int[] HowSum(int targetSum, int[] numbers)

As you can see, this method returns an array. We need to check if its result is the same as expected.

Problem description - HowSum

## HowSum tabulation

Write a function `howSum(targetSum, numbers)` that takes in a `targetSum` and an array of numbers as arguments.

The Function should return an array containing any combination of elements that add up to exactly the `targetSum`. If there is no combination that adds up to the `targetSum`, then return null.

Solution - HowSum

Let's create a solution cell for this

"✅HowSum tabulation".Display();

public int[] HowSum(int targetSum, int[] numbers) {
    int[][] dp = new int[targetSum + 1][];
    dp[0] = new int[0]; //[]

    for (int i = 0; i <= targetSum; i++) {
        if (dp[i] != null) {
            foreach (int n in numbers) {
                if (i + n <= targetSum) {
                    var list = new List<int>(dp[i].Length + 1);
                    list.AddRange(dp[i]);
                    list.Add(n);
                    dp[i + n] = list.ToArray(); // [ ...d[i], n]
                }
            }
        }
    }

    return dp[targetSum];
}

// test cases
(int targetSum, int[] numbers, int[] output)[] testCases = {
    (7, new int[] { 2,3 }, new int[] { 3,2,2 }),
    (7, new int[] { 5,3,4,7 }, new int[] { 4,3 }),
    (7, new int[] { 2,4 }, null),
    (8, new int[] { 2,3,5 }, new int[] {2,2,2,2 }),
    (300, new int[] { 7,14 }, null),
};

// execution
foreach (var (targetSum, numbers, output) in testCases) {
    var result = HowSum(targetSum, numbers);
    var numbersStr = Newtonsoft.Json.JsonConvert.SerializeObject(numbers);
    var resultStr = Newtonsoft.Json.JsonConvert.SerializeObject(result);
    var outputStr = Newtonsoft.Json.JsonConvert.SerializeObject(output);

    // assert
    Console.WriteLine($"f({targetSum}, {numbersStr}) => {outputStr}, actual: {resultStr}{ (resultStr == outputStr ? " ✔" : " | WRONG!!! ❌") }");
}

The idea is very simple - convert all complex types into strings and compare strings. For our purposes this is good enough.

In the next post Practicing algorithms using Polyglot Notebooks - part 3 - helpers I will show you how to simplify the last part (execution and assert inside foreach) to avoid code duplication in each cell and make the code more concise.

Gist for this article can be found here

Practicing algorithms using Polyglot Notebooks - part 1 (setup)

Krzysztof Koziarski — Wed, 28 Dec 2022 21:59:45 +0000

There are many ways to practice algorithms: using online editors or by writing console apps and even more complicated programs with unit tests. You can also practice it on LeetCode.

I would like to show you tools I use to write and resolve algorithmic problems. I hope you’ll find it useful too.

I'm .NET developer and I will focus on C#/.NET, but you can use it for JavaScript as well.

Polyglot Notebooks (formerly .NET Interactive)

Polyglot Notebooks can be used for practicing algorithms. In this article I will show you how to install, configure and troubleshoot Polyglot Notebooks.

Installation

Polyglot Notebooks is a VS Code extension. To use it you need to:

Install the latest .NET 7 SDK
Install the Polyglot Notebooks extension from the VS Code marketplace.

Getting started - create new notebook

To create a new polyglot notebook, open the Command Palette(Ctrl+Shift+P) on Windows or (Cmd+Shift+P) on MacOS, and select Polyglot Notebook: Create new blank notebook -> Create as .dib -> C#

In the new cell write:

$"Hello world at {DateTime.Now}".Display();

and press CTRL+Enter to execute it. You can also execute current cell by clicking the play icon.

The .Display() method is a special extension method which shows the result in an output cell. It’s available only in Polyglot Notebook.
In the above example it is the same as writing

Console.WriteLine($"Hello world at {DateTime.Now}")

There are two types of cells: code and markdown.

You can add them by clicking + in the top bar buttons (1) or the one appearing on hover cell (2).

At the bottom right corner of each cell (3), you can see if this is a markdown cell or code cell with its language.

Reusing previous cells

Variables, methods and classes from previous cells can be accessed in next cells but only if you execute the previous cells first.

If you don't, variables will not be available. Similarly, if you change values or method implementation in previous cells without executing, then only old values will be available in next cells.

Configuration

The default configuration is good enough to start working with the notebooks. Below, I share some overrides that I think will make your work with Polyglot Notebooks much easier.

Create workspace

In the same folder where your notebook is placed, create a VS Code workspace file. I will name it dotnet.code-workspace.
You can use mine:

{
    "folders": [
        {
            "path": "."
        }
    ],
    "settings": {
        "omnisharp.enableAsyncCompletion": true,
        "omnisharp.useModernNet": true,
        "interactiveWindow.collapseCellInputCode": "always",
        "notebook.showFoldingControls": "always",
        "notebook.cellToolbarVisibility": "hover",
        "notebook.cellFocusIndicator": "border",
        "notebook.diff.ignoreMetadata": false,
        "notebook.diff.ignoreOutputs": true,
        "notebook.dragAndDropEnabled": false,
        "notebook.lineNumbers": "on",
        "notebook.outline.showCodeCells": true,
        "notebook.diff.enablePreview": false,
        "notebook.consolidatedOutputButton": false,
        "notebook.compactView": false,
        "notebook.output.textLineLimit": 50,
        "vsicons.associations.files": [
            { "icon": "pddl_happenings", "extensions": ["dib"], "format": "svg" }
        ],
        "files.exclude": {
            "**/.gitattributes": true,
            "**/.gitignore": true,
            "**/*.code-workspace": true
        }
    },
    "extensions": {
        "recommendations": [
            "vscode-icons-team.vscode-icons",
            "ms-dotnettools.dotnet-interactive-vscode",
        ]
    }
}

There are some settings for notebook.* that I prefer, but it's up to you to experiment with those settings.

As you can see, there is also a recommended vscode-icons extension. This is to set an icon for .dib files:

"vsicons.associations.files": [
    { "icon": "pddl_happenings", "extensions": ["dib"], "format": "svg" }
]

The result will be:

Add some keyboard shortcuts

I recommend adding some keyboard shortcuts to make it easier to operate notebook cells. Open the Command Palette(Ctrl+Shift+P) on Windows or (Cmd+Shift+P) on MacOS, and type Preferences: Open Keyboard Shortcuts (JSON), then add the following configuration

{
    "key": "o",
    "command": "notebook.cell.collapseCellInput",
    "when": "notebookCellListFocused && !inputFocus && !notebookCellInputIsCollapsed"
},
{
    "key": "o",
    "command": "notebook.cell.expandCellInput",
    "when": "notebookCellInputIsCollapsed && notebookCellListFocused"
},
{
    "key": "q",
    "command": "notebook.cell.collapseCellInput",
    "when": "notebookCellListFocused && !inputFocus && !notebookCellInputIsCollapsed"
},
{
    "key": "q",
    "command": "notebook.cell.expandCellInput",
    "when": "notebookCellInputIsCollapsed && notebookCellListFocused"
},
{
    "key": "w",
    "command": "notebook.cell.clearOutputs",
    "when": "notebookCellEditable && notebookCellHasOutputs && notebookEditable && notebookEditorFocused && !inputFocus"
},

This will basically allow you collapse/expand cells by simply pressing o or q and clear cell output by pressing w

.gitignore

Set line ending for *.dib files:

###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto

# Never modify line endings of dib files
*.dib text eol=lf

Troubleshooting

Infinity loop

While practicing algorithms, it is very likely that you will write an infinity loop like below.

Unfortunately, the stop button (1) doesn't work in that case and will not stop executing the cell. To stop an execution, you need to click Restart button on the top (2) or open Command Palette(Ctrl+Shift+P) and type Polyglot Notebook: Restart the current notebook's kernel. In that case, variables from previous cells will not be available and you will need to execute the previous cells again.

Broken layout

Sometimes when you open a bigger notebook with many code and markdown cells you can get a broken view like this:

To fix this you need to collapse all cell inputs by opening Command Palette(Ctrl+Shift+P) and typing Notebook: Collapse All Cell Inputs. You can then expand all cell inputs if you need to.

Next post Practicing algorithms using Polyglot Notebooks - part 2 - introduction

Gist for this article can be found here

DEV Community: Krzysztof Koziarski

NuPhy Air75 V2 - firmware upgrade & troubleshooting

Upgrade instructions

Important notes

Instruction

1. Download QMK Toolbox

2. Upgrade QMK firmware

3. Upgrade Dongle Firmware

4. Upgrade RF Firmware

Troubleshooting

Step 2 - Missing WinUSB driver

Step 2 - Can't connect to USB dongle

Step 4 - Unstable connection to dongle (typing characters repeats)

Step 2 - Flashing failed - keyboard is dead

Simplifying Git Worktrees with PowerShell

Git Worktree

What the script does

Using the script

1. Creating/switching a worktree for a branch

2. Deleting a worktree

3. Switching to the root directory (master)

4. Listing existing worktrees

Summary

The script

How to edit any text on any page

Simple (bookmarklet) version

Developer version

Running Azurite emulator in the background on Windows startup

Options for starting the Azurite emulator

Option 1 - use Docker

Option 2 - Run Azurite manually

Option 3 - Adding Azurite to the Windows startup

Installation

Create batch script

Create VBScript

Windows auto-startup

Find running Azurite process(es)

React + Vite + GitHub Codespaces

Building a React application with Vite.js

1. Build the application - run one of these commands

2. Install & run

3. Change running port

4. Installing extensions

5. Create Dev Container

6. Configuring the dev container

7. Configure start command

8. Push to GitHub

Extras

Open in local Dev Container

Running CRA in Codespaces

Practicing algorithms using Polyglot Notebooks - part 3 - helpers

Helpers

Reminder - reusing previous cells

Helper methods

Asrt class

Log(...) method

.Str() method

Example algorithms

Fib

HowSum

AllConstruct

Navigation

Practicing algorithms using Polyglot Notebooks - part 2 - introduction

First algorithm

Structure

Create algorithm

1. Problem description - Fib

2. Practice - Fib

3. Solution - Fib

Output

More complex results

Problem description - HowSum

Solution - HowSum

Practicing algorithms using Polyglot Notebooks - part 1 (setup)

Polyglot Notebooks (formerly .NET Interactive)

Installation

Getting started - create new notebook

Reusing previous cells

Configuration

Create workspace

`Asrt` class

`Log(...)` method

`.Str()` method