I will speak at your event

The success of your presentation will be judged not by the knowledge you send but by what the listeners receive. - L. Walters

Speaking

I love public speaking. I've given more than 60 talks so far (Sweden, Germany, England, Czech Republic, Belgium, Poland) and I'll be happy to speak at your event! Please consider travel and accommodation reimbursement. Below you will find a list of the topics I've been speaking about recently. Each time I adjust the content and the length of a talk to the specificity of the event and the audience.

See all the talks I gave so far

My current topics

Architect's Guide to Frontend Frameworks

Modern web is evolving so fast that it's challenging to make the right decisions about a project not only for the web devs, but also solution architects. Putting jokes about JS frameworks aside, most of the major tools are built around certain patterns and architectural decisions that one might not grasp at the first sight. It's often very different than the classical Object-Oriented and Imperative Paradigms. Many of the tools that pop up each week do solve issues with performance, design and complexity, often by introducing IoC or making the code declarative. And sometimes, by introducing new complexity.

In this talk I will walk through the most important concepts that modern JavaScript ecosystem relies on. These include: different strategies for view re-renders, view-as-a-function, reactivity on the UI, push-based control-flow, handling client application state and splitting webapps into microfrontends. Let's NOT talk about the frameworks, but the concepts they are built upon.

If you're keen on webdev, this talk is for you. If you're interested in architecture and different ways to tackle problems, this talk is also for you.

back to top

The many meanings of Inversion of Control (IoC) in JavaScript

Inversion of Control is a programming technique used in all kind of languages and platforms.

Often mistakenly, identified with Dependency Injection, is actually an entire set of various solutions that, among others, JavaScript is using a lot. We're gonna take a look at real life examples of inverting the control, design patterns, as well as tools such as React, Redux, RxJS. All the whys, whats and hows.

back to top

RxJS: Everything is a Stream

Observable Streams are a common abstraction over pretty much everything that moves and/or changes. Discussing abstract concepts might be pretty difficult.

Therefore, in this talk we're gonna find metaphors of RxJS concepts in the surrounding world! We'll be looking for occurences of Observables, Observable Streams, Hot and Cold ones, Subscriptions, different types of Subjects and ways to deal with Backpressure. We'll also dive into why Hot and Cold term somehow harmful simplification.

back to top

5 Architectures of Asynchronous JavaScript

In this talk we'll discuss 5 alternative approaches to handle async operations: callbacks, events, promises, coroutines and reactive streams. None of them is either legacy or a silver bullet - a good dev needs to pick the right tool for the job.

However, in order to understand them, we must step back to fundamentals all these rely on: the mechanics of event loop and run to completion rule, as well as learn to distinguish between sync and async flow. Then we proceed to design patterns built on top of each of the 5 approaches, discussing their strengths and limitations. Funfacts, such as famous Promise.race() included!

back to top

Async Functions Awaiting You

Farewell callback hell, farewell promise chaining... the most awaited upcoming feature of ES8, async await, is taking async JavaScript to a new level. Let's code async processes in a more readable, concise and extensible manner.

During this talk we'll discuss the fundamentals: promises, generators and coroutines - and introduce async await. We'll have sequential and parallel processing explained, along with most common usecases - and gotchas. After this talk you'll never say that generators scare you or that async await is complicated - expect to find them simple.

back to top

JavaScript + Java = TypeScript

JavaScript is the most accessible platform of our times. Yet, it has many downsides, especially when it comes to big scale applications, being developed by multiple developers.

TypeScript is a solution to that problem. Being quite a new guy, it has already found its place in the JS kingdom, among rivals such as ES6, inspiring alternative langs like Flow to rise, and finally making old folks like CoffeeScript obsolete. Angular2 chose TypeScript as its language. It has bindings for most existing libraries already. Some people, including me, state they'd choose TypeScript for development of most projects, both existing and new ones. So why is that?

In this talk I'll highlight the native-JS problems that TS solves and compare it to JS and ES6. Moreover, we'll see how do non-Frontenders see TypeScript. I'll share my experience of big enterprise apps development.

TypeScript is a revolution, be part of it. This talk wil broaden your horizons. Come & join.

back to top

Backend-less Development revisited

"It's obvious that SPA interfaces rely on RESTful APIs". But does it have to be like this always? Tight-coupling between interfaces and APIs result in great development issues. Backend-less development is an emerging approach of decoupling the two sides, enabling them to be developed independently.

The costs and the benefits of mocking the entire API. The three possible architectural approaches in doing so. Mock engine examples in Angular.js and sinon.js. Simulating business logic in mocks using plain JavaScript and JSONs. Using JSON Schema do generate massive amounts of mock data on the fly. The technical and business aspects of separating frontend and backend - these are the topics I will cover.

Mock your API and make your frontend truly independent!

back to top

Component-based Frontend Architecture

SPAs made server-side web legacy. Frontend applications started to grow bigger and become more complex. This made it a lot more time consuming to add new features, refactor existing code and detect bugs. Especially, when dealing with overbloated controllers, cross dependencies and some grotesque ways to handle client data flow.

A possible solution, Component-Based approach, is leveraging the goodness of functional programming paradigm up to the architectural level. There are very sane concepts and patterns that components should be built on top of, including pure functions, sync/async one way data flow, composition, separation and being stateful or stateless. Components are easier to reuse, make prototyping your apps blazingly fast and allow developers to focus on the right thing.

This talk is framework-agnostic, although there will be some code examples. But let's learn the paradigms, not the frameworks! Once you get the architectural concept, you know what you're looking for.

back to top