The work journal 2024-03-27T16:03:51 conversation: 01ht0afgwryks5fepkvvm0kn28 by Simon Willison (GitHub) describes the author’s process of using AI prompting to write a console text-wrapping algorithm.

He prompted with “JavaScript that takes a big string of text and word wraps it at the specified width, adding newlines where necessary.” The answers meandered around a solution space that seemed over-engineered and not particularly fruitful—the answers all used regular expressions, which seems kind of like overkill, when... [More]

The article Prefer test-doubles over mocking frameworks by Steve Dunn writes,

“This is testing implementation and not behaviour. Your SUT called something and there is likely an observable side-effect of that. Test the side-effect and not that a particular method was called. If the code is refactored (e.g. you change the implementation but not the behaviour), then your test that checked that a method was called will likely break, but your test that tested the behaviour should remain unchanged and should... [More]”

The Talk − Bringing C# nullability into existing code by Maarten Balliauw is a 66-slide deck that I summarize as follows:

• The C# nullability feature is for build- and design-time. It does not enforce anything at runtime. That means that you still have to check parameters for null.
• The C# nullability feature is available to solutions working with .NET Framework and .NET.
• For .NET Framework, you have to explicitly set the <LanguageVersion> to 8.0 (however, there are a bunch of cons associated with doing this, as... [More]

Introduction

This article defines concepts like repository and working tree and then discusses how you can use .gitignore files to determine the files and folders that Git considers during operations.

Concepts

From a command line, you can run git init in any folder to make any folder a Git repository. Doing so creates a .git folder with a database and configuration files for the local repository. Git considers any folder that contains a .git folder with these configuration and database files... [More]

This is another excellent 1-hour tour of another complex corner of .NET. Toub describes and shows how the source-generated RegEx engine works.

Deep Dive into RegEx with Stephen Toub by dotnet / Scott Hanselmann (YouTube)

• The generated source is human-readable and debuggable.
• It is well-commented.
• It updates in real-time as you change the expression.
• It includes XML documentation that describes the regular expression in plain English.
• They rewrote the compiler in .NET 7 to not only better support source generators, but also to be able to emit not only IL, but source... [More]

This is another video from Stephen Toub that is just chock/full of useful information.

Writing async/await from scratch in C# with Stephen Toub by dotnet (YouTube)

At 27:30, they start to discuss about the nomenclature of Task and how it differs from an Action. It’s funny that neither of them mentioned that tasks in .NET are called promises pretty much everywhere else (JavaScript, Java, etc.). Some libraries also use the word future. For more information, see Futures and promises (Wikipedia).

As he’s building everything, it is really astonishing to note that Hanselmann has to... [More]

This is a great interview with the master of performance-optimization in .NET Stephen Toub. If you’re relatively well-versed in C#, .NET, and Linq, then you can just jump to the second video (linked below). I actually watched the second one first. I didn’t feel like I’d missed anything.

Deep Dive on LINQ with Stephen Toub by dotnet (YouTube)

Stephen Toub’s the guy who writes the 100+-page release notes on performance. See the following links.

• Performance Improvements in .NET 5 (46 pages)
• Performance Improvements in .NET 6 (109 pages)
• Performance... [More]

This video is from a great channel, which published a lot of great videos a while back. They covered pretty much everything already, but circled back to JavaScript for 2024.

Interview with Senior JS Developer 2024 by Programmers are also human (YouTube)

Some choice quotes from the video.

“We push on save.”

“2024 is the year of the serverlesslessness.”

“They say that every year, but this year they’re out of VC funding.”

“Don’t write this down, next week all of this is gonna change.”

This guy just keeps knocking it out of the park. Pretty much everything he mentioned... [More]

The following video discusses the downsides of the current implementation of primary constructors:

The C# 12 Feature You Shouldn’t Use, Yet by Nick Chapsas (YouTube)

To sum up:

• Primary constructors don’t have a readonly backing field; you can still assign to it within the type.
• You can’t control the visibility of the generated property or backing field.
• You can’t throw exceptions, except in a... [More]

The article Continuous Integration by Martin Fowler makes many interesting points. It is a compendium of know-how about CI by one of the industry heavyweights, who’s been using it for a long time.

While I found a lot of what he had to say interesting, I did wonder how applicable CI is for the kinds of teams that I know and work with. He makes several statements toward that end that pretty severely limit the applicability of what he calls “true CI” for many, if not most, teams.

I think he should have started... [More]

The article The web just gets better with Interop 2024 by Jen Simmons (Webkit Blog) writes,

“The Interop project aims to improve interoperability by encouraging browser engine teams to look deeper into specific focus areas. Now, for a third year, Apple, Bocoup, Google, Igalia, Microsoft, and Mozilla pooled our collective expertise and selected a specific subset of automated tests for 2024.

“Some of the technologies chosen have been around for a long time. Other areas are brand new. By selecting some of the highest priority... [More]”

I published a very similar version of the following article in the DevOps Wiki at Uster Technologies AG. Since nearly all of that post is general knowledge that I would have been happy to find before I started my investigations, I’m sharing it here.

Overview

When we think about navigating or debugging our code, we usually focus on the code we’ve written ourselves—local sources in our file system. IDEs have classically focused on being able to debug and navigate this code.

More and more,... [More]

The article Exploring Generative AI by Birgitta Böckeler (MartinFowler.com) is chock-full of helpful tips from eight newsletters totaling 25 pages that she wrote throughout 2023. I include some of my own thoughts, but most of this article consists of citations.

A lot of my analysis and notes boils down to: you need to know what you’re doing to use these tools. They can help you build things that you don’t understand, but it’s not for medium- or long-term solutions. I’ve written a lot more about the need for expertise in How... [More]

The latest video by Nick Chapsas has a more-than-usually clickbait-y headline. The “big” problem that NativeAOT has, is that it’s 4% slower during runtime than the JIT-compiled version.

NativeAOT in .NET 8 Has One Big Problem by Nick Chapsas (YouTube)

That doesn’t seem like such a big problem to me, when the point of AOT is to improve cold-start times for applications launched on-demand. For that use-case, AOT shines. It’s over 4x faster on startup than the JIT-compiled version. It’s incredibly impressive that JIT-compilation takes less than 1/10 of a... [More]

A build started started failing after a commit. However, the errors had nothing to do with the changes in the commit. A little investigation revealed that the cloud agent had started using a newer version of the build tool that included an expanded set of default warnings. These warnings started appearing first on CI because developers hadn’t had the chance to update their tools yet.

The “warnings as errors” setting turned what would have been a build with a few extra warnings into a failing... [More]

I read through the article Your GitHub pull request workflow is slowing everyone down (Graphite.Dev) with great interest because I, too, am not thrilled about how PRs work. While I agree with the problems Graphite see with PRs, I think they miss other problems—and I don’t like their solution very much.

PRs are, apparently, HUGE

“The single most important bottleneck is PR size − large PRs can make code reviews frustrating and ineffective. The average PR on GitHub has 900+ lines of code changes. For speed... [More]”

The article Some notes on Local-First Development by Kyle Matthews (Bricolage) focuses on a very good trend in app development, but focuses a bit too much on what he calls DX, or developer experience.

“I see “local-first” as shifting reads and writes to an embedded database in each client via“sync engines” that facilitate data exchange between clients and servers. […] The benefits are multiple:”

• Simplified state management for developers.
• Built-in support for real-time sync, offline usage, and multiplayer... [More]

This is a brilliant interview, in that Oren Eini just talks for about 40 minutes, answering pretty much just one or two questions.

Oren Eini on Building Projects that Endure by Technology and Friends (YouTube)

At one point (I forget where), he says,

“I don’t like unit tests.”

Agreed. I likelove automated tests. They’re indispensable. But I think unit tests are only useful when you want to focus on a failing integration test. David rightly points out that they’re really good for pinpointing where a problem actually happens, but Eini says that they also “hinder change”... [More]

The following video is a talk by Robert Martin “Uncle Bob”, one of the graybeards worth listening to. This video from 2011 is wide-ranging and contains a lot of brilliant advice. It’s stuff that we’ve known for a long time now, but every generation of programmers needs to re-learn these things about every 5-10 years. You usually can’t stop people from just reinventing the wheel because who wants to watch videos of or read blog posts written by old dudes, ammirite?

Ruby Midwest 2011 − Keynote: Architecture the Lost Years by Robert Martin by Robert C. Martin in 2011 (YouTube)

At 10:00, he talks about... [More]

As I was reading the absolute train wreck of a unit test in Testing with a Lisp (Daily WTF), the song “What the fuck is going on?” popped into my head, like it always does when I see that a programmer not only didn’t understand the assignment, not only doesn’t know how to program, but also doesn’t know that they don’t know how to program.

They are living their best life because they don’t think that “knowing how to program” is required in order to be a programmer. Neither does their boss or team, I guess.... [More]

I was recently asked something like the following question, which I am citing with a few minor edits.

We would like to do a course about SW development with Python, preferably an online course, so that we can start at our own pace.

We don’t want a Python course, but would instead like a course more about SW development. It would be great if it were in Python because we are comfortable with it.

The interesting topics would be:

• object-oriented programming
• functional programming
• design... [More]

Note: I found this old draft containing my response to a colleague.

I 100% agree with you, in general. I absolutely want to know immediately when an assumption I’ve made does not hold.

But…😁

The degree to which I’m willing to crash depends on whose consistency I’m basing my assumptions on. When I call a method in my code from another method in my code, I’m absolutely going to assert that an argument is not null. I can control that. My IDE will tell me when I might be passing null. That... [More]

This article is a copy of the white papers and process description that I wrote for Encodo Systems while I still worked there. I’ve preserved a copy of it here and in the linked articles.

Through our many years of experience building software, we’ve accumulated methodologies and principles that lead to quality software.

• The experience and know-how we bring to our consulting services also make us excellent partners in development-process consulting.
• We have experience in reviewing existing... [More]

Encodo keeps the SOLID principles in mind when designing software.

DI & IOC

We implement the Inversion of Control [I] pattern with the dependency-injection pattern (D) to allow for a large amount of flexibility in how an application is composed. We’ve applied this principle throughout the Quino framework and use it in our products as well.

What does this mean? It means that the product or framework doesn’t make any decisions about which exact components to use. Instead, it indicates the API... [More]

These are the two core principles that guide how we write code:

• KISS: Keep It Simple, Stupid
• YAGNI: You Ain’t Gonna Need It

KISS

This first principle is a constant reminder to ourselves to avoid the seductive call of cleverness. Most code does not need to be clever. Very occasionally, it is necessary to implement something with real flair, that requires explanation.

The best code, though, requires no explanation. The best code gets its job done in a very boring way, using the same... [More]

Tests are code. Writing tests is not a “step”—it is part of writing the code itself. The component is nothing without its tests.

It should be easy to verify any requirement with a test. The tests should tell the story of the requirements.

A developer can test any component in isolation (unit testing) or can test the component in the constellation in which it normally exists (integration testing).

Tests are code

Just so we’ve said it: tests are not a place to use a different coding style... [More]

Good documentation is part of every piece of quality software. What do we mean by “good”, though? Or “documentation”, for that matter? Quality software should be self-explanatory, but don’t be fooled into thinking that you don’t need to write documentation.

Actors & Use Cases

Documentation has an audience. Before writing anything, consider who you’re writing it for. What are the possible audiences?

Evaluators

Evaluators are interested in what your software does, how it interacts with other... [More]

An important part of the software process is the final step: delivery.

If you can’t get your software into your customer’s hands, then what’s the point of writing it at all?

Goals

There are several at-times cross-cutting goals. In descending order of importance, they are:

• Improve reliability and quality of releases
• Improve efficiency of the release process
• Improve testing feedback loop
• Improve efficiency of the development process

Definition

There are several aspects to continuous... [More]

Design by Contract is a software engineering practice in which software requirements and promises − the “Contract” − are explicitly written into the code. The code is, at the same time, better documented, more reliable and easier to test against. Encodo uses this technique to ensure software quality.

A brief overview of contracts

A software contract is composed of several components: preconditions, postconditions and invariants. Preconditions are what a component requires of a client, whereas... [More]

A healthy and active review culture is essential for any team interested in building quality software. At Encodo, we’ve been doing reviews for a long time. They’ve become an essential part of everything we do:

• Analysis
• Estimates
• Design
• Architecture
• Coding

  • Style
  • Performance
  • Coverage
  • Security
• Deployment
• And more…

Definition

What we mean by review is not a formal process at all. It is simply that you prepare work you’ve done for an informal presentation to a team member. Explaining what... [More]