When it comes to writing documentation, nobody wants to do the job. And whatever documentation does get written is quickly outdated because nobody wants to update it, either. The most accurate documentation of how a system works is the code itself, but even “self-documenting” code falls short of describing why it was written that way. […]
When you need to add a major bit of functionality to your system, what’s the first thing you do? Naturally, you start looking through whatever package repository is appropriate for a solution that fits. While there’s nothing inherently wrong with this, it’s important to think of the trade-offs made by adding external dependencies.
Software development is a mentally challenging activity. Recently, I was thinking about this when I came across a psychology theory called cognitive load.
When you create a new project in Xcode, you’re given the option of including two types of tests: Unit Tests and UI Tests. But I’ve often wished that these two weren’t mutually exclusive. There have been times when I’ve wanted to test UI components in isolation, but I wasn’t sure how feasible it was, or […]
If you’ve ever glanced at Azure Functions and F#, you might think they were made for each other. And yet if you want to create a new Azure Function project in Visual Studio, C# is apparently your only option. Maybe someday, Visual Studio will include support for Azure Functions in F#, but for now it’s […]
A frequent part of my daily workflow involves adding files to Git. Since I like to keep commits relatively small and focused, that often means adding only a subset of changed files in my working tree. With the git command-line client, that is usually accomplished by copying and pasting the files I want from the […]
I like unit tests. They’re often the best documentation of a project’s behavior. They provide assurance that code modifications haven’t broken anything. But too many or poorly-written tests can have the undesirable effect of cementing code in place, making it more difficult to change. The following are some practical things I keep in mind when […]
Having worked on an app with both native iOS and Android versions, it’s been interesting to compare and contrast the layout approaches of both platforms. iOS has had a constraint-based layout system for quite some time now in the form of AutoLayout, while Android has only recently added a similar system called ConstraintLayout.
Debugging is a drag. I think we can all agree that working on new code is generally more fun and interesting than debugging or maintaining existing code. But the fact is that much of our time is spent doing the latter. When estimating time required a project or feature, it is practically impossible to predict […]
While writing an Android UI test involving a NumberPicker, I discovered that instrumenting the NumberPicker using Espresso was not as straightforward as some other Android controls.