Speaker

Austin Gil

Austin Gil

Developer Advocate & Cool Dude at Akamai

Portland, Oregon, United States

Austin is a web developer from Portland, Oregon. He's been breaking and fixing websites for a decade and has worked with award-winning agencies, innovative tech start-ups, and government organizations.

His goal is to keep building cool things for the web and have some fun teaching folks like you through writing, open-source, live-streaming, The Function Call podcast, speaking, and running workshops.

He's also trying to get better at writing his bio. Please cut him some slack.

Area of Expertise

  • Information & Communications Technology

Topics

  • HTML
  • CSS
  • JavaScript
  • Vue
  • Node
  • Accessibility
  • A11y
  • ExpressJS
  • Web
  • Web Development
  • Frontend
  • Backend
  • Full Stack
  • Remix
  • React
  • Vue Js
  • Programming
  • Software
  • Coding

What the Heck is Edge Computing Anyway?

The Edge is the new frontier of computing possibilities, offering promises, opportunities, and it’s own set of challenges. In this talk, we’ll break down what it is, why it’s awesome, and how it fits into your application architecture.

We’ll cover things like:
- What are the benefits
- What are the limitations
- When it makes sense
- When it doesn’t make sense
- How to get started

What's a dev gotta do to make a div around here?

A fanciful journey following your code from conception in the editor through the awkward build processes into deployment pipelines out to the real world of public internet and off to its final destination, being rendered in a user's browser.

The internet has become a complex place. With the advent of frameworks, build tools, and deployment services, the distance between developers and browsers is growing. Developer Experience has improved, but with these abstractions, we've introduced layers of obscurity.

This talk is intended for web developers of all skill levels, as it fills the gaps in knowledge of how our work works. The information is not critical, but it's fascinating nonetheless.

We'll take a deep dive into what happens after you hit save, what processes take place to get your code transformed for production, how does it get deployed, how it gets to the user, and the steps the browser takes to actually render the page.

Maintainable & Resilient Projects Through Internal UI Libraries

In this talk I’ll discuss the benefits of creating your own, internal UI library. It’s something I consider to be a best practice which will make your applications more maintainable and resilient to change. We’ll look at what it means, how to begin, and what options are available to help you.

Vuetensils: A Tasty Toolset for Vue.js

What began as a repository of common UI patterns that I've been copying and pasting from project to project would eventually be published with the hopes of making the web more accessible, without compromising on performance or bespoke styles. It took years of research, trial-and-error, and hours coming up with a clever name. Today, Vuetensils provides a collection of naked UI components providing the markup, accessibility, and functionality you want, and nothing more. You bring the styles.

Lessons learned building an ALMOST amazing tranpiler plugin

I had an idea for an atomic CSS-in-JS library that could be compiled away to have no runtime dependency, automatic deduplication of styles, and extremely transferable knowledge. Some existing tools were close, but none were quite right, so I decided to build it myself.

Turns out it's kind of hard. The bad news is it didn't turn out nearly as cool as I had hoped. The good news is that I learned a lot and want to share with you.

In this talks, we'll look at taking an idea from a concept to a creation, what a transpiler is and why we need one, how to write a plugin to transform code into more better code, and some considerations around library designs.

JSDocs: It's like TypeScript for the rest of us

If you’re a JavaScript developer, chances are, you’ve heard about TypeScript. In this talk, I want to share an alternative approach to incrementally enable type-checking without all the tooling.

JSDocs allows you to can introduce type-checking into your project bit-by-bit as it makes sense. You can stick to working within JavaScript projects, or adopt TypeScript syntax when and were it makes sense for you and your team.

I break it into four stages:
Enabling type-checking in a JavaScript file
Enabling type-checking in a whole JavaScript project
Integrating type-checking into CI/CD Pipeline
Generating type definitions for Open-Source Libraries

Make Accessibility Easier to Get Right and Harder to Get Wrong (workshop)

Want to learn about accessibility through hands-on experience? Then check out this workshop where we'll go over these highlights:

- Gain practical knowledge around disabilities and accessibility without getting overwhelmed.
- Discover tools and methods to improve how you audit your own projects for accessibility.
- Practice hand-on empathy exercises.
- Learn how to navigate applications with a keyboard and screen-reader.
- Build reusable components that enforce accessible practices.
- Recognize common pitfalls in component design.
- Incorporate tooling to catch errors in your editor, UI, Git workflow, repository, and CI/CD pipeline.

Building Super-Powered HTML Forms with JavaScript

Almost every website on the internet uses forms in one way or another. Most are dependent on them. Think of where we would be today without forms. No search engines, no social media, no ecommerce. Forms are the foundation for companies like Google, Twitter, and Amazon. So shouldn’t we invest in building the best forms we can?

I recently took a deep dive into understanding as much about forms in order to build the best forms possible:
- Semantics
- Accessibility
- Styling
- User experience
- Security

Now, I want to show you how to use JavaScript to give your forms super powers without bloating your client-side bundles.

Make Accessibility Easier to Get Right and Harder to Get Wrong

Want to build accessible websites, but worried you're not an accessibility expert? Let's make things easier for everyone by building accessibility supports into the entire development lifecycle.

We'll look at integrating tools in:
- Design tools
- Code editor
- Components
- Browser
- Tests
- Git repos
- CI/CD pipelines

This will help you and your team avoid some of the most common accessibility issues, and free up more time for the a11y folks to work on bigger issues.

Austin Gil

Developer Advocate & Cool Dude at Akamai

Portland, Oregon, United States