skalpin.blog

GitHub Universe 2025

Thu, 30 Oct 2025 00:00:00 +0000

I expected GitHub Universe to be all talks about AI, and AI tools and not very technical. The talks were hit or miss. Sometimes they were well structured, and some were all fluff. I was happy to see a few talks that were technical, and I was able to attend some talks that were about building developer community. I really enjoyed the talk by LEGO. The presenter walked through the different strategies implemented at the company to drive collaboration and product development.

The layout of the conference was strange. There isn’t a single conference room. Instead they booked a campus. It has several buildings and sometimes talks are difficult to get to. They can either be far apart, or I just get lost getting to it. For example there was a building that has a large conference room on the north end. However GitHub blocked off a section of the building for GitHub partners. So to get to the conference room on the north end, I needed to go outside, and walk around the partner area. Below are some notes from a couple of the talks I found particularly interesting.

Developer Experience at LEGO

I particularly enjoyed the talk on building developer experience at LEGO. The company broke down silos and simplified efforts into products. Product teams are a cross-functional group that have the people and knowledge necessary to develop and maintain a product. They split the initiative into 3 main concerns. Discoverability, Community, and inner-source / documentation.

Discoverability

Finding the right person to help with a problem is often a friction point for developers at any large company. It can be difficult to find the right person to message for any particular problem. It can also be difficult to find existing packages or APIs you can leverage that already solve your problem. Of course the tool used is a heavily customized Backstage instance. Backstage is where you can search for documentation, apis, packages, or other products. Not only does it make everything discoverable, but it serves as an onboarding tool for developers new to your product. Communities are also an important discoverable catalog item in backstage.

Community

Building community is difficult. To have a community you need to have people that are driven to work together. It requires people with a shared interest and energy to thrive. Communities drive newsletters, dev fairs, and an annual devcon where developers can come listen or speak to their peers about a topic.

Inner-sourcing and Documentation

Inner-sourcing helps prevent the “Waiting for someone” problem. Often developers find problems with a dependent package or api that needs to be correct before the work can continue. Most of the time developers are happy to contribute to the dependent project to not only lift the block, but also to contribute back to the larger community of projects using the dependency. For inner-sourcing to work, each project needs to define contribution guidelines to facilitate incoming change requests from other developers.

CodeQL

CodeQL is a tool I have been using for some time now, but I wasn’t aware of the feature that allows for custom extensions. The feature allows for you search for specific code patterns and alert developers on what was found. The documentation provided to the developer is included in a markdown file and can include as much information as necessary to explain why it’s an issue. I am currently using CodeQL to look for accidental commits with secrets in them, but I wonder if I can use CodeQL to look for or help teams with migrations. There will always be documentation that is out of date, and can lead development teams down the wrong path. With CodeQL I think we can improve the adoption of newer practices.

DataOps

Fri, 05 Apr 2024 00:00:00 +0000

I’m new to this world. I’ve been thinking about it recently because DevOps often get’s questions from Data Science Engieers asking about how to do certain things in git, and I’m learning Data Science has some similarties and differences to traditional software development.

Software Engineering vs Data Engineering

In the software world, multiple developers are working on the same code base. They are all making new features, or correcting issues. Then when the code is considered “okay”, it runs through a CI/CD pipeline is packaged together and that package is deployed (or consumed or something).

In the Data world, multiple engineers are working on the same dataset, but they’re not really packaging up an artifact to share with the client. The engineers instead are finding ways to present the data in a meaningful way for their clients.

However, there are several process that need to be shared across the data engineers too. These process will take data from multiple sources, transform it, and then dump it to a data warehouse, or into another format that is easier for the engineers to consume.

Engineers need source control so they can collaborate on pipelines to ETL (or ELT) data, and to share what they are working on with other engineers. But there’s no concept of a SQL module that you would package into an artifact for another engineer to consume. Sharing is purely copy & paste from anothers example.

DevOps

DevOps I understand well. Before DevOps, developers would make their changes, and then tell an operations team how to run the application in production. Operations engineers were then responsible for making sure the application continued to run. This works as long as the application works (hint, it never does) and the Operations team is already setup to handle the workload. For example an application may need a specific version of the dotnet runtime installed, and the ops team may not have a machine that supports that yet. You can read all about it yourself in “The Phoenix Project” by Gene Kim but the answer is that everything works better when developers and operations engineers work together instead of blaming each other for failing applications.

DataOps

DataOps to me sounds a lot like the Agile manefsto. (DataOps vs Agile) As far as I know, Data Engineers and Operations engineers have never clashed. Data Engineers only need access to the tools, and data from operations. Also Operations are not responsible for making sure that a specific query works properly. So why choose the name “DataOps”? I am disappointed. I was hoping to find a group of individuals searching for a way to streamline a Data Engineers workflow. I need something to describe how branches should live in source control, what the folder structure should look like, and when to use a CI/CD pipeline. I want standards and best practices.

I will be thinking about this more over the next week, but right now I see 2 paths.

Data Engineers use folders for different environments, and experiments. Imagine having a dev,qa,prod folder and copying the SQL files from one to the next when you want to “deploy” to that environment. The source control flow becomes dead simple. Branch from main, make your change, merge back to main and destroy your branch.
Data Engineers use git branches for environments, and experiments. This I think makes sense for experiments. I don’t really want to put it into the master branch because I don’t know if it works yet. Even if it does work, I don’t know if I want to keep it. I need this space to be the way I left it so I can revisit it whenever the business wants to see the results again with new data. Branches for environments is fine; we’ve been doing that forever. This is where things like ETL processes, and datawarehouse schema changes should exist because the concerns are shared among the whole team. Deployments to an environment then are managed by the environment. The database keeps track of which schema changes have already taken place, and runs the new ones (in order).

Database Concurrency

Fri, 29 Mar 2024 00:00:00 +0000

I am in a technical book club and we are currently working through a book “Designing Data-Intesive Applications” by Martin Kleppmann. We just finished Chapter 7 - Transactions. This chapter focuses on transactions, but really zeros in on why transactions exist. They exist to help developers prevent concurrency issues.

Transactions

Personally, transactions are not my first thought when working on an application feature. Generally I’m concerned with what type of data needs to be stored, how the applciation should read it, and making sure the application writes to the correct records. What happens when multiple users are using the application is often an afterthought. As in after a bug has been submitted that some data was overwritten.

Even before committing to using transactions, I prefer to structure the data in a way that doesn’t require me to update multiple records. I would rather have my application read and write data in an isolated way so that it never needs to worry about another user overwriting it.

Of course this is nieve. Sure, you can structure your data and data access as cleanly as you want, but you are going to run into situations where denormalizing the data to improve performance will force you to write data to multiple records assuming they are in the same state as you read them.

Optimistic Concurrency Control

Optimistic Concurrency Control assumes that data conflicts will not occur and provides better performance. This is because it does not require the database to lock and keep track of resources that are being worked on.

Transictions are one form of optimistic concurrency control, but there are other ways the application can make sure writes are not ovewriting another users data.

There are some great articles that discuss concurrency, but since I tend to use entity framework with SQL server, this is my favorite. https://learn.microsoft.com/en-us/ef/core/saving/concurrency?tabs=data-annotations#optimistic-concurrency

SQL Server has the concept of a rowversion column type that can be used by Entity Framework. When data is read / manupliated / written back to the database, the rowversion remains the same in application code. Then when data is written back to the database, the database can check the rowversion value given and the current rowversion on the row. If they don’t match, the database server can abort the write, and throw an exception to the application code. The application can then decide what to do with it.

Aggregate Roots and Concurrency

So which persistent objects need to have a rowversion column in the relational database to make sure that data does not get lost? An aggregate is a collection of objects that make up an entity. For example a Customer entity will have an address value. But you probably don’t want to access address directly. In our application Address only makes sense in the context of a Customer. Therefore our application shouldn’t update an Address directly, it should update a Customer’s Address.

Concurrency needs to be considered at the Aggregate Root because the Aggregate Root holds the invariants to make sure state remains consistent and valid. When the Aggregate Root object is loaded into memory, it needs to have a concurrency token or rowversion that will allow the application to detect when the Customer object has been updated without their knowledge. This will allow the Customer to determine if it can safely continue with the update, or if it needs to abort the change due to a conflict.

Summary

This is a quick overview of optimistic concurrency control, transactions, and how it applies to your application model. I completely skipped over pessimistic concurrency control because I do not work on any systems that need it, and I don’t think may do. Most applications can get away with optimistic concurrency control, but it’s important that application developers think about concurrency. It’s too easy to do your feature testing locally, find that everything is working okay, and push changes to quality assurance for testing. Then only to discover bugs that are difficult to reproduce, diagnose and resolve.

Devcontainers

Fri, 15 Mar 2024 00:00:00 +0000

Development containers have completely changed my local development workflow. They make it easier for me to use the correct version of the tools I need for each specific project, and they help keep the tools consistent across my team. So what is a devcontainer?

The concept of a devcontainer is simple. I want to make changes to an application which means I need to be able to build and run it locally, however I don’t know what tools I need or how to install them. In some cases I cannot install the correct version of a tool. This can happen when I am working on separate projects that need different versions of a tool that cannot be installed at the same time on my operating system.

For example, I am writing this blog using Jekyll. I don’t necessarily want to install ruby, gem, and jekyll on my system to update the blog. It’s much easier to spin up a container with the tools installed and make the changes in there.

For this walkthrough I am going to be using Rancher, Visual Studio Code, and the Devcontainer extension.

Setup Rancher

This is the most difficult step getting started with devcontainers. You need to have something to run the containers, and docker is my tool of choice. Since Docker Desktop is no longer free for Enterprise developers, I have selected Rancher Desktop to get docker setup on my system. You can download and install it from https://rancherdesktop.io/. You do not need to setup Kubernetes for this to work properly.

Setup Visual Studio Code

I’m assuming you already have Visual Studio Code, but just in case yo don’t download and install it from https://code.visualstudio.com/download

In the extensions window, search for “Dev Containers” or ms-vscode-remote.remote-containers.

Setup your project

Open your project folder in Visual Studio Code. From the command window find Dev Containers:Reopen in Container. This will give you a menu to add the configuration to the user data or to the workspace. I suggest you choose workspace so that it saves the configuration with your project. That way any developer who needs to make changes has access to this container.

Then all you need to do is select the base container image you want to work with. For my blog I am using Jekyll, so I selected an image with Jekyll installed.

Edit your project from a container

What happes now is the VS Code extension pulls the image, and mounts the folder you had open into a docker volume and attaches it to the conatiner. It also sets up a non-root user (probably vscode) in the container so that edits to files are mapped to the appropriate user on your host system and not root. Additionally it sets up git credentials so you can make changes and push them to the remote server.

You’ll notice it created a .devcontainer folder with a devcontainer.json file. This file tells VSCode that your project can use a devcontainer, and which image to use for it.

More information

For more information checkout https://containers.dev/

Visio Plugin Testing in Docker

Tue, 28 Jul 2020 10:50:00 +0000

Problem

I am currently working with a plugin to Visio. We have been writing and running automated tests using the WinAppDriver. This driver takes COM endpoints and exposes them as a web service so that your automated tests can be written just like any other website using Selinum. The issue is, when UI tests run locally, they take over the whole work station so you can’t multi task or work on anything else. Additionally I would like to find a way to automate these tests as part of a pipeline so they can be run more frequently.

Solution 1 - Setup a virtual machine

This works but it feels heavy. I still cannot run tests in parallel. However I can run tests without taking over my main machine which is good because it means I can still respond to emails while the tests run. It would be better if I could get Visio running in a docker container and spin up several instances so I can run tests in parallel.

Install Visio in a Docker Container

The first hurdle is going to be installing Office, and specifically Visio into a docker container. I got a lot of help from this blog post Install Microsoft Office In Windows Container. Though I only care about Visio, and we only support the 64 bit version of Visio. I modified the office.xml configuration to look like

<Configuration>
  <Add OfficeClientEdition="64" Channel="Monthly">
    <Product ID="VisioProRetail">
      <Language ID="en-us" />
    </Product>
  </Add>
   <Updates Enabled="TRUE" Channel="Monthly" />
   <Display Level="None" AcceptEULA="TRUE" /> 
   <Property Name="AUTOACTIVATE" Value="1" /> 
</Configuration>

And my docker file looks like

#download odt setup files
FROM mcr.microsoft.com/windows:1903 AS build
WORKDIR C:\\odtsetup
ADD https://download.microsoft.com/download/2/7/A/27AF1BE6-DD20-4CB4-B154-EBAB8A7D4A7E/officedeploymenttool_11617-33601.exe odtsetup.exe
RUN odtsetup.exe /quiet /norestart /extract:C:\\odtsetup

#download office files for the selected configuration
FROM mcr.microsoft.com/windows:1903 AS download
WORKDIR C:\\odtsetup
COPY --from=build C:\\odtsetup\\setup.exe .
COPY config.xml C:\\config.xml
RUN setup.exe /download C:\\config.xml

#copy setup files and run setup
FROM mcr.microsoft.com/windows:1903
WORKDIR C:\\odtsetup
COPY --from=build C:\\odtsetup\\setup.exe .
COPY --from=download C:\\odtsetup\\Office .
COPY config.xml C:\\config.xml
RUN setup.exe /configure C:\\config.xml
WORKDIR /

#remove odt setup
RUN rmdir /s /q C:\\odtsetup

#create a new office object that was installed
RUN powershell -Command new-object -comobject visio.application
RUN mkdir C:\\Windows\\SysWOW64\\config\\systemprofile\\Desktop

#activate visio
RUN cscript "C:\Program Files\Microsoft Office\Office16\OSPP.VBS" /inpkey:<your license key>

VOLUME C:\\data

The next step will be to install the plugin we are working on, the win app driver, and start a selenium hub node.

To be continued…

Installing nvm in WSL with fish and omf

Fri, 21 Jun 2019 19:23:41 +0000

Node Versions

Using node on multiple projects is great, until each project starts using a different version of node (╯°□°）╯︵ ┻━┻ Nvm is a tool that allows developers to manage different versions of node on the same machine. Nvm works great in Windows, Linux, and OSX; let’s see if we can get it running on the Windows Subsystem for Linux (WSL). And while we’re at it, let’s get it running with fish and oh-my-fish (my preferred shell).

Nvm is a script not a executable. This means an nvm.sh file is placed on your computer. To “execute” it, the path to the script is included in the .bashrc, .profile, or .zshrc.

Note: it (╯°□°）╯︵ ɥsıɟ ʇɹoddus ʇou sǝop

Installing nvm

Step 1 Install nvm.sh

From the github page we can start by installing the script curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash

Step 2, Install fenv

Next I am going to use the fenv to run nvm.sh from bash with all of the appropriate environment variables set. To install fenv run omf install foreign-env.

Step 3, Setup fish function

The fish shell will allow you to setup aliases just like bash, but it also allows developers to create functions as modules under the .config/fish/functions/ directory. Create a new file in this directory named nvm.fish. Copy and paste the following function into the file

function nvm
    fenv source ~/.nvm/nvm.sh \; nvm $argv
end

Run nvm

Now just restart your shell and start using nvm as you normally would!

Import From Service to SQL

Fri, 15 Feb 2019 00:00:00 +0000

Problem

why do we need to be talking about this?

SQL Server is much faster at loading records in batches.
What happens if we need to pull the data from another source? I don’t want to block until the enumerable completes.
Migrating data from blob storage

I was recently tasked with moving a large data set of items from Azure blob storage into SQL Server. When I am faced with a migration problem I always look for a producer/consumer solution to keep the memory usage low. Often the dataset is too large to load into memory, and then dump to the destination all at once. I also heavily use IEnumerables because I can return the items that have been retrieved, while the producer goes back to retrieve more.

Here is example code of how to load items from blob storage. There is a query api, and it will return a set number of records, along with a continuation token if there are more records to retrieve.

private IEnumerable<T> RetrieveEvents()
{
    foreach(var url in GetBlobUrls($"{containerRootName}/{blobFolderName}")
    {
        foreach (var blob in DownloadBlobs(url).Result)
        {
            yield return blob;
        }
    });
}

private IEnumerable<Uri> GetBlobUrls(string directory)
{
    // List the blobs in the container.
    BlobContinuationToken blobContinuationToken = null;
    do
    {
        var blobListingDetails = new BlobListingDetails();
        var results = GetBlobResultSegmentsAsync(directory, blobContinuationToken, blobListingDetails).Result;
        // Get the value of the continuation token returned by the listing call.
        blobContinuationToken = results.ContinuationToken;
        foreach (IListBlobItem item in results.Results)
        {
            yield return item.Uri;
        }
    } while (blobContinuationToken != null); // Loop while the continuation token is not null.
}

private async Task<string> DownloadBlobs(Uri blobUri, string containerName)
{
    var appinsightsContainer = await blobContainerFactory.GetBlobContainer(containerName);
    var cloudBlockBlob = new CloudBlockBlob(blobUri, appinsightsContainer.ServiceClient);
    using (var sr = new StreamReader(await cloudBlockBlob.OpenReadAsync()))
    {
        return sr.ReadToEnd();
    }
}

public class BlobContainerFactory
{
    private string blobConnectionString;

    public BlobContainerFactory(string blobConnectionString)
    {
        this.blobConnectionString = blobConnectionString;
    }

    public async Task<CloudBlobContainer> GetBlobContainer(string containerName)
    {
        CloudStorageAccount.TryParse(blobConnectionString, out var storageAccount);

        var cloudBlobClient = storageAccount.CreateCloudBlobClient();
        var appinsightsContainer = cloudBlobClient.GetContainerReference(containerName);
        if (!(await appinsightsContainer.ExistsAsync()))
        {
            await appinsightsContainer.CreateAsync();
        }

        return appinsightsContainer;
    }
}

Assuming you have a large number of JSON files, calling RetrieveEvents will iterate through the blob uri’s in the storage account, download the data, and return it as an IEnumerable<string>. So far so good, now let’s try and write those items to SQL.

SqlBulkCopy is easily the fastest way to move a large number of items to a SQL instance. You can pass it a large number of items, set the batch size, and let SqlBulkCopy batch and upload items for you.

var blobContainerFactory = new BlobContainerFactory("<yourconnectionstring>");

WriteAllToSql(RetrieveEvents());

public void WriteAllToSql(IEnumerable<T> allItems)
{
    using (SqlBulkCopy copy = new SqlBulkCopy(connectionString))
    {
        copy.DestinationTableName = tableName;
        copy.BatchSize = 1000;
        copy.EnableStreaming = true;
        foreach (var columnMapping in columnMappings)
        {
            copy.ColumnMappings.Add(columnMapping);
        }
        copy.WriteToServer(allItems.GetDataTable(tableName));
    }
}

public static class DataTableAdapter
{
    public static DataTable GetDataTable<T>(this IEnumerable<T> enumerable, string tableName)
    {
        var dataTable = new DataTable(tableName);
        var properties = typeof(T).GetProperties();
        foreach (var propertyInfo in properties)
        {
            dataTable.Columns.Add(propertyInfo.Name, Nullable.GetUnderlyingType(propertyInfo.PropertyType) ?? propertyInfo.PropertyType);
        }

        foreach (var item in enumerable)
        {
            var dataRow = dataTable.NewRow();
            foreach (var propertyInfo in properties)
            {
                dataRow[propertyInfo.Name] = propertyInfo.GetValue(item) ?? DBNull.Value;
            }

            dataTable.Rows.Add(dataRow);
        }

        return dataTable;
    }
}

In order to create a DataTable object however, each item in the original enumerable needs to be interated through for a row to be added. The issue is, all of the events need to get loaded into memory before anything gets written to SQL.

Solution

Instead of commiting the entire collection at once, let’s add a non-blocking function that creates chunks of data to be written to SQL. That way the blob storage reader can be waiting on a web request and the SQLBulkCopy can write what it currently has. This extension method will take single items, and create an IEnumerable<IEnumerable> of those items. If there are items in the original collection -> gather them up, otherwise commit what has been gatherd and block until there are more items. This function can optionally take a maximum size if your destination cannot handle a large dataset.

public static class EnumerableExtensions
{
    public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> enumerable, int? maximumSize = null)
    {
        var queue = new BlockingCollection<T>(new ConcurrentQueue<T>());

        var producingTask = Task.Run(() =>
        {
            foreach (var element in enumerable)
            {
                queue.Add(element);
            }

            queue.CompleteAdding();
        });

        while (!queue.IsCompleted)
        {
            var itemList = new List<T>();
            foreach (var item in queue.GetConsumingEnumerable())
            {
                itemList.Add(item);
                if ((!queue.Any() || (maximumSize.HasValue && itemList.Count >= maximumSize)) && itemList.Any())
                {
                    yield return itemList;
                    itemList = new List<T>();
                }
            }
        }
        
        if(producingTask.IsFaulted)
        {
            throw producingTask.Exception;
        }
    }
}

Using a blocking collection and a Task allows us to iterate through the original list, while still allowing items to be collected and returned. GetConsumingEnumerable() will block until more items have been added to the queue.

foreach(var items in RetrieveEvents().Batch())
{
    WriteAllToSql(items);
}

Now, if the calls to blob storage are being throttled, the items will be collected and written to SQL. Also while the first call to SQL is being made, items are still being collected and the initial batch size will increase. It should be noted that SQLBulkCopy will still batch writes to SQL using the batchSize set, so if the items size does grow to 1,000,000 records, SQLBulkCopy will take care of breaking it into chunks itself.

Dairy Enteligen

Thu, 14 Sep 2017 00:00:00 +0000

Look! A project I worked on is in the news! Dairy Enteligen

Dairy Enteligen Video

Use Git to Make Changes

Fri, 21 Jul 2017 00:00:00 +0000

I have been using git for a number of years and have come up with a workflow that lets me write code how I want, and then clean up the process later. My philosphy has always been

Nobody wants to know how I write code. This is a mess!

Creating a new feature

Generally on my projects we follow the gitflow process, but that still leaves me plenty of room to create my own process between git checkout -b <featureBranch> to creating a pull request in sourcecontrol. Here’s an overview of my process to introduce changes while I’m working on a team. After selecting a feature to begin work on I’ll create a feature branch. Then I commit a lot and I don’t worry about what my commit messages are. Periodically I’ll check to see if the development branch has been updated and if it has I’ll rebase my changes on top. If my branch has many many commits, I may squash some changes before rebasing onto the develop branch to make conflicts easier to resolve. Then when my feature is complete, I’ll do an interactive rebase onto the develop branch. The rebase allows me to reorder, group, squash, and edit commit messages until each commit is a complete thought and my history is a few commits ahead of develop. Then I’ll submit a pull request and ask for my branch to be merged into develop. I also use several aliases to make this process easier on myself.

Tools

First lets start with my tools.

Git for Windows (I’m using windows obviously)
Cmder (cmd shell)
Poshgit (powershell git tools)
Vim
kdiff3

Aliases used

git config --global alias.nf "!f() { git checkout -b stevek/$1; }; f"
git config --global alias.publish "!git push -u origin develop"
git config --global alias.pushf push --force-with-lease
git config --global alias.f fetch -p
git config --global alias.lg log --color --graph --pretty=format:'%Cred%h%Creset %s%C(yellow)%d%Creset %Cgreen(%cr) %C(bold blue)<%an>%Creset'
git config --global alias.in "!git lg ..origin/develop"
git config --global alias.update "!git pull --rebase --autostash origin develop"

Have No Fear

Git does not delete commits (for something like a month). If you have accidently reset or rebased you can always see the commits you had checked out with git reflog. This log keeps track of where you have been and you can always git reset --hard <commithash> to move back to where you were. The only changes you may lose are the ones you didn’t comimit.

Creating my feature branch

Create your branch with git nf <itemnumber>-<feature>. This will create and checkout a branch that looks something like stevek/1122-myNewFeature. The folder helps me keep track of my branches. Usually I own particular features and work on them myself. Then I generally like to push and set the upstream right away with git publish.

Making commits

Make commits freely. Do not working about building the code, do not worry about commit messages. This is the reason I love git. While I’m refactoring code I’m making commits that don’t build and half solutions. Then if I need to go back at any point I can find the commit and run git reset --hard <commithash>. That will reset my branch back to the specified commit and remove all my changes. Again, the only changes you will lose are the ones you didnt’ commit.

Watching for Changes From Developers

You should fetch the remote repository frequently. I also like to prune at the same time so I use git f. Then you can check to see if you need to update your feature branch by looking at the incoming commits. Do this with git in. Then if there are incoming commits, you can decide what to do. When updating my branch I generally choose to rebase unless I am working with other developers in the branch.

Cleaning Up History

Every once in a while I will realize that I’ve made several commits and either merging from develop or rebasing onto develop will probably be difficult. The reason is, you need to resolve conflicts for each commit. Find the commit to rebase onto with git merge-base <yourbranch> develop. Then clean up your history with git rebase -i <mergebasehash>. You only need to copy the first 6 characters or so of the hash.

The rebase command will open up your default editor (hopefully vim), and give you instructions on how to correct your commits. Save and close the file. Git will then follow your instructions / break / and open your editor to let you reword the commit messages you wanted to reword.

During the rebase if you have decided that you messed something up and want to abort run git rebase --abort. If instead the rebase worked well and you still want to undo it, take a look at the reflog git reflog and choose the previous commit hash. Then execute git reset --hard <hash>

Once complete you will notice that your remote branch and local have gotten out of sync. Execute git pushf to force the remote branch to match your local.

Grab Changes From Develop

When you feel you are ready to get updates from develop run git update. This will rebase your branch against the most recent commit in the remote develop branch and let you make changes to your commits if you wish.

Again you will have to force your changes to the remote branch with git pushf.

Repeat

Continuing on with your work you can repeate the process of rebasing / squashing / updating from develop until you feel the branch is ready and acceptable to be merged into develop.

Create a Pull Request.

Each system is a little different, but generally in GitHub or VSTS you would now go find your branch and create a pull request using the web ui. Then your fellow developers will make comments about your code, make you feel like garbage, and eventually accept your request.

Don’t Stop!

While this process is happening You don’t need to wait!. Grab another feature or bug, branch from the most recent commit in develop and start working! There is no reason to ever stop working while you are using git. (unless of course there is no work to do)

Installing Ubuntu on Windows 10

Wed, 13 Apr 2016 00:00:00 +0000

Get Excited

Because I’m a Windows .NET developer by day and a wannabe Ubuntu developer by night this new feature in Windows 10 is especially exciting for me so what am I supposed to do besides write a new blog article about it.

Windows 10 Build 14316

To start with you need to get the Windows 10 Insider Preview build 14316. The problem is, this cannot just be downloaded and installed. Using your MSDN license (or whatever) you should be able to find Windows 10 Insider Preview build 14295.

Then you need to set yourself up for insider preview builds from Microsoft. To do this go to Start Menu -> Settings -> Update & security -> Advanced options. From there you will see instructions on how to setup your account to receive the builds. You also need to make sure you are setup to receive builds “fast”.

One more thing to note: I had to wait 24 hours to receive an update to 14316 (bummer).

Enable the Linux Feature

Good! You’ve now got Windows Insider Preview 14316 installed. No you need to right click on the start menu and go to “Programs and Features”. Then navigate to “Turn Windows features on or off”. Once you’re looking at the windows features list select the “Windows Subsystem for Linux (Beta)”. This feature requires a computer restart.

Installing bash

So installing the Linux Subsystem will give you a new program called bash. Run it. You will be asked if you would like to install bash. Type ‘y’ and hit enter (duh). This will go download and install what you need to get going with bash. When it’s complete you will be presented with a root@localhost:~# prompt. As you probably noticed you’re root… so be careful.

Updating bash

The next thing you’ll need to do is update your package list. apt-get update will do it, maybe. I ran into some issues with my network. None of the sources could be found. In fact a simple ping www.google.com didn’t execute successfuly. It turns out there is a minor bug with the bash and IPv6 so you need to edit your sources list and move the IPv6 ones to the bottom or remove them completely. My generated /etc/resolv.conf looked like this:

domain hsd1.mn.comcast.net.
nameserver 2001:558:feed::2
nameserver 2001:558:feed::1
nameserver 192.168.0.1

Open up your favorite editor (vim, emacs, pico) and edit /etc/resolv.conf to put the IPv6 addresses at the bottom of the list.

domain hsd1.mn.comcast.net.
nameserver 192.168.0.1
nameserver 2001:558:feed::2
nameserver 2001:558:feed::1

Now you should be able to run apt-get update && apt-get upgrade to upgrade your systems package lists. Unfortunately you might have to do this every time you open bash if you want bash to have access to the internet.