Skip to main content

For this year's C# Advent, I decided to finally implement an idea that I've been kicking around for a couple of years now. It's a parody of Baz Luhrmann's Everybody's Free (To Wear Sunscreen) track from 1997. The "lyrics" are from a Chicago Tribune column written by Mary Schmich, entitled "Advice, like youth, probably just wasted on the young". Much of the advice in the original song has stuck with me over the years, and it continues to be relevant and entertaining.

I thought that a version created just for developers, programmers, coders, engineers would be fun. I commissioned the help of voice actor Noah Jenkins (on Twitter @GeekyVoices) to bring a voice to my writing, and I laid his voice over a karaoke version of the song. (By the way, if you need voicework, I can highly recommend him!)

Please enjoy! Make sure to check out all the other great entries into this year's C# Advent. I look forward to doing it again next year.

Lyrics:

Coders, developers, software engineers, and programmers in the year of 2020
Write unit tests
If I could offer you only one tip for the future
Unit tests would be it

The long term benefits of unit tests have been proven by studies
Whereas the rest of my advice
Has no basis more reliable than my own
Meandering, flawed experience
I will dispense this advice...now.

Enjoy the power and beauty of your code
But, never mind
You'll look back on your code in 6 months and wonder who let you near a keyboard.
But trust me, this means you're improving.
Seeing your past code as flawed just means that you are learning.
You are not as bad a coder as you imagine.

Don't worry about the future
Or worry
But know that worrying is as effective as trying to write the next Facebook on a TRS-80.
The real troubles in your career are apt to be things that you never learned in college or boot camp.
The kind where your team decides to deploy to production on Friday at 5pm.

Do something everyday that challenges you.

Draw.

Don't judge other people harshly in code review.
Don't put up with people who harshly judge yours.

Write docs.

Don't waste time on jealousy.
Some days you're killing it, some days you aren't.
The race is long
And in the end, it's only with yourself.

Remember the compliments, put them in a special folder.
Forget YouTube comments.
If you succeed in doing this, tell me how

Keep your old code in an open source repository
Throw away your unused domain names.

Take days off.

Don't feel guilty if you don't know what you want to do with your career
The most interesting people I know aren't doing at 40 what they thought they wanted to do at 22.
And many of them say they still don't know what they're doing.

Get plenty of C#

Be kind to your wrists
You'll miss them when they're gone

Maybe you'll start a company, maybe you won't

Maybe you'll get stock options and bonuses, maybe you won't.

Maybe you'll go into management.

Maybe you'll give up on computers completely and open a boutique when you turn 50

Whatever you do, don't congratulate yourself too much or berate yourself either
Your choices are at least partially chance, and so are everybody else's

Use your body
Use it on something manual and analog
Don't be afraid of stepping away from the computer, and what you might miss on Twitter
Honest labor will let your mind rest

Learn.

Even if your boss isn't going to pay for it
Read blog posts, even if you don't agree with them
Go to conferences, even if you spend more time in the hallway than the sessions
Education is not something you can ever finish.
DO NOT read the comments on Hacker News and Reddit, they will only make you feel terrible

(chorus)

Get to know your family
You never know when they'll be gone for good

Be nice to your siblings
They are your best link to your past
And the people most likely to stick with you in the future
Send a Snopes link if you must
But don't argue with their political views in public on Facebook

Understand that teammates come and go
But for the precious few you should hold on to
Work hard to bridge the gaps in geography and lifestyle
Because the older you get, the more you need the people that knew you when you were young

Work for a government agency once
But leave before it makes you grumpy
Work for a silicon valley startup once
But leave before it turns you into an insufferable hipster

Travel

Accept certain inalienable truths
Developers get distracted by newer frameworks
Bugs will always be around
You too will get old
And when you do, you'll fantasize that when you were young
New frameworks were always better
There weren't so many bugs
Certifications were important
And junior developers respected their seniors

Respect YOUR seniors

Don't expect anyone to hand you anything
Maybe you'll have stock options
Maybe you'll get V.C. funding
But you never know when either might run out

Don't be cocky about any once piece of technology
Or by the time you're 50, you'll be known as "that Windows Phone guy"

Be careful whose mentorship you seek
But be patient with anyone who supplies mentoring
Advice is a form of nostalgia
Dispensing it is a way of fishing the past from the garbage, wiping it off
Smoothing over the ugly parts and redeeming it for more than it's worth

But trust me on the unit tests

(chorus)

 

The Fourth Annual C# Advent

October 23, 2020 mgroves 0 Comments
Tags: csadvent csharp

This year's Advent is going to be a little different that the Advents in 2019, 2018, and 2017.

This year, the C# Advent has its very own site!

Not only that, but the process is more automated this year. Gone are the days of me having to maintain an Excel spreadsheet.

Step 1:

Go to www.csadvent.christmas. Find an open spot in the Advent, and click to claim it. You will need to login with GitHub. There are two spots every day, for a total of 50 spots.

Advent Step 1

Step 2: 

Fill out the request form. You'll need a name and email at least. You can also supply a URL for the link for your name (e.g. if people click "Matthew Groves", I want it to go to my Twitter). You can also add an optional comment. Only the Name and URL will appear publicly! Click submit.

Advent step 2

Step 3:

You should get a confirmation email. I will get an email too, so I can go in and approve your request (approval is a necessary, because there could be a date conflict, or there could be spammers, etc).

Advent step 3

Step 4:

When approved, you will get another email. Approval should be pretty quick if I'm awake (I'm in the eastern US time zone).

Advent step 4

Step 5:

Create your content. Don't publish it until the day you selected. Make sure to link back to www.csadvent.christmas. At any point, you can login to the Contributors Area to supply a link and title of your content.

Advent step 5

You do NOT have to do this until the day you picked. However! You will receive an automated email reminder 2 days ahead of time.

Step 6:

When it's your day, tell everyone about your article and the C# Advent! Tweet them! Submit others to Reddit! Facebook! LinkedIn! Whatever else! Let's show the world how great the C# community is! Please use the #csadvent hash tag when applicable.

Advent step 6

Thank you! Looking forward to another great Advent in 2020.

Note from Matt: This is a guest post by James Bender for the Third Annual C# Advent.

For those who don’t know me, I’m that guy. You know the type; the ones who is super OCD about their code, stresses component-based architecture that encourages reuse, and who’s into Unit Testing. I think a lot of problems in the world could be solved if we all just practiced Test Driven Development.

So, when Matt reached out to me about writing this post, the first thing I thought of was unit testing! And so that’s what this post will be about!

Everyone: GROOOAAAANNN

Hey! When you all start unit testing, I’ll stop harping about it!

While I prefer the idea of TDD, I understand that it isn’t always an option. People who are just starting off with unit testing might not feel comfortable with the “test-first” paradigm, which is totally understandable and completely fine. Some people (like myself) often inherit codebases where the code is already there, but there is not a test to be found. Sometimes, if feels like it would take a miracle to make these code bases even testable!

Behold, a Christmas Miracle!

Well, I may be overselling the whole “miracle” aspect, but this will still be pretty cool. We’re going to take some code and refactor it to make it more testable.

Here is our starting point:

This is an amalgamation of a lot of the problems I see with code that limit its testability. To be fair, this code as a lot of issues, but today we’ll just deal with the ones that limit its testability.

There are a variety of ways to deal with refactoring this, and not everyone will approach it the same way. In my case, the first thing I’m noticing is that the function we’ll be refactoring (ProcessDataExtract) doesn’t return a value. This can make it difficult to determine if my test passes; if I don’t have any output, how can I verify the method worked? Yeah, I could create a mock of the exportChannel object and ask it if its Save method was called, and what data it was called with. But this isn’t the best approach. I’m relying on a supporting object (the mock) to provide basic functionality that my test should be able to do without help. And what happens if there’s a change to ExportChannel causing me to change my mock? This makes this test difficult to maintain. So, for my first refactoring, I’ll be changing the return type:

On line 10, I change the function signature to return an IList of type string. I added a return statement on line 33 to return the results list that is sent to the Save method of the ExportChannel. This enables me to interrogate the results list directly to verify my test. It also makes ProcessDataExtract itself more useable by being able to provide (return) data as opposed to seemingly swallow it up.

The next thing I notice (frankly, it’s kind of hard to miss), is that I have some static dependencies. On line 8 I have a class-level reference to the DataStore service, and at line 12 (in the method body) I have another one to ExportChannel. These have got to go!

Those of you who might be new to testing might be asking why this is a problem? You’ve probably seen dozens of tutorials showing this being done. The problem is that this creates a very brittle piece of software that cannot adopt well to change. If I wanted to add a constructor argument to DataStore I would have to make a change everywhere this service is invoked. That could be dozens, if not hundreds of places. Another issue, which has a direct impact to testability, is that I may eventually have a situation where I want to use different specialized versions of this service in different situations. Creating a direct static dependency to DataStore in this manner makes that almost impossible.

In a testing environment I don’t want to use the actual production implementation of these services. They may make my test slow. Things like I/O operations, web service calls, and database access are notoriously slow. These are crucial for running the application but make testing difficult.

Another concern is that when I write a test, I ONLY want to test the specific code in my method; not the code in the dependencies, which should have their own specific tests. To solve these issues, when testing this code, I want to use mocked versions of these services. Mock are basically stand-in objects that can return canned values that the code can use to verify its logic. Mocking can be a very involved topic, and so I won’t got into a deeper discussion here. If you would like to learn more, please see the links at the end of this post.

But, with statically bound dependencies, how do I get the code to use my mock objects instead of the real ones when I want to run a test? The answer is to refactor our code to use Dependency Injection:

In this refactoring, I have added a constructor to the AppEngine class which takes a DataStore as a parameter. The consumer of this class will pass in an instance of DataStore (or an object derived from DataStore), which my class can use. Additionally, I added parameter of type ExportChannel to the method ProcessDataExtract. This again requires that the calling method provide an object of type ExportChannel. This enables me to pass in mocked objects as part of my test; my test will be the consumer of the AppEngine class and will be calling the ProcessDataExtract method.

As alluded to above, this not only enables to me to pass-in mocked values for testing, but also allows me to pass in specialized versions of those classes based on whatever my current context is, which enhances code reusability. This is especially evident with the ProcessDataExtract method. I may need to run several types of extracts with this method that would only very by the type of ExportChannel. Now, I can reuse this method and pass in whatever ExportChannel I want. This is similar to the Strategy Pattern, which you can read more about here.

So, this method is already looking a lot better. You might even think that we’re done, and there’s no way we can improve the testability of this method. But there’s still one problem. It’s subtle.

Do you see it?

Hint: What happens if I run this test now, and then run it again in an hour? Am I guaranteed to get the same results?

Look at line 17. This line creates a problem for me. The ProcessDataExtract function sorts records based on the current time. If I am using a mock of DataService to pass in a static, canned set of records the code is going to compare the current time captured on line 17 to the time in my test records. Time goes on, but my test data stands still, and eventually, my results are going to change, which could cause my test to act unpredictably.

When creating testable code, a good practice is to abstract away anything that might change. In this case, the value of DateTime.Now changes constantly. So, we need to take it out of our equation, at least for testing:

To solve this issue, I have removed the call to DateTime.Now on line 17 and made currentDate a parameter for the ProcessDataExtract function. This means that when I run my tests, I can pass in any date I want, which means I will be getting consistent test results. Like the previous refactor, it also enhances the reusability of this method. I’m no longer bound to the current date. I can run it for past dates and future dates without having to create a separate method.

And that’s it! With three easy-ish steps we took a piece of untestable legacy code and made it testable! Now, I know this was small example. But the concepts don’t care about the size of the code; there may be more work to do for some of these in larger code bases, but you will still be able to use these techniques to handle most refactoring situations.

Shameless plug: I you would like to learn more, please check out my book, which is available on Amazon.

Happy Holidays!

What is the C# Advent?

The C# Advents in 2018 and 2017 were so much fun. It's now time to sign up for 2019.

Just like last year, each day of the Advent calendar will have up to TWO blog posts. That means that there is a maximum of FIFTY slots! So, tell your C# friends and let's fill up this calendar.

A little history: I heard about the F# Advent Calendar, a tradition that's been carried on since 2010 (2014 in English). I think this is a great idea, and so I organized one for C#! (I asked Sergey Tihon for permission!). If you are running other developer advent calendars, just let me know and I will link to them here:

Let's Get Started

I need you to write a C# blog post, create a video, write an article, etc.

Here are the rules:

  1. Reserve a slot on Twitter (with hash tag #csadvent) or leave a comment on this post. You do not have to announce your topic until the day you reserve.
  2. Prepare your content (in English).
  3. Add a link in your content that links back to here, so that your readers may find the entire advent. You can host your content anywhere you'd like: your own site, dev.to, hackernoon, medium, wordpress, youtube, dzone, etc.
  4. Publish your content on the specified date. Your content must be related to C# in some way, but otherwise the content is completely up to you. I've posted a few ideas below to get your creativity flowing.
  5. Share your post on Twitter with hashtags #csharp and #csadvent

Below are all the slots, and who has claimed each date.

I will do my best to keep this up to date. The slots will be first come first serve. I also allowed last year's authors to get first crack. I will claim the last remaining spot for myself. I will prepare a post just in case someone has to drop out.

DateClaimed byContent
Dec 1, 2019 Brant Burnett Simon Painter  IAsyncEnumerable Is Your Friend, Even In .NET Core 2.x Hacking C#: Programming for the Truly Lazy
Dec 2, 2019 Luis Antonio Beltran Chris Ayers 2FA with Twilio Authy and C# (special guest: Xamarin) Dependency Injection, Architecture, and Testing
Dec 3, 2019 Kelson Ball Morgan Kenyon An Example of Partial Function Application in C# The Difference Between IEnumerable and IQueryable Explained
Dec 4, 2019 Ryan Overton Carl Layton Default Interface Methods in C#: Love 'em or Hate 'em? The Outbox Pattern in C#
Dec 5, 2019 Dave Cook Manuel Grundner To Null, or not to Null?!? The journey of porting pretzel to .NET Core
Dec 6, 2019 Lukáš Lánský Simon Timms Coverage-Driven Test Selection Machine Learning for Boring Applications
Dec 7, 2019 Chase Aucoin Kendall Miller Aurora Serverless with Entity Framework Core Better String Formatting with String Interpolation
Dec 8, 2019 Matt Eland Jeremy Sinclair Experimental C# with Scientist .NET Creating a Simple Wizard Component with Blazor
Dec 9, 2019 Meziantou Cecilia Wirén Thread-safe observable collection in .NET Overflow on integers - count with this security risk!
Dec 10, 2019 Andrew Lock James Hickey .NET Core, Docker, and Cultures - Solving a culture issue porting a .NET Core app from Windows to Linux Modular Monoliths And Composite UIs With .NET Core Razor Class Libraries
Dec 11, 2019 DotNetCoreShow Roman Stoffel The .NET Core Podcast - Episode 40 - Noda Time with Jon Skeet C# Loves Code Patterns
Dec 12, 2019 Brian Jackett James Curran Creating a C# Azure Function to Call Microsoft Graph Cleanup Scaffolded Code with modelbuild
Dec 13, 2019 Barret Blake Ed Charbeneau, Daniel Roth, Chris Sainty, Egil Hansen The Nightmare Before Blazor Getting Started with Blazor: All There is to Know From the Experts
Dec 14, 2019 Benjamin Howarth Martin Zikmund   A Christmas C# riddle
Dec 15, 2019 Jonathan Danylko Hilary Weaver-Robb 10 More Useful C# Extension Methods for 2019 Refactoring RestSharp Sample Tests to Make Them More Maintainable
Dec 16, 2019 Shahed Chowdhuri Ian Bebbington ASP .NET Core code sharing between Blazor, MVC and Razor Pages The Seven GUIs of Christmas
Dec 17, 2019 Joe Zack Chris Sainty Streaming process output to a browser, with SignalR and C# Introduction to Blazor Component Testing
Dec 18, 2019 Garo Yeriazarian Stuart Turner Vertically Sliced Command Line Tools in C# and .NET Core 3.1 Improving Code Readability with Linq (and MoreLinq)
Dec 19, 2019 Baskar Rao Stephen Lorello How to use Subscriptions in GraphQL C# Santa’s Nexmo Helper
Dec 20, 2019 Andrea Angella Layla 15 reasons why you should learn C# in 2020 Get off the naughty list with Twilio Autopilot, Azure Functions and Table Storage
Dec 21, 2019 Muhammad Azeez Patrick Lioi How do Object Relational Mappers (like Entity Framework) work? Patterns for using Entity Framework in C# 8
Dec 22, 2019 James Bender Eric Potter Refactoring for Testability – A Christmas Miracle! C# Strings with Ranges, and Indexes
Dec 23, 2019 Andrew Craven Lee Englestone Microservices and Outside-in Tests Using C# and Docker Compose Compiling Code without Visual Studio
Dec 24, 2019 Thomas Carpe Azmat Ullah Khan   PDF Digital Signatures with Itext7, Bouncy Castle and .NET Core
Dec 25, 2019 Mike Jolley Calvin Allen Adding HATEOAS to an ASP.NET Core API C# 8 is old news. Onward, to C# 9!

Alternates:

  • IF ALL FIFTY SLOTS FILL UP, please leave a comment or tweet with #csadvent anyway and I'll put you on this standby list:
  • Standby list:
    • Myself.
    • You, if you want to be.

Some ideas/topics to help inspire you:

  1. Blazor - C# for the browser
  2. Your latest open source contribution - show the community how you contributed and why
  3. Your favorite C# language feature - it doesn't even have to be a new feature, just blog about something you love about C#
  4. Introduce your favorite NuGet package / library. Even if it's a library you take for granted, not everyone has heard about it.
  5. How to avoid a pitfall you found with performance/memory/etc
  6. Integration/deployment of a C# application with Jenkins, Docker, Kubernetes, TeamCity, Azure, etc
  7. Write a "how to" for one of the many tools discussed in an episode of the Cross Cutting Concerns podcast or the DotNetBytes podcast
  8. Interview someone about C# and post the audio or a transcript.
  9. Implement a simplified example of a design pattern in C#

Thanks to everyone who is participating!

If you were an author of a C# Advent blog post in 2018, you get a chance to sign up earlier than the general public.

Tweet #csadvent or leave a comment below with the date you want to blog on. Each day has up to TWO slots. If someone has already claimed the day you want, that day may still be available.

The general call for C# Advent authors will go out soon, so please claim your dates as soon as possible. Just like last year, you do NOT have to pick a topic right now. If you DO want to pick a topic, I will pencil it in, but you are free to change it at any time up until the date you pick.

Matthew D. Groves

About the Author

Matthew D. Groves lives in Central Ohio. He works remotely, loves to code, and is a Microsoft MVP.

Latest Comments

Twitter