Forem: Claudio Bernasconi

Giving My First User Group Talk

Claudio Bernasconi — Tue, 12 May 2020 19:10:22 +0000

Last Thursday, May 7th, 2020, was the first time I spoke in front of an audience about software development topics. The talk was titled: “Blazor Web- & Mobile Development using C#“.

Yes, I know what you maybe think: This guy has 80+ blog posts, runs a YouTube channel, etc. But yes, it was the first time I spoke live in front of an audience.

I was invited to speak about Blazor at a local Mobile user group. Because of the current situation with social distancing in place, the organizers decided to move the event online. It was my chance to show some of my knowledge in front of their audience – live on Twitch.

How I got invited

It was a few months ago that a friend of mine asked the organizer of the Mobile user group if he wanted to invite me to speak about Blazor.

It was my friend who knew me and my YouTube channel and knew about my interest in Blazor. He is a co-worker of one of the organizers of the user group.

Only a few days later, I received an offer to speak at the next meeting of the Mobile user group. As we all know, 2020 has its indistinguishable storybook, and things changed in the meantime. So the event was held online.

How I prepared myself

I did the usual things somebody planning a presentation would do. I created a slide deck and started thinking about what code samples I should show, and I debated what parts I wanted to code live.

It took me a lot of time to build an application that shows everything I wanted. In the end, I dodged this project and started from scratch. I created small projects from scratch while giving the presentation.

There were questions about more complex applications, but I believe the simple projects helped a lot of the audience understand the fundamentals of Blazor.

Telling everybody about the fundamentals of Blazor was the goal of my talk anyway.

What I have learned

I postponed my first user group talk for a long time. I always thought that I do not belong to the group of speakers. It’s not that I would consider myself a real speaker by now – but hey, at least I gave my first user group talk.

I don’t like presenting in front of people I don’t know. If it is a smaller group of people that I mostly know and trust, it is no problem for me to go on and on about a technical topic and discuss for hours about solutions.

When it comes to an unknown audience, I tend to be very scared. It was always the case when I had to present in school, and it was the case when I had to perform during my degree at the university.

Every time I was forced to give a presentation, it turned out to be okayish or even pretty good. I never had a terrible experience, but it is just something that I don’t like doing. But this time, it was fun, and I learned a lot from the questions of the audience.

It seems like it is a big difference if you have to talk about something they want to hear from you compared to when you speak about something that you like and understand.

I like the format. I enjoy how I was able to help people understand the fundamentals of something new from my home office while they were having dinner, watching me in their homes.

It was a lot of help that I was able to give my first user group talk in my native language. I’m still worried a lot when I think about speaking in English.

I am very grateful for the opportunity I got to give my first user group presentation for this audience. I want to thank everyone involved in the organization of the event and everyone who attended the event from their couch.

I might think about streaming more on my Twitch channel in the future. It was a lot of fun, and maybe people tune in again? We’ll see how things turn out.

How I streamed to Twitch

The talk was streamed on Twitch. I used OBS to capture my screen and to add overlays. I used multiple scenes to make it a unique experience for the audience. It took me a long time to create different layouts, and in the end, I ended up only using three out of the four created scenes.

At the beginning of the talk, there was an introduction from the organizers. To bring them onto the stream, I opened a Skype call, and I recorded their webcam as well as share their screens. It worked quite well. The audio was clear; the video sometimes lagged a bit. But for an introduction, it worked well enough.

After the introduction, I started with the main part of the meeting, my talk. I did not have the opportunity to see the reaction on the faces of the people in front of me, but I encouraged them to use the Twitch chat to interact with me. And they did.

Only a few minutes in, people started asking questions, and it was a fun experience to talk in front of my camera.

After the presentation, I asked people to join a Discord server that I created specifically for this talk. Around ten people jumped into the server, and we talked about 30 minutes about the presentation.

Developers love online events

After my talk, I checked the Twitch statistics of my presentation. It turned out that, on average, 31 viewers were watching the stream with a peak of 37. There were 72 unique viewers over 70 minutes of my talk.

Those numbers might not sound impressive to you. Maybe you talked in front of a much bigger audience? But for me, it was a lot. Taking into consideration that the Mobile user group usually attracts about 10-15 attendees, we had at least doubled the audience for this event.

It leads me to the conclusion that developers tend to prefer online events over offline events. I’m not sure what the reason is. Maybe it is the lack of alternatives in times when you are supposed to sit at home? Anyway, it was a great audience to give my very first talk.

What I would do differently

My first user group talk was a great experience, and I overcame my fear of presenting in front of a group of talented, well-educated, and experienced developers.

There is not much I would do differently. The most important thing I would do differently, though, is to start a lot earlier with the preparation.

It was around two weeks before I had the presentation that I finally started creating my slide deck and started working on the source code I wanted to show. It put more pressure on my shoulders than required.

Also, I underestimated the effort it takes to create beautiful scenes for OBS. I wanted to use my color scheme and my logos. It was a lot more work than expected. I would have started earlier if I could go back in time.

Other than that, I am delighted with how everything turned out.

What you can learn from my experience

It doesn’t matter if you cannot attend events in person. If you have a decent setup, streaming from home is an option.

If you are scared of giving your first presentation, I can tell you that you don’t need to be afraid of it. Local user groups tend to have a very forgiving audience. Also, the size of the audience is usually not too big.

If English is not your native language and you hesitate because you think you sound silly or don’t find the right words, maybe give your first presentation in your native language. It helped me a lot.

If you are the organizer of a user group, don’t cancel all the upcoming events. Try to get them online. People will show up, and they’ll have a good time and learn something new anyway.

This article was originally published on claudiobernasconi.ch on May 10th, 2020.

Blazor Components: How to Split Template and C# Code

Claudio Bernasconi — Sat, 08 Feb 2020 22:29:43 +0000

In the Blazor Introduction and specifically in the article about How to Create a Blazor Component, we’ve seen how simple it is to write C# code for our components.

It’s not the only way to write C# code for our components, though. Instead of having the C# code below the template in the component file, we can move it into a separate file.

Reasons for separating code and template

Some people don’t like having the C# code directly in the component definition file. Although I personally like to have both artifacts within the same file most of the time, there are reasons to split the code into separate files.

You might want to reuse parts of your code for multiple components. You maybe want to put the shared code into a library.
Or you have a lot of C# code and a big template, and you feel like separating the matters will help with readability and maintainability.
As a WPF developer, you might be familiar with the concept of a view template and a code-behind file.

Maybe you prefer to have the template separated from the code-behind.

Moving the C# code into a code-behind file

Let’s take a look at the following ProductCard component definition that we build in the How to Create a Blazor Component article:

<div class="product-card">
    <div class="card" style="width: 18rem;">
        <img class="card-img-top" src="@imageUrl" alt="Card image cap">
        <div class="card-body">
            <h5 class="card-title">@productName</h5>
            <p class="card-text">@productDescription</p>
            <a href="" class="btn btn-primary">Add to cart</a>
        </div>
    </div>
</div>

@code {
    private string imageUrl = 
        "https://dummyimage.com/286x180/8EB1C7/FEFDFF.png&text=Awesome+Product";
    private string productName = 
        "Awesome Product";
    private string productDescription = 
        "You won't believe how great this product is until you actually use it yourself.";
}

Our ProductCard component file lives in the Components folder of our project. We create a new file in the same namespace with the name ProductCard.razor.cs. We open the file and insert the following class definition:

using Microsoft.AspNetCore.Components;

namespace BlazorApp5.Components
{
    public partial class ProductCard : ComponentBase
    {
        private string imageUrl =
        "https://dummyimage.com/286x180/8EB1C7/FEFDFF.png&text=Awesome+Product";
        private string productName =
            "Awesome Product";
        private string productDescription =
            "You won't believe how great this product is until you actually use it yourself.";
    }
}

As we can see in line 6 of the code above, we define a partial class derived from ComponentBase. The ComponentBase class comes from the Microsoft.AspnetCore.Components namespace and acts as the base class for all Blazor components.

We can now remove the @code directive from the template definition within the CardComponent.razor file. The component definition in the ProductCard.razor file looks like this:

<div class="product-card">
    <div class="card" style="width: 18rem;">
        <img class="card-img-top" src="@imageUrl" alt="Card image cap">
        <div class="card-body">
            <h5 class="card-title">@productName</h5>
            <p class="card-text">@productDescription</p>
            <a href="" class="btn btn-primary">Add to cart</a>
        </div>
    </div>
</div>

If we position the cursor on a variable definition and press F12, we will still jump into the code-behind file to the location of the variable definition.

This is how it looks in the Solution Explorer within Visual Studio:

We have successfully separated the template and the C# code of a Blazor component into different files.

How Blazor components work

Let’s take a look at what we just did. We learned that we could use the @code directive in a .razor file, or we can use a separate .razor.cs file to write our C# code.

The way we define our code only matters at development time. When we compile the application, the compiler turns our @code directive into a C# class for us.

In the end, the .NET runtime executes the code that the compiler creates for us. There are different ways to achieve the same compiler output.

When should I separate the code-behind?

As written above, there are different reasons why you might want to separate the code-behind from the template definition. I suggest having a rule on how you want to create your components.

I’m currently a friend of having both the template and the code within the same file. As long as it’s maintainable, and as long as I don’t want to reuse parts of the code, it feels natural to me.

If I either want to reuse code or if the code file becomes too big, I tend to split the definition into separate files.

In the end, it is a personal preference. The goal of this article is to give you a choice. I hope you understand how to separate the code from the template, and why you might want to do it.

What’s next?

Check out these other blog posts about Blazor:

If you’re interested in learning more about Blazor, you’ll definitely want to join my email list, where I talk a lot about Blazor, share information with the community, and offer answers to your questions.

If you want to dive deep into Blazor, you can also check out my upcoming Blazor – Creating Web Applications with C# online course. Everyone signing up before the launch of the course in April will be eligible for a massive discount.

This article was originally published on claudiobernasconi.ch on February 8th, 2020.

How to Create a Blazor Component

Claudio Bernasconi — Sat, 01 Feb 2020 15:24:19 +0000

Creating a Blazor component is one of the first things we want to do when we create a Blazor application. As we learned, Blazor applications consist of many Blazor components. A Blazor component represents a part of the user interface and can be reused in your application or even in multiple applications.

If you prefer to watch a video instead of reading this detailed article, I don’t judge you.

A Blazor component consists of an HTML (and CSS) template and C# code that glues the application and the component together.

For the code example in this article, I used the standard Blazor Server application template of Visual Studio 2019 Community Edition. You might want to do the same if you’re going to code along and use the snippets provided below. This code works with .NET Core 3.1.

Blazor Components are Razor Components

When we want to create a Blazor component within Visual Studio 2019 Community Edition, we right-click on the folder we want to create a new component for and click on the add new item menu option.

Within the Add New Item dialog, we click on Visual C# and choose Razor Component as our file template. Fill in a Component name and click on the Add button on the bottom right corner to create the file.

In this article, we’re going to create a ProductCard component.

It’s important to understand that in the context of Blazor, we use Razor components, which means that we build components using the Razor syntax. In the context of this article, we reference our component as a Blazor component, because we use it in a Blazor application.

The structure of a Blazor Component

The selected Razor component template generates a simplistic file in our Solution Explorer.

<h3>Component</h3>

@code {
}

We have two parts. In the upper half of the Blazor component, we have the HTML template. In this case, a single

tag with the name of the component represents the component template.

In the lower part of the Blazor component, we have a @code directive, which wraps C# code for our Blazor component. Up to now, there is no C# code within our new Blazor component.

Implementing the Blazor component template

We want to change our Blazor component template to something more useful than only the name of the component.

As I wrote at the start of this article, this component is created within the default Blazor Server app project template generated by Visual Studio 2019 Community Edition.

This project template has Bootstrap included, which we’ll use as a user interface components library for our Blazor component template.

 <div class="product-card">
    <div class="card" style="width: 18rem;">
        <img class="card-img-top" src="@imageUrl" alt="Card image cap">
        <div class="card-body">
            <h5 class="card-title">@productName</h5>
            <p class="card-text">@productDescription</p>
            <a href="" class="btn btn-primary">Add to cart</a>
        </div>
    </div>
</div>

We use the above code snippet as a template for our Blazor component. It will represent a product card, which could possibly be found within an online shop.

Most of the template uses standard HTML tags, including div, img, h5, p, and a. Some of those tags have classes attached to them that are defined in Bootstrap. It allows us to style our template without having to write the CSS ourselves.

How to use Variables in Blazor Components

We need to take a close look at the template where we use @imageUrl, @productName, and @productDescription.

Those definitions are placeholders for variables defined in the C# part of the component. The C# part of the component belongs below the template definition and is wrapped within a @code directive.

@code {
    private string imageUrl = 
        "https://dummyimage.com/286x180/8EB1C7/FEFDFF.png&text=Awesome+Product";
    private string productName = 
        "Awesome Product";
    private string productDescription = 
        "You won't believe how great this product is until you actually use it yourself.";
}

The variables are defined as private string variables. It’s important to understand that those variables are not defined within an explicit class definition, nor are they static.

The variables are part of the Blazor component class deriving from Microsoft.AspNetCore.Components.BaseComponent, but the class definition does not have to be explicitly written. It’s a handy shortcut we use within Blazor Components.

The complete ProductCard Blazor Component looks like this:

<div class="product-card">
    <div class="card" style="width: 18rem;">
        <img class="card-img-top" src="@imageUrl" alt="Card image cap">
        <div class="card-body">
            <h5 class="card-title">@productName</h5>
            <p class="card-text">@productDescription</p>
            <a href="" class="btn btn-primary">Add to cart</a>
        </div>
    </div>
</div>

@code {
    private string imageUrl = 
        "https://dummyimage.com/286x180/8EB1C7/FEFDFF.png&text=Awesome+Product";
    private string productName = 
        "Awesome Product";
    private string productDescription = 
        "You won't believe how great this product is until you actually use it yourself.";
}

How to include a Blazor Component in a Page

Now that we have our first component completed, we want to show it on a page. A page in Blazor is a Blazor Component itself, that also provides the ability to be addressed using a route.

For now, let’s use the default Blazor Server application template and add our created component to the Index.razor page.

@page "/"
@using BlazorApp5.Components

<h1>Welcome!</h1>

<ProductCard></ProductCard>

To include a component within another component, we can use an HTML tag with the name of the component. In our case, can be used to place our Blazor component within the Index Blazor Component.

If you defined the ProductCard component in another namespace than the Index component, e.g., Components, we need to add a using statement at the top of the Index component. You can see that using statement on line 2 in the code snippet above.

Your first Blazor Component in Action

Let’s take a look at our Component in action. We start the application and we immediately see our ProductCard component rendered on the index page of the application.

This is the foundation of a Blazor application. Sure, there are advanced topics, including Component parameters, Routing, sharing data between components, and much more.

But when it comes to creating Blazor components, you have learned all the required fundamentals to explore the world of Blazor components yourself.

This article was originally published on claudiobernasconi.ch on February 1st, 2020.

Blazor Introduction – What is Blazor?

Claudio Bernasconi — Tue, 21 Jan 2020 14:54:12 +0000

I’m excited as you are to learn about Blazor. In this article, I’m going to explain what Blazor is and why it might be a useful technology choice for your future projects.

This article is going to be a high-level overview of what Blazor is and how a Blazor application looks like for a .NET developer.

If you prefer to watch a video instead of reading this detailed article, I don’t judge you.

The goal of this article is to provide you with a fundamental understanding of what Blazor is. We’ll take a look at how it works, and which existing technology is used to make it all happen.

What is Blazor?

Microsoft develops Blazor, and it is a framework for building interactive client-side web user interfaces with .NET. It allows .NET developers to build modern web applications.

Blazor allows us to write interactive web UIs using C# instead of JavaScript. Blazor has a component model comparable to React or Angular, and it uses C#, HTML, and CSS to build user interfaces.

The first interesting aspect of Blazor is that because we write C# on the server and the client-side, we can share the code as well as libraries between the two.

Blazor sits on top of ASP.NET Core and has access to all the new features of the .NET platform.

Blazor Uses Open Web Standards

Blazor is built on top of open web standards. Unlike Flash or Silverlight, there is no need for a plugin in the browser to run a Blazor application. Blazor works in all modern browsers on desktop and mobile.

Blazor Allows Code Sharing

You can use existing .NET Standard libraries in your Blazor projects. Writing your code in .NET Standard libraries allows you to use it in any project, including Xamarin, ASP.NET WebApi, Blazor, Desktop applications using WPF, and more.

JavaScript Is Still an Option

Maybe you already have experience using JavaScript web frameworks, or you are familiar with the rich ecosystem of JavaScript libraries. The great news is that we don’t need JavaScript for Blazor, but if we want, we can use it.

Blazor allows us to call JavaScript APIs and libraries where we need them.

Blazor Has First-Class IDE Support

Both Microsoft IDEs, Visual Studio, and Visual Studio Code provide a great Blazor development experience not only on Windows but also on Linux and macOS. There are also command-line tools that allow you to use other IDEs or editors to write your Blazor applications.

Blazor Has a Rich Component Eco System

We are busy developers, and we don’t want to build our user interface from scratch. Luckily, although it is early, there are multiple well-known 3rd party component libraries available, or they are being developed while you read this article.

Blazor Is Open Source

If you want to understand how something works internally, you can look up the code on GitHub. Blazor is open-source and already has many contributors to its core projects.

You can learn more about all the Blazor features on the official Blazor product page.

Create Your First Blazor Application

First of all, make sure that you are running the latest version of Visual Studio 2019, which is a good idea anyway if you want to have the most performant tool to get your job done. We also need to have the .NET Core SDK 3.0 or newer installed.

Let’s start Visual Studio 2019 and create a new project. In the project template selection screen, we choose Blazor App.

If you don’t see Blazor here, chances are you need to install the web development workload in the Visual Studio installer. If that’s a problem for you, let me know in the comments below, and I’ll create a short video or an article about it.

In the next screen, we choose a project name, set the location of the project, and click on the Create button.

Next, the “Create a new Blazor app” screen appears. We choose to create a Blazor Server App for this Blazor introduction. I’ll write about Blazor WebAssembly Apps in another article on this blog.

If you don’t have the Blazor WebAssembly App option, you can install the template. Blazor WebAssembly is currently in preview. Therefore the template is not included in the web development load installed using the Visual Studio installer.

We click on the Create button to create our first Blazor Server app.

The First Impression of a Blazor Server App

First of all, let’s compile and run the application to get a first impression of how a Blazor app looks in the browser.

We see a classic Single Page Application with navigation on the left and the content on the right.

Let’s click on the Counter menu to open the Counter view. If we click on the Click me button, the counter increases by 1.

Let’s click on the Fetch data menu option, which loads data from the server and renders it into a grid.

It’s not the most spectacular application, but it lets us explore a lot about how a Blazor Server app works. Let’s stop the application and take a look at the source code of the project.

The Blazor Server Project Structure

In the Solution Explorer of our project, we see the three folders Data, Pages, Shared, and a few top-level files.

In this introduction article, we don’t learn about the Startup of the Blazor Server application or its configuration. Instead, we want to know how Blazor looks for an application developer.

The Counter Component

We open the Pages folder and double click the Counter.razor file to open it in the editor. This Blazor component uses Razor syntax, which allows us to have an HTML template and add C# logic where we need it.

@page "/counter"

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}

In this component, we have a currentCount variable that we want to display on line 5. The C# code is wrapped within a @code directive. We don’t need a lot of ceremony like defining a class. Instead, we create the variable we need and implement a method to increase its value.

On line 7, we define the IncrementCount method to be executed on a button click.

On line 1, we have the @page directive, which tells Blazor router at which URL the component should be available.

The FetchData Component

Now, let’s take a look at the FetchData component. The structure of this component does not differ much from the component we explored before.

@page "/fetchdata"

@using BlazorApp3.Data
@inject WeatherForecastService ForecastService

<h1>Weather forecast</h1>

<p>This component demonstrates fetching data from a service.</p>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th>Temp. (C)</th>
                <th>Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in forecasts)
            {
            <tr>
                <td>@forecast.Date.ToShortDateString()</td>
                <td>@forecast.TemperatureC</td>
                <td>@forecast.TemperatureF</td>
                <td>@forecast.Summary</td>
            </tr>
            }
        </tbody>
    </table>
}

@code {
    private WeatherForecast[] forecasts;

    protected override async Task OnInitializedAsync()
    {
        forecasts = await ForecastService.GetForecastAsync(DateTime.Now);
    }
}

On line 4, we make use of Dependency Injection to get an instance of the WeatherForecastService class. We have a slightly more complex layout definition using a for each statement on line 26 to repeat the HTML template for the items of a collection.

And on line 44, we have a method that executes an async call to retrieve data from the server using the injected WeatherForecastService instance.

The Blazor Roadmap

An important thing when learning a new technology is being able to decide if it’s worth putting in time and effort to learn something new. For example, it’s valuable to know where the development of the technology will be a few months or years from now. The Blazor team did a good job and released and talked about their roadmap multiple times.

While we already got Blazor Server with the release of .NET Core 3.0 in September 2019, we’ll soon get Blazor WebAssembly in May 2020. As mentioned at the beginning of the video, Blazor WebAssembly will allow running a web application within the browser instead of executing the logic on the server.

In the next step, Blazor will allow us to provide a full-featured Progressive Web Application (PWA). PWAs provide offline support and will enable us to integrate with the notification system of the host, create app icons on the home screen, and much more.

Furthermore, Blazor will support a hybrid model that allows us to run our applications within the Electron shell. It will allow us to create a full-featured desktop application using Blazor.

With Blazor Native, we will be able to create native applications (without an Electron shell) for desktop and mobile systems using Blazor.

Blazor starts by enabling .NET developers to build robust and modern web applications using the latest .NET Core platform. Going down the road, we’ll get many more options to make sure our applications can run as desktop or mobile applications too.

If we understand how Blazor components work, we’ll be able to create reusable components and services that we can use across all platforms from the web to native applications on phones or desktop.

Conclusion

I hope you’re excited as I am to develop an application using Blazor. This article has been a high-level introduction and overview of Blazor. In the next article, we will go more technical and learn how to write code for our first Blazor application.

I will be releasing an online course about Creating Web Applications with Blazor in April this year. The online course guides you step-by-step from learning the fundamentals to building complex applications using Blazor. Check out the course page to get a massive discount and early access by subscribing to the email list.

Let me know in the comments below what you think about Blazor? Do you like what you’ve seen so far? Have you already started building applications with Blazor?

This article was originally published on claudiobernasconi.ch on January 21st, 2020.

Review of the Year 2019

Claudio Bernasconi — Thu, 02 Jan 2020 11:56:37 +0000

It is that time of the year again. The year rushed by, and now it is time to look back to what I planned to do, what I achieved and what I want to do differently next year.

Blogging

I want to start off talking about my blog. I started my blog a long time ago back in 2008. One year ago, I wrote a detailed article about my 10th anniversary with this blog.

It was November 2018 when I committed to blogging regularly once again, after another break. I only wrote a few articles a year in 2018, and I wanted to change that.

And let me tell you I changed it. I was consistently publishing at least one article per week from November 2018 until July 2019. After that, I took a little break to plan my 5-week trip to the United States. This article is the 33rd and final article for 2019.

The image above shows the number of page views per month, starting from November 2018 and ending in December 2019. At the time of this writing, there are still five days left in 2019, which means that the December numbers will raise a little higher in the end.

What counts for me is that I found my way back to blogging, and I had a lot of fun researching and writing those 33 articles in 2019. Also, it seems like some articles were interesting to the readers as my monthly page views increased from 3500 in November 2018 to around 19’000 in October 2019. I now have more than five times more readers on my blog than a year ago. I am delighted with the results.

Looking forward to 2020, I can only imagine how far this journey will go if I continue to blog about my experiences as a developer regularly. I have a few secret plans for 2020 that I do not want to share yet publicly, but when the time comes, I’ll announce it here first.

Another 5X increase in page views would mean to reach 100’000 page views a month by the end of 2020. I’ll love it for sure if that happens.

You can access the blog archive to find all the articles I wrote in 2019 and also the articles from the years before.

I also started to cross-post my blog articles to dev.to. If you want to make sure you don’t miss out on future articles, consider following me on dev.to.

Claudio BernasconiFollow

I'm a passionate Software Engineer, Blogger, YouTuber, and Counter-Strike player

It is an excellent platform featuring articles from all over the world, which publish articles for developers on various topics.

The goal for 2020 is to continue writing articles, at least 20 of them, and to hopefully break through the 20’000 page views per month barrier. An ambitious goal would be to set 50’000 page views per month as a goal.

YouTube

With the end of 2019, my first year running my developer YouTube channel comes to an end as well. I uploaded 11 videos, and I gained around 600 subscribers and more than 30’000 views.

I wrote several articles about my YouTube journey on this blog. I wrote about 10 Tips for Your Developer YouTube Channel, which could be interesting to read if you plan to start your channel or want to get more traction on your existing channel.

I also wrote a review about my first 365 Days of Building a Software Developer Channel on YouTube. This article goes into detail about my results and what I did in the last year to grow my YouTube channel.

I am satisfied with the results. I wish I were able to create and publish more videos in a year, but more than a video per month on average was not possible. I hope to improve next year. I want to set a goal of 2 videos per month. We’ll see if that happens.

If you haven’t check out my channel, please do so and consider subscribing if you want to follow my journey and learn about software development on the .NET platform.

The goal for 2020 will be to continue creating videos, as stated above. From a metrics perspective, it would be great to reach monetization for the channel by the end of Q1.

Remote Work

2019 is also the first remote work year for me. I am an employer of a local company that has a focus on remote work and enables developers to be as productive as possible by letting them leverage their tools and software that fit them best.

I’m glad for this opportunity, and I am sure that my overall productivity has increased because I can entirely focus on work and do not need to worry about commuting and to lose time when sitting in traffic jam anymore. It helped with the quality of my life a lot. I am very thankful for this opportunity.

At the beginning of 2019, I wrote a detailed article about How Working from Home Really Is. If you consider working remote in the future or if you’re working yourself remotely, this will be interesting to you.

In Autumn of 2019, I recreated my home office by building a custom standing desk. It took me a lot longer than expected, but I am satisfied with the results. When the cable management is finally done correctly, and my desk is cleaned up, I want to share the setup I’m using soon. There will be a video on YouTube, and you’ll also see me blogging about it for sure.

I am not going to change anything about working from home in the next year. I am happy it all worked out, and I’m looking forward to a highly productive 2020.

The United States West Coast Trip

A review of 2019 would not be complete if I would not mention the five weeks I spent on the West Coast of the United States of America. I’ve been in New York twice so far (2014 and 2018), but I’ve never been to the West Coast before.

It worked out to go on a 5-week trip to the West Coast with my girlfriend this year, and it was an incredible experience. I was able to gain so much insight into the lives of other people, and I realized that I am very privileged the way I’m can live my life and how I earn and spend my money.

From big cities like San Francisco, Los Angeles, San Diego, Phoenix, and Las Vegas to National Parks, including the Grand Canyon and many other great places, I was able to visit them all.

We drove our rented 2018 Ford Mustang GT about 3800 miles across California, Arizona, Utah, and Nevada. It was a great experience. I’ll want to to that again, sooner than later.

Twitter

In 2019 I set a big focus on Twitter. I love to connect with other developers on the platform. I read many, many blog articles; I would not have come across if it was not for Twitter.

I also happily share my blog posts on Twitter, and of course, I hope that people notice my contributions and value them high enough to press the share or the like button. In the end, I do it because I love doing it, but it is a motivation boost when I get feedback to something I wrote on my blog or a video I created for YouTube.

I managed to grow my Twitter following from about 300 followers to around 1500 in 2019. I don’t know why so many people decided to follow my journey, but I am pleased about it, and I hope to deliver the content that people are looking forward to.

One tweet went to the roof in 2019. I never had Tweet go viral before, but I believe that it is what happened to the tweet below. It also resulted in about 300-400 people following me. I am glad you joined my journey.

// Detect dark theme var iframe = document.getElementById('tweet-1192105997462102016-737'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1192105997462102016&theme=dark" }

If you are following me on Twitter, drop me a message and say hi. If you’re not, you might want to join my journey sooner than later.

The goal for 2020 will be to continue post engaging content, share my content, and build relationships with other creators in the programming community. It would be great to reach 4000 followers by the end of 2020.

E-Sports Live Events

I could not end the 2019 review without mentioning the two Counter-Strike: Global Offensive events I visited. I went to the ESL One Cologne 2019 event with my Counter-Strike friends, and I went to the StarLadder Berlin Major 2019 with my girlfriend.

Cologne was a spectacular experience. I’ve never been to a live esports event before, and it was a great experience. I have been playing Counter-Strike since 2003, and if I would not be a software developer, I’m convinced I’d want to start a career playing Counter-Strike (streaming, content creation, or whatever).

It took me years to find people who want to attend an event like this with me, and it also took time to find a suitable event. I am thrilled that it worked out to attend two events this year. There is nothing planned for next year, but I’d love to sometime in the future visit another Counter-Strike live event.

Thanks to everyone who made it possible for me to experience joy at those events.

I’m looking forward to a fantastic 2020.

This article was originally published on claudiobernasconi.ch on December 27th, 2019.

10 Tips for Your Developer YouTube Channel

Claudio Bernasconi — Sun, 15 Dec 2019 10:50:42 +0000

I started my YouTube channel a year ago, and you can read a personal retrospective about it in another article.

In this article, I’m going to share ten tips for other developers who want to start their own YouTube channel or that have a YouTube channel and want to grow their audience.

1. How to Make More Content

I care about the content I put on my channel. I want to share accurate information with state of the art quality, which means that I put pressure on myself to have great audio and video quality and that my voice-overs are on point.

I want to make it as comfortable and straightforward as possible for the viewer to follow along. Most of my videos teach something new to the audience, and it is essential to be able to focus on the content when learning.

On the other hand, I want to produce as much content as possible for my channel. I want to accumulate watch time on my videos, and I want to be able to help as many people as possible.

Those two things contradict each other. It is not possible to do both at the same time. You can get caught up in detail, or you rush your content and do not meet your quality goals.

So what can you do that helps to produce more content within the same time?

One of the best tips to speed up the video creation process is batch producing. Writing two scripts on the same day, and recording and editing two videos on the same day and scheduling them to go online in different weeks.

Make sure to have some reusable video assets that you can effortlessly put in your video. I have an end screen and an intro that I currently use in all of my videos. Once created, it only takes a few seconds to insert the clips into the next tutorial.

It is worth taking the time to do it once, but right and reusing it for future videos. It also helps with branding, as people start to recognize that multiple videos are from the same creator.

2. Why You Don’t Need Expensive Equipment

I bought a Rode Podcaster microphone, a microphone arm, and a Logitech C920 webcam. In retrospective, I would not invest as much money in my equipment early on.

To get a good result, you need to understand how to use your equipment. The more advanced it gets, the more complicated it is. I am glad that I bought a USB microphone instead of getting an XLR microphone. An XLR microphone would require additional hardware to plug it into a computer.

On the other side, the difference between the sound quality of a 50$ microphone and a 200$ microphone is not that big. As long as you do not record your voice using the webcam or an internal notebook webcam, your voice over audio quality will be good enough.

Don’t forget that the echo in your room is still a problem if you buy the most expensive microphone. So maybe work on that first? But again, don’t invest too much money at the beginning of your journey.

Hint: I purchased a 100$ webcam, but decided not to put a face cam into my tutorial. I could have invested that money into something else, for example, a software license or to pay a visual artist to do graphics for me.

3. Why You Should Create a Video Schedule

Something I want to do in the future is to have a content schedule. What I mean by that is taking the time to plan videos for three months in advance.

First, you create a spreadsheet with the weeks of the year and the video titles. The goal is to set time aside to fill in the schedule in advance and execute on that plan.

[IMAGE]

Having a schedule allows you to focus on creating the content instead of planning the content. It is a hack to separate planning from executing, and it should help you become more productive because once you sit down to create a video, you know what topic you talk about next.

Every week when your publication day comes closer and closer, you’ll feel uncomfortable if you haven’t started working on your video, and it naturally becomes a priority for you to start working on that video. Otherwise, you won’t make your plan. And guess what?! You won’t like that.

Hint: Do not plan too far ahead, because you might want to change direction, like doubling down on content that works for your channel or to follow a trend. A plan is a plan; it does not mean you cannot alter it.

4. Understand the Real Value of Thumbnails

Most YouTubers want to make you believe that you have to have the best thumbnails to get clicks on your videos. It might be right for people who search for content on YouTube that they will more likely click on an appealing Thumbnail than on a default thumbnail. Granted.

But when you start a channel, I think the most important thing is to get out as much quality content as possible as fast as you can. Sure, thumbnails are essential, but if you do not have enough content, it is tough to make enough watch time to become eligible for monetization.

Thumbnails look different from niche to niche. Also, you need to decide if you want your thumbnails to fit the style of your niche, or if you want to do something different and stand out with your videos on the YouTube search result pages.

In my opinion, it is not important how you make that decision, but make sure to choose a strategy, create a template, and stick with your style long enough to see if it works for you.

If your thumbnail strategy works for you – great, if it does not, make a change and try something different. YouTube offers enough analytics to let you make informed data-based decisions.

But please, don’t get obsessed with creating thumbnails to the extent that you do not have time left to create new content for your channel. That won’t take you any further.

5. What’s the Best Way to Monetize?

I am currently not making any money from my YouTube channel. When I will reach the monetization requirements and enable ads on my videos, I expect to make around 1$ a day. It is not a massive amount if you don’t have thousands of views per day.

Let me tell you that most CPMs (Cost per thousand ad impressions) are between 2$ and 10$ depending on the niche and how competitive the ad space is for your topic.

It means that if you have 1000 video views per day, you’ll end up receiving between 2$ and 10$ that day. It is not anything, but you won’t make a living off of 1000 video views per day (depending on where you live).

If monetization is the reason for your channel, I’d suggest trying something else than relying on YouTube ad revenue. For example, you could try to sell your own products, sell merchandise, or try to do affiliate marketing by putting links to other people’s products in your video description and mention it in your videos.

6. More Content Is Better Content

Sacrificing quality over quantity is not what I talk about here. But let me tell you that when you start a new channel from scratch, you need to get content into the channel as much as you can.

The more content you have on your channel, the higher the chance becomes that people on YouTube will find your channel. If they enjoy watching your video, they’ll eventually subscribe and continue to view your content.

My perception is that quantity brings in new people, while quality makes them subscribe, come back, and engage with your content in the future.

7. What Video-Editing Software Should You Use?

If you are new to video creation, you might have no idea what software you need to create videos, and if you start searching for software on Google, you will get overwhelmed.

Should you use something cheap or free like Windows Moviemaker or iMovie for Macs? Or should you learn a more professional video-editing software like Adobe Premiere Pro, Sony Vegas, DaVinci Resolve, or whatever?!

That’s at least how I felt I had when I started creating videos more than two years ago. Yes, I already started creating videos before I launched my YouTube channel in December 2018.

If you don’t know where to start, have no preference, and are on a budget, I recommend going with DaVinci Resolve. You can read a lot about why I switched from Adobe Premiere Pro to DaVinci Resolve in another article.

8. Should I Switch to Another Video Editor?

Many people who think about starting a YouTube channel do not know which video editing software they should choose. I am convinced by now that there is no best software and that it depends on the kind of videos a creator wants to make.

Nonetheless, I would suggest choosing a tool and sticking with it. If you know a tool, stick with it and use it. If you’re on a budget and want to use a powerful tool, I cannot recommend DaVinci Resolve enough. It is free, offers many features, and for me, it was easy to learn the basics.

If you learned something else like Windows Moviemaker or iMovie and it does everything you need, stick with it. There is no need to learn new tools if you don’t get something out of it.

You’d be better off creating content than wasting time looking for another software solution to solve a problem that your current tool already solves.

9. Don’t Get Overwhelmed by the Numbers

When you start your YouTube journey, you are at risk of starring at numbers instead of creating content.

It is crucial to have an eye on your analytics to makes adjustments to your strategy. Making a decision based on facts instead of personal opinion is always a great idea! But make sure you are not caught up in looking at your stats for longer than you spend time producing your content.

The stats I recommend paying attention to in the beginning is how many videos you upload and how many views those videos get. If you manage to create content that people like, double down on that type of content.

If a video does underperform compared to another of your videos, take a look at the CTR (click-through-rate). If it is lower compared to your other video, your thumbnail might need some improvements.

Otherwise, maybe your video targets a competitive keyword, and you cannot outrank the established channels. If that is the case, maybe niche down further and try to create content for a keyword that is less competitive.

In the end, it’s your goal to rank number 1 for your keyword if somebody searches for that keyword on YouTube.

10. Make Sure You Love the Process

It will take many, many videos until you finally start getting feedback on your content. People will eventually start liking your videos, subscribe or leave a comment. But it takes time.

You need to love the process of researching a topic, writing a script, recording and editing the video, recording a voice-over, and putting everything together – over and over again.

You even need to like the process of improving your process of creating videos. You need to become better at everything.

Make sure you produce videos in a niche where you relate to the content. People will not enjoy watching your content if you don’t love creating it. Also, who wants to have a successful channel that forces you to create more and more videos that you hate creating?

Keep in mind that creating YouTube videos is a lot of work and that everything that takes a lot of work is going to be more comfortable when you are passionate about what you do.

BONUS TIP: Branding Is Essential, but Not Everything

I know you want to have the best-looking logo, header image, and intro in your videos. I do think they’re necessary. I used a lot of time to get mine right. At least, they are acceptable for me to use them in my videos right now.

The truth is that you can always invent and improve your graphics over time. If in doubt, use your time to create quality content and not to improve your visuals by 1% using 10 hours of your time.

If you are not a visual designer, or if you do not want to get hold off creating content, consider hiring a designer on Fiverr or Upwork.

YouTube is the second biggest search engine in the world, and it cares mostly about content. Every video that holds the viewer on the YouTube platform is a win because YouTube can serve more ads to the user.

Become YouTube’s best partner by providing content that people love consuming.

If you read that far and want to know more about my journey, consider subscribing to my YouTube channel and follow me on Twitter.

This article was originally published on claudiobernasconi.ch on December 11th, 2019.

Also, as an Amazon Associate, I earn from qualifying purchases.

365 Days of Building a Software Developer Channel on YouTube

Claudio Bernasconi — Fri, 06 Dec 2019 12:34:20 +0000

It is almost a year since I uploaded the first video to my YouTube channel in December 2018. Considering the 40+ hours I put in for my first video, it is safe to say that I started working on my YouTube channel more than a year ago.

In this article, I am going to share the insights I gained from growing my channel from zero, how my channel growth in the last 12 months was, and what the future of the channel will be.

If you want to think about starting your own YouTube channel, or if you are interested in taking a look behind the curtains, this is for you.

How it all got started

The first video took me a lot of time to create. I worked on and off for about three weeks for my first video. Eventually, I uploaded my first video titled Introduction to Dependency Injection in C# on December 14th, 2018.

About a year later, I think it is time to share my thoughts about the success or failure of the channel and what I learned about creating a YouTube channel from nothing during the last year.

I wrote about the first few weeks up to three months of my YouTube channel earlier this year on my blog. You might want to read that article first to get a detailed overview of how and why I started my YouTube channel.

After being half a year on YouTube and having uploaded my 10th video by the end of June 2019, I wrote another article highlighting the experience and the statistics of my channel after being active for six months.

It was also the time that I switch from Adobe Premiere Pro CS 6 to DaVinci Resolve 15 for editing my videos. Later this year, I updated DaVinci Resolve to the most recent version 16 release.

I am delighted with the choice I made. You can read a lot about why and how I changed the video editing tool in another article I wrote in June.

A planned and an unplanned break

I always had in mind that I want to slow down during the Summer months. Summer is pretty short where I live, and I want to get the most out of it when it is there.

I like outdoor activities a lot and most sports I do require me to go outside. It is unnecessary to say that activities like cycling, running, inline skating or walking, all are much more fun when the weather is warm and sunny.

I also planned a 5-week trip to the west coast of the United States starting at the end of September until the end of October. What I forget is that a 5-week journey needs to be planned and structured in advance.

Because I decided to organize everything myself, I had to put in the work to plan the route, book hotels and a rental car, make sure everything with the flight and the immigration will work smoothly, etc. It was a lot more work than I expected.

Delicate Arch, Arches National Park, UT

To be fair to myself, this is/was my first longer trip to a foreign country in my life, and I learned a lot not only during the vacation but also while preparing for it.

Right before leaving for the United States, I decided to build an electric standing desk for my workplace. I will share this exciting journey soon. If you don’t want to miss out on this beautiful new setup, follow me on Twitter, where I will share all about it soon.

In the end, what was planned to be a 6-week summer break and a five-week vacation in Autumn became glued together to a 4-month break, including vacation preparation from July till the end of October.

Hint: Don’t beat yourself up, if real life happens, and you need to take a break from YouTube. Nonetheless, come back strong after that break and continue to produce as much content as you can.

Getting back on track

After coming back from the United States, I got back into video production mode. I created and uploaded my 11th video about How to Create HTTP Requests in .NET Core in early November 2019.

I plan to produce and upload two or three more videos before the end of the year. Most likely, this will require me to put in more work than I wanted before Christmas – but if you would like to reach your goals, you have to put in the work they say.

The channel growth

The last detailed report about my channel was at the 6-month mark. I had accumulated around 450 hours of watch time, and I had 200 subscribers on my channel.

At the time of writing this article, I just passed the 500 subscriber mark, and the accumulated watch time in the last 365 days is about 1400 hours.

YouTube: Watch time per day (in hours) over the last 365 days

Comparing the statistics of the 6-month mark with the 12-month mark, I see a 2.5x increase of the subscriber count and a 3x increase of the overall watch time.

Although I set the bar high to reach the monetization requirements by the end of the year (which require me to have at least 1000 subscribers and 4000 hours watch time during the last 365 days), I am satisfied with the results.

When I take a look at the last 60 days, the 510 watch hours break down to 8.5 hours a day, which is already pretty close to the 11 hours a day required by the monetization requirements.

Especially when I think about the extended break I took from producing content for YouTube, the channel growth is satisfying.

YouTube promotes great content

I have read many comments from small YouTubers complaining that they do not get enough views from YouTube and that YouTube favors more prominent channels over (their) smaller channels.

I believe it is true that once the ball is rolling, everything becomes simpler. But saying that YouTube does not support smaller creators is entirely wrong. I have a few videos that are optimized for YouTube Search and that are receiving great feedback.

Those videos are being watched enough by the audience that YouTube starts suggesting those videos to a broader selection of people.

It is what makes YouTube a magic platform. People that are interested in my content will eventually find it. I do not have to care about finding the viewers, I need to focus on creating great videos, and YouTube will be my partner in crime to find the audience. There is no short path to success, but the quality and consistency will win in the end.

Hint: Creating a (series) playlist allows you to tell YouTube that some of your videos belong together. If your viewers watch your video, they might also be interested in your next video in the playlist.

Playlists are a great tool to communicate to YouTube that people might be interested in another video of yours. Use them to your advantage.

Retrospective on the first year of my YouTube channel

I managed to produce 11 videos within my first year on YouTube. Initially, I set a goal to upload every other week, which would presumably result in having around 25 videos after a year. It turns out the goal was not realistic, or I did not reach it – if you want to judge me.

Nonetheless, I am committed to continuing building my YouTube channel in my second year. I saw that it could work. People watch valuable videos, and I can create content that people want to watch.

I have a few videos that generated a crazy amount of views. I could not have imagined a year ago that one of my videos about the new Visual Studio 2019 features would reach 8500+ views.

When I created this particular video, I was aware that the timing would be right because Visual Studio 2019 is about to be released. Still, I did not expect that so many people will end up watching my video when there are many other videos about the topic.

The future of my YouTube channel

Although I set a goal to reach the monetization requirements by the end of 2019 in my article from June, this is still my next big goal. I like challenging goals, but they should also be achievable. Otherwise, I lose motivation.

Therefore, I set the goal to reach the monetization requirements by the end of Q1 2020. I also set the goal to upload every other week. It will require me to put in more work, but it will also help the channel grow as desired.

More content means that more potential viewers will find my videos, and every new video contributes to the overall goal to reach monetization.

I also learned a lot about video editing, voice-over recording, screen recording, and video planning. All those learnings contribute to a more streamlined process and should reduce the amount of work required to put out new content.

How is this ever going to be sustainable?

The honest answer is – I am not sure if it will ever be. It is a lot of fun creating those videos. Creating videos is a creative process that requires different skills compared to software development. I learned a lot that I would not have learned if it was not for my YouTube channel.

I also believe that the documentation of this process, this blog, helps other people getting a picture of how starting a YouTube channel from scratch really is and maybe helps them avoid common pitfalls or setting realistic goals.

If you are a developer and consider starting your own YouTube channel, or you already have your channel, check out this Facebook group where you can become part of a group of highly motivated people.

One thing that I care about is how much value I provide with my contributions. I believe that my videos help people learning about software development that could not afford an expensive online course or a subscription to a membership program to learn how to program.

After all, my videos are watchable for free, and I believe that this opens up the chance for a big audience to learn something from me. There was no YouTube when I first learned how to program, and I comprehend that it can be a great source of quality information nowadays.

If it works out and people continue to watch my videos, the channel might grow to a size that allows me to earn a side-income from the ad revenue, or maybe get a sponsorship deal. Both would support me to allocate more time to the channel, which, in return, will result in more free videos for the community.

What makes a good video tutorial?

I created 11 video tutorials so far, and in my opinion, there are three essential parts of a high-quality video tutorial:

Audio quality. Most people believe that video quality is the most important aspect of a tutorial. In reality, people will bounce from your video if the audio quality is terrible, while they can live with a lower visual quality of the video.
Scripting takes a lot of time but ensures that a tutorial is on point and does not waste the watcher’s time. I believe that many people are happy with my tutorials because they get much value out of only a few minutes of video.
If you have source code in your tutorial, make it available for people. I would prefer if people write the code themselves, but the reality is that people are lazy. If you provide the source code with your video, people are more likely to play with your code and therefore learn something from you. If they learn something, they are more likely to follow your journey, subscribe to your channel, and will become a regular viewer in the future.

What do you think is the most important aspect of a high-quality tutorial video? Let me know in the comments below, or tweet it @CHBernasconiC.

Closing thoughts

Maybe I will look back to those articles in a few years with a smile in my face how different I thought at the beginning of the journey. I am excited to ride along on the YouTube journey during the next few months, and I will work hard to achieve my goals.

If you want to know more about me and my journey and follow along, consider subscribing to my YouTube channel, and follow me on Twitter.

If you have any questions about this article, about creating a YouTube channel, or anything else – please hit me up on Twitter or leave a comment below this article.

This article was originally published on claudiobernasconi.ch on December 4th, 2019.

Live Programming on Twitch Is Growing Fast

Claudio Bernasconi — Thu, 06 Jun 2019 07:18:23 +0000

Streaming on Twitch has become very popular. What once was a hobby for only a few people has transformed into a big industry with countless full-time streamers.

If I think about streamers and Twitch, I think about entertainment and gaming, most likely eSports. What started as a gaming platform has transformed into other fields, including programming.

The Rise of Programming Channels

There are more and more programming channels where software developers develop, test, and deploy software live in front of their community. Some developers involve their community and ask them for contributions. There are even game developers streaming on Twitch.

While researching for this article about 500-3000 people were watching one of the programming channels. Sure, Fortnite, Dota or Counter-Strike have a more extensive fan base, but depending on the time and weekday 1200 people are not that bad at all.

Twitch organized their channels in different categories. A streamer has to choose a category that fits his content. For gamers, it’s usually the game title their playing for example Fortnite. For technology related channels, there are two dedicated categories available. There is the Science & Technology category, and there’s the Basic Programming category.

Why Do People Watch Programming Channels?

People like watching other people doing things online. It’s the main reason why people watch streamers like Ninja or Shroud playing video games. They want to be entertained – they want to watch a show.

Most streamers are online for several hours, which means the show is much longer than any regular tv series. People can be entertained for an extended period.

Some people also want to learn from other gamers. Shroud, for example, is known for his outstanding aiming capabilities and his short reaction times. People think that if they watch a better player play the same game the play, they can learn something.

I watch professional Counter-Strike players streaming on Twitch to find out lucrative spots on different maps and how to react to certain events during a match.

One of the most exciting thing about streaming is that the community can interact with the streamer. If you enter a channel, you can take part in the discussion in the chat. Moderators keep the chat clean and remove people who do not respect the rules of a chat room. You can also ask a question which might get answered by the streamer.

How Do Streamers Make Money?

You can donate money or subscribe to a channel for 5 dollars per month which both supports the streamer. Some streamers earn enough money through subscriptions that they can do it full-time.

People return to their favorite streamers because they can see the person making progress. It’s interesting to see how other people play a game that you don’t have the time or money to play yourself. It’s also interesting to see how a player solves a level that you’re not able to do it yourself. You get tips for your next gaming session.

What’s the Difference between Live Streaming and Videos?

It’s very interesting to see people creating software on Twitch. You can take part in a project and see how something gets built from the ground up.

The most significant difference between videos on platforms like YouTube or Pluralsight is that not everything works as expected. Videos on those platforms are cut and errors removed from the final video.

Usually, YouTube videos are too perfect. When I watch a video, everything works, and I feel like I am the only person who does not get all things right the first time.

Watching a person live coding is an entirely different experience. You get to see all the errors, mistakes, and thoughts needed to create some piece of software. You also have the opportunity to ask questions while the person is doing something.

You can also comment on videos or video courses, but the time it takes to get an answer is usually much longer compared to a question asked in the Twitch chat while the other person is working on the project.

How Can You Get Involved?

If you are a software developer and want to get involved in Twitch, I would suggest to go to Twitch.tv and browse through the available channels. I also included a list of streamers that are popular or that I can personally recommend at the end of this article.

Maybe you want to take it a step further and want to live stream yourself? Great! I’d say that the programming community is still underrepresented on Twitch and that it’s possible to build a community yourself if you’re passionate about building software in the open.

Try it and see if you like it.

Recommended Programming Channels

In my opinion, any good article about programming on Twitch should include a few recommended channels.

The following list contains programming channels that I either watch myself or that have a good reputation listed in no particular order.

Kent C. Dodds JavaScript, web development, React, open source, node.js
Shmellyorc Game development, C#, Full stack development
HardlyDifficult C# & Unitiy game development, C# development, Cryptocurrency
Jeff Fritz C# .NET, .NET Core, Visual Studio
Kazuken ASP.NET Core, JavaScript, web development, technology talk
Lana Lux Game development in Unity using C#
Mike Jolley VS Code theming, VS Code extension development, C++, PowerShell
David Ortinau User experience, Xamarin.Forms, MVVM, Native Mobile development
Tim Beaudet C++, Python, TurtleBrains game development
James Montemagno Xamarin.Forms, SignalR
DevChatter C#, ASP.NET Core, web development
Ardalis ASP.NET Core, Azure
RamblingGeek C#, Azure, Docker, bot development

If you’re a streamer yourself, reach out to me, and I will add you to the list.

In addition to this list, there is a popular article on Medium which features many more popular and exciting programming channels.

What do you think about programming on Twitch? Let me know in the comments below.

This article was originally published on claudiobernasconi.ch on May 29th, 2019.

How I Earned 2000$ with a Mobile App

Claudio Bernasconi — Mon, 03 Jun 2019 08:24:48 +0000

I usually blog about .NET related topics on this blog. I got asked by a friend, why I did never blog about my mobile app, and how I earned 2000$+ with it. Well, I guess it’s true, I never talked about it, and I never wrote about it (except this article from 2015).

I have to admit that my mobile app is not a .NET app, but an Android app written in Java and published in the Google Play Store.

It’s finally time to reveal all the secrets that made me rich so you can become wealthy too – I’m kidding. This article gives insights into my experience programming, marketing, selling, and rewriting my first mobile app.

I also share what I’ve learned during the process and what I would do the same again, and what I would do differently in another mobile app project.

Did I really earn 2000$?

Let’s talk about money first. Yes, I made more than 2000$ in sales with a simple mobile app in the Google Play Store. Let’s dive deeper into what money went into my pocket.

Back in November 2010, I released my first (and only) mobile app to production. After the initial release, I made several updates and a complete rewrite in Spring 2017.

Let’s take a look at the earnings. The following data shows the sales, which means that 30% of the amount went to Google, and 70% of the amount went into my pocket.

My currency is CHF, and all the data is provided in CHF. At the time of this writing, the USD is 1:1 to CHF, so it makes it easy for people to understand, and I do not need to convert those numbers. I use USD in this article.

Year	Sales
2010*	303.85$
2011	1178.08$
2012	451.08$
2013	209.38$
2014	122.35$
2015	113.19$
2016	42.48$
2017	18.21$
2018	18.15$
2019	3.90$

*only November/December

As you can see, I made most of the profit in the early months after the release. Within the first 14 months (end of 2010 and the complete 2011) I made about 1480$ in sales.

In total, I made about 2179$ in sales, which is a net profit of 1525$.

It also means that between 2012 and today I only made about 700$. There are a few things I learned that I want to share with you:

Make sure that your app is working and feature-rich when you first launch it. Sure, you might use agile development practices, but your app should be working and have a minimal feature set. My app got pushed in the market, and therefore, I got many downloads in the first few months. If the app did not solve a real problem, people would not pay for it, and the store would not have recommended my app to new people.
Developing an app is not only writing its first version and never touch it again. It’s not a money machine like real estate or something else like that. I did not care about the app after it’s launch, which was a mistake. I would suggest planning to work on the app after it’s release as long as it’s in the store. I only did a few bugfixes, but I never made any more significant improvements, and I never added additional features. I guess that’s the reason why after only 1 year the sales dropped significantly.
You can make some side money, but you won’t become rich from a single app. Sure, if you build the next Uber with an entire engineering team and funding, the sky is the limit.

But if you’re an independent developer without a team and you develop your app in the free time don’t expect to make that much money from it. I have to say that 1000$ per years seems pretty neat to me, and I did never expect to make more than a few dollars out of it.

The app I made

I made CarParking Schweiz, which is a directory for parking lots in Switzerland. If you open the app, you can see which parking lots are open and how much parking space is available.

More screenshots available on Google Play.

Besides the listing, I also included a map view that shows all the parking lots, and if you press on a parking lot, you can start navigation to it using Google Maps.

The app has a one-time price tag of 1.95$. I don’t like subscriptions myself and I think most consumers do neither. Therefore, I decided to go with a paid app with an upfront cost. 2$ is a small amount in my country and I might even be able to raise the price, which I never did.

How I got the idea

I wanted to create something for myself that helps me finding a parking lot when I visit different areas in Switzerland. In the cities, there is often traffic jam, and I was sick of searching for parking opportunities. I wanted to jump into my car and drive to the closest available parking lot to my destination.

What I learned from it:

It is crucial to have a clear goal in mind. Your app should solve a problem for the user. It does not matter how hard that problem is to solve; it is essential that the app solves the problem.
The motivation to finish the project was to be able to solve a real-world problem for me and to learn how to develop mobile apps. At the time of the release of this app, mobile apps were pretty new, and I wanted to gain some experience developing a mobile app.

How I developed the app

Back in the days Eclipse and the Android Developer Tools (ADT) were the way to go. I installed that software on my computer, and I was ready to go.

Everything I needed to know to build an app was the programming skills that I already had and the online documentation of the Android platform, and of course, an Android device to test the app. Back in the days, I used an HTC Desire, which was my first smartphone.

The rewrite in 2017

After a few years, I got back to the project and thought about modernizing the app. There were new Google Maps APIs I had to use. The old API was retiring, and there were other platform changes like the physical buttons that disappeared from the devices.

I got back to the code base and let me tell you; it was a pain to develop with Eclipse and ADT. The tools were bad in 2010, but they did not improve in 7 years. At least not to something I wanted to use. I was used to Visual Studio, which developed a lot and offered many more features.

It was time to try the new Android Studio. I installed Android Studio and decided that the app was that old that I would write it from zero. I opened up the IDE and started working. Except for a few resources, I completely rewrote the app to fit the current platform requirements.

When I completed the project and released version 2 of my app, I hoped that it would gain traction again and make a few sales. As it turned out and as I described above, it did not go according to plans.

Things I would consider for a new project

Going into a new project I would consider the following key learnings:

Make sure to solve a real-world problem. If the app solves a problem, there is a potential market for it.
Your app has to solve the problem well. There are millions of apps in the store, and you want people to install your app. It has to stand out and do it better, faster, or in a unique way. Marking people would refer to this point as a unique selling proposition (USP).
You can make money as I explained in detail above. People are willing to spend money on apps that solve their problems. Sure, there might be free apps available, and if you do not want to make money, you can always create a free app.
But if you want to sell your app, make sure to get the pricing right. In my case, I sell my app for 1.95$, which worked for me pretty well. I have to admit that I never tried a higher price. Make sure to test what works for you best and do not hesitate to change the price often when your app is new.
Completing a project like developing an app from start to finish helped me to understand the project lifecycle of the software in general. I had to do everything from planning to designing, developing, and marketing on my own, and I have learned a lot. This knowledge helped me a lot to understand business processes in the company I was working for in my day job.

Technology choices

If I created a new mobile app today, I would try Xamarin. Microsoft acquired Xamarin in 2016. Xamarin development was very pricy before Microsoft bought it. After the acquisition, most of the resources such as the Xamarin University, became free for developers.

Also, one of the downsides of my Java code for the Android platform is that the app only runs on Android smartphones and tablets. It was always my goal to bring the app to the iPhone, but without a Mac, I could not compile the app, and I would have had to rewrite the code in another programming language.

Xamarin and Xamarin Forms offer a compelling platform to develop a single code base, cross-compile to either Android or iOS, both resulting in a native app for the respective platforms.

Conclusion

This article explains how and why I created my first (and only) mobile app back in 2010. It also reveals how much money I made from it and that it is possible to make money with a simple app.

If I come across another problem I want to solve; I would consider writing a new app again. It was a fun experience, and the few extra dollars helped me to pay my bills during my time at the university.

Although it is still possible to write Android apps in Java, as an experienced .NET developer with a heart for C# programming, I would try Xamarin and Xamarin Forms for my next mobile app.

Let me know in the comments if you also wrote an application, which technologies you used, and what your results were.

This article was originally published on claudiobernasconi.ch on May 22nd, 2019.

Modernizing Existing Windows Desktop Applications

Claudio Bernasconi — Tue, 21 May 2019 14:16:52 +0000

In my last week’s post, I wrote an overview of different frameworks for .NET desktop applications. As soon as my article was published, Microsoft announced big news for Windows desktop developers.

With the recent Microsoft announcement of .NET 5 which will be released in Autumn 2020, Microsoft will unify the developer experience for all supported platforms.

Going forward, .NET 5 will support targeting Windows, Linux, macOS, iOS, Android, WebAssembly and more all with the same .NET 5 APIs.

This image grabbed from the announcement shows the unified .NET platform featuring desktop development, web development, cloud, mobile, gaming, Internet of Things, and Artificial Intelligence.

In this article, we’re going to focus on what implications this has for existing Windows desktop applications and what we as developers can do to prepare ourselves as well as our applications for the move to .NET 5 and why we should consider doing it in the first place.

What about .NET Core 3.0?

Microsoft has announced the release of .NET Core 3.0 for September 2019. .NET Core 3.0 allows us to migrate our existing desktop applications by adding WinForms and WPF support to .NET Core.

".NET Framework 4.8 will be the last major version of .NET Framework."
– Scott Hunter, Director of Program Management .NET

On the other hand, he also mentions that:

"If you have existing .NET Framework applications that you are maintaining, there is no need to move these applications to .NET Core. We will continue to both service and support .NET Framework, which includes bug–, reliability– and security fixes."
– Scott Hunter, Director of Program Management .NET

So we do not need to migrate our applications, but if we do, we get to use all the benefits that come with .NET Core such as side-by-side deployment, new features, performance improvements, and cross-platform support.

In my opinion, migrating to .NET Core 3.0 is the first step in preparing an application for the new .NET 5 world. For any application that will be in production for more than just a few years and that is in active development I suggest migrating to reap the benefits of all the new .NET Core implementations.

Microsoft also offers us to further develop our WinForms applications after the migration to .NET Core 3.0. Because of the WinForms support we can develop our WinForms applications as long as we do not need newer platform features like the Microsoft Store, proper multi-monitor support or other features from the new Windows 10 APIs.

Before the announcement of .NET Core 3.0, the only option was to migrate WinForms applications to UWP applications if you wanted to run them on .NET Core and make use of new APIs. The release of .NET Core 3.0 gives us the option to stay on WinForms as a UI framework.

For applications that are no longer in active development, but more likely in maintenance mode, it is not required to migrate them to a newer version of .NET. Security patches will still be available for the (full) .NET Framework.

What are the benefits of .NET 5?

The announcement states three key improvements in .NET 5:

A single runtime and framework for all platforms
Take the best out of .NET Core, .NET Framework, Xamarin, and Mono
Provide everything in a single open-source code-base

In short: All projects should be based on the same project files, have the same APIs available to them, and benefit from the same performance improvements.

If you want to dive deeper into the announcement of .NET 5, make sure to check out the official Microsoft announcement.

In my opinion, .NET 5 brings developers closer together. Whereas Xamarin or UWP developers, as well as ASP.NET Core developers, enjoyed new tools, framework releases and APIs, WinForms and WPF desktop developers often felt left outside. .NET 5 will change that.

Today, you need to learn slightly different project file structures, different APIs, and different tools when dealing with different project types.

With the unification of all the targets and platforms, every developer will have the same tooling and the same APIs available to them. It’s a vast improvement.

.NET 5 closes the gap and allows for much simpler knowledge transfer between those targets and project types.

Again, for me, it’s a no brainer to migrate all existing applications that still are in development to .NET 5 when it’s been released in 2020.

XAML Island

XAML Island allows us to use UWP controls in Win32, WinForms, and WPF applications. It also allows us to access UI related Windows 10 APIs from existing applications. Without XAML Island, those APIs were exclusively available to UWP applications.

XAML Island provides a way to modernize applications that cannot be rewritten as a whole but could benefit from access to controls based on Windows 10 APIs.

Thomas Claudius Huber has written an in-depth blog post about how to use a UWP control in an existing WPF application.

If you have newer applications and older applications it can be a viable use-case to migrate some controls within older applications to UWP controls instead of rewriting the entire application all at once.

It is worth mentioning that XAML Island 1.0 is released as part of Windows 10 version 1903. Any version prior will not support XAML Island.

Conclusion

Desktop developers often felt left out from all the shiny new things .NET Core had to offer. There were only a few new features for .NET Framework-based applications.

With the announcement of .NET Core 3.0 and its support for WinForms and WPF applications, Microsoft shows a migration path for existing Windows desktop applications which allows those applications to benefit from all the .NET Core improvements.

With XAML Island Microsoft offers another way of gradually modernizing existing .NET desktop applications by allowing them to use UWP controls.

In my opinion, there is a bright future for .NET and desktop development on .NET. With .NET Core 3.0 we get the chance to benefit from all the improvements of .NET Core. And with .NET 5 Windows desktop developers are finally on the same page with all other .NET (Core) developers.

This article was originally published on claudiobernasconi.ch on May 15th, 2019.

.NET Technology Stacks for Windows Desktop Development

Claudio Bernasconi — Fri, 10 May 2019 11:32:36 +0000

Despite the trend in modern software development to the web and mobile platforms, desktop applications are still all around us. When it comes to Line-of-Business-Apps, many applications solely run on Windows desktop machines.

Most developers have to deal with existing applications. When we read the news about upcoming changes to .NET Core or the shiny new things like Blazor or Web assembly we kind of feel left out.

What we need to keep in mind is that there is also innovation happening in the .NET development for Windows desktop applications. When it comes to migrating old projects to newer frameworks or when we have to choose a stack for an entirely new application we have many choices.

This article intends to give an overview of all the choices available and to give (sometimes opinionated advice) on when to choose which technology stack for your (next) application.

In this article, we’re going to take a look at the following technologies:

Win32 and COM
WinForms
Windows Presentation Framework (WPF)
Universal Windows Platform (UWP)
Electron (.NET)
Avalonia

Win32 and COM

The oldest still viable approach to build a Windows desktop application is using C++ and the Win32 APIs. Granted, it’s not the newest and hottest technology stack, but it’s still in use, and the applications run on most Windows versions.

Win32 has been introduced in late 1995 with the release of Windows 95 and is available in all following Windows releases including Windows 10.

Modernizing an application written using C++ and the Win32 APIs is a hard task. I do not know about anything else than rewriting the entire application using another technology stack. Most newer technologies require either Visual Basic .NET or more often C# as the programming language.

If you have another migration path than a complete rewrite – please write it in the comments below this article.

Windows Forms (WinForms)

WinForms is the Windows desktop technology stack introduced with the .NET Framework in 2002 to make desktop development much simpler. After about 15 years of closed source development, Microsoft announced to open-source WinForms on December 4th, 2018.

WinForms allows the developer to get results quickly. Visual Studio has a built-in editor which enables us to drag and drop controls from the toolbar onto the dialogs. By double-clicking onto the controls on the dialog, Visual Studio generated click handlers in the code which allow us to write the application logic.

The advantages of WinForms are obvious: Rapid prototyping, gaining fast results and the opportunity to work with a graphical editor in Visual Studio to create the user interfaces. WinForms apps run on all Windows computers with an installed .NET Framework.

Because Microsoft started to bundle the .NET Framework to the Windows operating system nearly every computer runs at least one, most of the time multiple version of the .NET Framework.

The downsides of WinForms are the limited design options, the close relationship with Visual Studio which makes application development outside Visual Studio nearly impossible, and generated code which can be a pain using version control systems when multiple developers collaborate on the same project.

In my opinion, WinForms is still viable if the developer wants or needs to get a quick result, has limited experience in UI programming or programming in general and if the user experience requirements are not that big.

Microsoft announced that starting with the release of .NET Core 3.0 there will be an option to run WinForms applications on .NET Core instead of the (full) .NET Framework.

In my opinion, every application that is still being developed and runs on WinForms should be migrated to .NET Core or at least have a strategy in mind how to approach it. .NET Core has so many advantages that in most cases you don’t want to miss out on them.

Windows Presentation Framework (WPF)

With the release of .NET Framework 3.0 in 2006, Microsoft introduced the Windows Presentation Framework (WPF) as an alternative to WinForms for Windows desktop development.

The main difference between WinForms and WPF is the design language. For WinForms apps, we use the graphical designer, and for WPF applications we use XAML as a markup language to describe our user interfaces.

The advantages are obvious. Using an XML-like languages developer have full control over the structure of their user interfaces. Custom designs were enabled by WPF and implementing custom controls to build richer user experiences became possible.

Using the data-binding mechanism and utilizing the MVVM design pattern WPF applications allow developers to split their code between user interface design code and business logic. Application logic can and should be written in class libraries with no dependency on any user interface framework. It allows for more maintainable and reusable code.

On the other side, development becomes much more demanding and requires more knowledge. Gaining results can be hard in the beginning, and there are always multiple ways to solve a problem. WinForms is often limited but forces you to a more straightforward solution on the other side.

WPF gives enormous power to the developer which allows for the option to create amazing user interfaces. If the developer puts too many elements on his dialogs or if he loads too much data at once the applications quickly feel slow. Also, WPF applications typically take longer to start compared to WinForms applications.

For a long time, WPF was the quasi-standard when it came to Windows desktop development. I worked on WPF projects from 2008 to 2018, and there are many successful projects still running on WPF.

If you need to create an application that only runs on Windows desktop computer, WPF is still a viable choice in 2019.

Microsoft announced that starting with the release of .NET Core 3.0 not only WinForms, but also WPF applications can run on .NET Core which means WPF applications can take advantage of the performance improvements of .NET Core. It’s a great thing when keeping in mind that performance is one of the most significant downsides of using WPF.

Universal Windows Platform (UWP)

UWP applications are a modern alternative to WPF and WinForms applications. UWP replaces the Windows Runtime (WinRT) and requires Windows 10.

UWP apps can be distributed using the Microsoft Store and are an excellent choice for end-user applications because the distribution of the application can be done using the Microsoft Store. It feels a lot like mobile development but for desktop computers.

UWP also runs not only on desktop computers, but also on the Xbox One, and other Microsoft devices.

UWP apps can be developed either in C# using XAML which feels a lot like writing a WPF application (with a few restrictions) or using JavaScript and HTML.

I wrote a big Introduction to the Universal Windows Platform article a few weeks ago on this blog. If you want to dive deeper into UWP apps you might want to check it out.

You’ll also find my recommendation on when to create a UWP app instead of a WPF application in the article above.

Electron (.NET)

Electron allows developing desktop applications with web technologies (HTML, CSS, and JavaScript). Electron runs your application on Chromium as a node application which means that Electron opens a browser window and lets you run your web application similar to a native desktop application.

The advantage is that Electron applications are cross-platform and also run on iOS and Linux. Some of the better-known applications using Electron include Slack, GitHub Desktop and Visual Studio Code.

On the downside, we have heavy CPU and RAM usage because the behind the scene running Chromium process consumes a lot of resources. Electron applications run on Windows 7 and newer.

Well, how is this technology related to this article? The answer is Electron.NET.

Electron.NET allows us to develop Electron applications using ASP.NET Core. We can write C# and have the same APIs as Electron offers to JavaScript developers. In general, Electron.NET comes with the same advantages and disadvantages compared to Electron.

Electron.NET can be a viable migration path for web applications that need access to computer resources that are not available on the web. It’s also an excellent technology for experienced web developers who want to get started with (Windows) desktop development in .NET.

Avalonia

Avalonia is a cross-platform XAML Framework for .NET Framework, .NET Core and Mono. Avalonia has a similar look like WPF or UWP interface definitions because it utilizes a XAML dialect for the view definitions. It also supports MVVM, data-binding and much more.

Avalonia is new which means that they do not have a lot of legacy code in their framework. Unlike WPF where there is code older than a decade that cannot be removed because of compatibility issues.

I haven’t use Avalonia in my projects, and therefore I cannot go into much detail about if I would suggest to use it for production (yet). Keep in mind that Avalonia states on their website that their framework is currently in beta phase.

What I can say though is that it’s an alternative for developers who want to go for a newer, more cutting-edge option instead of using the established WPF or UWP technologies and are not keen on putting their app in the Microsoft store.

Summary

That’s it. We covered many older and newer technology stacks which enable developers to write desktop applications using .NET programming languages. All of them come with their unique set of advantages and disadvantages.

When it comes to starting a new project, WPF and UWP are choices I would recommend if you’re not sure where to start. WPF is very mature, and there is a lot of knowledge available on the Internet. UWP is a great choice if you want to make use of the Microsoft Store.

For the classic forms over data application, WinForms can be a viable choice too. Just make sure if WinForms can fulfill all the customer requirements before choosing WinForms over WPF or UWP.

For experienced ASP.NET (Core) developers stepping into the desktop world, Electron.NET can be an exciting option. It’s especially true if the application should be cross-platform.

Avalonia can be a viable choice for experimental projects or developers who want to build their product using cutting-edge technology on .NET Core.

Let me know in the comments below which technology stack you like the most and which and why you use certain technology in your current project.

This article was originally published on claudiobernasconi.ch on May 9th, 2019.

Should You Listen to Music While Programming?

Claudio Bernasconi — Sat, 04 May 2019 09:37:01 +0000

Do you listen to music while working on your programming project? Is it okay, helpful or a bad idea? Are you an enterprise developer and are you able to make this decision or are you forced to sit in a quiet environment or listen to your boss’ favorite radio program?

I recently discussed the topic, and I was not sure on which side to put myself. From time to time I like having a quiet environment which lets me focus on a problem and dive deep into the internals of any given code.

On other days, I like having music in my ears. Sometimes it helps me concentrate on a specific problem and helps me avoid other distractions.

In this article, I’m going to discuss the pros and cons of listening to music while programming. Some information is based on a bit of research, and I also give my own opinion on the topic.

Pro

Listening to music can help you get into the “zone”. It’s a powerful state most developers hit from time to time where the world seems to be irrelevant and the only thing that needs to be done is the problem you’re working on.

Music also helps you reduce the impact of the environment on you. If you’re working in an open space office or in a noisy restaurant it might be helpful to reduce the noise around you and by listening to music you have control over what you hear.

Music can motivate you to get things done. Sometimes you think hard about a problem and cannot decide on which solution fits best and you end up in a deadlock in your brain. Music can help you get things done. The nature of tracks ending and rhythms changing can urge your brain to make decisions. I do not have scientific evidence for this, but I once read about it and I think it’s true for me.

You can block off co-workers. Seriously, depending on your office situation it can be helpful to isolate you against people lurking around and asking you stupid things. I am all for working together as a team and if someone has an important question he or she can always approach me at my desk. But how often people stop by just to talk to you about their weekend and other non-work related things? It’s happened to me, and I am sure, it happened to you.

Contra

One of the most heard arguments against listening to music while working is that you get distracted from work. Indeed, if most of your day consists of changing tracks, adjusting volumes, managing your playlist, and finding the newest music to listen to, it can be a big distraction.

Some people also claim that your brain cannot do multiple things at once and therefore it is generally a bad idea to listen to anything while doing work.

Different types of music

An interesting topic is the type of music you listen. Usually, I listen to different music while working than I listen to while working out or doing something else in my free time. It is personal preference, but I have my logic why this might be a good thing.

First of all, I do not care about the music itself. If you listen to the new album of your favorite interpret, I am sure you want to catch more of it than just a few bits. Therefore, you should listen to it in your free time.

In general, music with fewer lyrics tends to work best for me. If there is too much singing or rapping going on my brains needs too much energy to absorb the lyrics.

Office rules

I am not a fan of rules. It is especially true when it comes to working. In my opinion, every person knows himself best and is mature enough to do the right thing at the right time. But some offices have rules about using headphones or listening to music.

If the rules fit you, perfect, if not, I would try to speak up about it and provide arguments on why listening to music would help you do your job better. Sometimes you do not have the freedom to decide. You either accept it, or you move on.

Randomly generated playlist

I like the Flow functionality of Deezer. It’s an algorithm which selects music tracks for you. I think it’s trained based on my playlists but also on the music I listened to in general on the platform. It creates a good mix of different music styles which can run in the background and which help me to focus on my work.

I do not have to change tracks, and there are also new tracks mixed-in which makes it enjoyable even after a few hours or weeks. There is always something new in there, while some of the well-known tracks will be repeated over a few days.

Music to code by

I have never tried it, but as a regular listener to the DotNetRocks podcast, I know about Carl Franklin’s Music to Code by project. I’ve heard many success stories from people listening to those tracks which are “scientifically designed to quickly get you into a state of flow and keep you there”.

As I wrote above, I have not tried it yet. Do you have any experience with it? Let me know in the comments below. It might be worth checking it out in the future. I like the idea behind the project.

Conclusion

There is no right or wrong. There is no yes or no. If it makes sense for you to listen to music while working, you should do it. Some people will benefit, others don’t.

In my opinion, it’s up to you, how you want to work. With music, or without. The only important thing is that you make your decision on your own and that you make the most appropriate decision. Everyone is different.

Maybe it makes sense to listen to music for specific tasks while it’s best for you to have absolute silence when working on something different? Who knows?

There is no general answer to the question of whether you should listen to music while programming or not.

Let me know in the comments below how you deal with listening to music while programming. I am curious about your experience!

Other Resources

This article was originally published on claudiobernasconi.ch on February 20th, 2019.