Implementation of Schedules and Timelines

Planby is a React based component for a quick implementation of Schedules, Timelines, Electronic Program Guide, Music/Sport events, Calendar Planner  and many more ideas.  It uses a custom virtual view which allows you to operate on a really big number of data. The component has a simple API that you can easily integrate with other third party UI libraries. The component theme is customised to the needs of the application design.

This talk has been presented at React Advanced 2023, check out the latest edition of this React Conference.

Watch video on a separate page

FAQ

PlanBy optimizes performance through a virtualized view that only renders elements visible to the user. It performs background calculations and refreshes the view dynamically as the user scrolls, ensuring efficient data management and faster application performance.

Using PlanBy, developers can build a variety of scheduling applications such as conference schedules, music event timelines, TV guides, and calendar planners. Its flexibility and features support diverse implementation needs.

Installing and setting up PlanBy is straightforward. Developers can add the component to their project using yarn or npm, and the setup involves importing a few components, one hook, and two wrappers, making it simple and minimalistic.

Yes, PlanBy is designed to handle and display both past and future events. Users can navigate through the timeline both horizontally and vertically to explore different events laid out across the timeline.

Performance is crucial in timeline applications due to the potential presence of a large number of elements. Without proper optimization, such applications can suffer slowdowns or even browser crashes, making performance solutions like those in PlanBy essential.

PlanBy is a React-based component designed to help developers implement customized timelines efficiently. It uses minimal resources and is developed with React and TypeScript, featuring a custom virtualized view for handling large amounts of data.

PlanBy includes several key features such as a sidebar, timeline, layout, and live program refreshing. It also offers an optional feature to hide elements not needed in the layout, and its API allows for customization according to developer preferences.

Karol Kozer
Karol Kozer
6 min
23 Oct, 2023

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Today's Talk focuses on implementing schedules and timelines using the PlanBy component. PlanBy is a React-based tool that offers a simple interface and features like sidebar, timeline, layout, and live program refreshing. It uses a custom virtualized view to handle large amounts of data efficiently. The component allows for easy customization and can be used to build schedulers, conference agendas, TV guides, and more. Installation is straightforward, requiring only a few components, one hook, and two wrappers.

1. Introduction to Timelines and PlanBy Component

Short description:

Today I'm going to talk about how to implement schedules and timelines. Timelines are simple tools that display time, cyber, and content. Users can view future and past events horizontally and vertically. The user perspective focuses on time, cyber, and content. Without optimization, having many elements on the website can cause performance issues and crashes. Positioning programs in the layout can also be problematic. Good and bad solutions depend on project goals and user interaction. The PlanBy component is a React-based tool for implementing timelines quickly and simply.

Hi everyone. Today I'm going to talk about how to implement schedules and timelines. I'm sure each of us has faced a number of problems with timelines. My name is Karol Kozer. I am senior software engineer and I am the creator of PlanBy and OpenSource project.

Let me say a few words about timelines. Timeline is a really simple tool that displays time, cyber and content. At the top, we have a timeline with time. On the left there is a sidebar listing the providers. In the middle, there is a layout with events positioned in a timeline. Basically, users have the possibility to view all future and past events for all given providers, both horizontally and vertically.

Let's take a look at what problems we have with timelines. Let's focus on how it looks from the user perspective. The user can see only the time, cyber and the content. Basically, the user can move around the layout, both horizontally and vertically to see future and past events. I would like to also mention that our user doesn't care about the technical implementation and solution in our app.

Let me cast some light on how it works under the hood. Without any optimization and performance solutions, we can have, let's say, 5,000 elements on the website. The most important thing in this type of feature is performance versus really big data on the website. Basically, keeping all the elements without any optimization and performance solutions on the page can lead to terrible slowdowns of the application, which eventually caused the browser to crash. Also the positioning of all programs in the layout seems simple, but sometimes could also be problematic.

Let's focus on the following question. Are they good and bad solutions? I would say that this is a really complex topic and it only depends on what would you like to achieve or what is the right solution for your project. Also, you have to keep in mind how to quickly interact with the user. You have to think about features like filters, reminders, modal and many, many more. Finally, I would like to introduce you to the plan by component. The definition of plan by is quite straightforward. Plan by is a React-based component that lets you implement your own timeline so fast and simple. That's the whole definition, nothing crazy. Plan by is developed with React and TypeScript with minimal amount of resources.

2. PlanBy Component Features and Installation

Short description:

Plan by uses a custom virtualized view to handle large amounts of data and position elements in the schedule. It renders only visible elements, making it faster and more efficient. The component has a simple interface with features like sidebar, timeline, layout, and live program refreshing. You can customize the layout and easily build schedulers, conference agendas, TV guides, and more. Installation is straightforward, requiring only a few components, one hook, and two wrappers.

Plan by uses a custom virtualized view, or you can call it timeline virtualized, which allows you to operate on a really big amount of data and position all the elements in your schedule out of the box. And this is really, really cool.

Next, I would like to focus on how plan by works. Basically, Plan by only renders the elements which are visible to the user and performs all calculations in the background. When the users scrolls down or to the right, Plan by is refreshing the view with only visible elements to the user. All the elements outside of the layout are not included in the HTML structure, making the Plan by component much faster and more efficient.

Plan by has a simple interface and includes all the necessary features like sidebar, timeline, layout, and live program refreshing. In addition, there is an optional feature allowing to hide any element you don't want to include in the layout. Basically, component has a really simple API that allows you to implement your own items along with your preferences. You can use plan by styles components to develop main features, you know, or make custom styles in line with the chosen design.

Let's take a look what we can build with plan by. Using plan by you can build wherever you want, schedulers, conference, music events, TV guides, calendar planners, and many, many more ideas. The installation of the component is really easy. You just need to install the package using yarn or npm. The setup is very simple and minimalistic. The setup is very simple and minimalistic. I really like that. All you need to do is to import a few components, one hook and two wrappers. And that's it. Let's hold the setup. This is really, really simple, and you can create beautiful schedules like this one in a few minutes. Thank you very much for your time and see you at React Advanced London.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

A Framework for Managing Technical Debt
TechLead Conference 2023TechLead Conference 2023
35 min
A Framework for Managing Technical Debt
Top Content
Today's Talk discusses the importance of managing technical debt through refactoring practices, prioritization, and planning. Successful refactoring requires establishing guidelines, maintaining an inventory, and implementing a process. Celebrating success and ensuring resilience are key to building a strong refactoring culture. Visibility, support, and transparent communication are crucial for addressing technical debt effectively. The team's responsibilities, operating style, and availability should be transparent to product managers.
Debugging JS
React Summit 2023React Summit 2023
24 min
Debugging JS
Top Content
Watch video: Debugging JS
Debugging JavaScript is a crucial skill that is often overlooked in the industry. It is important to understand the problem, reproduce the issue, and identify the root cause. Having a variety of debugging tools and techniques, such as console methods and graphical debuggers, is beneficial. Replay is a time-traveling debugger for JavaScript that allows users to record and inspect bugs. It works with Redux, plain React, and even minified code with the help of source maps.
Building a Voice-Enabled AI Assistant With Javascript
JSNation 2023JSNation 2023
21 min
Building a Voice-Enabled AI Assistant With Javascript
Top Content
This Talk discusses building a voice-activated AI assistant using web APIs and JavaScript. It covers using the Web Speech API for speech recognition and the speech synthesis API for text to speech. The speaker demonstrates how to communicate with the Open AI API and handle the response. The Talk also explores enabling speech recognition and addressing the user. The speaker concludes by mentioning the possibility of creating a product out of the project and using Tauri for native desktop-like experiences.
A Practical Guide for Migrating to Server Components
React Advanced 2023React Advanced 2023
28 min
A Practical Guide for Migrating to Server Components
Top Content
Watch video: A Practical Guide for Migrating to Server Components
React query version five is live and we'll be discussing the migration process to server components using Next.js and React Query. The process involves planning, preparing, and setting up server components, migrating pages, adding layouts, and moving components to the server. We'll also explore the benefits of server components such as reducing JavaScript shipping, enabling powerful caching, and leveraging the features of the app router. Additionally, we'll cover topics like handling authentication, rendering in server components, and the impact on server load and costs.
Power Fixing React Performance Woes
React Advanced 2023React Advanced 2023
22 min
Power Fixing React Performance Woes
Top Content
Watch video: Power Fixing React Performance Woes
This Talk discusses various strategies to improve React performance, including lazy loading iframes, analyzing and optimizing bundles, fixing barrel exports and tree shaking, removing dead code, and caching expensive computations. The speaker shares their experience in identifying and addressing performance issues in a real-world application. They also highlight the importance of regularly auditing webpack and bundle analyzers, using tools like Knip to find unused code, and contributing improvements to open source libraries.
Monolith to Micro-Frontends
React Advanced 2022React Advanced 2022
22 min
Monolith to Micro-Frontends
Top Content
Microfrontends are considered as a solution to the problems of exponential growth, code duplication, and unclear ownership in older applications. Transitioning from a monolith to microfrontends involves decoupling the system and exploring options like a modular monolith. Microfrontends enable independent deployments and runtime composition, but there is a discussion about the alternative of keeping an integrated application composed at runtime. Choosing a composition model and a router are crucial decisions in the technical plan. The Strangler pattern and the reverse Strangler pattern are used to gradually replace parts of the monolith with the new application.

Workshops on related topic

React Performance Debugging Masterclass
React Summit 2023React Summit 2023
170 min
React Performance Debugging Masterclass
Top Content
Featured WorkshopFree
Ivan Akulov
Ivan Akulov
Ivan’s first attempts at performance debugging were chaotic. He would see a slow interaction, try a random optimization, see that it didn't help, and keep trying other optimizations until he found the right one (or gave up).
Back then, Ivan didn’t know how to use performance devtools well. He would do a recording in Chrome DevTools or React Profiler, poke around it, try clicking random things, and then close it in frustration a few minutes later. Now, Ivan knows exactly where and what to look for. And in this workshop, Ivan will teach you that too.
Here’s how this is going to work. We’ll take a slow app → debug it (using tools like Chrome DevTools, React Profiler, and why-did-you-render) → pinpoint the bottleneck → and then repeat, several times more. We won’t talk about the solutions (in 90% of the cases, it’s just the ol’ regular useMemo() or memo()). But we’ll talk about everything that comes before – and learn how to analyze any React performance problem, step by step.
(Note: This workshop is best suited for engineers who are already familiar with how useMemo() and memo() work – but want to get better at using the performance tools around React. Also, we’ll be covering interaction performance, not load speed, so you won’t hear a word about Lighthouse 🤐)
Build Modern Applications Using GraphQL and Javascript
Node Congress 2024Node Congress 2024
152 min
Build Modern Applications Using GraphQL and Javascript
Featured Workshop
Emanuel Scirlet
Miguel Henriques
2 authors
Come and learn how you can supercharge your modern and secure applications using GraphQL and Javascript. In this workshop we will build a GraphQL API and we will demonstrate the benefits of the query language for APIs and what use cases that are fit for it. Basic Javascript knowledge required.
Building a Shopify App with React & Node
React Summit Remote Edition 2021React Summit Remote Edition 2021
87 min
Building a Shopify App with React & Node
Top Content
WorkshopFree
Jennifer Gray
Hanna Chen
2 authors
Shopify merchants have a diverse set of needs, and developers have a unique opportunity to meet those needs building apps. Building an app can be tough work but Shopify has created a set of tools and resources to help you build out a seamless app experience as quickly as possible. Get hands on experience building an embedded Shopify app using the Shopify App CLI, Polaris and Shopify App Bridge.We’ll show you how to create an app that accesses information from a development store and can run in your local environment.
Build a chat room with Appwrite and React
JSNation 2022JSNation 2022
41 min
Build a chat room with Appwrite and React
WorkshopFree
Wess Cope
Wess Cope
API's/Backends are difficult and we need websockets. You will be using VS Code as your editor, Parcel.js, Chakra-ui, React, React Icons, and Appwrite. By the end of this workshop, you will have the knowledge to build a real-time app using Appwrite and zero API development. Follow along and you'll have an awesome chat app to show off!
Hard GraphQL Problems at Shopify
GraphQL Galaxy 2021GraphQL Galaxy 2021
164 min
Hard GraphQL Problems at Shopify
WorkshopFree
Rebecca Friedman
Jonathan Baker
Alex Ackerman
Théo Ben Hassen
 Greg MacWilliam
5 authors
At Shopify scale, we solve some pretty hard problems. In this workshop, five different speakers will outline some of the challenges we’ve faced, and how we’ve overcome them.

Table of contents:
1 - The infamous "N+1" problem: Jonathan Baker - Let's talk about what it is, why it is a problem, and how Shopify handles it at scale across several GraphQL APIs.
2 - Contextualizing GraphQL APIs: Alex Ackerman - How and why we decided to use directives. I’ll share what directives are, which directives are available out of the box, and how to create custom directives.
3 - Faster GraphQL queries for mobile clients: Theo Ben Hassen - As your mobile app grows, so will your GraphQL queries. In this talk, I will go over diverse strategies to make your queries faster and more effective.
4 - Building tomorrow’s product today: Greg MacWilliam - How Shopify adopts future features in today’s code.
5 - Managing large APIs effectively: Rebecca Friedman - We have thousands of developers at Shopify. Let’s take a look at how we’re ensuring the quality and consistency of our GraphQL APIs with so many contributors.
0 To Auth In An Hour For Your JavaScript App
JSNation 2023JSNation 2023
57 min
0 To Auth In An Hour For Your JavaScript App
WorkshopFree
Asaf Shen
Asaf Shen
Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool.
We will enhance a full-stack JS application (Node.js backend + Vanilla JS frontend) to authenticate users with One Time Passwords (email) and OAuth, including:
- User authentication – Managing user interactions, returning session / refresh JWTs- Session management and validation – Storing the session securely for subsequent client requests, validating / refreshing sessions
At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods.