Build code, not walls

You might have read already about Jamstack. You probably already used Next.js, and recently you may be hearing a lot about the headless CMSs. This quick course will put all the pieces together and show you why Storyblok, combined with Next.js, is the best combo for your next project. Stop by and try it yourself!
- In-depth Jamstack knowledge. How it changed from old times to the modern world. Learn how Jamstack was created by comparing Static Sites and Dynamic Sites.
- How Next.js serves content, and how content is served with Static Site Generation (SSG).
- Atomic design methodology, and how this is applied to the content management system.
- Hands-on project experience by building a Jamstack project with Next.js and Storyblok.
Prerequisites
-
Any Text . Visual Studio Code recommended
-
Node.js LTS
-
NPM or Yarn
-
GitHub account
-
Vercel account
- Familiarity with JavaScript, React, and Git. Having worked with Next.js before is a plus
What's included
1. Introduction and overview of the workshop
2. Introduction to Jamstack
3. Introduction to Atomic Design
4. Overview of Headless CMS
5. Introduction to Storyblok
6. Next.js app creation
7. Storyblok space creation
8. Next.js and Storyblok connection
9. Custom components creation
10.First-page creation
11. Introduction to Visual
12. Dynamic pages addition
13. Blog section creation
14. Deployment on Vercel

Have you ever wondered how React works?
What would it feel like to create the magical lines that make up the tool we all grew to learn and love?
Come along on our journey to implement React from scratch, making a simple React project work with your own my-react.js library.
What's included
- Introduction
- Rendering our first component
- Update cycle and the VDOM
- Meet the hooks
Prerequisites
- Some knowledge of React.

In this workshop, you will get a first-hand look at what end-to-end type safety is and why it is important. To accomplish this, you’ll be building a GraphQL API using modern, relevant tools which will be consumed by a React client.
What's included:
1. Welcome
&
kickoff
2. Set up Prisma (lesson 1)
3. Set up a GraphQL server (lesson 2)
4. Build the GraphQL schema (lesson 3)
5. GraphQL on the client (lesson 4)
6. Bridge the gap (lesson 5)
7. Wrap up
Prerequisites
- Node.js installed on your machine (12.2.X / 14.X)
- It is recommended (but not required) to use VS Code for the practical tasks
- An IDE installed (VSCode recommended)
- (Good to have)*A basic understanding of Node.js, React, and TypeScript
by

In this workshop, you will learn how to create a Custom Component System from scratch in React, and take it to the next level.
You will learn best practices when building a Component System, as well as the tools that you can use to be a more effective collaborator with other cross-functional teams.
What's included
1. Introduction
2. Learn the fundamentals of a Component System
3. Setting up the development environment
4. Importing fonts
5. Choosing a base React Component Library
6. Writing our first components
7. Setting up a centralized theme
8. Writing custom styles to inject to our components
9. Injecting icons to our components
10. Adding hooks
11. Making components responsive
12. Adding dark mode
13. Deploying your Component System
14. Exporting your Component System to a design tool
15. Prototyping with your production components

Using a library might seem easy at first glance, but how do you choose the right library? How do you upgrade an existing one? And how do you wade through the documentation to find what you want?
In this workshop, we’ll discuss all these finer points while going through a general example of building a code editor using CodeMirror in React. All while sharing some of the nuances our team learned about using this library and some problems we encountered.

We know that React is for the web and React Native is for Android and iOS. But have you heard of react-native-web—for writing an app for Android, iOS, and the web in one codebase? Just like React Native abstracts away the details of iOS and Android, React Native Web extracts away the details of the browser as well. This opens up the possibility of even more code sharing across platforms.
In this workshop you’ll walk through setting up the skeleton for a React Native Web app that works great and looks awesome. You can use the resulting codebase as a foundation to build whatever app you like on top of it, using the React paradigms and many JavaScript libraries you’re used to. You might be surprised how many types of app don’t really require a separate mobile and web codebase!
What's included
1. Setting up drawer and stack navigators with React Navigation, including responsiveness
2. Configuring React Navigation with URLs
3. Setting up React Native Paper including styling the React Navigation drawer and headers
4. Setting up a custom color theme that supports dark mode
5. Configuring favicons/app icons and metadata
6. What to do when you can’t or don’t want to provide the same functionality on web and mobile
Prerequisites
- Familiarity with building applications with either React or React Native. You do not need to know both.
- Machine setup: Node LTS, Yarn, be able to successfully create and run a new Expo app following the instructions on
https://docs.expo.dev/get-started/create-a-new-app/
by

React Testing Library is a great framework for React component tests because there are a lot of questions it answers for you, so you don’t need to worry about those questions. But that doesn’t mean testing is easy. There are still a lot of questions you have to figure out for yourself: How many component tests should you write vs end-to-end tests or lower-level unit tests? How can you test a certain line of code that is tricky to test? And what in the world are you supposed to do about that persistent act() warning?
In this three-hour workshop we’ll introduce React Testing Library along with a mental model for how to think about designing your component tests. This mental model will help you see how to test each bit of logic, whether or not to mock dependencies, and will help improve the design of your components. You’ll walk away with the tools, techniques, and principles you need to implement low-cost, high-value component tests.
Prerequisites:
- Familiarity with building applications with React
- Basic experience writing automated tests with Jest or another unit testing framework
- You do not need any experience with React Testing Library
- Machine setup: Node LTS, Yarn
by

There are many advantages to using GraphQL as a datasource for frontend development, compared to REST APIs. We developers in example need to write a lot of imperative code to retrieve data to display in our applications and handle state. With GraphQL you cannot only decrease the amount of code needed around data fetching and state-management you'll also get increased flexibility, better performance and most of all an improved developer experience. In this workshop you'll learn how GraphQL can improve your work as a frontend developer and how to handle GraphQL in your frontend React application.
What's included:
1. Getting started with GraphQL
2. GraphQL Queries
3. Mutating Data
4. GraphQL in React
5. Using a GraphQL Client
by

Are you a React developer trying to get the most benefits from TypeScript? Then this is the workshop for you.
In this interactive workshop, we will start at the basics and examine the pros and cons of different ways you can declare React components using TypeScript. After that we will move to more advanced concepts where we will go beyond the strict setting of TypeScript. You will learn when to use types like any, unknown and never. We will explore the use of type predicates, guards and exhaustive checking. You will learn about the built-in mapped types as well as how to create your own new type map utilities. And we will start programming in the TypeScript type system using conditional types and type inferring.
by

- Introduction
- Prerequisites for the workshop
- Fetching strategies: fundamentals
- Fetching strategies – hands-on: fetch API, cache (static VS dynamic), revalidate, suspense (parallel data fetching)
- Test your build and serve it on Vercel
- Future: Server components VS Client components
- Workshop easter egg (unrelated to the topic, calling out accessibility)
- Wrapping up

You’ve built apps with frontend frameworks before? - Then you surely came across the terms ""declarative"" and “reactive”. Since React got released in 2013, most modern UI frameworks or libraries want to be it, but what do these terms actually mean? And what’s the difference between “declarative” and “imperative” code?
It took me a long time to grasp these concepts - but when I finally did, I saw frontend frameworks in a totally new light! And I hope you will feel the same after this talk.
In this very interactive workshop, we’ll delve into a lot of code examples to deeply understand the terms - with examples using vanilla JavaScript, React and Svelte. But the learnings will be universal. After this talk you’ll be able to confidently join discussions about the ""declarative"" and ""reactive"" nature of any new package or library.

In this workshop we’ll build a GraphQL Yoga server from scratch, as well as cover how you can use Yoga inside of frontend applications like Next.js. We’ll also look through the plugin ecosystem of Envelop, and what can be added to Yoga to fully customize it to your needs.
by