Asbjørn Ulsberg
Architect and developer at PayEx by day, musician and demoscener by night
Oslo, Norway
Actions
Software developer hobbyist since 1989, web developer since 1996 and professional full-stack developer since 2000, Asbjørn enjoys every aspect of development; from design and architecture to implementation, maintenance and operations. He is a passionate believer in the free and open web, dabbles in web standards when time permits and thinks Fielding might be on to something with his 2000 doctoral dissertation. He loves to both create and listen to music, the taste of whisky and beer and spending time with his wonderful daughter and wife.
Area of Expertise
Topics
Hypermedia As The Engine Of Application State
Everyone familiar with REST has heard or read the acronym HATEOAS. Some may even know what it stands for and will be able to spell it out.
Few, however, truly understand what it means. This talk explains how you should think about your application as a state machine and how you can change the state of your application through hypermedia.
Versioning Is A Red Herring
For software developers, versioning is such an engrained part of what we do that we naturally think it applies to all sorts of software, regardless of how it is used. For long-lived, distributed systems, versioning takes a different form.
This talk explains how instead of a versioning strategy for your web API, you should have a change strategy. The talk goes through what this means in practice, a set of rules you should follow to ensure that you don't break clients all the while allowing your API to change and evolve with minimum code debt.
Evolving compositional user interfaces
Ever since we started breaking applications into services, be it in the era of SOA or more recently with microservices, we’ve struggled to incorporate user interfaces into our decoupled, distributed architectures. We’ve seen frontends versioned separately with tight coupling to our services, breaking cohesion. We’ve seen the rise of Backend-For-Frontend and the emerge of micro frontends. We talk about composition, yet so many projects fail to implement actual composition. Instead we end up with some kind of compromise, with repeated business logic in the front-end, back-end and API, making it hard to scale – especially when multiple teams are involved – causing lock-step deployment, latency, bottlenecks and coordination issues.
What if we could find a viable solution that allowed us to scale development, keep distribution and cohesion and also provide composition of user interfaces?
In this talk you are introduced to the evolution of compositional user interfaces and existing patterns while we discover their pros and cons, before diving into the architecture and development of compositional interfaces using hypermedia and micro-frontends. We go beyond the simple “Hello World” example that always seems to work, and you’ll learn patterns in modelling and design that will get you up and running with decoupled, composed user interfaces in your day job.
What's In A Model?
If you know the Model-View-Controller pattern, have you ever questioned why Microsoft's defaults encourage you to group everything by their type? Models here, Views there and Controllers over there. If grouping by type is such a good idea, why aren't we grouping all Strings, Integers and Booleans together as well?
Perhaps there's a better way? This talk will give you ideas for how to structure your applications differently and doing it in a way that will make you more proficient in your programming language all the while being able to more clearly represent and model the real world in code.
After this talk, you will appreciate and understand better when to respect the DRY principle and when to break it. You will learn the difference between a data model, a view model, a message model, a domain model and when to use which. You will learn when and why you should throw exceptions, when to use object initializers and when to use constructors.
This may all sound basic, but at its core, this is all very hard, since modelling is hard. And modelling is hard because it is essentially about distilling the real world into code and the real world has absolutely no interest in being modelled. The real world is complex and chaotic, so we need all the tools we can muster to bring it into order.
This talk will give you a few of these tools.
Øredev 2019
What's In A Model?
If you know the Model-View-Controller pattern, have you ever questioned why Microsoft's defaults encourage you to group everything by their type? Models here, Views there and Controllers over there. If grouping by type is such a good idea, why aren't we grouping all Strings, Integers and Booleans together as well? Perhaps there's a better way?
This talk will give you ideas for how to structure your applications differently and doing it in a way that will make you more proficient in your programming language all the while being able to more clearly represent and model the real world in code. This may sound basic, but at its core, this is all very hard, since modelling is hard. And modelling is hard because it is essentially about distilling the real world into code and the real world has absolutely no interest in being modeled. The real world is complex and chaotic, so we need all the tools we can muster to bring it into order. This talk will give you a few of these tools.
Nordic APIs 2019 Platform Summit
What’s Your Problem?
An API isn’t stronger than its weakest link and what’s often ignored in the ongoing maintenance and development of an API is the constant effort required to provide great self-servicable error messages. What this means is that without great, user-friendly error messages, your API is not going to be great.
Just think about your first interaction with an API. How many failing requests have you sent before you have dug yourself through swathes of error messages and documentation to get to that one penultimate successful request making your heart sing and fists shaking in the air?
Great error messages make them not feel like errors, but like friendly guidance towards a working request. They should be detailed enough to let the developer fix whatever problem there is themselves, like a dialogue between a customer and a support technician.
This talk will give you ideas of how to handle errors and exceptions that occur in your application, be it with the incoming request, database failures or errors received from a 3rd party and how to serialize them into user friendly and actionable problem messages.
NDC Oslo 2019 Sessionize Event
Nordic APIs 2018 Platform Summit
Compositional UIs With Hosted Views and Hypermedia
In the new brave world of decoupled and autonomous microservices, there’s a lot of knowledge, best practices and attention given to APIs. But once you start integrating these APIs in a UI, it quickly becomes a monolith of highly coupled components that replicate a lot of the functionality provided in the underlying APIs.
As everyone probably knows and agrees to by now, monoliths are not a design goal. By making your UI compositional through hosted views and by moving some of the business logic from the client to the server through the use of hypermedia, you can achieve full vertical integrations that are horizontally decoupled in a microservice fashion all the way from the persistence layer and up to the user interface.
DevOps Pro Vilnius 2018
From Source To Production With Ease
When puzzling together a build pipeline, going from source code to a built artifact that is released to production, there's a lot of pieces that need to go together. How do you mint a version number? How do you perform the actual build? Where do you put the build artifacts? How do you securely and confidently deploy the artifacts to production?
This talk attempts to answer all of these questions by providing real-world experience with tools and techniques that solve each piece of the puzzle, using Cake, GitVersion, TeamCity and Octopus Deploy.
NDC Lightning 2017 Sessionize Event
NDC Oslo 2017
Get Better With All Things Git
Git seems like an impenetrable matrix of commands and arguments that only Linus Torvalds and his closest friends can understand. After this talk/workshop, you will know that this is not the case and even be able to contribute to open source projects on GitHub.
Git has some 157 commands, each with several arguments that can take a number of possible values. This complex matrix of seemingly infinite combinations unquestionably gives the impression that only Linus Torvalds and his closest friends are capable of truly understanding and using Git efficiently.
This talk/workshop will make you understand the core of Git and how the "command matrix" is basically just fluff. Very powerful and useful fluff, but fluff nonetheless. What Git does is basically introductory high school graph theory in its simplest form. If you understand nodes (or points) and edges (or lines) and are able to point your index finger at a node, you should hopefully leave this talk a bit more informed and perhaps hate Git an ounce less than you did before the talk.
After teaching the core of Git, the workshop (or talk) will go on to show how you can use Git Flow, GitVersion and GitHub in concert to become a much more efficient, structured and overall better developer.
Secure, Flexible & Modern APIs for Payments
At this free, half-day event, we gave an introduction to REST and Hypermedia, and spoke about the important role OAuth2 plays as the central piece of the authorization puzzle.
Nordic APIs 2016 Platform Summit
The REST And Then Some
This talk is for developers dabbling in REST, but who aren’t yet invited to Roy Fielding’s thanksgiving dinner. It will go through the history of REST and how it relates to SOAP and RPC-style APIs before delving down into the concepts of hypertext and hypermedia, how to implement them in your API and last, but not least; Why!
If you’ve started exploring the world of REST and miss the comfort of safe typing and service discovery of SOAP and WSDL, this talk is for you. You will learn why this is missing in the world of REST, what alternatives exist and how your API can embrace them and become much more self-descriptive and user friendly than RPC-style APIs could ever dream of!
WS-REST 2016
Workshop on Web APIs and RESTful Design
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top