Next step Git for those that already know add and commit

When I first started using Git a while back it seemed pretty straight forward although I had to get used to the disconnected nature of Git which is different than how TFS works (or used to work). I mostly used Visual Studio’s Git integration and usually it worked like a charm.

But then after a while things started to get complicated. I had to work with submodules, change the remote URL, and handle untracked files. That is when I decided to move out of my comfort zone in Visual Studio and into the Git CLI.

The Git CLI is not easily remembered and everything can be done in more than one way so I started my own compilation of useful commands. Below is the result of that compilation. I hope it can be hopeful for those of you going through the same process and please let me know if you have any Git gems of your own that belong on the list.

The list

In no specific order whatsoever.

Edit configuration

On Windows the Git configuration file is usually placed under “c:\Users[user]”. You can also start an editor from the command prompt.

git config --global -e

Set editor for commit messages

To change the default editor for commit messages to Notepad++, add a [core] section to the config file looking like this.

[core]
    editor = 'C:/put-your-folder-here/Notepad++/notepad++.exe' -multiInst -notabbar

From now on Notepad++ will open when ever you run git commit without the -m switch.

Set merge tool to Visual Studio

[diff]
    tool = vsdiffmerge
[difftool]
    prompt = true
[difftool "vsdiffmerge"]
    cmd = \"C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Professional\\Common7\\IDE\\CommonExtensions\\Microsoft\\TeamFoundation\\Team Explorer\\vsDiffMerge.exe\" \"$LOCAL\" \"$REMOTE\" //t
    keepbackup = false
    trustexistcode = true
[merge]
    tool = vsdiffmerge
[mergetool]
    prompt = true
[mergetool "vsdiffmerge"]
    cmd = \"C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Professional\\Common7\\IDE\\CommonExtensions\\Microsoft\\TeamFoundation\\Team Explorer\\vsDiffMerge.exe\" \"$REMOTE\" \"$LOCAL\" \"$BASE\" \"$MERGED\" //m
    keepbackup = false
    trustexistcode = true

Submodules

Cloning submodules

If the repo contains submodules, and you want to bring the code in the submodules down, you’ll need to clone recursively.

git clone --recursive https://github.com/hocuspocus/icsharp.git

Change submodule to own fork

If you have cloned a repo with a submodule and you want to change the submodule to a different fork (if for example you have forked the submodule), you need to edit the URL in the file .gitsubmodule.

[submodule "Engine"]
    path = Engine
    url = https://github.com/scriptcs/scriptcs.git

After saving .gitsubmodule, run the command.

git submodule sync

It seems that this may detach from HEAD, so a checkout may be necessary (before making any local changes).

git checkout

If you have trouble downloading the code for the submodule, try running the command:

git submodule update --remote

Start merge tool

If there is a merge tool, you can start your merge tool (set in the config file).

git mergetool

Compare to remote

Start by fetching all from the remote repo:

git fetch origin

Then compare with local:

git log HEAD..origin/master --oneline

If you are happy with the results, you may merge the remote changes with the local repo:

git merge

Show remote URL

Show remote URL for “origin”:

git remote get-url origin

For a bit more information you may use:

git remote show origin

I your remote has moved, you can change the URL using set-url:

git remote set-url origin https://hocuspocus@bitbucket.org/myteam/myproject.git

Delete branch

Delete the remote branch:

git push -d  

For example:

git push -d origin my-feature-branch

You may also use:

git push  :

Delete the local branch:

git branch -d 

Delete local changes

Undo all unstaged local changes:

git checkout .

Undo git add for at single file:

git reset folder/file.cs

Undo git add . :

git reset .

Fix untracked files

git rm . -r --cached
git add .
git commit -m "Fixed untracked files"

Create an alias for a command

If you are tired of typing long hard-to-forget commands you can create aliases.

git config --global alias.a "add ."
git config --global alias.c "commit"

You can now just type git a to add unstaged files.

Aliases can also be added directly to the config file.

[alias]
    a = add .
    c = commit

Some Advice for Beginners

If you are new at programming, here is some sane advice for you.

The list is built from my own experience since we are all newbies at something, right?

The list could be a lot longer but I have picked 7 important pieces of advice that recently have had some relevance for me while mentoring.

1. Have Fun!

Yes, that’s right. This is the first and most important piece of advice. Coding is supposed to be fun. If you are not having fun, maybe coding is not for you 🙂

2. Use Existing Guide Lines

You may be a beginner and you may be in over your head but the sooner you start using existing guide lines such as naming standards and best practices, the sooner your coding skills will take off. Your company may have existing coding standards (they should) and they are there for a reason. Following guide lines and standards will help you and your mentor better understand the code.

Also, your code will probably not pass code review without following existing standards and it is a real pain to fix it all later.

3. Your Code is not a Special Case

I am sorry I have to break this to you but your code is in no way ground breaking or requires special treatment. That means you do not get to use gotos liberally, use inheritance like the world has never seen before, or put all 3,000 lines of your program in the same file.

Everybody else can do without strange constructs and so can you.

4. Read the Error Messages

If the compiler refuses to compile your code, then by all means read the errors messages. They may be cryptic but you might as well get used to them because it won’t be the first time you see them.

Runtime errors can be hard to figure out but the next item on this list may help you with that.

5. Debug Everything

Debugging is really, really, really important. Someone once gave me the advice to always debug through your code. So this piece of advice applies to everybody, not just beginners.

Debugging will help your understand how your code is working. Whenever I write a piece of code I step through it with the debugger, even though it appears to be working. A good way of doing this is to debug through your unit tests.

So, learn how to debug in the programming environment that you are starting to learn. Did I mention that it is important?

6. The Error is Most Likely in Your Code

If your code fails (and it will) it is like 99.99 percent certain that you are the one who introduced a bug. The bug is not in the programming language or in the platform. It is in your code!

So it you think that .NET cannot save files larger that 50 lines or that C# is slow at simple math operations, then you are wrong.

The bug is in your code!

7. Stop Excusing

Everybody seems to make excuses for their code. There is no reason to. Your code has bugs and it could be designed better but I am yet to meet a programmer who writes perfect code. If your mentor ridicules your code, you need to find a better mentor (yes, we are all guilty of laughing at some poor guy’s code).

That’s it. I hope it will make your journey into coding a tad easier.

Deploying ASP.NET Core Applications from Bitbucket to Azure

Give the most tedioust jobs to your laziest employee and they will automate it.
My boss

That’s right. I am lazy. I hate repetitive tasks. And as a developer you probably feel the same way.

One of those repetitive tasks is deployment

There are numerous ways and frameworks to set up automated builds and deployments. Some of them can do just about anything almost up to the point where they will make you coffee while you wait for your builds.

Recently while working on a small ASP.NET Core website I found out that Microsoft Azure has a very simple deployment tool for building and deploying from your favourite code repository to an Azure web application. I was especially happy to find that it supports BitBucket even though it seems anything not-on-Github is not cool.

Well, I am too old to be cool and I like Bitbucket so bear with me.

Setup

Setup is a breeze. Got to the new Azure portal and create your new web application.

After the web app has been created, go to your web app and choose “Deployment Options”.

azure-deployment-options

The next steps allow you to log in to your source code provider (i.e. Bitbucket) and choose project and branch (typically the master branch). The beauty here is that Azure supports pulling code from all kinds of sources like Dropbox, Onedrive, Github, and of course Bitbucket.

azure-deployment-options-configure

After you save your settings, Azure will fetch your last commit and start building it. You can se the progress by clicking “Deployment options” again.

azure-deployment-progress

Build Errors?

It looks like Microsoft has just recently upgraded the compiler but I have previously run into problems with building newer C# features such as inline declaration of variables like so.

var salaries = new Dictionary<string, decimal>()
{
    { "Jakob", 10000000000 },
    { "Some other guy", 42 },
};

// Inlining variable declaration
if (salaries.TryGetValue("Jakob", out var salary))
{
    // Do something with salary.
}

If you run into this problem, all you need to do is add the Nuget package Microsoft.Net.Compilers to your project. This will make sure that your project is compiled with the latest C# compiler.

Conclusion

This kind of deployment is extremely simple and easy, which is a good thing. On the other hand it will not run any unit tests in your project and it will deploy straight to production without any testing or staging. You might consider this solution for smaller, non-mission-critical sites.

Creating Your Own Visual Studio Project Template

All code on Github.

In previous articles (1 and 2) I walked through how to add Webpack and Typescript to a Visual Studio ASP.NET Core MVC project.

It turned out to be quite a cumbersome and error prone process and it is not something you wish for your worst enemy to go through twice (or maybe you do – I don’t know).

Luckily, it is quite easy to create your own project templates for Visual Studio so that you can repeatedly create new projects with the same setup.

As you probably know, you can create new projects for Visual Studio by using the dotnet new command. For example you can create a new ASP.NET Core MVC project by running

dotnet new mvc -n "MyFacebookKillerApp"

Type dotnew new to list all available templates.

Wouldn’t it be nice if we could do the same thing for our ASP.NET MVC with Webpack and Typescript thingy project? Fortunately, we can (otherwise this would be a very uinteresting article).

First step is to configure our template.

Configuring the Template

Start by creating a folder named “.template.config” at the root folder of your solution. This is typically where the .sln file is sitting.

Create a file named “template.json” inside the “.template.config” folder. Insert the following into the file and change the relevant properties (such as author, identity, shortName, and sourceName):

{
  "author": "Jakob Christensen", 
  "classifications": [ "Web" ],
  "name": "ASP.NET MVC Core with Knockout/Webpack/TypeScript",
  "identity": "t4rzsan.MvcKnockoutTypeScript", // Unique name for this template
  "shortName": "mvcknockouttypescript", // Short name that can be used on the CLI
  "tags": {
    "language": "C#"
  },
  "sourceName": "CoreWebApplication2", // Will replace the string 'CoreWebApplication2' with the value provided via -n.
  "preferNameDirectory": true,
  "exclude": [ "**/[Bb]in/**", "**/[Oo]bj/**", ".template.config/**/*", "**/*.filelist", "**/*.user", "**/*.lock.json", "**/node_modules/**/*" ]
}

Choose something brief but meaningful for “shortName”. This is the name that you will use when running the dotnet new command.

The property “sourceName” is important. When the template runs, the string “CoreWebApplication2” will be replaced by whatever the user specifies for the -n(ame) parameter for dotnet new. The text will be replaced in all files. That includes namespaces in .cs files and renaming of .csproj files. So you must change “CoreWebApplication2” to whatever you used as project name for the solution, you are using as template for your template (if you know what I mean).

I have set “preferNameDirectory” to true which means that dotnet new will use the name of the current folder as project name if -n has not been specified.

When you are done with the configuration it is time to register the template.

Registering the Template

You install the template by running the command dotnet new --install [folder] where [folder] is the path to the parent folder of “.template.config”. So, for me that would be

dotnet new --install C:\Users\Jakob\Source\Repos\CoreWebApplication2

When listing the installed templates you will we your own short name in the list:

dotnetnewinstall

Finally, let’s see if it works.

Using the Template

Create a new folder somewhere for your new project and CD your way to the folder in the command prompt. Start by typing (insert your own short template name):

dotnet new mvcknockouttypescript

That’s it. Very cool!

By the way, Don’t forget to update npm and install all dependencies for the new project.

npm update npm@latest -g
npm install
npm run build

Working Effectively with Windows as a (non-)Developer

There are lots of great articles on how to know your tools to be a better programmer. I thought I’d chip in give and give 10 tricks on how to be a good Windows user and hence also a better developer. These tricks are very simple and have been part of Windows for a while (some even before Windows 10) and yet they are unknown to many Windows users.

There has always been an ongoing war on whether macOS or Windows is the better. I am a user of both and I love and hate both of them (although I am more effective on Windows). I hope the following tricks can be of help to Mac users who sometimes need to use Windows, and also of help to existing Windows users who perhaps can learn a new trick or two.

I would be happy to hear about what tricks you use to make life easier so please join in on the comments.

These tricks all apply to Windows 10.

1. Show file extensions in Explorer

For some reason the default setting in Windows is to hide all known file extensions.

There should be a law against that.

So, the first and most important trick is to get Windows to show all known file extensions in Windows File Explorer.

For example, I had a client that stubbornly claimed that double-clicking the MyApp.exe file would only show some gibberish in Notepad. After a while it occurred to me that the standard .NET configuration file MyApp.exe.config file showed as MyApp.exe on the client’s machine because the file extension .exe was hidden.

So, the first thing you do on a new Windows box is to open Explorer, click Options -> Change folder and search options. Go to the View tab and clear the check box for “Hide extensions for known folder options”.

2. Use the Run command

The second most important trick is the “Run” command in Windows. Mac has its very useful Spotlight Search, and Windows has its equally useful Search feature in the Start menu, but I find the Run command much more useful.

The Run command allows you to run one-line command line instructions. You get to the Run command by typing Windows+R on the keyboard. That will open up a small dialog to the lower left where you can type any command.

The Run command gives you a very fast way to start apps or open web pages. The following are a few common examples:

  • calc (starts Calculator)
  • notepad (starts Notepad)
  • excel (starts Excel)
  • winword (starts Word)
  • mstsc (starts remote desktop terminal)
  • inetmgr (starts the IIS Manager)
  • cmd /f:on (starts a command prompt with tab completion)
  • www.dev.to (opens the default browser and goes to dev.to)
  • http://dev.to (same as above)
  • %programfiles% (opens Explorer and goes to the program files folder, usually C:\Program Files)
  • control panel (opens the Control Panel)
  • services.msc (opens the services panel)

3. Use Windows Search

I already mentioned it above, and I will mention it again. Few people realize that Windows has built-in search similar to Mac’s Spotlight search.

Just press the Windows button on the keyboard to open the start menu and start typing immediately. This will search for apps and files and the search results show immediately on the start menu. It evens searches tags in images and content in pdf files.

I actually never understood the hatred for Windows 8 and 8.1 and the large start menu. To me it was just a big friendly searchable start screen. But I guess I was the only person in the world that liked it.

Unfortunately, Windows Search does not search the internet.

4. Use the Power menu

The power menu is shown when you press Windows+X on the keyboard. The power menu gives you immediate access to the most important stuff such as settings, event viewer, network connections, and the command prompt.

Speaking of the command prompt, if you prefer to use PowerShell, you can replace the command prompt with PowerShell on the power menu. Right-click your taskbar and choose taskbar settings. Then turn on the setting “Replace Command Prompt with Windows PowerShell in the menu when I right-click the start button or press Windows-key+X” (now that’s a long sentence).

5. Easily start new instances of an app

As you know you can start an app by clicking its icon on the taskbar.

Now, if you want to start more instances of the same app, you hold left-Shift and click the icon.

And if you want to start an app as administrator, you hold left-Ctrl and left-Shift and click the icon.

You should pin command prompt and PowerShell to the taskbar so that you can start and administrator prompt just by left-ctrl + left-shift + clicking it.

You can also start an app that has been pinned to the taskbar simply by holding the Windows key and pressing the number for the app. So, for example, Edge is the third app om my taskbar, so I can start it simply by pressing Windows+3 on my keyboard.


(I apologize for my hopeless, childish handwriting)

6. Use the Snipping Tool

This tool is very helpful for capturing screen shots and I use it all the time, for example for writing blogs. Just search for “Snipping” in your start menu to use it.

You may find difficulties in snipping a screen shot of menus and such but of course I have a trick for that:

  1. Start the Snipping Tool and click New.
  2. Press the Esc button on your keyboard.
  3. Open whatever menu you wish to capture.
  4. Press Ctrl+Print Screen on your keyboard.
  5. Now you can draw a rectangle of with the Snipping Tool to capture the menu.

7. Copy the path of a file

Left-shift and right-click a file to reveal a number of extra items on the context menu. One of them is “Copy as path” which will copy the file’s full path to your clipboard. Neat.

8. Use shortcuts

Some common shortcuts:

  • Windows+E: Start File Explorer
  • Windows+D: Show the desktop
  • Windows+I: Open settings
  • Windows+Ctrl+D: Create new virtual desktop
  • Windows+Ctrl+right arrow: Go to next virtual desktop
  • Windows+Ctrl+left arrow: Go to previous virtual desktop
  • Windows+Ctrl+F4: Close current virtual desktop
  • Windows+arrow up: Maximize window
  • Windows+arrow down: Minimize window
  • Windows+arrow left or arrow right: Snap window to the left or right border

By the way, if you grab a window by the title bar and shake it with the mouse, all other windows on the desktop will be minimized.

9. Keep your Windows desktop clean

With Windows search and the run command, who needs icons on the desktop?

Add shortcuts to the taskbar for the apps that you use the most for easy access and leave the desktop clean and uncluttered.

10. Easily create connection strings

The last trick for now is for developers. I find it incredibly useful and I have not met a single person who knows about it since I learned it many years ago. So I decided to include it here as a small bonus for those who made it this far.

I can never remember the syntax or the property names for connection strings when connecting to a database from code on Windows which is why this trick has helped me for years. A long time ago at a conference (in Boston I believe) I saw the presenter creating a file on his desktop with the extension .udl. Then he double-clicked the file which opened a small dialog where he entered SQL Server instance name and selected authentication and database name.

After dismissing the dialog he opened Notepad (by pressing Windows+R and entering “notepad”) and he then dragged the .udl file to Notepad, revealing a beautiful connection string. How about that!

By the way, the .udl trick won’t work unless you have followed the very first trick on this list: “Show file extensions in Explorer”.

I hope you find above useful 😀

Which is better for teaching? C# or F#

Recently I have had the pleasure of training a couple of colleagues in the wonders of programming. At work we use C# for most of our applications so naturally I started preparing my material in C#.

I did not get very far before it occurred to me: This is going to be a long haul…

Now, my colleagues are smart, really smart, much smarter than me, but they do not have much experience in programming. They have been using SQL, some VBA, and perhaps a bit of R, but none of them have been doing real application development and they know nothing about OO theory.

Unfortunately, you do not get very far with a language such as C# without knowing just a little bit about OO programming.

Let’s start with the compulsory and useless “Hello, world” example:

using System;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, world");
        }
    }
}

That’s a lot of code just to print out a stupid message on the screen.

“What are all those things for?” my colleague complains and I answer “We’ll get to namespaces, classes, static, void, arrays, and more stuff later”. He’s not happy and continues “Do I really need to write all those curly braces and semicolons?”. And when I tell him yes, and don’t forget that it’s all case sensitive, he breaks down and says “I miss VBA…”.

Of course curly brackets and case sensitivity has nothing to do with OO but I think we can all agree that OO is really, really hard. Heck, I don’t even master it after years of C++ and C#.

I find that it takes a long time for beginners to grasp OO and when they start to see the light they will abuse inheritance and create everything as singletons. And interfaces seem to be impossible to understand even though I do my best with lousy metafors such as cars and DVD playsers.

Usually, beginners actually tend to completely ignore that C# is object oriented and they take a straight forward approach and create a very long Main function.

So, perhaps teaching my colleagues C# is not the right approach. Perhaps I should try teaching them a functional language instead such as F#? Now, I am not saying that functional languages are easy but I do think that you can get really far with F# without knowing advanced stuff such as monads. In F# the “Hello, world” example boils down to

printfn "Hello, world"

Very simple. Not much to talk about.

Besides, there are a couple of important points to consider when bringing F# to the table:

  • My colleagues are all mathematicians and functional languages are perfect for math stuff.
  • F# is a .NET language and will work together with all the C# code in our company.
  • F# can work as a scripting language for makeshift assignments.

I am thinking that it would suffice to teach the basics of F# such as record types, functions, pattern matching, the Seq module, type providers, and perhaps partial application.

What do you think? Would F# be easier to grasp or should I go for the usual C#?