Explore upcoming talks from events
JS GameDev Summit 2023
JS GameDev Summit 2023
Sep 28 - 29, 2023
Node Congress 2024
Node Congress 2024
Apr 4 - 5, 2024
C3 Dev Festival 2024
C3 Dev Festival 2024
Jun 14 - 15, 2024
React Day Berlin 2024
React Day Berlin 2024
Dec 13 - 16, 2024
Node Congress 2025
Node Congress 2025
Apr 17, 2025
JSNation 2025
JSNation 2025
Jun 12 - 16, 2025
React Summit 2025
React Summit 2025
Jun 13 - 17, 2025
JSNation US 2025
JSNation US 2025
Nov 17 - 20, 2025
Talks
Showing 100 talks
Panel Discussion: What's the big next step for Vue/Nuxt?
Vue.js Live 2024Vue.js Live 2024
43 min
Panel Discussion: What's the big next step for Vue/Nuxt?
Eduardo San Martin Morote
Maya Shavin
Konstantin BIFERT
Daniel Roe
Alexander Lichter
5 authors
We're focusing on performance improvements, both in build and development time. Additionally, we're exploring the use of WASM for deploying binaries into production. WASM is great for performance. Data loader is also important. The target audience for the podcast is Vue developers, including middle to senior developers. The podcast aims to provide new and advanced topics, including features, examples, use cases, and inspiring stories. Podcasts are complex without screen sharing, but videos can provide more in-depth content. Nuxt will be interesting to see. VaporMode in Vue enables performance through built-time transforms. The merging of Wiz and Angular brings core primitives and resumable components. Nuxt community is focusing on performance. The Vue router has an open issue with many routes. Legacy issues with ESM and TypeScript cause pain for maintainers and consumers. Node and the required ESM are exciting. Accessing Cloudflare primitives in development. Micro frontends have a shell with multiple frontends and require a general store. Web components have shown promise, but there are pain points. Mitosis and ReactiveView are alternative solutions. Web components are the best way to adhere to browser standards, but they may have limitations. Nuxt has seen successes despite the limitations of web components. Nuxt 3 has invisible improvements and a good developer experience. The migration from Nuxt 2 to 3 had communication challenges. The Talk will resume after a short break.
The Hitchiker's Guide to Event Driven Architectures
Node Congress 2025Node Congress 2025
21 min
The Hitchiker's Guide to Event Driven Architectures
Today's Talk introduced event-driven architectures with Node.js. The event loop in Node.js enables non-blocking interaction between components. The event emitter class is used to handle events synchronously. Redis and Apache Kafka are popular tools for event handling, with Kafka providing scalability and persistence. Kafka.js is a JavaScript library that supports transactions and compression. Server-sent events are used to send events to the client. A plugin and library are used to convert an event emitter to an async iterator. The client displays emojis and updates the vote count.
Lock, Stock and Barrel - Simplify your Codebase
Node Congress 2025Node Congress 2025
24 min
Lock, Stock and Barrel - Simplify your Codebase
This talk focuses on the challenges of working with large codebases, such as unclear module boundaries, code repetition, and cluttered flows. Dead code is identified as a major problem that adds clutter and cognitive load to developers. The abstract syntax tree (AST) is introduced as a tool for systematically accessing code. TSmorf is recommended for finding and removing dead code by traversing and manipulating the AST. Cyclic dependencies are discussed as another issue, and MADGE is suggested as a tool for identifying and resolving circular references. Barrel files are presented as a method for organizing code and resolving cyclic references. The process of replacing imports and removing empty calls is explained. The key takeaways include the importance of a good layered architecture, eliminating dead code, breaking cyclic dependencies, and reducing barrel files.
The Alleged ‘End’ of Node.js Is Much Ado About Nothing
Node Congress 2025Node Congress 2025
26 min
The Alleged ‘End’ of Node.js Is Much Ado About Nothing
Hello, welcome to Node Congress 2025. Node is not dead and will remain popular for a long time. Node has a large number of downloads across different platforms. Despite known vulnerabilities, older versions of Node are still widely used. Node.js is an active and thriving project with a strong focus on security. Recent updates have introduced new features and improvements, including ESM support, stable threads, and web platform compatibility. Node is governed by the OpenJS Foundation and maintained by collaborators. Consensus-seeking is important for the project's development. Start contributing and be part of the future of Node.js.
Bull-Ish Your Queues With BullMQ
Node Congress 2025Node Congress 2025
23 min
Bull-Ish Your Queues With BullMQ
Hello, and welcome to this talk where I talk about queues and Boolean Queue. Today I want to tell you a story of a team working on a client project that needed to handle a simple queue. They approached the platform team for help, but were only given one queue, which wasn't enough. The team had to find a solution using the tools they already had, such as Posgas SQL and Elastic Cache. The first possible solution was pgboss. If you don't know pgboss, it is a simple npm package that you can install in your node application and basically create a sort of queue system on top of Posgas SQL. And expose an API to call the queues and handle the queues inside of your application. The only solution left is Elastic Cache and Redis. And in this particular scenario, what shines is BoolMQ. BoolMQ is a simple npm library that implements a fast and robust queue system on top of Redis. It can be used to decouple your code and create a microservices architecture. You can create a flow by depending on different queues and creating the result based on each queue's result. Out of the box, BoolMQ provides parallelism and concurrency. Additionally, you can have OpenTelemetry set up and a UI dashboard for queue monitoring. To create a PullMQ queue, provide a name and a connection string to Redis. The code includes a run method that continuously pushes new temperatures into the queue. The consumer uses a worker to handle data and execute queries. Close the connection when closing the Node.js process. Run the publisher to push data and the consumer to receive data. Create multiple publishers or consumers as needed. The second demo shows how to set up OpenTelemetry in your Node.js environment to track what happens inside your queues. Use BullMQ Hotel and the BullHotel instance to track telemetry for your queues. The last demo demonstrates the use of Fastify with BullMQ to create a UI for managing queues. You can do whatever you want with OpenTelemetry. The last demo showcases a Fastify application within the UI. Fastify is a simple framework for handling Node.js APIs. Set up Fastify using the Fastify adapter exposed by BullMQ, BullBoard. Expose the '/UI' API to show the UI in the server. The UI allows you to interact with the queues and view completed items. BullMQ is a straightforward solution for handling queues and can be easily scaled using Redis. For most cases, using a queue is necessary and well-documented. However, it relies on Redis, which means data loss if Redis goes down. Additionally, you'll need to learn another library. Thank you for listening!
Running Java in Node.js with WebAssembly
Node Congress 2025Node Congress 2025
19 min
Running Java in Node.js with WebAssembly
Hello, everyone. Welcome to my talk on running Java in Node.js with WebAssembly. Many organisations have a lot of Java code, and as they adopt newer technologies such as Node.js or CloudFloat workers, maintaining interoperability with this existing code becomes important. WebAssembly is a stack machine-based thing, like the JVM, but with a different instruction set. It improves over Asm.js with a new binary format and supports streaming compilation, SIMD, and 64-bit integers. Compiling Java code to WebAssembly involves converting JVM instructions, handling local slots, recovering if statements, and understanding control flow. Short circuit conditionals and loops are important to consider in the conversion process. Additionally, memory allocation, object creation, and program memory are key concepts. Overall, this talk explores the challenges and techniques involved in running Java in Node.js with WebAssembly.
What is a Vulnerability and What’s Not? Making Sense of Node.js and Express Threat Models
Node Congress 2025Node Congress 2025
17 min
What is a Vulnerability and What’s Not? Making Sense of Node.js and Express Threat Models
In this talk, we will discuss security, vulnerabilities, and how to improve your overall security. We will explore various vulnerabilities and the difference between developer errors and misconfigurations. Understanding threat models is crucial in determining responsibility for vulnerabilities. Developers have the ultimate responsibility for handling user input, network data, and other factors. Understanding threat models, best practices, and taking ownership of dependencies are key to improving security. Security is an ongoing process that requires dedication and understanding.
WinterTC and How Standards Help Developers
Node Congress 2025Node Congress 2025
5 min
WinterTC and How Standards Help Developers
WinterTC is working on standardizing JS runtimes to avoid vendor lock-in and provide a universal API. This involves defining which web APIs should be included, such as URL and WebAssembly. The goal is to create a definitive list of APIs for server-side JS runtimes.
Using AI as Your Performance Expert in Node.js
Node Congress 2025Node Congress 2025
20 min
Using AI as Your Performance Expert in Node.js
Today's Talk discusses the transformation of performance monitoring with AI in Node.js. AI-powered tools can analyze massive amounts of data and provide actionable insights, making performance debugging faster and more efficient. Traditional profiling techniques are often time-consuming and require deep expertise. AI-powered diagnostics analyze data and provide recommendations for optimizing performance. AI-driven performance analysis correlates performance issues with system metrics and generates code optimization suggestions. Advancements in performance debugging include detecting CPU bottlenecks, memory leaks, and combining multiple data sources for context-aware insights. The AI-powered demo showcases the detection and optimization of performance issues in a Node.js application. Integrating AI-powered performance monitoring is straightforward and requires a mindset of continuous learning and curiosity in performance optimization.
It’s Not Magic: Elevate Auth Security with PKCE Best Practices
Node Congress 2025Node Congress 2025
5 min
It’s Not Magic: Elevate Auth Security with PKCE Best Practices
The talk discusses the need to enhance auth security with Pixie Best Practices and the limitations of current standards like OAuth 2 and OpenID Connect. It introduces Pixie as an added layer of security over the authorization code flow and explains how it prevents code injection. Pixie enhances security by connecting client requests with responses from the authorization server, preventing cross-site request forgery attacks. It is recommended for public clients and will be required for all clients in the upcoming OAuth 2.1 spec. The talk also highlights the benefits of Pixie for enhancing security in web apps. Learn more about Pixie and best practices at FusionAuth, where Kim Meida, Senior Director of Developer Relations, provides developer-first auth and auth APIs.
Inside the Engine: How Modern JS Test Runners Work and the Traps They Hide
Node Congress 2025Node Congress 2025
22 min
Inside the Engine: How Modern JS Test Runners Work and the Traps They Hide
Hello, I'm grateful that you chose to watch my talk. Thank you. Last week, I had to run some unit tests while I was coding. Business performance can be awesome. It has very interesting and outstanding features. These test sets are overly complex. It's easy to find yourself troubleshooting for hours. VTest has almost 200 configuration options. By explaining how things work, we can answer questions about using complex third-party runners versus the built-in node.js runner. Understanding better helps avoid pitfalls, troubleshoot faster, and identify opportunities for configuring things better. The CLI layer does validation and hands over to the VTest class. It searches for test files, runs them efficiently using a pool of workers, and ensures isolation to prevent issues with dirty state. VTest uses the piscina library to facilitate work with multiple workers and improve performance. The workers prepare by setting the right globals, initializing snapshots, deciding the test runner file, and starting coverage collection. Each worker executes all the tests in a file and sends an RPC message when done. The decision to reuse or create a fresh worker is determined by the isolate configuration option. Consider spreading tests among more files to fully utilize the machine. Choose between process, thread, or VM as the worker type. In terms of isolation, you can choose between using a process, a thread, or a VM. Process is the heaviest in terms of performance cost, while thread is lighter. VM performance depends on known slower aspects like accessing globals. Process is the classic choice for stability, but thread has limitations and known issues. VM has reporting issues with memory leaks. Benchmark results showed that using multiple processes was 50% better for real-world applications, but for unit tests, one process was ten times faster. Thread was slightly faster than process, and VM was slower. The price of isolation with process worker types was approximately three minutes. Without isolation, the tests lasted only two minutes, much faster, but with a few failures. Threads showed similar results with a few failures. The risk of dealing with testing issues increases without isolation. By default, tests run sequentially inside workers, but you can configure them to run in parallel using the 'concurrent' keyword. However, tests still run sequentially despite specifying 'concurrent'. Concurrency in VTest is based on promises and requires asynchronous work. Unit tests run sequentially and concurrency has no isolation. Mocking in one test affects other tests running simultaneously. In choosing worker configurations, it depends on the context. In-file concurrency is best avoided, and the process worker type is recommended as the default. Isolation is crucial in integration tests but not mandatory in unit tests. Inside the worker, a TypeScript file is handled, and failures can occur when mocking functions. Mocking doesn't work in the worker. The worker handles TypeScript files and transpiles them using Vite server. Vite server replaces imports and hoists the mocking. Vite introduces a new module loader in the runtime. Vite hoisted the mock to the first line in the transform code to make it before the import. Additionally, Vite changes mocks to dynamic imports, ensuring that mocking works. Vite intercepts function calls on the file import level, but cannot intercept calls between functions in the same file. Moving function two to a different file or using an object export can solve this issue. Function one calls function two on the same object context. Use Spy to replace functions inside the object. Vite offers a range of plugins for different functionalities. You can fix import issues by customizing Vite's runtime. The Vite server handles dependency resolution and transformation. Consider using the built-in test runner or mockup for small-scale testing. Gain a better testing experience with Vite's customized runtime.
Dabbling With Deno — Tales From a Web Developer Playing With a New Toy
Node Congress 2025Node Congress 2025
26 min
Dabbling With Deno — Tales From a Web Developer Playing With a New Toy
Thanks for a great talk. I'm Phil Hawksworth, head of developer relations at Deno. I'll be available for Q&A later. Connect with me on social media at philhawksworth. So he took Node and he split it, and he sorted it, and joined it, and Deno was born. But naming things is hard. I've been building for the web for 25 years. Across different places, I've observed that web developers tend to follow trends over the years. JavaScript has become ubiquitous, powering the web from the front end to the server and beyond. Node.js has played a significant role in bringing JavaScript into the mainstream, increasing its resilience. The natural evolution of JavaScript is exciting, with new tools emerging. Personally, I'm cautious about adopting new tools, but I stumbled upon Deno while building edge functions on Netlify. It is powered by Deno under the hood and resembles JavaScript. I was writing functions in JavaScript and TypeScript without realizing that Deno was powering them under the hood. I got excited about using a site generator called Loom, which led me to discover Deno. Installing Deno and running its commands got me started. Deno is an open source JavaScript, TypeScript, and WebAssembly runtime with secure defaults. It's built on V8, Rust, and Tokyo and offers a JavaScript runtime, TypeScript toolchain, package manager, and task runner. Deno is a tool that encompasses various functionalities, including testing, linting, formatting, benchmarking, and compiling. Its API is based on web standards, making it familiar to web developers. Enabling Deno in your IDE provides insights into your code and hinting across the Deno ecosystem. Deno package management allows you to import packages from the NPM or the node ecosystem to ease the transition. Managing dependencies and updating packages is simplified with Deno. Deno clean purges the cache, allowing gradual repopulation. Tasks in Deno are managed in Deno.json and can be run using the commands run or task. Deno's built-in test framework allows for running tests using the command denotest. Deno includes a built-in TypeScript and JavaScript toolchain, eliminating the need for additional configuration. Deno allows running TypeScript files without the need for compilation. It offers tools for type checking, generating type definitions, formatting code, and linting. Deno simplifies and unifies various tools, making it easier for teams to adopt a consistent toolset. Deno's security model and performance are robust. Explore examples, tutorials, the Deno Discord, Blue Sky updates, and a deep dive video to learn more about Deno. Thank you for your time!
NodeJS & AI: Building Smarter Applications
Node Congress 2025Node Congress 2025
19 min
NodeJS & AI: Building Smarter Applications
Today's Talk explored combining Node.js and artificial intelligence to build smart applications. Two types of models, closed and open source, were discussed, with closed models accessed via an API and open source models hosted locally or on the cloud. The use of RAC (Retrieve of Method Generation) to enhance models was explained, along with the process of obtaining data and improving retrieval performance. Chunking, embedding, and vector databases were introduced as techniques for organizing and transforming data. The Talk also covered data retrieval using semantic search and the generation of human-readable answers using models. The concept of enhancing models with agents was discussed, focusing on how agents break down complex goals and utilize external functions. The use of tools and the React pattern in implementing agents was highlighted. Lastly, the Talk touched on implementing agent patterns and enhancing LLMs, with demos and code available for further exploration.
From Cloud to Edge Computing - Unleashing the Power of Webassembly at the Edge
Node Congress 2025Node Congress 2025
21 min
From Cloud to Edge Computing - Unleashing the Power of Webassembly at the Edge
In this Talk, the speaker covers the fundamentals of edge computing, cloud computing, and web assembly. They explore the synergy between WebAssembly (Wasm) and Edge computing and provide a use case demonstrating how Edge utilizes Wasm and edge computing. The evolution of cloud computing to edge computing is discussed, with a focus on adding computing to the CDN layer. The recent developments in compute capabilities on CDN networks, such as edge workers and serverless functions, are highlighted. The potential of WebAssembly for backend development and distributing portable binaries is showcased, along with its support in Node.js. WebAssembly runtimes and their role in enabling quick execution and secure sandboxing at the Edge are discussed. The talk also mentions the ability to perform secure data collection and the announcement of a component registry for WebAssembly components.
Make Hono work on Node.js
Node Congress 2025Node Congress 2025
15 min
Make Hono work on Node.js
Today's Talk is about making Hono work on Node.js. Hono is a backend for web frameworks that supports TypeScript. It started as a Cloudflare workers framework and now supports multiple runtimes. The Node.js adapter allows Hono applications to run in Node.js by converting Node.js APIs into web standard APIs. Benchmark tests show that Hono is faster than Express but slower in some core areas. The Node.js adapter has been widely used and has undergone performance improvements. Overall, adding Node.js support to Hono has been successful in reaching more users and improving quality.
The Path to Native TypeScript
Node Congress 2025Node Congress 2025
24 min
The Path to Native TypeScript
Today's Talk discusses the integration of TypeScript in Node.js. The path to native TypeScript in Node.js is explored, including the history of user requests for native support. Implementing TypeScript in Node.js poses challenges due to differences in stability guarantees and tool compatibility. TypeStripping is a transpilation-focused implementation that removes non-JavaScript features, making it stable across TypeScript versions. The Amaro package, built on SWC, provides compatibility and speed for type stripping. Experimental Strip Types and Transform Types flags enable erasable TypeScript features. TypeScript has limitations such as namespace and enum support in JavaScript and code migration issues. TypeScript Import Types and Syntax Detection are ongoing developments. Ambiguity in syntax between JavaScript and TypeScript is addressed with an erasable syntax only flag. Future steps include bug fixing, performance improvements, and upcoming Node.js releases.
What's in a Node.js Bug – A Case Study
Node Congress 2025Node Congress 2025
23 min
What's in a Node.js Bug – A Case Study
I'm going to talk about character encodings, specifically a Node.js bug related to UTF-8. Two popular encodings are UTF8 and UTF16. The bug was discovered in August 2024 and was traced to a specific pull request in the Node.js core repository. The bug is caused by an incorrect implementation of the fast write string method. Lessons learned include the importance of naming conventions and thorough testing beyond coverage analysis.
Thinking Like an Architect
Node Congress 2025Node Congress 2025
23 min
Thinking Like an Architect
In modern software development, architecture is more than just selecting the right tech stack; it involves decision-making, trade-offs, and considering the context of the business and organization. Understanding the problem space and focusing on users' needs are essential. Architectural flexibility is key, adapting the level of granularity and choosing between different approaches. Holistic thinking, long-term vision, and domain understanding are crucial for making better decisions. Effective communication, inclusion, and documentation are core skills for architects. Democratizing communication, prioritizing value, and embracing adaptive architectures are key to success.
ChatGPT Unleashed: Revolutionizing Web Development from Idea to Deployment
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
22 min
ChatGPT Unleashed: Revolutionizing Web Development from Idea to Deployment
Welcome to Chad GPT, Unleashed, Revolutionizing Web Development. I'll share my journey and lessons learned about GPT-03-Mini-High. TLDR: Good with slower-changing technologies, poor with rapidly moving ones. Let's test the application by building a vision board. User stories, requirements, acceptance criteria, and design principles were well-executed. Mobile responsiveness, accessibility, security, and scalability are important. LLM struggled with error handling and installation, but we managed to troubleshoot. The app creation process was painful, but we created a better version. Some end-to-end tests failed. Automated tests didn't consider challenges and project structure. Continuous integration failed during deployment, but manual deployment worked. Majority of LLM tools worked. AI's impact on hiring: current roles remain, but new hires are affected. AI enhances my abilities, reducing the need for hiring. Thank you for your time.
Supercharging Your Developer Workflow with Amazon Q Developer
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
26 min
Supercharging Your Developer Workflow with Amazon Q Developer
Vikash Agrawal
Abeetha Bala
2 authors
Today's Talk introduces Amazon Q Developer, an AI-powered conversational assistant that assists with software development lifecycle (SDLC) tasks. The speaker demonstrates building a 2048 game using Q Developer, which automatically detects the codebase and implements logic for the front end. The agent also generates tests for the code and helps identify bugs. Q Developer can generate documentation by analyzing the code and facilitate code reviews to find security vulnerabilities. The session covers error handling, deployment using AWS SAM, and debugging with Q Developer and CloudWatch. The speaker plans to deploy the application on EC2 in the future.
How AI Can Automate 70% of Code Review: Reducing Burden and Improving Code Quality
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
15 min
How AI Can Automate 70% of Code Review: Reducing Burden and Improving Code Quality
Hello, everyone. I'm Mansa Hari, and I'm very excited to open the session on how AI can automate 70% of code review and reduce the burden on developers. AI can cut review time, automate PR suggestions, and identify code issues. Implementing AI code reviews can reduce manual review time, ensure high code quality, and accelerate development cycles. The future of AI in code reviews includes understanding business logic, intuitive code suggestions, and hybrid AI-human reviews. Tools like Co-Pilot can be used to automate code review tasks and improve code quality.
Managing Context in AI Coding Assistants: Achieve Better Results with Fewer Hallucinations
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
20 min
Managing Context in AI Coding Assistants: Achieve Better Results with Fewer Hallucinations
Today's Talk discussed integrating context into AI coding tools using the MoloContext protocol (MCP). The demos showcased the use of Conduit, an MCP tool, for bug tracking and feature addition in software development. The Talk also highlighted the use of Fetch in Cursor to summarize GitHub issues and create Jira bug reports. It demonstrated how Conduit can be used to manage issues, make code changes, and perform Git commits. Additionally, it explored the integration of Conduit with Windsurf to add a user interface for the conduit application. The Talk also touched upon implementing MCP in the AIDER AI coding system and using MCP and Windsurf for Conduit integration. Overall, it emphasized the importance of context and choosing the right tools for efficient software development workflows.
AI Engineer End-to-End Workflow: Productivity Challenges and Their Solutions
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
22 min
AI Engineer End-to-End Workflow: Productivity Challenges and Their Solutions
Today's Talk explores productivity challenges and solutions for AI engineers, focusing on an application called Contoso Chat. The end-to-end workflow is examined from a productivity perspective, introducing the concept of Exposure to AI. Building an AI application involves ideation, augmentation, and operationalization stages. Provisioning and setup are crucial steps, with infrastructure as code being a productivity tool. GitHub Codespaces and development containers provide consistent development environments. Azure AI Inference API allows easy iteration and prototyping. AI-assisted evaluation involves training AI models and using evaluators for grading responses. Custom evaluators can be created. Overall, the Talk emphasizes the importance of productivity throughout the AI engineer's journey.
Revolutionizing Technical Documentation with AI
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
15 min
Revolutionizing Technical Documentation with AI
Hello, I'm Vitaliy Shchur. AI is revolutionizing technical documentation, creation, aimement, and maintenance. Precise, well-structured technical documentation is crucial for successful projects. With AI-powered tools, we can automate documentation processes, ensuring consistency, clarity, and efficiency. AI can create epics, user stories, and test cases. It applies a standardized glossary, detects outdated content, and improves readability. Digital assistants and tools like Miro Assist help gather requirements and enhance meetings. Automating epics and user stories creation from the SDD reduces manual effort and keeps documentation up to date. AI simplifies test case generation, improves documentation readability, and detects ambiguities. AI tools like GitHub Copilot and Microsoft Copilot automatically generate API documentation, code comments, and suggestions. AI eliminates the need for users to read documentation through personalized chat bots and virtual assistants. Challenges include manual review, context limitations, security concerns, and initial productivity drop. Best practices involve combining AI with human expertise and training AI models. The future of AI in documentation includes improved accuracy, intuitive integration, and increased automation.
How to Master Cursor for Rapid Development
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
29 min
How to Master Cursor for Rapid Development
I'll walk through some of the ways I set up Cursor to help speed up my full stack workflow. The main thing to check is indexing the code base. Cursor also looks at the get graph file relationships. Another important setting is large context, which allows absorbing larger files and multiple files of context in the prompt window. Iterating on lints helps find and fix errors faster. Web search tools and uploading your own docs are also available to enhance the prompt window. These are all preferences, including auto select, YOLO mode, and models. Rules are also crucial as they guide the model to understand your workflow. Implement best practice error handling and adjust rules as the models and system prompts change. MCPs like sequential thinking, Postgres SQL, and Puppeteer help refine thoughts and automate workflows. Creating a product requirements document in a .md file allows AI to ground itself in project information. The game was successfully implemented and all items were checked off. Debugging strategies involve adding debug logs to help identify issues. Use commit messages to provide clear documentation for changes. Demonstrating the use of AI in debugging by setting up and utilizing debug logs. Showcasing the benefits of providing debug information to resolve issues. Overview of various topics including indexing rules, linting, MCPs, PRDs, tech stacks, and checklists.
Can Machines Learn Bug Language?
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
27 min
Can Machines Learn Bug Language?
In this Talk, the speaker discusses the importance of analyzing bugs in software development. Analyzing bugs goes beyond just counting them; it helps improve processes, understand root causes, and gain insights through machine learning. The Talk emphasizes the need for proper communication with bugs and the importance of preparing the bug analysis environment. Automation and visualization can improve bug analysis efficiency, and a comprehensive analysis of different metrics is necessary to gain insights for improvement. The Talk also highlights examples of bug analysis and the use of machine learning for pattern recognition. Bug severity estimation using machine learning algorithms and the use of clustering for bug analysis are also mentioned. Overall, the Talk provides valuable insights on bug analysis and its role in improving software quality and productivity.
Leveraging Developer Productivity Engineering Practices for Greater Impact as an IC
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
26 min
Leveraging Developer Productivity Engineering Practices for Greater Impact as an IC
Hey, my name is Mikhail Levchenko. I've changed my job and became a full-time developer productivity engineer. Let me share a little story. Imagine being a wealthy trader in 15th century Europe. Delivering spices for profit was not an easy task. Middle East nations heavily taxed any traders. But the Portuguese sailed around Africa using the Mariner's Astrolabe. Fast forward, Gerardo Mercator invented a map perfectly suited for deep ocean navigation. The Dutch East India Company became the new king of the spice trade. Developer productivity is about building a cozy environment for developers, solving hard problems, and identifying process bottlenecks. It focuses on the whole development process as a product. By leveraging this perspective, you can drive change among developers and other roles. Observing developer processes as a product involves meeting stakeholders, formulating a vision, creating a model and metrics, finding productivity problems, and proposing solutions. The stakeholders include developers, CEOs, CTOs, engineering managers, and other roles involved in software development. The goal is to make everyone more productive, guided by the motto of happier developers building better software faster. There are three highlighted frameworks in this talk: DORA, DEVX, and Mertrix. DORA focuses on speed and reliability with metrics like acceleration frequency, lead time, failure rate, and recovery time. DEVX addresses the human factor with metrics related to feedback loops, cognitive load, and flow state. DX4 is a recent metric that combines DORA and DEVX, introducing proprietary metrics for top management. It includes a failure rate to encompass reliability and a percentage of time spent on new features. Engineer-developed metrics like the reliability metrics from Dora and the percentage of time spent on new features are valuable additions. Talking to top management about changes is made easier with a cool metric. Research concerning metrics, consult stakeholders, and read literature to improve understanding. Try prototypes before developing custom tools as a last resort. Confirm success with empirical metrics. Release managers often feel constantly interrupted and overwhelmed by the task of supervising a release. Sharing the role with the entire team proved to be ineffective, leading to forgotten procedures. Automation and streamlining of the release process improved satisfaction and reduced delayed releases. Make developer productivity part of company goals and culture code. Advocate for developers to top management. Drive change by starting small, experimenting, and using tools as a last resort. Find ways to make teammates more productive.
AI-Powered Frontend Development: Building Better UIs Faster
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
19 min
AI-Powered Frontend Development: Building Better UIs Faster
Today's Talk introduces the use of large language models (LLMs) to enhance front-end development. LLMs can act like our brains by maximizing the good parts and minimizing the bad parts. A demo in Cursor, an IDE, showcases how LLMs can be used with the builder.io Figma plugin. The Talk emphasizes the automation of tasks, such as adding a settings button and resolving errors, with the AI agent. Feedback and manual verification are crucial to ensure desired results. Tests and continuous iteration are recommended for stronger guarantees of correctness. Monitoring and guiding the AI agents is important to stay on track. Connecting to other tools like Figma and using AI prompting can further enhance code generation. The CLI enables code base integration and parallel development. Visual prototyping and seamless updates are possible with the Builder tool. Overall, the Talk highlights how LLMs can revolutionize front-end development by automating tasks, improving efficiency, and facilitating collaboration.
How Windsurf Breaks Through the Celling for Retrieval
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
22 min
How Windsurf Breaks Through the Celling for Retrieval
Hello, Productivity Conference. We are Winsurf, a brand new AI-native code editor. Today, I'm going to show you how the product works, the guiding principles behind its development, and some tips and tricks on using AI in development workflows. Our agent is a powerful tool that abstracts away grunt work, making developers focus on building and shipping great products. It performs background research, predicts next steps, and automates decision-making. Windsurf integrates deeply into the application, understanding what you're doing and providing tools to achieve your goals. The agent can remember instructions and behave like an extension of yourself. Building for the future of intelligence, Windsurf aims to improve productivity and revolutionize coding with AI agents.
The Next Chapter of Dev Productivity: Aligning Experience with Excellence
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
19 min
The Next Chapter of Dev Productivity: Aligning Experience with Excellence
Hi, everyone. Thanks for joining this talk on the next chapter of Dev Productivity, aligning experience with excellence. My name is Jeff Schnitter. I'm a Solution Architect at Cortex, and frankly, I'm not sure if I'm qualified to give the talk about Dev Productivity and aligning experience with excellence across the entire industry. So, good developer experience make developers happy. Great NGX makes the business thrive, and this ties it back to developers being happy. NGX excellence is really a constant journey. The adoption of those tools makes sense. It's still really difficult to make sense through all of that. Think about a developer whose job is really to understand the complexity of writing code and deploying it in different environments. Developer productivity is about reducing friction and enabling them to write better, performing, and secure code. Customers are on different paths in their journey to engineering excellence. AI can play a huge role in the engineering ecosystem. Metrics and a broader perspective beyond tools are necessary for engineering excellence. DevEx and engineering excellence are essentially the same, focusing on freeing up developers to write feature code and get ideas to production while addressing challenges like cost and security. Cortex invites you to join engineering excellence activities and share thoughts on completing the journey from DevEx to engineering excellence. The conversation and journey never end, so being prepared and adaptable is crucial.
Notes System That Will Let You Thrive: Craft Your Own Path to Productivity
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
22 min
Notes System That Will Let You Thrive: Craft Your Own Path to Productivity
Hello, welcome to my presentation on building your own Node system. I want to share my tips and mistakes so you can learn from them. Having a personalized system is valuable. I use a combination of Bullet Journal and Apple Notes. Logstick is my current system and I love it because it allows easy creation of notes and tags. The four core things that make a system work are engagement, easy search and retrieval, frictionless addition of new notes, and feeling supported. Note-taking provides peace of mind and eliminates the need to remember and search for information. Customize your note system to suit your preferences. Experiment with different note-taking apps and find one that works for you. Consistency matters more than the tool you use.
Maximize Productivity with AI Agents
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
25 min
Maximize Productivity with AI Agents
I'm Tejas Kumar, a software developer with over 20 years of experience. AI agents are defined as entities that act on behalf of users or groups to produce specific effects. Agents consist of an orchestration layer, a language model, and tools represented as JSON functions. Langflow is an open-source tool that allows users to build their own AI agents by connecting language models and tools. Composio is a tool that enhances agent capabilities by offering integrations and apps, such as Google Calendar integration. MCP (Model Context Protocol) is a way to share context with models and extend their capabilities. It allows functions to be made available to models over standard input/output or an HTTP endpoint. MCP can be used with GitHub to perform various tasks like searching and fixing code issues. The Talk covered the basics of AI agents, building agents with Langflow and enhancing them with Composio, and using MCP with GitHub. The speaker encouraged audience questions and exploration of these concepts.
AI-Powered Development: From Curiosity to Creativity
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
19 min
AI-Powered Development: From Curiosity to Creativity
Welcome to my talk on AI powered development. We'll explore the implications of AI tools and where the value lies in software development. We're transitioning to a new age where AI plays a significant role in coding. The new workflow involves asking AI for code, verifying it, and continuing to build. AI tools are available in the market, offering different options for developers. It's important to choose the right approach that aligns with your goals. Keeping IDE and AI separate allows for better control. The value of AI-powered development lies in architecture, scalability, and creativity. We're in the early stages of AI-powered development, presenting a significant advantage for those entering the field now.
Building the Next Generation of AI Developer Tools
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
26 min
Building the Next Generation of AI Developer Tools
Hello, everyone. My name is Krzysztof, and I will be talking today about developer tools, AI, and how we use both of those to create the next generation of developer tools. GitHub Copilot, released in 2021, revolutionized developer tools by automating boring parts of coding and keeping developers in a state of flow. Suggestions are shown directly in the editor and clearly separated from the real code. Chat interfaces, like Chat GPT, solve quality of response issues and are useful when flow doesn't exist. The next generation of tools focuses on structured exchange, user control, and iteration. GitHub Spark allows users to create small applications without focusing on code. Designing applications with the user in mind and handling ambiguity is important. Real-world software tasks require human guidance, and exploring new ideas beyond chat-based AI is necessary. Always consider the human aspect and ethical considerations when using AI-powered features.
Can AI Truly Enhance Manager Productivity?
Productivity Conf for Devs and Tech LeadersProductivity Conf for Devs and Tech Leaders
27 min
Can AI Truly Enhance Manager Productivity?
Today's Talk discussed the potential of AI to enhance managerial productivity. The importance of frameworks and Git in coding was emphasized, as well as the need to stay updated with new technologies. Various AI tools and their use cases were mentioned, with a focus on data security. The benefits of using AI agents and case templates for project management were highlighted. AI tools for presentations, automation, and bias in AI models were also discussed. The limitations of AI and ethical considerations were mentioned, emphasizing the need for human creativity and accountability. Overall, the Talk provided valuable insights into the role of AI in software development and engineering.
How to Train Your Designer?
React Day Berlin 2024React Day Berlin 2024
17 min
How to Train Your Designer?
Hello, I'm Dora Moxie, a UX designer with experience in software development. Training a designer benefits the whole development process, ensuring smooth delivery. Designers have a unique perspective and prioritize problems by involving engineers and testing solutions. Effective communication and documentation lead to faster delivery. Designers empathize with the customer and understand the problem and business requirements. Collaboration between designers and developers is crucial for solving problems. The product trio of product management, engineering, and design work together as equal partners. Collaboration and iterative design lead to learning, growth, and stronger solutions. Be open-minded and collaborate with designers and involve users to solve real problems and increase satisfaction.
Testing Our Way to a Better Developer Experience
React Day Berlin 2024React Day Berlin 2024
21 min
Testing Our Way to a Better Developer Experience
I want to talk about the importance of testing and how it can improve the developer experience. Lack of tests can lead to issues and breakdowns in productivity. The challenges of using TDD and testing last are discussed, along with the benefits of writing tests early. Effective tests provide valuable feedback and save time. Prioritizing user-focused testing and using tests as documentation are recommended. Tests should resemble user behavior, and enhancing testing capabilities with linters and custom matchers is suggested. Advanced testing techniques can improve developer productivity.
Future-Proof Your UI: Building With Web Components
React Day Berlin 2024React Day Berlin 2024
27 min
Future-Proof Your UI: Building With Web Components
Today, Darko discusses the use of web components to futureproof UIs and their compatibility with multiple frameworks. He addresses the challenges of web components and introduces the Solid Element tool for better developer experience. The demo showcases the usage of props and slots in web components and explores event handling. Darko also demonstrates how to integrate web components with React. He emphasizes that web components are not a silver bullet but are valuable for specific use cases and can be replaced with frameworks. He highlights the usefulness of web components for design systems and projects like SuperTokens. Web components are also suitable for widgets and leaf components.
Plants vs Thieves: Automated Tests in the World of Web Security
React Day Berlin 2024React Day Berlin 2024
25 min
Plants vs Thieves: Automated Tests in the World of Web Security
Hello everyone, and I'm so happy to see you here in React Day Berlin. This talk is on security and testing, two topics I'm passionate about. It's a wonderful allegory on web security using Plants vs. Zombies as inspiration. There are reasons to focus on testing as a line of defense. Learn your application and its vulnerabilities. Tests are the messenger, listen to them. Use OWASP's top 10 ranking to understand the most important security risks, including broken access control and cryptographic failure. Injection is a major security risk. Writing proper tests and using test cases can help mitigate this issue. To test for injection vulnerabilities, write negative tests that simulate extra injections in input fields. Test content security policies using Cypress. Implementing best practices and multiple defenses can keep attackers at bay. Automation is essential for detecting security issues in your app. Write test cases, use the features of test frameworks, and consider using different types of testing.
How I Support Over 100 Languages in My React app...and You Can Too!
React Day Berlin 2024React Day Berlin 2024
28 min
How I Support Over 100 Languages in My React app...and You Can Too!
I'm Richard Kerrigan, and I'm thrilled to be here today to show you how you can add multilingual support into your React apps. The problem we're trying to solve is that most websites, web apps, only publish content in one language, which is not convenient for users and is not inclusive for people for whom that language is not their primary language. We need a way to support other languages and dialects on our websites and web apps without adversely affecting our team's productivity. Now there are various ways we could approach solving the problem, depending on the resources we have available to us. But for the sake of this talk, let's assume that we don't have much budget to dedicate to this feature, nor do we have a team that can translate content for us. This is a fantastic use case for AI and automation. When my team started tackling this problem, we found the Azure AI translator service. It offers ad hoc text translation and document translation, with key features such as language support, cost-effectiveness, and accuracy. It also allows the use of custom glossaries to tweak the translation process. However, there are some limitations, such as compatibility with certain file types and the need for result validation and possible tweaking. Let's now focus on designing the workflow for translating content stored as JSON. Here's an example of how you could achieve this. We're taking the pieces of data that need to be translated and sending each piece through the translator. Then, we send the translated content as a response. For JSON content, the translation can be done at runtime in a React server component or an API route. For HTML or Markdown files, the translation can be incorporated into the CI-CD workflow, involving Azure Blob Storage, Azure Function App, and the app's source code files. Instead, we've moved the translation process to our GitHub Actions workflow. We provision the necessary resources in Azure, build and deploy the function app, and then perform the translation process. We configure the translation endpoint, specify the glossary for tweaking translations, and execute the translation. Once the translation is complete, we create a new blob in the output location. Our GitHub workflow ensures that all translations are done before proceeding to the next step, where we upload and download the artifact for deployment. This ensures that all content is translated and avoids errors for missing files. When setting up the translation process, it felt like magic. The pipeline for translating Markdown content is the same as for HTML content. The difference lies in how the metadata is handled. In HTML, the metadata is stored in the head of the file, while in Markdown, it is within the front matter section. When translating HTML files, the head needs to be translated as part of the process. For Markdown files, the metadata needs to be translated separately due to issues with Azure AI Translator. The translation function parses and translates the original files' metadata, then combines it with the translated files' content. The GitHub actions workflow provisions Azure resources, builds and deploys the function app, and runs the translation process for both HTML and Markdown files. The process is now deploying the ARM template that includes the necessary resources. We discussed the problem of limited language support on websites and web apps, the benefits of Azure AI Translator, and alternative solutions. We also explored different versions of the app for translating JSON, HTML, and markdown content without learning a new language. If interested, you can find more information and resources on GitHub and Azure AI Translator. The workflow is now deploying and translating the markdown files. It ensures all files are translated before deployment. Once the translation is complete, the files are put back into the repository. The deployment process guarantees the presence of all necessary resources. After a brief wait, the web app is ready to be viewed. The blog contains multiple posts. The metadata provides the title and excerpt for each post. The markdown is parsed into HTML for rendering. Formatting is preserved in different languages. Feel free to connect with me on LinkedIn or X.
Critical CSS
React Day Berlin 2024React Day Berlin 2024
18 min
Critical CSS
In this talk, we'll explore what critical CSS is, when to use it or not, how to implement it effectively, and some common challenges and use cases. The critical rendering path is a sequence of steps the browser takes to convert HTML, CSS, and JavaScript into visible content on the screen. Time and CPU are crucial factors in rendering content quickly, especially for mobile devices. Critical CSS matters because the CSOM can't be built incrementally, and the order of CSS rules affects their specificity. There are two primary ways to add CSS to your HTML: inline styles using style tags or external stylesheets using link tags. Critical CSS aligns only the styles needed to render the above-default content, reducing the size of render-blocking styles. There are manual and automatic tools for identifying critical CSS. Critical CSS is commonly used for static websites with statically generated pages. Testing the effect of critical CSS can be done using Lighthouse, Chrome Performance tab, or WebPageTest.org. BISTIs requires some extra handling but offers better performance. Over-inlining CSS and wrong style order can cause issues with critical styles. Implement optimization at build time.
From Lag to Lightning: Boosting React Native Performance
React Day Berlin 2024React Day Berlin 2024
17 min
From Lag to Lightning: Boosting React Native Performance
Hello, everyone. Today I'll talk about boosting React Native app performance. We'll explore optimization techniques, practical strategies, tools, and examples. Performance is crucial for mobile apps. Slow apps lead to frustration, abandonment, and revenue loss. We need to maintain 60 frames per second and overcome performance challenges. Let's understand the React Native architecture, legacy model, and the new architecture with JSI, fabric renderer, and turbo modules. Performance issues in React Native arise due to the single-threaded nature of JavaScript. The React Native bridge can be overwhelmed by large payloads, so using JSI for direct native communication is a more efficient solution. Profiling tools like Flipper, Chrome dev tools, React dev tools, Xcode instruments, and Android profiler help identify bottlenecks. Offloading heavy computations to web workers or JSI can improve JavaScript performance. Enable Hermes engine for improved performance. Optimize flatlist usage, delay non-urgent tasks, and prevent memory leaks for better app performance. Use initial numToRender and maxToRenderPerBatch props, memoize render item, and clean up side effects for optimized rendering. Preload and cache images, delegate gesture processing to the native thread, and continuously test the app under real-world conditions for smooth rendering and fluid UI.
Case Study: Building Accessible Reusable React Components at GitHub
React Day Berlin 2024React Day Berlin 2024
22 min
Case Study: Building Accessible Reusable React Components at GitHub
Hey, I'm Sid, and I work on the design systems team at GitHub. Let's talk about building accessible React components with a focus on screen readers. Use the correct HTML element for accessibility. For example, on GitHub, there are three tabs with options. These tabs are made using buttons. Let's see how a visually impaired person using a screen reader would access this website. What do they see? I'm going to enable the screen reader and walk you through what happens. When turning on the screen reader, it sets the context and tells you where you are. For example, on the React app, a button labeled 'Code' has focus and a menu popup. Inside the popup, there are several buttons with different labels. Something interesting happens. If I can't see the UI, I'm hearing buttons but no tabs. Screen readers cannot infer things like tabs from visual design. To provide this information, we can use the ARIA spec and its roles. By adding a role tab list to the div and role tab to each button, the semantics are conveyed. The role overrides HTML semantics. Screen reader identifies tabs, pronounces 'code spaces'. Default behavior of a tab is auto-focus. We can add aria-selected attribute to specify selection. Using React, I'm using an expression to set aria-selected based on the selected tab. The navigation into the tab panel is disorienting. There are separate groups for the tab list and tab panel, and there is a need for navigation between them. Use arrow keys to navigate within the widget. Remove tabs from the tab index, only the selected tab should be focusable. Implement arrow keys for navigation. Press tab to enter the tab panel. Press shift tab to go back up. Keyboard navigation is a common pattern extracted into a hook. Decide which keys to bind based on the widget type. Change selected tab on focus. Consider the ARIA authoring practices guide for keyboard interactions. Differentiate between instant and activated tabs. Follow the ARIA spec and use the APG as an informative resource. Screen readers may not always follow the ARIA authoring practices guide. Use correct HTML elements, add ARIA roles, properties, and states. Implement keyboard navigation. Use a GitHub example of notification settings with proper semantic elements. When selecting notification channels, the options are presented in a pop-up. The focus is on the first checkbox, indicating that it is the first option. The screen reader reads the status of each option. After selecting the desired option, the form can be submitted. The change is saved and the user is notified. The focus is recontextualized on the collapsed menu popup button. Not rendering the fourth option in certain conditions hides it from screen users. Removing the conditional and disabling the fourth checkbox until necessary eliminates this issue. Using IR disabled instead of disabled makes the element accessible for screen reader and keyboard users without affecting styling or click cancellation. You have to add your own class name and make sure it is disabled. It is accessible by keyboards. Voiceover on Mac uses 'dimmed' to signify IR disabled. Adding another span that requires at least one channel. Additional descriptions can be added using aria-describeby. SCREEN READER Only notify for failed workflows. Requires at least one channel to be selected. Dimmed unticked. Tick box. Now you know the label, why it is disabled, and that it's dimmed. And let's see if it's If I mean. Never. Menu popup collapsed. This flow seems more intuitive. You know all your options up ahead. One option was disabled, enabled something else, and it became enabled again. Much more clear. Feels like a better UI. We need to design with accessibility in mind. Accessibility isn't something that you can just sprinkle on in the end. We have to bring it way earlier in the stage. Be careful when disabling elements. Use RLDisabled. Short list of six things to consider. Links on my website. Follow me on Blue Sky.
ESLint One for All Made Easy
React Day Berlin 2024React Day Berlin 2024
21 min
ESLint One for All Made Easy
Hello everyone! I'm Anthony Fu, a coaching member of Vit, Vue, and Nuxt. Today, I'll share my findings and practices in exploring ESLink and its ecosystem. ESLink v9.0 released 7 months ago with the new FlatConfig, which simplifies plugin configuration and provides full control and customization in JavaScript. Migrate legacy config to FlatConfig with eslink-migrate-config CLI and use eslink-config-inspector for visualized step tool. Flag config utilities make config customization easier and allow project-aware configs. ESLink is a powerful AST toolkit and can be used as a formatter. Use ESLink for maintaining stylistic rules and customize it to fit your project's needs.
The Superpower of ASTs: How We Saved 16% on Our Bundle Size
React Day Berlin 2024React Day Berlin 2024
20 min
The Superpower of ASTs: How We Saved 16% on Our Bundle Size
Our story is about a super tool that reduces bundle size without changing code. It removes input statements, improves performance, and reduces bundle size. ASTs are used to optimize constant files by removing references and replacing with values. Bubble is a tool for code manipulation using ASTs. Manipulating code with Bubble paths allows for removing unnecessary variable declarations. Careful handling and testing are necessary when using AST tools. Guarding assumptions and writing exec tests are key practices. Completing the AST development lifecycle ensures correct code updates. ASTs are a powerful tool for software development.
Mastering Cache Control: Optimizing Performance for React Applications
React Day Berlin 2024React Day Berlin 2024
10 min
Mastering Cache Control: Optimizing Performance for React Applications
Today we're going to talk about utilizing caching to optimize our web application performance. We will discuss caching data and resources outside of our React application, how to control and avoid caching problems, and the benefits of caching for improving web application loading times and reducing server load. We can cache static resources like images, media files, scripts, and CSS, as well as application data like the list of articles or posts. However, we need to be cautious with caching data that may become outdated. The service worker and browser cache can intercept network requests and load responses from their caches. Additionally, headers such as cache control and eTag can be used to control caching behavior. The CDN, a content delivery network, maintains cached resources globally and aims to deliver content efficiently. Different caching points store various types of content, improving performance and enabling offline functionality.
Decoding Vector Search and Embeddings for React Developers
React Day Berlin 2024React Day Berlin 2024
28 min
Decoding Vector Search and Embeddings for React Developers
Welcome to my talk at React Day Berlin. Today, we'll discuss vector search and embeddings for React developers. Traditional search is broken, resulting in poor user experiences. Converting data into embeddings unlocks more accurate search, content recommendations, and document comparisons. Vector search measures the closeness or similarity of vectors using distances. In vector search, the closest relevant documents are found based on similarities between vectors. There are multiple ways to calculate the distance between data in vector search. Generative AI applications often deal with both textual and image data, making vector search useful. By converting queries and data into vectors, semantic meaning is considered, allowing for more accurate results. React and Next.js developers have access to a range of toolings, including BlankChain and AI SDK from Vercel. Retrieval augmented generation enhances search results by converting data into vectors and generating more coherent text. The user query is converted into a vector and matched using vector search, and the response is generated using the AISDK from Vercel.
How to Show 10 Million of Something: Frontend Performance Beyond Memoization
React Day Berlin 2024React Day Berlin 2024
29 min
How to Show 10 Million of Something: Frontend Performance Beyond Memoization
Today's Talk focused on performance optimization in React apps, specifically in handling and rendering enormous amounts of data. The speaker discussed various techniques and tools to achieve better performance, such as optimizing data relay, rendering, data processing, memory usage, and denormalization. They also highlighted the importance of optimizing network performance, payload size, and request handling. The Talk emphasized the need to measure before optimizing, focus on bottlenecks, and make small improvements that actually benefit users. Overall, the Talk provided valuable insights and recommendations for improving performance in React apps.
Atomic Power: the Story of StyleX
React Day Berlin 2024React Day Berlin 2024
25 min
Atomic Power: the Story of StyleX
Hello, I'm Naman and today I'm going to talk about atomic power and the story of StylX. CSS preprocessors like Sass and Less emerged to address challenges with CSS. In the evolution of CSS, there was a fork in the road with some moving towards CSS modules and others towards CSS in JS. Atomic CSS is about breaking styles into small, reusable pieces. Tailwind is a successful implementation of atomic styles. Stylix is a JavaScript compiler that generates atomic CSS and allows for defining styles once and reusing them. The speaker demonstrates the conversion of a design to Tailwind classes using Stylix. The TW function and parser in StyleX are discussed for defining constants and converting them into StyleX objects. Atomic CSS is a widely agreed concept and Tailwind can be used with StyleX. The React Strict DOM project is mentioned as a tool for writing UIs for web and React Native.
How to Code Images in React with SVG
React Day Berlin 2024React Day Berlin 2024
22 min
How to Code Images in React with SVG
Today's Talk is about coding images in React with SVGs. SVGs are powerful when combined with JavaScript and can be used to create interactive elements. Understanding SVG syntax and positioning is important, as SVG elements are limited to SVG-specific elements. The circle element in SVG can be styled and used to create shapes. The rectangle element is commonly used for charting and can be customized. The path element offers flexibility and can be built from multiple segments. Transformations and curves can be used to create complex shapes and animations. Bezier curves, both quadratic and cubic, are useful for bending lines and creating smooth transitions. Advanced features like drawing arcs are available in SVG. For more examples and use cases, visit svgtutorial.com.
React Compiler - The Missing Piece for Optimizing React Applications
React Day Berlin 2024React Day Berlin 2024
30 min
React Compiler - The Missing Piece for Optimizing React Applications
Today's Talk introduces the React compiler and its optimizations in React 19. The compiler handles optimizations internally, allowing existing optimizations to coexist. React 19 also brings server components, enhanced hooks, improved reference handling, and asset loading optimization. The React compiler follows the same principles as a typical compiler, with a Babel plugin and ESLint plugin identifying optimizations. The compiler optimizes components by performing in-place updates and reducing unnecessary re-rendering. The React compiler playground helps understand the optimization process. Caching JSX and configuring the React compiler can further optimize specific components. The React compiler is compatible with React 18 and 17 with some configuration, but using React 19 is recommended. Connect with the speaker for more information and subscribe to their YouTube channel. Thank you for watching!
Beyond React Testing Library: Testing React Libraries (and library-like code)
React Day Berlin 2024React Day Berlin 2024
22 min
Beyond React Testing Library: Testing React Libraries (and library-like code)
My talk is called Beyond Testing Library, Testing React Libraries or Library-like Code. We want to optimize code by minimizing re-renders, avoiding tearing, and ensuring granular rendering. React Testing Library may not always be the right tool for libraries or library-like code. We test for synchronous results, but there are cases where unwanted re-renders and inconsistencies can occur. We need to avoid flaky tests and bug propagation. The new Testing Library React Render Stream library simplifies testing by replacing complex wrappers and assertions. We test for multiple independent components and ensure correct re-rendering. We introduce Suspense and DOM snapshotting to test granular rendering. The final test provides increased confidence and meets all special requirements.
From Hip-Hop to Code
React Day Berlin 2024React Day Berlin 2024
26 min
From Hip-Hop to Code
Today, Elisabeth Oliveira shares her journey from being a hip-hop artist to becoming a design engineer. She highlights her experiences as an artist, including collaborations with Nike and Cristiano Ronaldo, but also the challenges of exploitation and cyberbullying. Transitioning into coding, she faced setbacks but found success as a coder in Dublin. She discusses her project, Cassette Tape, which automates illustrations and won the React Amsterdam award. Elisabeth also demonstrates her SVG audio player and performs a karaoke version of her song. She encourages combining passions with code and emphasizes the importance of open source. She concludes with insights on reconciling with hip-hop and starting projects. Overall, she shares her experiences in bridging the music and tech worlds.
Make the Web Weird Again
React Day Berlin 2024React Day Berlin 2024
29 min
Make the Web Weird Again
I'm Elian, the lead developer at React Bricks, and today I will talk about the weird web and how we as developers have the power to make it even weirder. We can use APIs like the Battery Status API to manipulate websites based on battery levels, but we should also be cautious about its potential for misuse. Another interesting API is WebHID, which allows interaction with hardware devices through the web browser. Tejas introduces WebMIDI and demonstrates how it can be used to control web applications using MIDI devices. The speakers emphasize the importance of embracing the fun and weirdness of web development and encourage experimentation. They also discuss the tolerance for failure and the joy of pushing the limits in building unconventional projects. Overall, the Talk highlights the potential for creativity and innovation in web development.
From Redux to Zustand to Jotai to Zustand to Custom: Our State Management Horror Story
React Day Berlin 2024React Day Berlin 2024
29 min
From Redux to Zustand to Jotai to Zustand to Custom: Our State Management Horror Story
Today's Talk is about Plux, a TypeScript application built with React and Three.js. The speaker discusses the challenges they faced with state management and their journey of switching libraries multiple times. They started with Redux but later introduced GSDAN, a faster and easier-to-maintain state management library. They optimized performance using selectors but realized it became a problem when dealing with documents with many nodes. They replaced Zustand with Jotite for better performance but encountered limitations and ultimately implemented a custom store, resulting in a significant improvement. The speaker emphasizes the importance of not locking into a solution and shares their timeline for the changes. They also mention considerations for state management, recognizing performance issues, and the possibility of open-sourcing their solution.
Building Web Applications with Signals at Grammarly
React Day Berlin 2024React Day Berlin 2024
29 min
Building Web Applications with Signals at Grammarly
Hello, welcome, everyone. Today, I'm going to talk about building web applications with signals in Grammarly. Signals are like values that can change over time and are used in Grammarly's editor for real-time updates. Signals can be implemented with React and are leveraged for state management and business logic. They enable functional reactive and declarative programming, allowing specific actions to be defined. Testing signals can be done using classical unit tests or marble tests. Signals are a perfect fit for Grammarly's domain and can be easily integrated with various libraries and frameworks. Handling cleanup and unsubscribing to signals can be done through the dispose method and React lifecycle. The main challenges in signal-driven systems are testing and debugging streams. Marble tests provide control over signal emission and combined states can be calculated using the view function. Grammarly is considering migrating to the signals proposal in the future. Thank you, Alexey!
Build Things That Don’t Scale at All
React Day Berlin 2024React Day Berlin 2024
9 min
Build Things That Don’t Scale at All
My talk is about building things that don't scale. It starts with wanting to use a specific app and then deciding to build your own app. Building something that scales requires thinking about various factors like analytics, monetization, SEO, expansion, localization, and competition. Building fun and non-scalable apps can also be enjoyable. Examples include an app for automatically cropping screenshots and a private chat app. The use of Expo Go as a launcher for Expo apps and hosting servers for auto-updates is discussed. The creation of a Google calendar synchronizer using Expo Development Builds is also mentioned. The final takeaways are to think small, have fun with libraries but avoid using too many, and stay away from the app store for as long as possible. Visit the speaker's website for more information.
React via Rust and Rescript: Why and How?
React Day Berlin 2024React Day Berlin 2024
31 min
React via Rust and Rescript: Why and How?
I'm here to talk about Rust and Rescript, languages in the React community that offer interesting possibilities. Writing React in different languages can improve performance and code correctness. TypeScript can be messy and has challenges in Material.UI, while Rescript offers better code quality and type safety. Rescript supports advanced React features and using functions for JavaScript APIs. The power of Rescript and WebAssembly lies in writing better React code and optimizing performance. Integrating SVG into React with Rust provides fast rendering and keeps the structure intact. Learning new languages can improve code quality. Re-script debugging and SVG performance are important considerations. React Server Components and beginner Rescript projects are discussed in the Q&A session.
Evaluating React Application Performance with a Sip of RUM
React Day Berlin 2024React Day Berlin 2024
10 min
Evaluating React Application Performance with a Sip of RUM
Hello, everybody. How are we all doing? I'm going to talk about Rome, OpenTelemetry, and identifying performance bottlenecks and issues in React applications. The pillars of observability are logs and metrics. Logs are structured messages that warn, indicate, or error. Metrics include throughput, latency, custom and core web vitals. Traces allow us to see through the pathway of our application and identify bottlenecks. One common open standard for collecting these signals is open telemetry. React's client instrumentation is experimental and mostly unspecified. The open telemetry demo provides an example of front-end tracing in React, giving you a unique service name and basic metrics. The demo shows an HTTP POST request with the pathway and timing. The open telemetry project is still working on core web vital metrics and other enhancements. Real user monitoring (RUM) fills the gaps in open telemetry, capturing missing information. In conclusion, we discussed the importance of capturing logs, metrics, and traces and provided resources for further exploration.
Little Bits of Iterative Component Design
React Day Berlin 2024React Day Berlin 2024
10 min
Little Bits of Iterative Component Design
Hey, everybody. My name is Daniel, and I like rocks. I'm a design system leader at Personia and something that I do like that is also a bit nerdy is math. I like math. There's many ways to solve a problem. One way to build it in an API is to make it with props. The next possible way could be composable components. Which one is better? Senior engineer answer would be, well, it depends. Props are really good with TypeScript. On the other hand, composition... You could have other types of components. You could create other types and put them and still work. Let's say I want to wrap it in a tooltip. You can see a bit of the differences in approach. This is a masonry layout. What kind of strategies can I use as an engineer for making my own decisions? One that I know is this one called YACNI. Over time, this creates tech debt. If you make a little bit of effort and make this reusable, it can go a long way in terms of API. And then the special situation that you want to handle just handling outside. At some point in my career, I was using a lot of YACNI and I started to work at Shopify in an open source project and I started to care about the APIs that I released because they are supposed to enable people to do the things they want to do and if it doesn't happen, then it's really sad. It's the same with design systems. If you make an API that is not good, there's a cost to it. How can I make good APIs? Let's see some of the big ones. TC39, they are the group that's actually creating the new JavaScript APIs. I made my own process that I call iterative component design where I try to figure out what is good enough for a release before putting it out. The step one is to prototype. And this is, again, doing Yagni. I think you can have better APIs if you follow a proper process. Second step, I usually write an RFC. When you do this, you realize what parts of your API sound really weird to explain. And the final step here is to share. Sharing is difficult because sometimes we have pride as developers and we don't want to take feedback and we just want to release immediately. But the problem with not getting feedback is that when you're working with a problem, you're unable to see objectively anymore. Sharing is good. All the APIs, there's never a state of nirvana for APIs. There's always feeling like something is not right, something is broken here. All my time working, I felt that we never got there and probably we will never. So all you can do is probably enjoy the process of creating APIs. That's my final advice. Thank you.
Making an Emulator in JavaScript?
React Day Berlin 2024React Day Berlin 2024
29 min
Making an Emulator in JavaScript?
Hello, everyone. Thank you for being here instead of the other talk. Emulation is when something pretends to be something else, like a computer pretending to be a PlayStation 1. There are two types of emulation: hardware emulation and software emulation. Software emulation is when the software mimics the behavior of a console. JavaScript is not the ideal language for emulation, but it can still be used. The speaker built an emulator for Chip 8, a simple console from the 70s, as a fun project. The emulator focuses on the screen and utilizes Canvas. The Chip 8 screen is small, measuring 64 by 32, and is monochrome. The CPU and memory are important components in emulation, and understanding hexadecimal notation and bitwise operators is crucial. The speaker explains the use of hexadecimal notation and bitwise operators in manipulating bytes. Creating a switch statement for instructions is an important step in the emulator development. The legality of emulation is discussed, along with advice on not providing ROMs or proprietary BIOS. Emulation projects can be complex, and reverse engineering consoles is mentioned. The speaker highlights the performance of JavaScript in emulating consoles. They also mention their availability for further questions and provide information on how to follow their work.
Make Real: Tldraw’s Accidental AI Play
React Day Berlin 2024React Day Berlin 2024
32 min
Make Real: Tldraw’s Accidental AI Play
I'm Steve Ruiz, the founder and CEO of Tealdraw. TLDR is a canvas app in React that allows developers to build with their SDK. TLDR pays attention to details that enhance the canvas experience and can be used to interact with different elements. TLDR's demos showcase its versatility, but may not perform well on social media. TLDR's AI collaboration features allow users to quickly turn their drawings into AI-generated images. The Make Real project helps users create user interfaces by drawing and providing prompts, generating working prototypes. The system behind Make Real can handle complex interactions and ambitious projects. OpenAI integration and the Steel Draw Computer enable building workflows and multi-stage generations. The goal is to bring the Canvas from being specialized to a primitive for the web. Teal Draw is free for open source and non-commercial use, with options to purchase licenses for additional features.
Meet React Flight and Become a RSC Expert
React Day Berlin 2024React Day Berlin 2024
31 min
Meet React Flight and Become a RSC Expert
My name is Mauro and I work for a company called Doubleloop in Italy. Today, I'm going to share my learning journey through puzzles and challenges related to React Server Components (RSC). RSC allows for server-side rendering and streaming of components. React flight, a protocol used to serialize and share rendering jobs, is a key feature of RSC. RSC can be used without a server, known as React Serverless Components. Using RSC, different types of content can be switched using the useState hook. RSC can be effectively used on a server by starting Node.js with a specific flag. Client-only components recognized by RSC can be executed on the client. React Streaming Components introduces the streaming concept and allows for continuous updates of the page. Advanced features of React Streaming Components include asynchronous rendering, suspense, and recursion. The React Strange Constraints challenge focuses on optimizing rendering by sending the initial page as HTML. The use of a proxy and RSE payload allows for client hydration of RSC. The possibility of using languages other than JavaScript, such as Rust, for server components is explored. RSC has the potential to become a language-agnostic protocol. The meaning of client-server roles in RSC can be extended. RSC offers streaming capabilities and the ability to balance server and client work. Infinite streaming is possible with server sockets. RSC hydration is believed to be faster than regular hydration. The Talk concludes by encouraging questions during the Q&A session.
Fine-Grained Reactivity Without Any Compiler
React Day Berlin 2024React Day Berlin 2024
29 min
Fine-Grained Reactivity Without Any Compiler
My name is Nicolas, and today, I'm going to talk about Fine-Grain Reactivity without the compiler this time. React is reactive, but it re-renders unnecessary components. Fine-grained reactivity is achieved by updating specific elements instead of whole components. Pigment encountered reactivity problems while building real-time financial data boards. They created their own reactive system on top of React to achieve fine-grained reactivity. They used custom hooks like useShell, useComputed, and useWatch to integrate React with their reactive system. They also considered using native JavaScript for optimization but chose to preserve React. They use external libraries like Zestand for flexibility, and maintaining reactivity during React updates has not been a problem.
The State of the Web: Key Insights From the HTTP Almanac 2024
React Day Berlin 2024React Day Berlin 2024
30 min
The State of the Web: Key Insights From the HTTP Almanac 2024
Today's Talk focused on Almanac 2024, a report that examines web sustainability. The speaker discussed various aspects of web sustainability, including page weight, unused CSS and JavaScript, image optimization, text compression, caching, and the usage of AI. They emphasized the need to reduce data transfer and carbon emissions through practices like green hosting and the implementation of lazy loading, responsive images, and text compression. The speaker also highlighted the importance of individual action and collaboration in achieving a more sustainable web. They called for volunteers for the next edition of the report and encouraged engineers to adopt greener practices. Overall, the Talk provided valuable insights into the current state of web sustainability and offered recommendations for improvement.
React 19 and the Compiler for the Rest of Us
React Day Berlin 2024React Day Berlin 2024
30 min
React 19 and the Compiler for the Rest of Us
Hi everyone. I'm Johnny, an application engineer who builds user-centric React 19 applications. Today, our goal is to help you reach production mountain with React 19. Let's start by gathering a crew and discussing the motives for installing the compiler. We'll revisit React rules and explore the compiler's impact on code. The React compiler translates from JavaScript to JavaScript and provides error reporting. It enables deeper levels of optimization and focuses on user experience. To upgrade to React 19, install the latest version and be aware of any compatibility issues. Check if any custom runtime code needs to be disabled. The React compiler can be used with versions 17 or 18 if you have runtime support. The compiler removes use memos and optimizes the initialization process based on static components. It provides granular reactivity and reduces rendering, making the application feel quicker. Follow React rules and conventions to ensure compatibility. Test custom hooks, be aware of the impact on build time, and address any unexpected issues like the removal of the global JSX namespace. Debugging tools and source mapping in Chrome are useful for understanding compiler output. Enjoy translating chants and exploring the possibilities of React 19!
The Age of Universal React: What’s the Catch?
React Day Berlin 2024React Day Berlin 2024
30 min
The Age of Universal React: What’s the Catch?
Mo Khazali
Anisha Malde
2 authors
We're going to talk about the age of universal React, the next paradigm shift of React. Universal React is cross-platform and follows the principle of learn once, write once, and run anywhere. React Native is born as a declarative way to build iOS and Android apps. React Native components and APIs are implemented in an interoperable way with React DOM, powering a large part of Twitter's web platform. Code sharing in a universal React app maximizes code reuse, reduces duplication, and allows platform optimization. React Native for Web is the compatibility layer that enables universal development, handling translations between React Native and React Dom. Expo is the framework of choice for React Native, with Expo Router V3 completing the universal story. Challenges in achieving parity with React Native Core due to specific platform implementations. React Strict DOM prioritizes web, bringing web APIs to React Native. Taking a universal React approach can improve performance across platforms. React Native Web and React Strict DOM prioritize performance and accessibility.
What Makes a Design System Win
React Day Berlin 2024React Day Berlin 2024
33 min
What Makes a Design System Win
Thank you all for welcoming me here. I am giving a remote talk on testing. The community here is warm and amazing. I hope Marin does well and we hope to see him soon. Six years ago, I joined a big tech company working on improving UX and UI. We released the UX improvement to 60 million users, but overlooked leveraging the design system. Recognizing the importance of the design system, I reached out to the design system manager to address the issue. I proposed solving meeting fatigue and defined my role as an internal developer advocate. Challenges in shipping code for developers and building credibility were discussed. The importance of fostering open communication, supporting users, and expanding workshops was emphasized. Continuing conversations through office hours and release demos improved adoption. Streamlining code updates and celebrating advocacy were key strategies. The speaker now runs a developer tools company called Tool Space.
Enhancing Forms with React Server Components
React Day Berlin 2024React Day Berlin 2024
27 min
Enhancing Forms with React Server Components
My name is Aurora, a web developer from Norway, demonstrating a practical example of working with forms and server components using React 19. The server function is created using the `useServer` directive and allows functions to be callable from the client. The form submission and validation are handled server-side using Prisma and a message schema with Zod. The useActionState hook is used for server-side logic and updating the client state. Client-side JavaScript is used for form behavior and preventing form reset. The form is progressively enhanced and can handle multiple submissions with feedback to the user. The talk also emphasizes the reusability of the pending pattern and creating custom client components. Optimistic updates are implemented using the useOptimistic hook. React 19 and server components offer a new option to create robust forms. Using server and client notations in production services should be done with caution due to potential data leakage. Endpoints and server functions should be handled securely. Other libraries like Conform and Vest.js offer options for optimizing forms with React 19.
React Query - The Bad Parts
React Day Berlin 2024React Day Berlin 2024
30 min
React Query - The Bad Parts
Top Content
React Query is a popular library with significant weekly downloads and positive user sentiment. It may have trade-offs like bundle size, but the actual size shipped is smaller. Bundle size optimization can be achieved by exporting only necessary features. React Query's declarative approach eliminates the need for custom data fetching solutions. It offers caching, request duplication, background updates, and more. RackQuery doesn't support normalized caching, but refetching after invalidation works fine. React's vision includes suspense architecture and server components. The documentation could be improved with a more structured flow. TensorStack Query can be a good choice for Next.js apps, but not necessary with mature frameworks. The 10 stack query and router concepts were discussed. Combining React Query with HTTP caching provides a robust caching solution.
React Server Components in AI Applications
React Day Berlin 2024React Day Berlin 2024
33 min
React Server Components in AI Applications
Good morning, React Day Berlin! Today we'll discuss the intersection of AI and React server components. AI engineering is like salt for React developers, enhancing product experiences. Generative UI uses AI to generate text and code, and we'll build a React app using server components with generative UI. AI can improve movie search by inferring context, and we'll build a collaborative movie search project. Implementing AI search involves creating an AI context and setting UI state. We can enhance the UI by adding a system prompt and creating an AI agent for rich UI. The generate function acts as a generator for the virtual DOM. Memory functionality and interactive movie components can enhance the UI further. The future possibilities include AI-generated UI for e-commerce and personalized recommendations. React server components and the intersection of AI and UI are essential for UI engineers. AI SDK is MIT licensed and available for further discussions.
From Insights to Innovation: Leveraging User Feedback and Data-Driven Strategies for Product Success
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
21 min
From Insights to Innovation: Leveraging User Feedback and Data-Driven Strategies for Product Success
Hello, everyone. I'm Sierra Coleman, and welcome to my talk. Today, we'll explore four key aspects of this approach: systematic gathering and analysis of user feedback, competitive analysis, using analytics tools like Looker, and the transformative role of AI in improving search match relevance. As a result, we saw dramatic improvements in the relevance ratings from our users, directly driven by user feedback. Competitive analysis helps us position ourselves uniquely and aligned to user demands. Looker and similar tools transform raw data into actionable insights, allowing us to make informed design decisions, segment users, identify bottlenecks, and have real-time visibility into product health. Integrating user feedback and data insights informs AI strategies to enhance search match relevance. AI techniques like embeddings, semantic search, and real-time scoring help improve search accuracy. Embrace these insights to enhance user experiences and drive success.
10 Game-Changing Personal Automations to Supercharge Your Productivity
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
27 min
10 Game-Changing Personal Automations to Supercharge Your Productivity
Hey there! I'm Andy O'Neill from WebLitica LLC. Let me introduce you to game-changing personal automations that can supercharge your productivity using Make, an automation tool. Make, a direct competitor of Zapier, can automate your work, connect to over a thousand apps, and easily scale your automations. One example is a daily briefing bot that helps you stay updated without overwhelming your brain with information. I've created my own AI personal assistant, also known as Jarvis, which summarizes a LinkedIn RSS feed, provides weather updates, and delivers the information as an audio file via Slack. You can use an RSS feed to get updates while commuting. One of my automations is a LinkedIn connection accelerator that generates personalized connection requests. Automate meeting notes with AI. This automation grabs and formats meeting notes, determines meeting duration, and adds them to Evernote. Automate voice-to-Evernote with your phone. Use an audio recording app to capture brilliant ideas on the go. Sync the recording to Dropbox, use ChatGPT to write the information, and save it to Evernote. Automate the transformation of emails into tasks in Monday. Content Curation for LinkedIn: Automate the process of generating and scheduling LinkedIn posts by watching an RSS feed. Unsubby Digest: Receive a daily summary of newsletters and manage email subscriptions more effectively. Save time and stay organized with this automated email summary. Automate faceless video creation for YouTube Shorts using an RSS feed and the Placid AI platform. Automatically generate a ranked list of candidates tailored to your needs with TapFlow. Automate capturing software recommendations to your second brain with a dedicated Slack channel. Save time by automating SEO optimized blog post generation. Get a free account with Make using the QR code. Start with the core plan for a free month. Take the Make Academy training to learn the basics. Join the co-build collective for business automation coaching. Get one-on-one help with your make automations. Connect and book a call at weblitica.com. Join the community and get started with Make.
No-Code Programmatic Pages for SEO and SEM Purposes
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
25 min
No-Code Programmatic Pages for SEO and SEM Purposes
Hello and welcome to the Productivity Conference! In this talk, Bożej Abel, CEO and founder of Lendingy, discusses the use of no-code programmatic pages for SEO and SEM. He presents two case studies, one about Lendingy and the other about the STS Gaming Group. The first case study focuses on generating leads by using programmatic pages to compare Lendingy with other solutions. The second case study explores how the STS Gaming Group leverages programmatic pages for real-time marketing of sports events. Both case studies highlight the benefits of using programmatic pages to automate and streamline marketing efforts.
Level Up Your Content with AI: A 20-Minute Crash Course
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
23 min
Level Up Your Content with AI: A 20-Minute Crash Course
Hi, and thank you for joining me today to learn about using AI to level up your marketing content. AI is important to marketers because it helps us do more. It benefits both low and high-performing marketers, leveling the playing field and boosting performance. Prompting effectively is crucial for creating quality content. Custom AI models can enhance content beyond commercial chat bots. To create good content with AI, follow the prompt framework and use specific prompts that follow best practices. Personalize content with GPTs by creating a marketing leader persona and training GPTs with specific instructions. AI can play a role in creating various types of content. These tools are changing our job and leaders prioritize hiring people with AI skills.
5 Ways to Turn Your Cold Outreach From “Meh” to “Wow!” With AI
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
40 min
5 Ways to Turn Your Cold Outreach From “Meh” to “Wow!” With AI
Hey, everybody. I'm Leo Goldfarb, a managing partner at albato.com. We're a no code integration and automation platform with 800+ out of the box API integrations. Our flagship product, albato embedded, is geared towards SaaS companies. Instead of burdening your team with developing integrations, you can embed our white labeled integrations in your SaaS. Our outreach is targeted mainly at B2B SaaS companies. We explore leveraging AI to boost outreach performance. Cold outreach has become increasingly hard, and some techniques that used to work are no longer effective. Let's dive right in and see the positive outcomes of our efforts, thanks to AI in our outreach. Even a reply like this is always better than no reply. We believe in making our messages meaningful and valuable to grab people's attention. There's a never-ending dilemma in cold outreach: personalized outreach or outreach at scale. With the help of AI, we can personalize at scale. Every outreach relies on high-quality prospect lists, impactful data points, and killer messages. The first pillar of outreach is high quality prospect lists. Gathering impactful data points helps prequalify leads. The spearhead of outreach is a killer message. The reply rate for this campaign was around 20%. After implementing AI in outreach, we focused on personalized and on-point messaging. We addressed the problem with integrations via Zapier and emphasized the need for native integrations. We leverage chat GPT to generate personalized messages and specific use cases for sense park customers. The campaign involves extensive personalization, including basic, buyer persona, and dynamic value propositions. We used an outreach dataset filled with AI-generated data points, including company details and integration use cases. We pulled customer reviews from G2 and used AI to identify the most common and critical problems with integrations. Chat GPT is good at determining review sentiment and identifying reviews mentioning integrations. However, it struggles with aggregating data and identifying hidden patterns. Chat TPT is better without setting hard boundaries, allowing it to be creative and provide convincing results. AI is effective at identifying isolated ICP criteria but struggles with complex composite ICPs. We attempted to use LinkedIn social activity as a conversation starter for sales, but the generated messages were off and dubious. To incorporate AI into our cold messages, we feed our prospect list to open AI via API. We train and tweak the language model through iterations until we're satisfied with the outputs. The AI-generated data points are then uploaded to our outreach automation tool, enabling hyper-personalized AI messages. We also offer white label, embeddable integrations for SaaS companies to provide seamless experiences within their platforms.
Methodologies for Implementing the Right No-Code Tech Stack
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
23 min
Methodologies for Implementing the Right No-Code Tech Stack
Welcome to my talk on methodologies for implementing the write no code tech stack. Today, we'll discuss choosing the right tools for your tech stack, process improvement methodologies, and give examples of no code tools for marketing teams. Consider user experience, budget, timelines, integration possibilities, customer support, and external expertise when choosing tools. Process improvement methodologies include lean management, continuous improvement cycle, brainstorming, process mapping, 5W1H, Lean management, the Deming cycle, Jodoka, and Kaizen. Total quality management is user focused, process centered, promotes integrated systems, is strategic, and systematic. Solver has its own automation methodology with four steps: identifying, executing, and continuous improvement through quality control and assessment. Some adaptable no-code tools for marketing teams are SmartSuite, ClickUp, and Zapier. ClickUp is a project management tool with different entities and lists for organizing content. Zapier is a no-code automation workflow builder that connects to thousands of cloud-based tools. Attend the workshop on December 10th to learn about Zapier's AI capabilities and tool integrations.
Mastering AI Content Automation for SEO: From Blog Ideas to Top Rankings
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
17 min
Mastering AI Content Automation for SEO: From Blog Ideas to Top Rankings
Hi all and welcome to my quick demonstration on how you can master AI content with automations for SEO. The wrong way to do AI-powered search engine optimization is by leaving everything to AI, which can lead to hallucination in content and regurgitation of existing information. Additionally, the lack of experience and expertise in AI can be a limitation. However, with the right approach and a little bit of research, automation can still be effective, as shown by the success of AI-generated content in ranking for certain queries like gaming laptop temperatures. And all this stuff is as a result from AI generated content. We can maximize it by following three steps: finding frequently asked questions, answering them with an AI writing tool, and checking and uploading the content. This approach can yield great results in the right niche. So, I've Googled gaming laptop temperatures and found the most frequently asked questions. One easy way is to scroll down to the people also asked section on Google. Another approach is to use the free tool called Also Asked. With machine AI, we can turn these questions into blog posts and generate traffic for our website that sells PC gear, gaming PCs, and cooling fans. We'll target gamers aged 25 to 40 looking for the best gaming gear. Instead of using a keyword, we'll paste the questions from the Also Asked section, making sure to vary them up a bit. Let's quickly write a cluster of interlinked blog posts using Machine.ai. Configure the settings, select the cluster of articles, and write them. Machine.ai allows direct publishing to WordPress, but it's recommended to publish as a draft for editing. The generated articles are ready to go, answering user search intent. Ensure your niche does not fall under your money or your life. Use AI and automations as an extension of your writing. Capture your ideas using an automation with Slack and transcribe them with Whisper. Use Perplexity to search for blog topics and generate well-structured content with a pre-trained GPT. Organize everything in a Google Sheet and publish wherever you want. All ideas are fleshed out using AI. Customize the output in HTML, markdown, or email format. Test a quick HTML preview to see the written blog post with interlinked information. Easily generate images and learn to use Slack and Make for automation.
Navigating the GenAI Revolution: 5 Strategies for Safe and Effective Marketing
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
25 min
Navigating the GenAI Revolution: 5 Strategies for Safe and Effective Marketing
Today's Talk discusses the effective use of Gen AI in marketing while prioritizing safety, ethics, and compliance. Challenges of using generative AI include data breaches, intellectual property theft, compliance violations, and damage to brand reputation. Best practices for implementing generative AI include secure data retrieval, masking techniques for sensitive information, and toxicity checking. Strategies for safe and secure usage of Gen AI involve implementing a sensitivity layer for data protection and developing a secure user interface. Additionally, ethics training, continuous education, and prioritizing ethical AI use cases are crucial for successful implementation.
From Scrapy to Scaled: You Finally Landed Resources to Grow Your No-Code Operations. Now What?
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
24 min
From Scrapy to Scaled: You Finally Landed Resources to Grow Your No-Code Operations. Now What?
Hi, my name is Phil Blayken. I am the head of Enterprise Innovation at Zapier, and I'm super excited today to talk to you about going from scrappy to scaled in no-code operations here at ProductivityConf. The rise of the ops hero starts with automating tasks using no-code tools like Zapier or Airtable, but it can lead to chaos if not managed properly. Proper documentation is crucial in no-code systems to avoid errors and ensure consistency. Effective management includes implementing monitoring tools and workflows, having clear accountability, and linking error resolutions to relevant documentation. Showcasing success stories and ROI helps to communicate the importance of your work and gain more resources. Selling pain instead of benefits can overcome resistance and help grow your career in ops using no code and automation.
Beyond the Buzz: Leveraging AI in Cross-Functional Communication and Collaboration
Productivity Conf - Practical AI in MarketingProductivity Conf - Practical AI in Marketing
17 min
Beyond the Buzz: Leveraging AI in Cross-Functional Communication and Collaboration
The Talk focuses on using AI tools for seamless collaboration across teams. AI serves as a translator between different teams, helping to overcome language barriers and jargon. Chat GPT prompts are used for effective communication and task tracking. Custom prompts are saved for mid-conversation use. Powerful tools like Chachi Petit and Arc Browser enhance quick communication and collaboration. Reflect generates AI-generated summaries and action items for messages, aiding in organization and prioritization.
Accelerating Value With HubSpot’s Unique Deployment Process and Team Structure
React Summit US 2024React Summit US 2024
15 min
Accelerating Value With HubSpot’s Unique Deployment Process and Team Structure
Watch video: Accelerating Value With HubSpot’s Unique Deployment Process and Team Structure
Welcome to Accelerating Value with HubSpot's deployment process and team structure. HubSpot is a leading growth platform that empowers businesses of all sizes to scale and succeed in the digital age. HubSpot's customer-centric approach focuses on value delivery, prioritizing the user experience, and building trust through consistent interactions. The front-end tech stack includes TypeScript, React, Redux, Styled Components, and GraphQL. HubSpot utilizes various developer tools to streamline workflows and reduce the technical burden on engineers. The testing philosophy at HubSpot emphasizes comprehensive testing, with a focus on unit, integration, and acceptance testing. HubSpot prioritizes customer-centricity, fosters innovation with small teams, and enhances developer efficiency with custom tooling.
Accessibility Granted: Building Inclusive Components One Test at a Time
React Summit US 2024React Summit US 2024
18 min
Accessibility Granted: Building Inclusive Components One Test at a Time
Watch video: Accessibility Granted: Building Inclusive Components One Test at a Time
At Evinced, the mission is to make the web more accessible for everyone. Accessibility issues are common despite intentions. Today's Talk focuses on coding in an accessible way using TDD to catch defects early. Unit tests can be written to ensure accessibility requirements are met. Testing Library provides utilities for testing accessibility. The ATDD approach allows continuous creation of tests for compliance. Unit testing is valuable for complex components. Advanced has developed an SDK called the Unit Tester for automating accessibility tests.
React UI Accessibility on TV - Practical Case Study in Real Production
React Summit US 2024React Summit US 2024
10 min
React UI Accessibility on TV - Practical Case Study in Real Production
Watch video: React UI Accessibility on TV - Practical Case Study in Real Production
I'm excited to talk about React UI accessibility on TV. Enact is a React-based framework designed for TV UI components. Keyboard navigation is the minimum requirement for accessibility. The Enact framework has a module called Spotlight for TV remote direction keys. All attributes and roles are supported in JSX. Practical cases include reading a Dingbae font icon with no text, handling range widgets, alert popups, and virtual components. Testing on actual devices is important. Useful tools for accessibility development include custom message announcements, static analysis with JSX A11y, and accessibility testing with Chrome DevTools.
Where Have the Women of Tech History Gone?
React Summit US 2024React Summit US 2024
29 min
Where Have the Women of Tech History Gone?
Watch video: Where Have the Women of Tech History Gone?
Hi everyone and welcome to my talk about the women in the history of computer science. I want to pay tribute to women who have done fantastic work in computer science. The history of computer science begins in 1840 with Ada Lovelace, who invented the concept behind the analytical engine and provided the first algorithms. Women played a significant role in early computing, such as the programmers of the ENIAC. Grace Hopper made significant contributions to the field, including the development of COBOL. Women have made significant contributions to artificial intelligence, such as Karen Spike Jones and her development of the TF-IDF method. It is important to highlight women in the tech field and provide role models for young girls. The talk aims to inspire and encourage.
Type-Safe App Configuration: A Powerful, Emerging Way to Accelerate Product Development
React Summit US 2024React Summit US 2024
20 min
Type-Safe App Configuration: A Powerful, Emerging Way to Accelerate Product Development
Watch video: Type-Safe App Configuration: A Powerful, Emerging Way to Accelerate Product Development
Today's Talk discusses type-safe app configuration and its benefits. It explores how app configuration can accelerate software development using the example of a SaaS company called Potion. The Talk highlights the use of feature flags to control app discounts and the advantages of decoupling discount control from the engineering team. It also covers the ability to run A-B tests, personalize discount messaging, and optimize for upgrades using an AI loop. The Talk emphasizes the flexibility of the app configuration system, allowing for managing multiple overlapping discounts and controlling various aspects of the app. Lastly, it mentions the necessary components of building a flexible app configuration system and how Hypertune offers these features.
Security Matters for Frontend Too! 7 Steps to More Secure React Apps
React Summit US 2024React Summit US 2024
29 min
Security Matters for Frontend Too! 7 Steps to More Secure React Apps
Watch video: Security Matters for Frontend Too! 7 Steps to More Secure React Apps
This talk covers seven steps to secure React apps, including dependency management, validation, secrets management, code exposure, content security, security implementation, and additional security measures. It emphasizes the importance of understanding dependencies and risks, using tools like NPM Audit and Socker.dev. It also highlights the need for dependency validation and package namespace, as well as input validation using libraries like Zod and Valobot. Secrets should be managed using tools like .env and a secrets manager, while code exposure can be minimized by separating server-side and client-side code. Content security policies and tools like Next Safe and Helmet are recommended for implementation. Additional measures include deep code analysis, code execution monitoring, and strict content security policies.
Making React Work in Chrome Extensions
React Summit US 2024React Summit US 2024
11 min
Making React Work in Chrome Extensions
Watch video: Making React Work in Chrome Extensions
Sriram Hariharan
Darshan Bhatta
2 authors
We're going to talk about making React work in Chrome extensions. We started building Chrome extensions during our freshman year and have learned a lot along the way. Chrome extensions have two parts: the content script and the background script. Our story begins before React, and we created the UT Registration Plus extension to simplify class registration. We initially built the extension using HTML strings and then tried using jQuery, resulting in unmaintainable code. When building Octoshop, we chose React for its support and package system, but integrating it with Ibotta's Vue extension led to a messy codebase. We centralized our code and managed Chrome's state using React portal and hooks, improving maintainability.
Writing Your First Vite Plugin
React Summit US 2024React Summit US 2024
19 min
Writing Your First Vite Plugin
Let's talk about writing your first Vip plugin. VIT, rollup, and Vip plugin are important tools in front-end development. Rollup is a bundler that can bundle JavaScript files into a single file. VIT goes through all the plugins and transforms files to JS modules. VIT and rollup have similar plugin architectures, allowing the use of existing rollup plugins in VIT. I'll discuss three plugin properties: resolve ID, load function, and more. Let's take a deeper look at the transform function. The resolve ID function determines the ID of the file or module, and the load function reads the file or module and returns its content. The transform function actually transforms the file or module into something else. For example, it can modify the code depending on the file extension. We can transform the result object into code by using object keys and map. This allows us to extract specific data and include it in the output. By making the code flexible, we can add additional information like 'built at' and utilize it for various purposes, such as displaying branch name or commit hash during deployment. You can implement various functionalities in the Vip plugin, such as reading Markdown files, implementing file-based routing, and creating domain-specific languages.
Beyond 1.0 - Lessons Learned and Things to Do After 1.0 Release of a Design System
React Summit US 2024React Summit US 2024
18 min
Beyond 1.0 - Lessons Learned and Things to Do After 1.0 Release of a Design System
Watch video: Beyond 1.0 - Lessons Learned and Things to Do After 1.0 Release of a Design System
Welcome to Beyond 1.0, a talk about scaling and maintaining design systems. A design system is a collection of reusable components, principles, constraints, and best practices governed by clear standards. We have expanded our design system over six and a half years to include over 70 components and support over 50 developers. To maintain a maintainable code base for your design system, enforce a singular code style across your entire code base through a linter. Use Next.js for a comprehensive and custom design system documentation site built with Markdown. We've improved our design system documentation by using react.gen typescript to dynamically parse out component props, allowing for more interactive and maintainable documentation.
How to Communicate Technical Ideas to Non Technical Audiences
React Summit US 2024React Summit US 2024
25 min
How to Communicate Technical Ideas to Non Technical Audiences
Watch video: How to Communicate Technical Ideas to Non Technical Audiences
Welcome to the session on communicating technical information to non-technical audiences. Today, we will explore how to apply your existing communication skills to share technical jargon. Understanding your audience through asking questions, making observations, and doing research is key to successful communication. When communicating with non-technical audiences, consider their baseline knowledge and avoid making assumptions. Use jargon when it is understood by all and explain unfamiliar terms when necessary. Analogies and stories can be effective in explaining complex concepts. Visual aids and experiences can enhance presentations. Clarify the purpose of communication to avoid misunderstandings. Utilize resources like written communication, podcasts, and videos to educate team members. Include others in technical conversations to learn and build something bigger. Effective communication requires context and understanding. Utilize the course 'Technical Communication for Non-Technical Audiences' on Pluralsight for further guidance.
How I Support More Than 100 Languages in My React app...and You Can Too!
React Summit US 2024React Summit US 2024
28 min
How I Support More Than 100 Languages in My React app...and You Can Too!
I'm Richard Kerrigan and I'll show you how to add multilingual support to your React apps. We need a way to support other languages on our websites and web apps without affecting team productivity. We'll explore a low-cost solution using AI and automation. When my team started tackling this problem, we looked at Azure and found the Azure AI Translator service, which offers both ad-hoc text translation and document translation. Key features include language support for over 100 languages and dialects, a generous free tier, Neural Machine Translation for accuracy, and the ability to use custom glossaries. Designing workflow for translating JSON content at runtime or incorporating translation process into CICD workflow for HTML or Markdown files. Exploring how to translate HTML files within a CICD pipeline. Translation service and storage account setup. Function app building and deployment. Configuring translation to Spanish with a glossary in CSV format for file translation. Sending a request to the translator and receiving the translated file. Discussing the problem of websites not offering content in additional languages. Highlighting the benefits of Azure AI Translator and its alternatives. Showcasing different versions of the app for translating JSON, HTML, and markdown content. Checking the progress of the workflow, deployment of Azure resources and function, and translation of markdown files. Quick explanation of infrastructure as code and deployment options. Changing languages shows translated title and excerpt while maintaining original formatting.
React Native, Meet node.js Native Addons
React Summit US 2024React Summit US 2024
18 min
React Native, Meet node.js Native Addons
Watch video: React Native, Meet node.js Native Addons
We'll be going over the use cases of Node.js native add-ons and how they are written with NodeAPI. ABI stability allows swapping out older versions of a library for newer ones without recompiling the rest of the app. Node API enables the use of the latest Hermes regardless of React Native Windows. NativeScript is a library for calling native APIs from JavaScript, eliminating the need for dealing with native code. To initialize the addon in React Native, we modified the approach by auto-linking the native script XC framework. We can read the battery level using inline JavaScript and make view changes like setting the background color. React Native reanimated can be used to work on the UI thread. Support for Node.js native add-ons and completion of the official ABI stable Hermes API would open up the ecosystem.
Speed Search: Making Expedia Flights Faster
React Summit US 2024React Summit US 2024
10 min
Speed Search: Making Expedia Flights Faster
Hello, everyone. I'm Hina from Expedia Group. This talk is about making Expedia flights faster. We will focus on performance initiatives on the Flight Search page, including prefetching and preemptive search. Monitoring is crucial with custom metrics like page usable time and non-supply overhead. Prefetching fetches JS bundles beforehand for faster CDN path retrieval, while preemptive search predicts Flight Search responses before the user lands on the page. The page performance improved up to 50% on both web and native. Preemptive search and microqueries were implemented to improve path and performance. Async loading and loaded query optimization resulted in an 8% improvement. Micro-front-end architecture improved bundle size and component reusability, leading to significant performance gains.
Building C++ / JSI Native Modules for React Native in 2024
React Summit US 2024React Summit US 2024
17 min
Building C++ / JSI Native Modules for React Native in 2024
Watch video: Building C++ / JSI Native Modules for React Native in 2024
In this talk, the speaker discusses the process of building C++ native modules for React Native. They explain that native modules allow for tighter platform integration and access to platform-independent performance code, but come with trade-offs such as increased build times and potential issues with crashes and package dependencies. The speaker clarifies the differences between the old and new architecture of React Native, highlighting the introduction of the JavaScript interface (JSI) and its benefits. They also explore alternative React Native architecture options, including TurboNativeModules and LegacyNativeModules. The speaker discusses the challenges of working with legacy native modules and the benefits of using NitroModules and pre-building native code. They conclude with recommendations for using Nitro modules, pre-building, and utilizing a compiler cache to optimize build times.
Gain Performance! Take Your Run Time to Build Time
React Summit US 2024React Summit US 2024
12 min
Gain Performance! Take Your Run Time to Build Time
Watch video: Gain Performance! Take Your Run Time to Build Time
Hi everyone! I'm Rohit, a founding engineer at Tria. We are working on bringing the world to Web3 using names. My talk is about gaining performance and taking runtime to build time. There is an upward trend in libraries towards build time optimization, especially in React. Build time optimization improves performance, reduces bundle size, and provides more predictable software. Babel is a free and open source JavaScript transpiler that allows leveraging latest JavaScript features and moving computationally heavy logic from runtime to build time. Building a Babel plugin involves checking for a style prop inside an HTML tag and searching for aliases or token values. The visitor pattern is used to define the JSX type of node and access its path and attributes. The plugin can be customized for different utilities by defining aliases and tokens in a config file. Helpful resources for understanding and building custom Babel plugins include the Babel handbook, Babel docs, astexplorer.net, and the speaker's Twitter account.
React Server Components: Elevating Speed, Interactivity, and User Experience
React Summit US 2024React Summit US 2024
20 min
React Server Components: Elevating Speed, Interactivity, and User Experience
Watch video: React Server Components: Elevating Speed, Interactivity, and User Experience
My name is Aurora, a web developer from Norway. Today, I'll be teaching you how to elevate speed, interactivity, and user experience with React components. I'll be coding a project task manager and improving it using Next.js, Prisma, Azure SQL, and Tailwind CSS. We will review the code, starting with the important layout component. We will also learn how to improve navigation and data fetching, enhance visual stability and user experience, fix search functionality, and add category filters with loading states. Additionally, we will explore the use of React 19 hooks to enhance interactivity. Finally, we will optimize rendering and achieve improved Lighthouse scores for better performance. Overall, this Talk covers a range of techniques and tools to enhance React projects and deliver a better user experience.
A 4-Year Retrospective : Lessons Learned From Building a Video Player From Scratch With React Native
React Summit US 2024React Summit US 2024
20 min
A 4-Year Retrospective : Lessons Learned From Building a Video Player From Scratch With React Native
Watch video: A 4-Year Retrospective : Lessons Learned From Building a Video Player From Scratch With React Native
Hello, React Summit. Welcome to this talk, a retrospective on four years in the making of our React Native video player. We will cover what went well, what didn't go well, and the lessons learned. We used React Native Video 5.2.1 and custom components to optimize the player. Streaming HLS, subtitles, and transcripts worked well. iOS performance was good, but the Android player and background audio management caused issues. Different media players and syncing audio players were challenges. Managing dependencies and versions was difficult. Upgrading React Native Video to version 6.4 improved stability and added notification features. Future updates will include DLL support and player-control separation.
Shining Offline: The Mobile BelIS-Online Wuppertal Experience
React Summit US 2024React Summit US 2024
17 min
Shining Offline: The Mobile BelIS-Online Wuppertal Experience
Watch video: Shining Offline: The Mobile BelIS-Online Wuppertal Experience
Hi, welcome to Shining Offline. I'll share how using the offline first approach saved us in the mobile urban lighting system. We'll discuss Kismet, the Bayless system, and the transition to a progressive web app. The system handled work orders, but the manual process caused unnecessary effort. In 2015, we built a native iOS app, but faced challenges with updates and communication. Eventually, we convinced the client to switch to a progressive web app. The new PWA's design improves usability and uses maps and services from the city's own infrastructure. Implementing the offline-first principle addressed many issues, and providing offline maps required using MapLibreGL app protocol. Offline communication with the iOS app endpoint and managing conflicts were also discussed. Offline-first requires significant effort but leads to user satisfaction. iPads are the devices of choice.
Building Scalable Multi-Tenant Applications With Next.js
React Summit US 2024React Summit US 2024
12 min
Building Scalable Multi-Tenant Applications With Next.js
Watch video: Building Scalable Multi-Tenant Applications With Next.js
Hello and namaste, New York. I'm excited to talk about building scalable multi-tenant applications with Next.js. We'll cover what multi-tenancy is, its advantages, key considerations, and how Next.js aids in development. Before starting multi-tenancy, let's understand what a tenant is. In multi-tenant architecture, all tenants share the same app but have different access, roles, and permissions. Easy maintenance, efficiency, scalability, and cost-effectiveness are some of the benefits of multi-tenancy. However, challenges include scalability, isolation, security, and customization. Next.js allows for easy organization of different domains and paths. Dynamic routing in Next.js enables the customization of layouts for each tenant, ensuring a personalized look and feel. Next.js API routing allows for isolating data fetching for different tenants. Middleware can handle request validation and provide features like authentication, authorization, server-side redirects, conditional redirects, and data isolation. Next.js offers scalability through caching, a component-based and modular approach, load balancing, serverless functions and platforms, and different types of rendering. Next.js continues to evolve and is a popular choice for multi-tenant architecture.
Limited to 100 talks. Adjust filters for additional content.