natural language processing Software Architecture Artificial Intelligence Web Development Azure ReactJS IoT microfrontends microservices
Munich, Bavaria, Germany
Dr. Florian Rappl is Solution Architect for IoT and distributed web applications at smapiot. His main interest lies in the creation of innovative architectures that scale in development and usage. He won several prizes for his work and is a Microsoft MVP in the area of development technologies. He regularly blogs and writes articles for popular magazines and websites in the web development space.
The architecture pattern of microservices can be found in many modern system landscapes, which offers flexibility for the backend services. On the other side, the frontend is very often realized as a monolith.
We present an example implementation of a highly modular frontend architecture based on microfrontends running in Azure, which mirrors the dynamic of a modern microservices backend with some crucial differences.
We will also introduce our concept for CI/CD with microfrontends, where Azure DevOps helps us to get from an idea to having a new feature online within minutes.
In the recent years React has become the most popular solution for creating reliable, fast, and maintainable web applications. In this workshop we look behind the hype and start from zero to become true React masters. We will cover:
- The React bread and butter; elements and components
- React's philosophy: The unidirectional data flow
- The lifecycle of components; from stateful components to SFCs
- Controlled vs managed inputs incl. DOM references
- VDOM and what the React reconciliation is about
- Server-side rendering
Furthermore, we will also touch the following topics:
- Testing React components
- React context (incl. global state management)
- React hooks
- React Native
Microfrontends have become a useful tool to break up the UI into smaller chunks that can be developed and deployed by independent teams.
Right now Blazor applications are still developed mostly in a monolithic culture. While libraries and components may be developed independently, their deployment is still centralized. In the long run this becomes a bottleneck.
In this talk microfrontends expert Florian Rappl introduces an established architecture for a creating modular frontend applications. He will show how this architecture can be implemented together with Blazor to create dynamic user experiences.
While REST is certainly a useful pattern to follow when designing backend APIs it also leaves a lot open and up to the implementation. The result is a mess that needs to be tackled by strict guidelines and frameworks for creating RESTful APIs. Therefore Florian introduces GraphQL as an alternative for backend APIs. Besides an actual look at what is GraphQL, a reference implementation for .NET is explored in all practical details.
The architecture pattern of microservices can be found in many modern system landscapes, which offers flexibility for the backend services. On the other side, the frontend is very often realized as a monolith. With the micro frontend architecture this can be now corrected.
Florian Rappl will cover the basic concept and an example implementation of a highly modular frontend architecture based on micro frontends, which mirror the dynamic of a modern microservices backend with some crucial differences. We'll see where micro frontends shine and where we should avoid them.
The architecture pattern of microservices can be found in many modern system landscapes, which offers flexibility for the backend services. On the other side, the frontend is very often implemented as a monolith. Ideally the frontend follows a similar pattern as the backend. As a consequence, the user experience for microservice backends will no longer be based on a static monolith, but rather on a highly flexible frontend.
Microfrontend experts Florian and Lothar present a framework for implementing a highly flexible solution to integrate decoupled modules into a rich frontend application. The essential buildings blocks as part of this framework will be introduced and discussed using the open-source framework Piral as a reference implementation. One of the building blocks is a dedicated provisioning service allowing the frontend to fetch modules tailored to the current user context. Together with feature flags, this service can be used to enable a variety of advanced usage scenarios. Other important aspects are the loose coupling of contained layers to provide flexibility for realizing the required functionality or advanced tooling for building and publishing feature modules.