Forem: Lars Richter

Do You Do Home Automation? Join Us!

Lars Richter — Thu, 22 Apr 2021 11:06:00 +0000

A lot of developers like tinkering with all sorts of tech. And if you own, build or rent a house or an apartment, home automation is a cool area to discover and play with.

But home automation can be frustrating as well. Which system should I choose? Should I go with an open-source system like Home Assistant? Or maybe with something like Philips Hue? Where do I start? Lighting? Heating? Cameras? Door locks?

But even if you found a system to go with, there will be hurdles. I mean, it's tech, isn't it? 😉 And that's where a community would be awesome. Asking questions. Giving advice to others. That's what we are here for. And Ben created a special (of course Forem-powered) community for everything related to technology in your home.

Join Hometechnica

It's not just about home automation. There is much more. Here is the "tagline" of Hometechnica.

Homebuilding in the age of automation, privacy, security, and alternative energy. Gadgets, ideas, and community.

If you are interested in any of these topics, come join us over there.

https://www.hometechnica.com

It will be fun. I promise. 😄

When Over-Engineering Hits You Hard

Lars Richter — Wed, 15 Jul 2020 08:34:10 +0000

I planned to write this post for a couple of weeks now. But recently I saw this discussion post from Ben:

How do you identify "over-engineering"?

Ben Halpern ・ Jul 14 '20

#discuss #codequality

This reminded me, that I should get back to this post and finish it.

It sounded so simple

We use custom NuGet packages and an internal NuGet-server at work to make reusable code easily available. One of those NuGet packages is a "utilities" package, that contains functions and services that come in handy quite often.

A few weeks ago, I wanted to use the EnumUtils. As you can probably guess by now, it provides functions to work with Enums. For example, reading a string representation for an enum-member that is defined in a Description attribute. But let's look at an example. Let's assume we have an enum called TicketStatus.

public enum TicketStatus
{
    [Description("open")]
    Open,
    [Description("in progress")]
    InProgress,
    [Description("testing")]
    Testing,
    [Description("approval")]
    Approval,
    [Description("done")]
    Done
}

And somewhere in my code, I want to get the description for a specific value of the enum.

TicketStatus status = GetCurrentTicketStatus();
// now what?

So, now what? I knew that class was called EnumUtils. But EnumUtils.GetDescription(status) did not work. There is no EnumUtils class. But my IDE told me, that there is something called IEnumUtils. OK... I get it. We use dependency injection a lot. Let's get an IEnumUtils thing injected into the constructor.

public class SomeServiceOrController
{
    private readonly IEnumUtils _enumUtils;

    public SomeServiceOrController(IEnumUtils enumUtils)
    {
        _enumUtils = enumUtils;
    }

    public string DoSomething()
    {
        TicketStatus status = GetCurrentTicketStatus();

        return $"Some message including '{_enumUtils.GetDescription(status)}'";
    }

    /* more methods here ... */
}

That was easy. And let me tell you something. It worked.

Then, what's your problem? 🧐

Good question. 😄

My problems with this came up when I started writing the tests for my DoSomething() method. Here is what I did:

[Fact]
public void DoSomething_IsWorkingFine()
{
    /* Doing stuff to create the test scenario... */

    var sut = new SomeServiceOrController(/* what to do here? */);

    var result = sut.DoSomething();

    result.Should().Be("Some message including 'in progress'")
}

What do I pass to the constructor of SomeServiceOrController? I already found out earlier that I cannot do new EnumUtils() because "EnumUtils" is not found. Sure, I could write a small hand-written mock or just use a mocking framework. This would totally work. But to be honest... I don't want to do that.

I mean... it's just a simple utils function. Why would I mock that? It just reads an attribute from an enum member. I see no need to mock that. That's why I checked the code of the utils package. And I found the following:

internal class EnumUtils : IEnumUtils
{
    public string GetDescription(Enum value)
    {
        /* the implementation is not important here */
    }
}

Do you see it? It's internal. That's why I cannot use new EnumUtils() in my project.
And I thought "But what if I don't have dependency injection available? There might be smaller projects, where we do not have DI in place. How would I use it there?". So I looked a little deeper in the code...

public interface IEnumUtilFactory
{
    IEnumUtils Create();
}

public class EnumUtilFactory : IEnumUtilFactory
{
    public IEnumUtils Create()
    {
        return new EnumUtils();
    }
}

First, the good part: Now I can use the factory in my test.

var sut = new SomeServiceOrController(new EnumUtilFactory().Create());

Now I don't have to mock that stuff. Great. But...
An additional interface (IEnumUtilsFactory) and an additional class (EnumUtilsFactory) just to wrap the new EnumUtils()? Really? Why does this thing need a factory? I don't get that.

Time to calm down

I felt the urge to change the utils package immediately. This implementation is just wrong. I will fix it and the world will be a better place.

After taking a short break and thinking about it a little more, my initial shock was gone. But another shock came. I realized that I did something I can't stand when others do it. I mean the "This is awful code. Why did anyone create it that way? I need to rewrite it to make it good." attitude.

You should always keep in mind, that the developer who created this code most likely had good reasons to do it that way. Maybe there were specific requirements. Maybe there were other constraints. Or they were just learning these concepts and thought it would be a good use-case for it. I mean, we have all been there, right?

Final thoughts

Over-engineering will always happen. Over-engineering is real. Sometimes it is just a few classes that could be reduced to a simple function. Sometimes it is worse and the entire system architecture is excessively over-engineered. But again: There will be over-engineering and we have to deal with it from time to time.

What about my scenario? I will talk to my colleagues about how we will deal with it. Maybe making the EnumUtils public would be a start. Or maybe keep the code as it is for now and create an extension method that does the same and can be used in new projects.

I think my takeaway is: Don't focus on the "bad code" and how you would have done it better. Focus on how to solve the problem at hand.

TCR - test && commit || revert

Lars Richter — Tue, 14 Jul 2020 19:17:13 +0000

I love to try new programming tools and techniques. Especially if they involve TDD, unit testing, or something related. A few months ago I learned about "test && commit || revert" and it instantly looked like fun to me.

"test && commit || revert" (or just "TCR") was originally invented during a Code Camp in Oslo by Lars Barlindhaug, Oddmund Strømme, Ole Johannessen and Kent Beck.
Kent Beck wrote about this in this blog post.

The main idea

The main idea comes from Kent Beck's "Limbo Story". It's all about making changes as small as possible so that they can be easily shared and merged. But how do you enforce small changes?

TCR works best if you have some kind of file watcher or any other trigger that will start the TCR process immediately "on save".
So every time you make a change (and save your files), the test will be run. If all your tests pass, the code will be committed to source control. So every state of your code that is successfully validated by the tests is committed. But here comes the interesting part: If the tests don't pass, your changes will be reverted. Sound scary, doesn't it?

In fact, it is not that scary if you think about it. Every little change you make will be committed separately. So you will just lose a small amount of work.

Show me the code

Well "code" is a big word here. But let's look at the command that is used. I am a .NET developer, so I use dotnet test to run my tests. But you can replace that part with whatever works for your stack.

dotnet test && git commit -am working || git reset --hard

It's really that easy.

"But my git log..." 😨

Sometimes, when I talk to other developers about TCR, their reaction is something like this:

Are you serious? Have you thought about the git log? It will just say "working" all the time. That's not helpful at all.

That's true. I don't think using "working" as a message for every commit is not super helpful. But I think it is not a big deal as well. When you are done with a specific part of your feature/bugfix, just squash your commits before you push your changes. Problem solved.

My experience with TCR

I have tried TCR using some katas and also on a few small side projects. I think it is fun. It forces you to make small steps which is a good practice in general.

But it comes with some extra costs as well. As mentioned in the last paragraph, you don't want to push your "working" commits, do you? That means you have to squash your commits manually all the time. Of course, it is not a big deal, but it's an extra step.

Also, I'm a big fan of TDD. And to be honest, I really miss the "watch it fail" phase when doing TCR. If you run the TCR process on every "save" event, you cannot watch your new test fail, because that will revert your last change (which was the creation of the test).

Final thoughts

I don't think you have to use TCR all the time and everywhere. But it is fun to try it. And you will learn to take super small steps. Again, you don't have to make these tiny-tiny steps all the time, but I think you should have the ability to do so. It might come in handy someday.

More resources on TCR

There are a lot of cool resources on TCR.

If you like podcasts, you should check out the "TCR" episode of "Hanselminutes" by Scott Hanselman
The SoCraTes UK community has a couple of TCR session available on YouTube
The awesome Kent Beck has a cool TCR introduction on YouTube as well

I'm Giving Away Coding-Related Books

Lars Richter — Sat, 04 Jul 2020 11:35:13 +0000

Hi everyone,

I'm giving a few coding related books. Most of them are in German (sorry for that), but two are in English. You just have to pay for the shipping. I hope those books can help anyone learn stuff, even if they are a little dated.

Just check out my twitter thread. It contains all the books.

Lars Richter

@n_develop

Hey Twitter,
I'm giving some old books away for free. You only have to pay for the shipping. Just two of the books are in English. The rest are german. I would be happy if those books can help anyone learn stuff, even if they are a little dated. Every RT is very welcome.

10:58 AM - 04 Jul 2020

Lars Richter

@n_develop

Of course I forgot, the photos... 🙈
So here they are.

11:12 AM - 04 Jul 2020

Lars Richter

@n_develop

11:12 AM - 04 Jul 2020

How Do You Use Your StreamDeck?

Lars Richter — Sat, 04 Apr 2020 13:25:19 +0000

I bought a used StreamDeck Mini yesterday and I'm really excited about it. I hope it will be delivered by Monday. I'm not a streamer (yet), but I think it will make an awesome productivity gadget.

I have some things in mind, that I will try:

In my IDE

Run all tests
Run unit tests only
Run integration tests only
Run tests in the current test session
Run code coverage test

In Microsoft Teams

Toggle mic
Toggle camera
Toggle "blur background"
Accept call

General work stuff

Start specific Jenkins pipelines
Start my IDE (JetBrains Rider)
Start VS Code
Start WSL (Windows Subsystem for Linux)

I'm totally aware, that most of the actions can be performed by a keyboard shortcut. But it's still fun to have such a cool gadget at my fingertips.

Update 21.06.2020

I have been using my StreamDeck mini almost every (work)day since I got it. And the way I use it changed a bit from what I have planned. So here is a short update on how I (really) use my StreamDeck.

You can have different configurations (called "profiles") for different applications. For example, I do have a profile for my IDE (Jetbrains Rider). In this profile a have buttons for "Run all my tests", "Cover all my tests" and so on. But I realized, that I still use the normal keyboard shortcuts for that. So I don't really use it there.

But I do use it a lot in Microsoft Teams. I do have "Toggle Mic" and "Toggle Webcam" to use in the video calls. And I have buttons to set my status to "Be right back", "Away" or back to "Available".

And there is one more thing. It's OBS Studio. That's a fantastic piece of software. Maybe you have heard of it. It's mostly used by streamers and people recording videos. But I don't really do both. I use it for video conferences.

You can create "scenes" in OBS which you can select by a single push of a button (on your StreamDeck). You can assemble these scenes just as you like. My "regular" scene is just my webcam signal. Nothing fancy here. The next thing is my "Be right back" scene. This shows a gif of a coffee mug with a "BRB" post-it on it. Then I have a "this is awesome" scene, where a put a confetti gif (with a transparent background) right over my webcam signal. It's always fun to use that one. :-)

And then there is my... let's call it... "boring meeting" scene... or maybe "I'll take a nap" scene. This will show a prerecorded 60-second video of me in a never-ending loop. And to be fair: I don't use it in boring meetings. I use it if the other people in the call do not have their webcam on. I think it's a matter of courtesy to activate your webcam during a video conference. So if I can't see them, they don't get the "real me". :-)

And getting back to my StreamDeck: All these scenes are always at my fingertips with my StreamDeck. It's a ton of fun.

It's your turn.

Do you have a StreamDeck? If so, how do you use it? Are you a streamer? Do you use it for productivity? Gaming? Do you have cool profiles or tips to share? Let me know in the comments.

Would You Be Interested In A Conference Talk About The Different "Schools Of TDD"?

Lars Richter — Fri, 28 Feb 2020 06:17:53 +0000

I'm planning to apply at two or three conferences this year. While thinking about possible topics, I thought about one of my favorite topics: Test-Driven Development. I like to read and talk about TDD. It sparks interesting discussions, like the "Is TDD dead" discussion, and forces developers to think about their processes and workflows.

While I'm familiar with the "classic" schools of TDD, the "Detroit School" and the "London School", I recently learned, that there is more. David Völkel invented the "Munich School of TDD". And, staying in Germany for that matter, there is also a "St. Pauli School of TDD". These instantly sparked my interest. So at the moment, I'm trying to play with these new concepts.

Do you think a talk about the different schools of TDD would be worth preparing? Or would it be "just another TDD talk, nobody wants to hear"? I would love to hear your opinion about that.

Organizing my life using Microsoft ToDo

Lars Richter — Thu, 13 Feb 2020 04:43:22 +0000

I forget a lot of stuff. I really do. When I was younger, my mother always said: "If your head wouldn't be attached to your body, you wouldn't take it with you". (Sounds a little less strange in German, but you get the drift)

Over the years I tried of lot of things to organize my life. For the last couple of years, I used a shared calendar with my wife. That worked good. Not perfect, but good.

"Microsoft To Do" to the rescue

By the end of last year, I started using Microsoft To Do more and more. For me, it started with being a simple checklist for "go shopping" and "buy a birthday present for Mark". But it changed a lot in the last weeks and months.

At the moment I have 15 lists in the app (not including the smart lists provided by the app). I have individual lists for stuff I have to do at home (like cleaning), blogging, tasks for my website, conference talks I want to create, CFP (Call for Papers) deadline, movies I want to watch, etc. etc.

Planing even "silly" recurring tasks

Some days I get up in the morning, look in the mirror and think "Boy, you really need a haircut". Or maybe "Man, I should have shaved days ago. I look like a caveman".

That's why I even schedule these simple tasks using this app.

"Haircut" - every 4 weeks
"Shave" - every second day
"Vacuum the house" - twice a week
...

Sounds stupid to you? Maybe. But it works well for me. I haven't had these "caveman moments" for quite some time. 😆

What should I do today?

Microsoft To Do comes with a pretty awesome feature called "My Day". It's a list you can fill with tasks from other lists. It also has recommendations (based on due dates and more) for tasks that you could add to "My Day". And every day you will start with an empty "My Day" list. All the tasks you did not finish yesterday will be removed.

You also have an "Add" button in "My Day". That doesn't make any sense, right? If the list is cleared every morning, where are the items, that I added to this list yesterday? The answer is "In your Tasks list". Every item you add to "My Day" will be created in "Tasks" and added to "My Day" as well. So no item will be lost.

Every morning I start my day by filling the "My Day" list. The great thing about that: During the day I only have to check a single list.

Staying social

Too bad, that this former co-worker/old friend/someone I liked and I lost touch.

Does this sound familiar? That's a thought I had a lot of times in my life. That's why I have a list called "social life". In this list I have scheduled tasks to stay in contact with people I don't meet regularly. I scheduled those tasks for about "every 4 months" or "every 4 weeks", depending on the person.

Happy Birthday, Anna!

I took this list stuff even further and added all the important birthdays to a separate list. I assigned a reminder and a due date for each birthday. "But how is this different than an event in your calendar?" you might think. Well, in the morning I will add the "Say Happy Birthday to Anna" task to "My Day". Every time I check "My Day" I will be reminded to send a message to Anna.

But the biggest advantage for me: It still might happen (for whatever reason), that I forget to send this message. But the next morning, when planing out "My Day", I will see a task "Say Happy Birthday to Anna" in red letters (because the due date passed) at the top of the recommendations. The message might be a day late, but I will write that message. 👍

Organizing the lists

When you start creating more lists, you might feel the need for more structure. Luckily, you can group lists. So I have a "Work" group, a group for my "Collections" (like "Movies to watch" and "Birthdays"), a group for all my technical (but private) stuff (like "Blogging ideas" or the tasks for my personal website). This way, the list overview stays organized and clean.

Sharing is caring

And of course, like any other good ToDo app, you can share lists with others. If you are planning a trip with friends or have a permanent ToDo list wife your spouse, just share a list and you are good to go.

Now, tell me about your tips and tricks. How do you organize your life? Do you use a specific app? Or maybe you are like my wife and can remember pretty much everything? Let me know in the comments.

All images were kindly provided by Microsoft and taken from https://www.microsoft.com/en-us/microsoft-365/blog/2019/09/09/announcing-new-version-microsoft-to-do/.

Handle flaky tests with quarantine and Xunit.SkippableFact

Lars Richter — Fri, 07 Feb 2020 12:32:15 +0000

We maintain the integration of a lot of third party services in my team. Five payment service provider, a tax service, ERP systems, etc. etc.

Besides or unit tests we also have a couple of integration tests (or integration contract tests) for every third-party service, to make sure that our client libraries still match their API. Sadly, the test environments of the third-party systems aren't always reliable. For example, one of the payment service providers fails during one out of 30 requests (some times even more often). For this provider, we have 8 integration tests (one for each function we are using) that will run during our CI pipeline.

This means, that every third or fourth run of our CI pipeline will fail due to this error. Reaching out to the payment service provider had no effect so far. So these 8 tests are classical "flaky tests". There are a lot of good posts here on dev.to about flaky tests and why they are really bad. Two awesome examples are

We Have A Flaky Test Problem

Bryan Lee ・ Dec 9 '19 ・ 18 min read

#testing #flakytests #microservices #distributedsystems

Pros and Cons of Quarantined Tests

Mark Lapierre ・ Jun 6 '18 ・ 3 min read

#testing #automation #qa

A lot of posts about this topic will explore ways to avoid flaky tests and that is a good idea. But those "contract tests" (depending on your third party system) might always be flaky. So how to deal with those tests? We cannot delete them, because they still provide value.

Quarantine flaky tests?

When I started to read up on flaky tests, I found that some people proposed to put all flaky tests you cannot delete in a separate test suite. For more information about that, read the before mentioned post about quarantined tests, or maybe the post by Martin Fowler called Eradicating Non-Determinism in Tests. The idea is to move the flaky (or in this case called quarantined) tests out of your CI pipeline to keep it healthy.

I totally understand the point, but deep inside I still wanted to run all the tests during our CI pipeline, because I wanted to see problems as soon as possible. But how do I keep those tests in the pipeline without having the pipeline broken every third or fourth run for "no reason"?

Skip tests for a specific reason?

Wouldn't it be great if the tests would still fail if they have a "real problem", but just ignore the test result if they fail for the connection issue?

That's what I thought. So I tried to find a way to skip the tests if we ran into the known connection issue with the payment service provider. But in xUnit.net there is no way to say Assert.Skip(); or Assert.Inconclusive(); or something like that.

But then I found this library called Xunit.SkippableFact. It does exactly what I need. With it, I can mark my tests (called Fact in xUnit.net) as SkippableFact and provide a way to tell it, which result to skip/ignore.

Let's look at a small example. Image a super useful service, that will receive a string and return the length of this string. And of course, the connection to this service is pretty unstable. About every third connection will run into a SecurityConncection.

public class UnstableServiceConnection
{
    public int GetLength(string text)
    {
        var random = new Random(DateTime.Now.Millisecond);
        if (random.Next(10) % 3 == 0)
        {
            throw new SecurityException("Something is insecure here!");
        }

        return text.Length;
    }
}

The tests might look something like this:

public class UnstableConnectionTests
{
    [Fact]
    public void GivenShortText_ReturnsCorrectLength()
    {
        var connection = new UnstableServiceConnection();
        var length = connection.GetLength("ABCD");

        length.Should().Be(4);
    }
}

On average, every third run of our nice test will fail. Sad, isn't it.

But with Xunit.SkippableFact we can do this:

public class UnstableConnectionTests
{
    [SkippableFact(typeof(SecurityException))]
    public void GivenShortText_ReturnsCorrectLength()
    {
        var connection = new UnstableServiceConnection();
        var length = connection.GetLength("ABCD");

        length.Should().Be(4);
    }
}

Now, the test will be skipped, if it throws a SecurityException.

And you are not limited to exceptions. You could check for almost anything inside of your test. Just use Skip.IfNot(myBooleanValueOrExpression); inside of your test.

[SkippableFact]
public void SomeTestForWindowsOnly()
{
    Skip.IfNot(Environment.IsWindows);

    // Test Windows only functionality.
}

Example copied from https://github.com/AArnott/Xunit.SkippableFact

The two-step process

In the end, we did both. We copied the flaky tests to a separate test suite that has to run "green" before a deployment. But we also kept the same tests as "SkippableFacts" in the CI pipeline. I think for us this was the best way to address these problems.

Now it's your turn. What do you think about it? Do you have similar problems? If so, how do you handle it?

Speeding Up Our Unit Tests From 15min To Less Than 2min

Lars Richter — Sat, 25 Jan 2020 20:30:55 +0000

Our codebase at work is pretty well tested. The code coverage is at 80+ percent. I'm working on our backoffice systems, which are developed on the .NET platform and consist of about 100 projects (services and components) and growing.
Most of our services/components live in a separate solution in which we also store the test projects for unit and integration tests.
While writing more code (and therefore more tests), the time needed for running our tests increased. By the end of last year (2019) the unit tests took 15 minutes to run.

Time for a Hackday!

But everything worked. In my previous companies, it would be difficult to get permission to "play" with the build and test scripts to improve it. But at my current company,
we do have the concept of "hackdays". Every month you can use one day to do stuff outside of the normal schedule. Maybe there is some code you always wanted to refactor but you never had the time to do so. Or maybe you wanted to extend the UI tests. Or you want to take a look into some new framework or technology that might be relevant for your work.
Whatever it is, you can work on those things one day every month.

So I invested a "hackday" to improve the speed of our test suite. I found out, that the tests itself weren't terribly slow. It seemed like the tests were not run in parallel.

Our old way

Why wasn't it running in parallel? To understand that, you have to understand the build and test process.
We had a csproj file to build and run our entire codebase. It uses MSBuild targets and commands to gather all relevant projects.
A simplified version of it would look something like this:

  <!-- ... doing the build somewhere here first ... -->

  <ItemGroup>
    <UnitTestProjects Include="**\*.Test.XUnit.csproj" />
  </ItemGroup>

  <ItemGroup>
    <IntegrationTestProjects Include="**\*.Test.XIntegration.csproj" />
  </ItemGroup>

  <Target Name="unittest">
    <Exec Command="dotnet.exe test %(UnitTestProjects.Identity) --no-build --no-restore" />
  </Target>

  <Target Name="integrationtest">
    <Exec Command="dotnet.exe test %(IntegrationTestProjects.Identity) --no-build --no-restore" />
  </Target>

If I run MSBuild on this project file with the target "unittest", it will find all relevant projects and run them using dotnet test. Finding the projects is pretty simple because we have a naming convention, which says that the unit test projects must be named like this: [ProjectName].Test.XUnit.
Accordingly, our integration test projects are named [ProjectName].Test.XIntegration.

So it is a two-step process:

finding the relevant projects
Running each project using dotnet test

When I checked the build log, I saw, that it tested one project at a time. If you are familiar with MSBuild it might have been obvious to you, but it took me some time to realize that.
Luckily, dotnet test using xUnit V2 runs the tests inside of a project (or even inside a solution) in parallel by default. So at least the tests inside of a project will be started in parallel.

So I started researching how I could run all the test projects in parallel. While reading through a lot of documentation, I always came back to the fact, that all tests inside a solution run in parallel by default. So what about referencing all the test projects in one solution file?

Our new way

Despite my worries that maintaining such a solution file would be a lot of effort, I wanted to at least try it to see the performance improvements.
So I wrote a little PowerShell script that would pick up all the unit and integration test projects (just like the MSBuild stuff) and put each type in a single solution. As you will see in the script, I needed to do some string "magic" to get relative paths to the test projects. That was needed because the CI server might run the build in different directories from time to time. So hard-coding the path wasn't an option. Also, hard-coding paths is a bad idea anyhow.

$pathobject = get-location | Select-Object @{N="PathLength";E={$_.Path.Length}}
$pathlength = $pathobject.PathLength + 1

$mylocation = (get-location).Path 

if (Test-Path $mylocation/_unittest.sln -PathType Leaf) {
    Remove-Item _unittest.sln
}

if (Test-Path $mylocation/_integrationtest.sln -PathType Leaf) {
    Remove-Item _integrationtest.sln
}

dotnet new sln --name _unittest
dotnet new sln --name _integrationtest

Get-ChildItem -Path . -Recurse -File -Include *.Test.XUnit.csproj | ForEach-Object { dotnet sln _unittest.sln add $_.FullName.Substring($pathlength) }

Get-ChildItem -Path . -Recurse -File -Include *.Test.XIntegration.csproj | ForEach-Object { dotnet sln _integrationtest.sln add $_.FullName.Substring($pathlength) }

After that, I ran the tests in that solution using dotnet test. The result was amazing. Instead of taking 15 minutes to run, it only took 1 minute and 20 seconds.
That's an improvement worth the name. :-)

But there was still the effort of keeping the file up-to-date, that scared me. After some more thinking a realized, that I had a script to generate this solution on demand already.
I inserted this script into our build pipeline. It now runs in parallel to our normal build step. This way, the time to run the entire build pipeline stays the same.
And when the pipeline gets to running the tests, it would run dotnet test on our newly generated solution file which includes all the unit tests.

Final thoughts

These changes shortened our feedback cycle quite a bit. So I think it is a hackday well spent.

If you have tips or tricks to shorten the feedback cycle, I would love to hear them. Let me know in the comments.

What's your latest (or favorite) "Can you fix my computer?" story?

Lars Richter — Fri, 12 Jul 2019 05:57:26 +0000

I'm a developer. Even in my spare time I don't build computers myself. I have a simple
laptop without any customizations (besides DEV.to stickers).

But still I'm the one guy every non-technical friend or family member asks for help.
To be clear: I know exactly why they do that. It's obvious, that I still know more stuff
about hardware and setting up printers than the non-technical friend. And that's ok.

But I don't want to complain about the fact, that I get asked to help. It's more about the fact how some people ask for help. Let me tell you about my last time.
We were on a sunday-afternoon trip with friends, at a very old farm that got converted into a museum.

Friend: Lars, we wanted to ask you something.

Me: Sure. What's up?

Friend: My iPhone broke. It fell on the floor. Now the display is broken. Could you try to make a backup?

Me: At least I can try. Do you have it with you? Just give it to me and I will try at home.

Friend: But you came by bike, didn't you?

Me: Yes?!

Friend: That might be a bit too heavy?

Me: The iPhone? No, I think I can handle that.

Friend: But there is also the laptop in the backpack. It would be nice of you could do the backup on our laptop directly, so that it is set up for the next time.

Me: Oh, ok. Yes, I can do that.

Friend: Would you also check the anti-virus stuff? I think the license expired. And maybe updates and stuff for all the other important things as well?

Me: Hmm... sure.

Friend: But still, isn't it too heavy? The bag with the laptop, the iPhone and the tablet?

Me: TABLET?

Friend: My daughter's teacher created some kind of account for some kind of app the kids should use. It would be super awesome if you could install that as well.

Me: Sure. No problem at all. Maybe something else?

Friend: No, I think that is it.

That's my latest story. What's yours? Tell me about your funniest, saddest and/or latest request.

People I Know - My little PRM

Lars Richter — Thu, 11 Jul 2019 06:41:07 +0000

What's the name of Jane's daughter again?

I remember, that Michael quit his job. But where did he apply for a new job? I'm sure he told me...

Does this kind of question sound familiar to you? Welcome to my life. :-)

My memory is not the best. Especially, when it comes to names and stuff. That's why I started using my Google Contacts pretty extensively.
Did you know, that you can store "relationships" in your Google contacts? That's pretty useful.
So on John's contact, I stored a couple of relationships like:
"Wife": "Jane"
"Son": "Michael"
"Daughter": "Rachel"

That helped me a lot already. If I knew I was going to meet John today, I just checked his contact to remember the names of his kids.
But last time we met, he told me something interesting about his son? What was it again? He broke his arm or something like that.
For this stuff, I used the "Notes" field on the contacts. It's just a free-text field to hold any information like "His son Michael broke a leg".
So if I check his contact (and the "Notes" field) before we meet, my first question could be "Hi John. How is Michael? Is his leg ok again?".

All that is pretty useful. But I was still missing some features. Because the "Notes" field can grow pretty quickly. And such a big chunk of free text can get confusing.
Wouldn't it be nice, if you could store a list of, let's call it "status updates"? Just a text and a date. These status updates (or "timeline") could be ordered by date.
That's much clearer.

I thought about using a simple CRM (Customer Relationship Management), but none of them really fit my needs or could easily be hosted on my server. While searching for
a simple CRM, I learned that PRMs are a thing. A PRM is like a CRM, but for personal use (instead of professional/commercial). It's a "Personal Relationship Management".
But I had similar problems with the already existing PRMs. For some of them, it was the price, for others the hosting, etc.

I'm a developer. So I built my own PRM.

It is called "People I Know" and you can find the source code on GitHub.

n-develop / peopleiknow

"People I Know" is a PRM (Personal Relationship Management)

People I Know

"People I Know" is a PRM

What is a PRM?

A PRM is a "Personal Relationship Management". On the web, you will also find the name "Personal CRM". So you can use "People I Know" to store information about the people you know. ;-)

Is it like my "Contacts" app on my phone?

Yes, somehow it is.

So, why would I use it?

There were a few reasons for me to build this application. For "normal" contact management, the standard android or iOS app would be fine. But there was something missing for me.

If you use the before mentioned services, you don't own your data. It is stored somewhere in Apples or Googles Cloud services.
The standard apps / services do not provide good possibilities to store some kind of timeline / updates for the contacts. You still have the "Notes" field, but it is limited…

View on GitHub

Feedback is very welcome. Please let me know what you think. If you see major issues, feel free to contact me or (even better) create an issue on GitHub.
Here are some TODOs that are still on my list:

Photo upload is still missing
Clean up the JavaScript. Right now it's just one "big" file.
Improve the mobile user experience

As you can see from the TODOs, my frontend skills are... let's call it "limited". ;-) I use Bulma for the styling and pure JavaScript (no framework, no jQuery) for the scripting. The backend is done in ASP.NET Core.

Again, feedback is very welcome. It's the first "toy project" that I share publicly.

How do you name your tests?

Lars Richter — Sun, 16 Jun 2019 19:25:51 +0000

As you might know, I'm a big fan of unit testing and TDD. But I often go back and forth on the naming of my unit tests. There are many popular naming schemes for unit tests. A few of them are:

[MethodUnderTest]_[TestedState]_[ExpectedBehavior]

That's a classical naming scheme.

ReadFrom_FileDoesNotExist_ThrowsException

[MethodUnderTest]_[ExpectedBehavior]_[TestedState]

This is pretty similar to the first scheme. Personally, I like this one a little better than the first one. This one reads a little more naturally. For example:

ReadFromFile_ThrowsException_FileDoesNotExist

It reads almost like "WriteToFile throws an exception if file does not exist".

Should_[ExpectedBehavior]_When_[TestedState]

Should_ThrowException_When_FileDoesNotExist

This also reads almost like a "normal" sentence.

When_[TestedState]_Expect_[ExpectedBehavior]

When_FileDoesNotExist_Expect_WriteToFailToFail

Given_[Preconditions]_When_[TestedState]_Then_[ExpectedBehavior]

Given_ReportIsWrittenToFile_When_FileDoesNotExist_Then_ExceptionIsThrown

JustDescribeWhatIsGoingOnAndWhatShouldHappen

This is something I fall back to from time to time. In these cases, my test read something like this:

OrderProcessorThrowsAnExceptionInCaseOfMissingCustomer

These are just a few examples. Feel free to add some more naming schemes in the comments.

Whats your favorite naming scheme? Are there naming schemes you do not like?