Halvor William Sanden

Articles and other writings

Categories
Display

Getting people to participate equally

2022 September // Teams and processes

Getting people to participate in meetings, workshops and their field of expertise goes beyond removing gates and lowering thresholds. We must also work with the participants’ inner threshold, whether too high or too low, because there is no correlation between one person’s words per meeting and the …

Set up a global chart.js config

2022 June // Programming – Tools – Gained knowledge

I needed to make a distributable global base config for the React version of chart.js that still allowed for local overriding. The nice thing about chart.js is that this is possible. On the other hand, it’s chaining-heavy, and the documentation for it is basic and lacks relevant use cases. The way …

Programming unique accessibility

2022 April // Making interfaces

Arguing against accessibility isn’t only about the inability to see things from the perspective of others. It might also come from mistaking universal accessibility for tailoring, thinking the interface will be less convenient or harder to use for some. A car might be custom-built for one person …

Target this pointer event

2022 March // Programming – Gained knowledge

With e.target, this and a bit of CSS, we can cover several use cases where we need to both register a click, or event, on an element and then do something with the same element. Let’s say we have a single button with the id loner that we want to hide when …

Iterating instead of redesigning

2022 February // Making interfaces – Teams and processes

When we work as if interfaces can reach completion, our fixes and new features tend to turn into redesign projects. We set out to make things right this time around; we might improve them but also change them to a degree where we introduce new issues. This form of redesign not only makes testing …

Sequential-functional teams

2022 January // Making interfaces – Teams and processes

"Every team needs a role x" can mean two things, either plainly "we need expertise x to make y" or more complicated "if you don’t have role x, you don’t have expertise x". The first meaning is easy enough to agree or even disagree with. The second one is a problem for the cross-functional team, its …

CS50 and my final project

2021 November // Gained knowledge

I completed Harvard’s CS50x: CS50’s Introduction to Computer Science on the last day of October 2021 and received a passing grade a couple of weeks later. It’s a course about "abstraction, algorithms, data structures, encapsulation, resource management, security, software engineering, and web …

Code knowledge to design

2021 November // Making interfaces – Programming

Successfully designing web interfaces requires the intentional picking of HTML elements. As interfaces aren’t clickable visuals, we can’t avoid code and we can’t hand things off to be "translated" into code it later. Knowing HTML doesn’t mean knowing each element by heart. Knowing HTML means …

Date input height in Safari

2021 November // Making interfaces – Programming

input type="date" in Safari renders an input much taller than others. Why not let it render like other inputs? The reasons are unknown. Luckily, it can be fixed by targeting the -webkit-datetime-edit pseudo-element …

UI sketches, not just a waste of time

2021 March // Making interfaces – Tools

Sketches – complete drawings as interface blueprints – have no place in interface design. Their fixed nature is fundamentally different to that of the fluid interface. Yet, that doesn’t mean such drawings are always entirely useless. Although I stopped making them several years ago, and people …

Friendly and unfriendly px unit use

2021 February // Making interfaces – Programming

Our job is not to control what every user gets but to give the interface the ability to perform the calculations it needs to provide enough flexibility. Technically and ideally, an interface is a set of instructions that should work with whatever technology the user prefers or requires. We can …

Keep using system fonts

2020 November // Making interfaces

“System fonts” sounds boring, like a choice not made. It has the air of “something an engineer would pick”; it doesn’t feel like a design decision. And it doesn’t allow us to put “friendly, well-rounded and warm font” in our presentations. All that is either wrong or pointless because: Using …

Design system docs without colour

2020 October // Making interfaces – Programming

Colour pages tend to be listed as one of the first items in a documentation because they are basic properties present in all other elements. But this turns them into base elements and makes the palette – and not users and functionality – the starting and reference points for new elements …

Contributing to Style Stage

2020 August // Programming – Gained knowledge

Style Stage is a project showcasing different ways to style one page just by switching the CSS. My contribution, Sysfonts, is meant to demonstrate the use of system fonts because that is, in my opinion, the best option for applications, both browser-living and native. I think they work pretty good …

Breaking and wrapping text with CSS

2020 June // Making interfaces – Programming – Gained knowledge

Overflow happens when an element is bigger than its container. Wrap is when an element continues on the next line instead of overflowing. Text wrapping happens by default at characters like spaces and hyphens, but not inside words. That works in most cases, but sometimes we need to control if and …

Principle for responsive tables

2020 March // Making interfaces – Programming

When I set out to solve responsive tables, I figured it would take a whole team a couple of weeks and we would build a microscopic component to provide clever shuffling of div elements. Instead, my conclusion led me to the opposite. Responsive tables are less about making them responsive and more …

Hugo timestamp with relURL

2020 February // Programming – Gained knowledge

I’m fairly new to Hugo, but I’ve worked with my fair share of template languages to feel reasonably at home. Enough to both see familiar patterns, but also wonder "why have they done it like that?" Although the documentation could be a lot better, my biggest gripe now is the patchy support of syntax …

Web typography: Header spacing

2020 January // Making interfaces – Programming

The default spacing places headers in the middle between two paragraphs. It is as if the headers don't really belong anywhere. The header becomes a visual separator, and the semantic connection to the text that follows it becomes unclear. The meaningful structure falls apart.The distance also makes …

Feedback in the age of pedants

2020 January // Gained knowledge – Teams and processes

If it is one typo in some notes. In the middle of a presentation. Immediately after the presentation. If your only feedback is typo based. If you wouldn't have appreciated feedback at the given time. If something is not finished and you have not been asked to give feedback. If your feedback is …

From SCSS and back to regular CSS

2019 September // Programming – Tools – Gained knowledge

After having used SCSS/SASS for about five years, I recently quit. It's a great tool, but other tools with the possibility to use only what you need have taken over. And CSS has changed as well. When I started using SCSS, it was for browser prefix mixins, I had some heavy stuff going on just for …

Git squash and rebase

2019 March // Programming – Tools – Gained knowledge

Git squash takes your commits and squashes them together, usually into one commit. Useful for creating one commit if you've got a lot of smaller commits that creates a messy Git history. Git rebase takes your branch and places it at the tip of the master branch (or whatever branch you rebase on) …