Video timestamps

• Pretty Logs
• Pretty Diffs
• Staging
• Searching
• Automation
• Dot Notation
• Rebase Onto
• Reflog
• ReReRe
• Summary

In his NDC talk, Philippe De Ryck provides a good summary on why we should:

• no longer use the implicit grant
• use backend-for-frontend for security-sensitive web applications

You don’t get to laugh a lot while watching a conference talk on DDD. I highly recommend this very dynamic talk by Alberto Brandolini at DDD Europe. Event Storming and pineapple don’t mix well.

What checkout actually does. Here is a past comment with links to the courses (they are pay-walled, unfortunately)

I don’t think I read that one. I created a separate link-post for that one. Thanks.

Mine happened when I watched Paolo Perrota’s Git courses on Pluralsight. That’s when it clicked for me.

This is a fun way to explain how technical debt accumulates in our systems. Not having good understanding of the domain results in low code quality and difficult to maintain code bases.

After the talk, one of the contributors says “you are preaching to the converted.” But we, engineers, need to learn how to communicate these concerns with the rest of the organization.

Good talk. Watching refactoring is fun.

I feel like most of what he talks about is common knowledge now. But then again, I stumble upon code written by experienced developers that is just like the one he started with: unclear responsibilities, poor encapsulation, etc. What is even worse is: I sometimes catch myself writing code like that :)

What we do requires continuous attention to detail. We sometimes get tired or lose focus. And that may result in poor quality code. However, that’s only one reason to end up with such code. I think the other (and more common) reason is accumulating functionality. Einar Høst’s talk about technical debt touches upon that aspect. You start with a beautiful model. But then if statements start raining on it. If we are not diligent, we end up with a mess.

I mainly develop in C#, and I agree that having to write so much boiler plate for type safety is really boring. C# is not perfect either (it doesn’t have discriminated unions, etc.) but at least it gives type safety out of the box.

However, in general, I think enums are widely misused. I see a lot of cases where they should have been classes with a factory, but ended up being enums with a lot of static functions and switch statements.

Because it is about a not-very-well-known feature of the language. Why would it matter that it’s old? I don’t think I have ever seen this in use in production code.