Snowdrift.tech

Free Web-Based Planning Poker for Teams

2025-09-17T20:55:00+00:00

I’ve been using Poinz for long enough it was time to run my own instance.

Poinz is an open-source web-based planning poker application for software development teams or anyone else who needs to perform estimates as a remote team.

Introducing EstimateThis.Work, a free instance of Poinz for anyone to use for their planning poker needs: https://estimatethis.work

Let me know if you have any questions or run into any issues. As with any Poinz instance, consider all information you enter to be potentially publicly available, since rooms are not password-protected by default. Second, don’t use it as a permanent data store. Record your scores in your issue tracking platform of choice.

Enjoy!

Configuring an HTTP Proxy in BlueStacks App Player on Windows

2025-02-20T12:52:00+00:00

Getting Started

To configure an HTTP proxy in BlueStacks App Player on Windows, for example to use Fiddler or a similar tool to inspect and debug HTTP traffic, use the ADB interface for BlueStacks.

First, launch BlueStacks App Player.

Open Windows Terminal and navigate to the C:\Program Files\BlueStacks_nxt directory.

Confirm that the app player is visible by running .\HD-Adb.exe devices. You should see the emulator device attached.

Configure the Proxy

Use the following command to configure the HTTP proxy, replacing the IP address and port number as appropriate to your setup:

.\HD-Adb.exe shell settings put global http_proxy 192.168.1.1:1234

You may need to restart the app player for the setting to take effect.

Remove the Proxy Configuration

Run the following commands to remove the proxy configuration:

.\HD-Adb.exe shell settings delete global global_http_proxy_host
.\HD-Adb.exe shell settings delete global global_http_proxy_port
.\HD-Adb.exe shell settings delete global http_proxy

You may need to restart the app player for the setting to take effect.

Including JIRA Issue Number in Commit Messages

2020-04-28T01:03:03+00:00

The project on which I am currently working requires by convention that all commits associated with a specific JIRA issue have messages that begin with the issue number, followed by a colon and the rest of the commit message.

Over time, I’ve grown tired of typing (and mistyping) the issue number for each commit message, and I’ve decided to automate the process with a script.

The obvious place to add this functionality is in a git hook. Git hooks are scripts that are called by git at specific times, and they allow the user to customize the behavior of git. Learn more about git hooks specifically here.

Due to integration between JIRA and Bitbucket on my project, each git branch already includes the issue number of the related JIRA issue. Thus, my git hook runs at commit time and checks the branch name for a JIRA issue number. If present, it makes sure my commit message begins with the issue number.

I’ve used PowerShell as a cross-platform scripting environment, so the script should work on Windows, OSX, and Linux with minimal modifications.

After a bit of experimentation, I settled on the following core script:

Due to a recent change in PowerShell, this script cannot be directly used as the commit hook, so I placed this core script in a central directory for Git hooks scripts, in C:\Tools\git-hooks\.

I created a second, wrapper script as follows:

I placed the script in the git hooks directory for my project, and it ran on my next commit.

To use with your project, place the core script in C:\Tools\git-hooks\ and the wrapper script in <project_directory>\.git\hooks\ and ensure it has execute permissions. You may also need to update the wrapper script with the correct path to your PowerShell executable (you can find this by executing Get-Command pwsh | Select-Object Source).

Update 11/27/2023: Added workaround to support newer versions of PowerShell.

Custom URL Shortener

2020-04-19T20:25:52+00:00

I’ve been on a mini-side-project spree lately, and I decided (on a whim) to set up my own URL shortener. If you’ve been on Twitter (or really anywhere online), you’ve probably seen the result of such services. It’s like bit.ly, but with a personalized address. For example, Microsoft uses aka.ms for their short-links.

After checking the features and pricing of a few providers (and considering a self-hosted solution, of course), I settled on Rebrandly. Their free plan offers unlimited links and the ability to use a custom domain.

First, though, I needed a short domain. After balking at the $40k+ price of some options, I found one that fit my expectations: davl.ink. It’s got the first few letters of my name, and includes the work “link.” A few clicks, and the domain was mine. I changed the nameservers over to Cloudflare and added the necessary A records to point the domain at Rebrandly.

The result: I can create short links to whatever I like, personalized with my own domain!

For example, this link will redirect you to my personal site: davl.ink/me. This link will send you to my photo stream: davl.ink/photos. I tweeted out a link to this post using this link: davl.ink/url-shortener-dd7e2.

Will I use this much? I don’t know. I like the ability to give someone a link that is short, memorable, and personalized. The ability to change the link destination after-the-fact has some great potential applications for preventing link rot. For example, if I change where my photo stream is hosted, I can change the short link to point at the new host. Anyone to whom I’ve already given the link can still use it.

Best of all, the only cost to me is the domain registration, which comes in at ~$19/year. Worth it? 🤷‍♂️

Paint and Perl

2019-05-09T20:00:00+00:00

I recently discovered this amusing paper from Colin McMillen and Tim Toady in which they evaluate the existence of paint splatters that do not represent valid Perl programs.

Read the paper here.

The result seems to be mainly complicated by the fact that Perl supports unquoted strings, so many random strings will evaluate as constants when provided to the Perl interpreter.

Why? Who knows. ¯\_(ツ)_/¯

Enjoy. 😊

Using ssh-agent with git on Windows

2019-01-31T21:00:00+00:00

I have multiple passphrase-protected SSH keys on my laptop that allow me to authenticate with various devices and services. I don’t mind typing my passphrase when logging in to a remote computer via SSH. To me, the action is conceptually similar to entering a local password at login. However, since I use SSH keys for authentication to GitHub, every git command that affects a remote repository results in a prompt for an SSH key passphrase.

This is really annoying.

I’ve seen ssh-agent mentioned as a solution to this issue, but only in the context of a Linux environment. How can I take advantage of this functionality on my Windows laptop? The ssh-agent that is included with git, while technically a Windows executable, is configured for a pseudo-Linux environment.

Thankfully, in Windows 11 and newer versions of Windows 10, OpenSSH ships as an optional feature. After enabling the feature, a proper ssh-agent is available for use.

Enabling and starting ssh-agent

After enabling OpenSSH in Windows, the ssh-agent service needs to be enabled. Open an elevated PowerShell window and run:

PS> Get-Service ssh-agent | Set-Service -StartupType Automatic

This will start the ssh-agent service automatically when your computer boots up.

Verify that your PATH is properly configured by executing the following:

PS> Get-Command ssh | Select-Object Source

Source
------
C:\Windows\System32\OpenSSH\ssh.exe

Validate that your output is similar to mine. The ssh executable should be in the System32 folder, not the Git for Windows directory. If your output doesn’t match, your PATH variable probably needs to be modified to prioritize the C:\Windows\System32\OpenSSH directory over the Git for Windows directory.

Start the ssh-agent service by executing the ssh-agent process.

PS> ssh-agent

The ssh-agent service should now be running. Since we set the ssh-agent service to start automatically, you’ll only have to do this once.

Importing keys

Keys need to be imported to the ssh-agent service so that they can be unlocked for use. Execute the following and follow the prompts to load and unlock your keys.

PS> ssh-add

You can view the available keys by running ssh-add -l.

Read more about importing ssh keys here.

Linking to git

Git for Windows uses the ssh binaries included with git by default. While this works well enough in most situations, one side-effect is that git has no idea how to talk to the Windows ssh-agent service. For git commands to use the Windows ssh-agent service, git needs to be informed of the system OpenSSH path. To accomplish this, the environment variable GIT_SSH needs to be set with the path of the system OpenSSH executable.

Run the following command to update the environment variable:

PS> [Environment]::SetEnvironmentVariable("GIT_SSH", "$((Get-Command ssh).Source)", [System.EnvironmentVariableTarget]::User)

Open a new PowerShell window to activate the new environment variables.

You’re done!

Test remote git commands with SSH authentication (e.g. git pull) and verify that the passphrase prompt does not occur with each command.

Congrats, you’ve just saved yourself a lot of time down the road.

Replacing ssh-copy-id on Windows

2019-01-28T21:00:00+00:00

The ssh-copy-id command is useful for configuring a server to allow authentication with a given set of SSH keys. Read more on the command here.

Windows comes with a built-in SSH client. It’s an optional feature, however, so it must be enabled before use. One missing component is ssh-copy-id. Many options exist that replicate its behavior, but I wanted something very simple that I could stash in my PowerShell profile.

Here’s what I created:

Examples

To copy default credentials, either from the SSH agent or from ~/.ssh/id_rsa.pub, run:

ssh-copy-id user@host

To specify the identity file to copy, run:

ssh-copy-id -i ~/.ssh/identity_file.pub user@host

This fulfills the main functionality of ssh-copy-id, but it doesn’t handle most error cases or any extended options. As such, it’s not intended to replace the original tool, but instead to simply provide a shortcut for Windows users of the built-in SSH client.

For the best SSH functionality on Windows, I recommend using the SSH tools available in the Windows Subsystem for Linux.

My Git Config

2018-09-29T17:00:00+00:00

I like to configure git to sign my commits with GPG and use the Visual Studio Code Insiders editor for config files and diffs.

To edit your global git configuration, run the following at the command line:

git config --global --edit

To compare two commits using the default difftool, run the following:

git difftool <commit1> <commit2>

Tip: Using Conda Environments with Jupyter on Windows

2018-09-23T03:00:00+00:00

Introduction

Conda environments don’t work well by default in PowerShell, and the environments don’t show up by default as kernels in Jupyter.

Using Conda Environments in PowerShell

Update 1/29/2019: Conda now officially supports PowerShell. Read more on the blog post.

The ease with which Conda environments can be used in PowerShell varies based on the version of Conda installed. Check your version by running conda --version.

Version 4.6 and Later

With the version 4.6 update, Conda supports PowerShell natively. To configure for PowerShell, run the following:

PS> conda init powershell

The conda init command will modify the activate/deactivate scripts and make changes to your PowerShell profile.

Prior to Version 4.6

You’ll need to install some additional software in order to use the activate/deactivate commands in PowerShell. Specifically, install the helpful tool from Pavel Koneski called PSCondaEnvs.

Note that if your PowerShell execution policy is Restricted (run Get-ExecutionPolicy to check), you’ll need to set it to RemoteSigned by running the following:

PS> Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

Now, install pscondaenvs with Conda:

PS> conda install -n root -c pscondaenvs pscondaenvs

Enter y when prompted to proceed.

Once pscondaenvs is installed, you’ll have new activate and deactivate commands available that work in PowerShell.

Making Conda Environments Available in Jupyter

First, activate the desired environment by running conda activate myenv (or activate myenv if using pscondaenvs). Ensure dependencies are available by running the following:

(myenv) PS> conda install pip
(myenv) PS> conda install ipykernel

Type y to proceed as needed. After the installation completes, run the following command to create a new ipykernel for this environment:

(myenv) PS> python -m ipykernel install --user --name myenv --display-name "Python (myenv)"

You’ll see the “Python (myenv)” kernel available when you next launch JupyterLab.

Publishing a Personal Site

2018-09-16T04:00:00+00:00

Sometimes I need to put a quick static site online without much fuss. This very site is an example.

Here’s how I do it.

Installing tools

For this post, I’ll assume you’re on a recent version of Windows. We’re going to use jekyll to handle the static site creation. In order to get it installed, we’ll need a few prerequisites.

Start off by installing chocolatey via PowerShell. Instructions are here. chocolatey is a package manager for Windows that I like to use to manage most utilities.

Once chocolatey is installed, we’ll use it to install ruby and git. Open an administrator PowerShell window and run:

PS> choco install git ruby -y

chocolatey will automatically download and run the appropriate installers.

Next, we’ll install jekyll. Open a new PowerShell terminal (to ensure the PATH is up-to-date with the chocolatey installations) and run the following:

PS> gem install jekyll bundler

This will install jekyll and dependencies. For details on installation, further instructions are here.

Setup site

Create a new GitHub repo for your site (click here). Enter a repository name (like your site name) and leave the repo public and uninitialized.

Open a new PowerShell terminal. Navigate to the directory where you’ll keep your project.

PS> cd ~\Source\Repos

Clone your GitHub repo and move into the directory.

PS> git clone git@github.com:username/site-name.git
PS> cd .\site-name\

Run the jekyll scaffolder to create the site structure.

PS> jekyll new .

Now we have a basic web site created. Let’s preview it.

PS> jekyll serve

jekyll will render the site and launch a preview server. Open http://127.0.0.1:4000/ to view the site.

Press ctrl-c and type y to shutdown the preview.

Publish site

Let’s get this site online. First, commit the changes to the git repo and push to GitHub.

PS> git add *
PS> git commit -m "Initial commit"
PS> git push

To host, we’ll use Netlify. Create a new site from your GitHub repo by following the instructions here. Select GitHub as the source, then find and select your repo. Use jekyll build as the build command and _site/ as the publish directory.

Wait for Netlify to deploy your web site. Once deployed, click the preview link (e.g. https://random-site-name.netlify.com) to view your site on the web!

Whenever you push to the master branch of your GitHub repository, Netlify will re-build and deploy your site.

Next steps

Suggested next steps:

Modify site content
Add a post
Add a theme
Configure a custom domain name