TLDR: I’ve built a middleware for handling JWT authorization. It’s written for the Rust ecosystem and supports many popular web frameworks such as axum, salvo and tonic. It’s called tower-oauth2-resource-server and you can find the source code on github. Feel free to use and contribute!

Over the last few months, I’ve delved into the art of writing a REST API using Rust. Specifically, I’ve used the axum crate to do so. Like most projects, mine eventually needed authorization. A way to validate incoming JSON Web Tokens (JWTs) from an external identity provider.

In case you missed my first post “Implementing a design system”, we chose to implement our design system with web components. This post will be about our thought process and the tradeoffs we considered when deciding on how we would implement with web components.

It is possible to write a web component using only native JavaScript and HTML, but it is challenging. It is much more common to use a library like Lit or Stencil. The library helps with registration of the web component and change management as well as interoperability with popular frameworks. In our case, in addition to Lit and Stencil, we also considered Mitosis, and compiling to web components with Solid or Angular.

For the last year one of my main projects at work has been to lead the implementation of a design system, building it together with my team. It’s not a perfect implementation but I’m quite proud of what we have accomplished so far with limited resources. I’d like to share some of our insights and experiences, about specific decisions we’ve made and why.

Let’s begin with the needs expressed by the organization:

Header Image by macrovector on Freepik

We love to share our knowledge and improve each other

That is why we have this series of presentations in the office about office ergonomics. Yes series, this is just the beginning, a general introduction to the topic. So this is a summary of the initial presentation. Later we will have more specific examples.

Who are you to tell me what to do

I am not telling you what to do but recommend ways to keep your joints and bones and muscles healthy, based on a lot of research and my own experience. I have been both a practitioner and a trainer in many different disciplines including

In the Devies book club we recently finished Modern Software Engineering by David Farley.

In Modern Software Engineering, Farley want to reclaim the meaning of engineering in “software engineering”. It’s not just about coding, it’s about doing what works to build better software faster - This involves processes, tools and culture.

The software industry is not like the manufacturing. The process of building software can’t be reduced to a production line; it’s rather a process of exploration and discovery. In this context, Farley suggests that there are two critical core competencies that software engineers must master: learning and managing complexity.

Sometimes I see people (myself included) working on software development tasks in a non-structured way. You might have a vague understanding of what you’re about to accomplish. Aimlessly traversing the code base, hoping to find places that you might need to change. You instantly start to chase new ideas, while forgetting about prior (and possibly important) ideas. It might be hard to determine when you’re done. You might not commit intermediary working states, and have a hard time finding what you’ve messed up once something is broken.

Background

This is probably not news to anyone that has been working as developer consultant. Large existing code base; in our case it’s an application that has existed for about 2,5 years and during that time it has developed several services and therefore has many endpoints.

Therefore when me and my colleagues had to start developing new features it was hard to know what was available and what wasn’t with over 50 different endpoints to hit.

tl;dr

Background

Continuous Deployment (CD) pipelines are great tools to automate the deployment process of a software. Their main objective is to minimise human error and maintain a consistent process for how the software is released.

For Xcode projects this becomes a time critical process once the project has to be built for different configurations and/or environments. Since every configuration might require a different signing method, or even different deployment platform.

At Devies we run a book club where we on a weekly basis discuss topics from a book that we are reading in a common pace. Recently we finished The Pragmatic Programmer, 20th Anniversary Edition. In this post, we’ll share learnings around some of the topics we have discussed.

Tracer Bullets vs Prototypes

Two of the topics discussed in the book are tracer bullets and prototypes. The concepts are similar but addresses different problems. A prototype is a cheap way to try out an idea, to answer questions about something unknown. Details that are not required to answer the question are left out in favor of quick feedback at low cost.

Hey fellow developers!

Upgrading libraries in your gradle file for an Android project is a crucial part of keeping your project up to date and running smoothly. However, it’s not uncommon to encounter errors or deprecated code after upgrading a library. If this happens to you, don’t panic! There are a few steps you can take to fix the issues and get your project back on track.

Understanding the Role of Gradle Files

In an Android project, there are two main gradle build files that you might need to work with: the “build.gradle” file and the “gradle-wrapper.properties” file.