The Function Call

In this episode Austin shares some cool things he's learned about recently. Edge compute can fix performance bugs in Apache, and the HTML capture attribute is a handy way to open up the user's camera. Grant goes into his new role where he gets to control TypeScript and ESLint rules at his organization; the ultimate power trip.

Links:

In this episode, Austin shares about his recent experience with Remix.run, a full-stack JavaScript web framework. We discuss what it is, what it's not, some things we like, some things we don't, and how you can think about it. TLDR: It's pretty cool. In fact, it even got Austin to write React.

It was a very serious chat (sorry, no bloopers).

Appreciations:

In this episode, Grant and Austin do some catch up on what’s been going on since the last call. Grant’s goes into all sorts of interesting stuff including Static Site Generation, working on design systems, migration from enterpriseGitHub to GitHub cloud, managing several different code bases with monorepos. Austin is mostly just happy to hear Grant talk about his day and shares some fun changes sing Akamai acquired Linode.

Shoutouts:

In this episode Grant and Austin are visited by special guest and creator of AgnosticUI, Rob Levin. Rob shares the story behind AgnosticUI, how it got started, why the world needs it, and some interesting bits into how it all works. We also discuss some more general topics around design systems, CSS, open source, accessibility and more. He is a great guy with a very interesting project, and we think you should check it out.

Links:

In this episode Austin gets into it with Grant about working with agencies, and some of the pitfalls related. After a bit of venting we actual come around to some interesting content related to Gatsby, React, and working with TypeScript. 

We cover:

• Merging className between parent and child components
• Using PropType vs TypeScript
• Which types to use for SVGs (JSX.Element, ReactNode, ReactElement)
• Inheriting type definitions for wrapper components

Links:

Grant wanted to share some things he wish he knew as a beginner that would have made his career easier. His tips boil down to:

• Communication
• Research
• Problem solving
• Language specifics dont matter
• Learn to read code
• Get good at being wrong

Shout outs:

Do you like progress? Well too bad because we’re using 90s technology until otherwise required!

In the episode, Austin schools Grant on why building forms to work with and without JavaScript matters, how you can do it, and some tips and tricks if you want to do it yourself. It’s one of those technical deep dive episodes that we like to mix in here and there and we get into native behavior vs JS, accessibility, UX, and more. We hope you enjoy.

Outline:

• Why it matters
• Default behavior
• Validation
  • Validity API
  • Different types of inputs
• Accessibility
• UX improvement
• Backend
  • Detecting native vs fetch requests

Links:

Isn't it obvious? We did the same thing everyone else is doing this time of year. We talked about recaps and highlights of 2021, and then some predictions and resolutions for 2022. Spoiler alert! 2022 is going to be a good year :D

Shou touts

Ever wondered what sort of equipment Austin and Grant have for their office setup? No? Well, we’re going to tell you anyway. We covered desks, chairs, monitor arms, peripherals, audio/video stuff, and more. It’s just as boring as it sounds, but we hope you enjoy it nonetheless. Hey, they can’t all be bangers.

Links:

Austin’s been working a lot with build tooling lately. In this episode, he takes Grant on a bit of a journey into the world of build tools and ASTs, or Abstract Syntax Trees. We talk Webpack, Rollup, Vite, Babel, and Acorn JS.

Links:

In this episode, Grant and Austin do some eggnog math before chatting about burnout, ES Modules, building plugins for different build tools, interesting thoughts around island architecture and Astro. We went all over the place. Hope you enjoy the journey.

Links:

In this episode, Grant and Austin sit down to chat about the latest tech news that's on their minds. We covered a whole slew of things such as:

• Trying to make magic with TS
• Cloudflare taking swings at AWS
• Dark mode vs light mode
• Browser extensions (scary)
• VSCode extensions (also scary)
• NPM postinstall scripts (extremely scary)

Shoutouts:

In this episode, Grant and Austin discuss some of the trials and tribulations of maintaining the same dependencies across multiple projects. Some topics we cover are Package Registry (NPM/GitHub Packages), Monorepos, Framework-specific tooling, Learna, and Git Submodules.

Links:

In this episode, we’re getting the band back together to talk about HTTP requests. We cover a little bit about what they are, go into the options we have for making HTTP requests with JavaScript, and explore some libraries that make life easier on us.

Links:

Experience makes you a stronger developer, except when it doesnt. Many in the dev community accept the idea that a lack of experience could be a liability on a project, however in a similar way someone with experience can have mental blocks as a result of that experience. We discuss in this episode how experience can influence decisions in a negative way.

Links:

In this episode, Grant and Austin catch up on some cool new things around web development. Specifically, Vite and Vitedge, a new full-stack framework for "Edge-side rendering". Sparked by that coolness, we explore other rendering patterns such as strict server-side, client-side, static sites (build time), lambda functions, and more. Finally, we end with a silly discussion of frameworks vs libraries.

Links:

In this episode, Grant and Austin talk all about environment variables. We cover the difference between private and public variables, how to keep them secure, keeping them in sync across teams, and where to store your precious precious variables. They may be keys, secrets, or just configuration strings, but hopefully this chat sheds some light on the subject for you.

Reference `dotnev` from Jest config:
// jest.config.js
module.exports = {
 setupFiles: ['dotenv/config'],
};

Reference `dotenv` from NPM script:
"jest": "node -r dotenv/config ./node_modules/.bin/jest",
"knex": "node -r dotenv/config ./node_modules/knex/bin/cli.js",

Links: 

Grant’s adventure into why compile time type checking isnt enough. Do you have a reliable data source. Is it really, really reliable? If not, you might like runtime type checking! Sometimes rapid parallel development is painful, solve that pain with runtime type checking! Austin and Grant discuss what problems lead to the development of runtime type checking apollo hooks. They cover the initial problem, the attempted solutions, and the process of developing the structure that allows this set of hooks to work.

Links:

We start out this episode with a nice little “Grant Rant” section, then slowly transition into PEGD. If you never got PEGD before, give this episode a listend, and you might get PEGD after.

What is PEGD? Well it's Progressive Enhancement & Graceful Degradation, of course.

It’s pretty sweet. You should try it some time.

Links:

In this episode Austin introduces Grant to the wonderful world of CSS resets and normalizers. We discussed what they are, why you might want one, and what makes them different from a library/framework. Austin had some technical difficulties at the end, but it was a fun show regardless.

Links:

Why did it break? Why does it work?

In this episode, Grant takes us on a Grant Rant about why the "It works and I have no idea why" meme is troublesome. How this erodes communication, confidence, and leads to a deeper sense of imposter syndrome. Austin goes along for the ride, mostly just for comedic value.

Shoutouts:

In this episode, Grant and Austin have a MEANINGFUL chat about markup, but it was all just semantics. We covered a wide range of topics from HTML to accessibility to JSON-LD, and more.

Links:

In this episode, Grant and Austin discuss some recent issues working with dates at work, advice about working with time and dates in JavaScript, what libraries we currently run with, and the future of time in the browser. We also share some takes on storing dates in databases, and the native HTML date input.

Links:

In this episode of The Function Call, Grant, AJ, and Austin sit silently in a room and just watch you buy your fifth tub of guacamole. Just kidding. We're talking all about analytics. We get into different types of analytics, various ways of implementing them, and some opinions of why we love and/or hate them. This was a very fun topic because it's so relevant today for balancing privacy and performance against business goals.

Links:

Like shaving yacks? Well this is the episode to listen to! We discuss our pointless opinions about programming and decide once-and-for-all "tabs vs. spaces" and all sorts of other things that don't matter.

TLDR:

• Is html a programming language; NO
• Single vs double quotes vs backticks; SINGLE
• Variable naming case; follow conventions? YES (per project/team)
• Semi colons; YES (but automate it)
• Curly Braces:  1TBS
• Dangling commas, YASSS!
• CSS order: "have structure"
• Ternarys: NO

Shoutouts:

In this episode we covered a whole gamut of client side options for storing data. Here's a list of some of the things we talked about:

In this episode, Grant and Austin talk about the idea of ambidextrous development, or the ability to translate between various frameworks, libraries, and languages. Well covered "stack blinders", copying code from StackOverflow, and freeing yourself from a framework limited view of development.

Background: Grant suggested this topic after seeing this tweet.

“I'm working on some ecommerce components that would play nicely with use-shopping-cart right now. Anyone have a good resource on making ACCESSIBLE side panels to slide from the right? They can't be keyboard selected when off-screen”