Come with me on a journey through hyperspace.

Remember Geocities? The unbridled creativity and questionable colour schemes of a bygone era. Or the early-00s teenage bloggers with pretentious domain names, expressing themselves through grungy photoshop brushes and scrappy PHP scripts. There was a time when websites existed as reflections of your personality or a shrine to your favourite band rather than carbon copies of a Facebook page or Twitter feed. Content wasn’t algorithmically curated, but shared through links pages and webrings.

With modern browsers, we have at our fingertips so many powerful APIs and tools to build the most incredible, beautiful and wonderfully pointless websites that have ever existed, in ways that are accessible and performant like never before. So why aren’t we? Why do all the websites look the same?

This is a manifesto for building something just for the fun of it, and a rallying cry to tell your story on a platform that’s entirely yours.

The goal of every great developer is to ensure that they are doing the best job that they can. Yet, with the advancement of software and the move to cloud-native ecosystems these past few years, things have become more difficult.

While developers used to be able to focus solely on the code that lived in their local machine, they now are also responsible for what happens once it leaves their machine and deploys to production.

Understanding what happens to your source code when you’re done writing it is a must-have skill for developers, starting from the building stage, integration, testing, and all the way through the CI/CD process.

In this talk, we’ll discuss everything the code goes through from the minute it leaves your local machine. We will dive into all the practicalities that developers need to fully own in order to step up their coding game and why they need to do so. Finally, I will share my real-life experience on what it takes to be a next-level developer through owning your whole development process.

In this time of the coronavirus epidemic, a lot of our plans have been canceled. From every bad situation, we need to try to see the good thing in it. Elad Shechter took his free time at home to create a pure CSS game. He will explain many tips and tricks on "how to create pure CSS games".

Bluetooth is present in every phone and laptop, making it the defacto choice for peripherals and the Apps that connect to them. It has achieved unprecedented economies of scale and pricing.

But what about Bluetooth for SaaS? Why is that not a thing? What if we could leverage all this investment and technology for extending SaaS applications with IoT capabilities?

This talk explores some of the trade-offs and opportunities that could come if Bluetooth could connect to your web backend, and the work we've been doing to create Bluetooth infrastructure and devices that can.

We hear about Developer Relations, or DevRel, quite a bit! We've also heard different definitions for it. We might've asked somebody in DevRel what they do and surely heard "Well, it depends..."

In this talk, we'll explore this!

We'll cover what the different pillars of DevRel are, the activities involved, and how to get started!

Have you ever thought about making some really awesome beats by coding? You can do that with Sonic Pi! Sonic Pi is based off of Ruby. You can create all types of beats and melodies with this technology and I can show you how to do it through a demo.

In this talk attendees will learn about Sonic Pi in a live coding environment, and will learn how to create different genres of music through coding.

Attendees will leave this talk with an understanding of Sonic Pi and learn about:

• making music
• making beats
• making songs
• music transcription and playback
• audio looping, computer-aided music composition
• development of computer-based musical instruments (including hybrid instruments)
• live performance

Plus, we'll conclude with a full live demo where I will turn my computer into a myriad of musical instruments to play music and songs of different genres

If you’re a JavaScript developer, you’ve no doubt jumped on the “Components are the best!” train, and use a development platform like React, Vue, or Angular. And for good reason, we all know of the joy of building applications from a collection of highly specialized, composable, and (hopefully) tested components can bring. Heck, the software practically writes itself! (But don’t tell our clients or bosses that.)

The problem (isn’t there always one?) is that as your application starts to grow, issues with this approach start to creep in. Consistency can be difficult to maintain. Testing starts to get more difficult. And while we often strive to build these components as stand-alone, isolated pieces of software, we usually end up needing to build and run the whole application to even see what they look like. And this can slow you down. And hey, wouldn’t it be nice if the QA people could actually help us out with some of this lower-level testing instead of having to go through the same simple 82-step process to make sure that we changed that font color from light blue to slightly lighter-blue?

The good news is that Storybook is here to make our lives (as developers anyway) so much easier!

Storybooks website says it’s an interface development and playground for UI components. But it’s so much more than that! With Storybook, you can develop your component in TRUE isolation, meaning that you don’t need to run the entire application to see how changes to your code affect how your component looks and works. It also helps developers stay consistent, helps provide component-level documentation, makes testing a lot easier, and enables QA to examine the components and try different scenarios to see how the component and the application react in different situations.

In this session, you’ll see how to add Storybook to your application, how the tooling works, and how to start writing your own stories. And while the examples will be in React, Storybook supports every major component-based platform, so the knowledge you gain will easily translate into whatever framework you’re working with.

UI performance bugs are probably the most frustrating bugs for both application users and developers. For application users they are just a bad experience that can lead users to abandon your product. For developers they are the hardest bugs to detect and ultimately debug––because they're basically impossible to find by just reading the code or running a typical debugger, and don't have any simple workarounds like others.

One of the less glamorous but incredibly useful tools to help catch and squash those elusive bugs before they reach your end user, is the browser dev-tools performance stack, which includes the Networking, Memory, Rendering, Code Bugs, and CPU. This talk will walk through some of the most common pitfalls in UI performance, and some good practices to help you avoid them. You can quickly reproduce these performance issues by calling the DOM and your app directly from the browser console, and running stress tests. Through code examples and a demo, you'll be able to learn some of the best kept secrets, tips and tricks for optimizing and debugging your UI performance for your fullstack apps.

We are excited to welcome Bruce Lawson to FullStack eXchange for a brand new keynote.

Stay tuned for additional details about Bruce's talk.

Do you know Git? I bet you do.

I also bet you use it, like 90% of the developers who answered last year’s StackOverflow survey. For sure you know all the basic commands to commit, pull, push... You might even rebase regularly, cherry-pick or bisect whenever it’s needed. Good for you — that's not what this talk will be about!

In this talk, we’ll focus on the rest of Git. The forgotten bits of trivia, the little-known, not-for-everyday commands. You won’t leave with much to apply directly in your terminal, but with plenty to talk about on your company’s messaging platform! We’ll jump from Git’s history to its core data structure, passing by some useful commands that you won’t resist trying out for yourself. If that sounds like fun to you, come on in!

Building static websites with a Jamstack approach offers a fantastic solution for building massively available systems without the downsides of traditional dynamic stacks like Rails, Express or Wordpress. But there is a different way. In this talk you will learn how to build massively available dynamic web apps with pure cloud functions. Functional Web Apps (FWA) are built with pure cloud functions, sport a builtin database and deploy quickly and reliably. No more waiting on slow builds. No more trading off a dynamic end user experience by pre-rendering spinners. We will build markup on the fly with the determinism and reliability of immutable deployments leveraging the power and simplicity of the ultimate building block: pure cloud functions.

This talk begins with giving a brief discussion on how and why should we build a micro frontends project. Then it extends into a detailed walk-through of micro frontends design process, including architecture, release process and automation. In addition, I will give demo of how we apply those good practices within the Chase UK App.

The modern technology stack traditionally consists of the Frontend, Backend and a Database. But we need a way to get our code from our computer to their server. The AWS Cloud Developer Kit (CDK) is a tool that allows us to write and deploy our infrastructure in languages used to write the rest of the stack, including Typescript. By leveraging the CDK we’re able to write our infrastructure, backend and frontend all in Typescript and even deploy it to Amazon’s serverless compute platform.

In this session Ryan will look at the basic concepts behind the CDK, what is happening when you use it and how it allows us to quickly and easily get a full stack Typescript application up and running in a language we are familiar with. We’ll look at how using the CDK allows us to fully embrace a DevOps culture and provide a friction free way to get our code into production using a language we are already familiar with.

In today’s increasingly digital business environment, the need to continue honing and upgrading skills is a given. Whether you’re a CTO reimagining a corporate technical strategy, or a developer creating systems that bring that plan to life, to improve your IT acumen you will need to translate the “people skills” you’ve built through your own unique experience —even if you started out as a hairdresser, like me. Those 15 years behind the chair taught me that success is 50% technical skills and 50% communication skills.

In this talk I will share three “soft skill” lessons from my salon days that have shaped my developer career and will help you apply your own personal experiences in furthering your professional journey:

• Listening to Learn and Learning to Relate Across Levels
• Walking In a Client’s Shoes
• Practicing Professional Patience

Wouldn’t it be great if you could use your coding skills to simplify your day to day tasks and boost your productivity with tools like Chrome Extensions? In this session, we will explore the magic behind Chrome Extensions and how you can write your own in just a few steps. We'll go over the basic manifest fields we need for that and conclude with a demo. I hope to inspire you to write Chrome Extensions, and that one of these days, I will see your creations in the Chrome Web Store.

Flipper is a platform for debugging mobile and web apps. Half a year ago, we decided to split the electron monolith in two parts: a standalone server and a UI. In this talk, we will cover why you need headless Flipper, what opportunities it unlocks for you. We will go over how Flipper can now be easily used for remote debugging, embedding, CI integration, and etc. We will overview how Flipper architecture transformed to support the migration, what Flipper is now, and how we plan to use it at Meta.

Unit tests? Integration tests? Mocks? Stubs? Fakes? How does this apply to the web? Let's look at all the ways you can test a web app and demo all the tools you'd use. We'll live-code most tests to show you exactly what makes a good testing strategy. You'll leave with a GitHub repo you can use to keep learning or fork and use in your own PWAs.

We all love sharing our work with the community, and GitHub Wrap enabled you to do just that. GitHub Wrap, a weekend project, got a lot of love on Twitter from the developer community. One could share the contributions they made to open-source using the tool. Created with tools like n8n, Cloudflare, and Cloudinary, the project handled 60k requests and delighted the tech community. But with love, there also came challenges. Join me to listen to my learnings from creating the project to managing it.

Regardless of the technology you know or the job title you have, you have amazing potential to impact your workplace, community, and beyond.

In this talk, I'll share a few candid stories of my career failures… I mean… learning opportunities. We'll start by debunking the myth that leadership == management. Next, we'll talk about some of the attributes, behaviors, and skills of good leaders. Lastly, we'll cover some practical steps and resources to accelerate your journey.

You'll walk away with some essential leadership skills I believe anyone can develop, and a good dose of encouragement to be more awesome!