Connect.Tech 2024 Recap | Brent Lineberry

I spent Tuesday and Wednesday at the Connect.Tech conference. It’s a front-end focused conference located here in Atlanta. Our team does a lot more back-end work, but we’re always dealing with the front-end, too, so there’s usually enough content for us to take advantage of this local conference.

My biggest takeaways were around improving my development practices: upping my accessibility testing, looking for improvements in our deployment process, and a kick-in-the-pants to look at Wardley Mapping again.

Sessions

I attended these sessions:

Day One: Tuesday
Day Two: Wednesday

Day One

Gant Laborde: Influence—Witchcraft and Wizardry

Gant gave the opening keynote on increasing your influence. He broke it down into some simple language changes (e.g. use “because”/give a reason for your request to increase the probability of a “yes”, and use “however” instead of “but” to reduce the negativity) and concepts (e.g. “reciprocity” doing something for others inclines them to do something for you and “consistency” getting someone to agree to a smaller thing increases the likelihood of them agreeing to a larger thing). He referenced lots of books from Robert Cialdini.

Overall these were good tips. It will be good to have these in my mind when I’m advocating for something important.

Chris Griffing: Cross-Framework Components using Custom Elements or Mitosis

I attended this session for the “Custom Elements” part of the title, but the emphasis was on the “Cross-Framework” part.

Chris presented an overview of custom elements before saying that they’re a bit of work incorporating into front-end frameworks. He introduced mitosis as a solution. You can write your components using the mitosis framework and then compile them to a slew of other frameworks.

I’ve been turning to web components as a way to progressively enhance a bit of html without using a framework. I could see a use case for mitosis in a context where one team owns the user interface that other teams implement in their framework of choice, but that is far removed from my work environment.

Guy Royse: Memory First: An Introduction to Redis

I’ve had limited exposure to redis, the most coming from trying to use it as the session store for a production express.js app, but only after seeing the errors in the production log saying the built-in session store is not appropriate for production.

Guy gave a great overview of redis, showing that it’s more than just a cache or session store, arguing that it’s best understood as a “memory first, nosql database.”

I appreciate knowing more about how redis works. Next time I work with it, I’ll bring it in during development so I can plan for it before publishing to production.

Ramond Camden: Intl is Your Superhero

This was a sleeper hit for me. I was planning on attending a different session, but that one ended up being cancelled.

Raymond introduced the Intl object, a “namespace object” (what I would consider a service class) with a bunch of utilities helping with internationalization. He ran through a ton of examples, and it really was impressive. You give up some control over formatting specifics, but it takes a lot of stuff off the table for formatting date ranges, numbers, currencies, etc. It will format according to the target culture, but it also seemed really nice to just get some smart formatting out of the box.

Since we build server-side first applications, most often in C#, I mostly wish that C# had these features available. Perhaps I can make use of this for a node application or if I ever am formatting on the client-side. An amazing API that I probably won’t get the opportunity to use.

Bekah Rice: Coding for Accessibility: Best Practices from the Front Lines

Bekah gave a talk on accessibility, covering the reasons we should take it seriously, basic principles, some common trouble spots, and tips on practical ways to test for accessibility. I particularly liked her “Tests You Can Do Yourself:”

Navigate only using your keyboard
Go outside (into the sunlight)
Read only headings and actions
Hide all images
Turn your sound off
Zoom in 400%

I often find myself in accessibility sessions. It’s an area where my typical approach is to write semantic HTML and cross my fingers. I’d like to get more capable with testing with a screen reader.

The final session on Tuesday was Ray going over the Navigation API. He did a walk-through taking various navigation elements (anchor elements, buttons, forms, etc.) and handling them with the Navigation API, showing what kind of data is exposed and ideas for use cases.

I didn’t quite understand the improvement of this over the History API and probably won‘t take a real look at it until Firefox and Safari implement it. One thing unclear to me in the talk was if the events also fire from the browser chrome (e.g. back and reload buttons). One of Ray’s examples intercepted an anchor element click and, with JavaScript, fetched the HTML at the anchor’s href url and loaded into the current page. But the URL for his page changed to the href target, so if he refreshed the page it would load the target page, not reload the current view. Perhaps the implementation could have been done without replacing the current URL, but it was unclear in the talk.

Day Two: Wednesday

Justin Reock: DevOps, 12-Factor, and Platform Engineering

Wednesday started with a keynote from Justin (I couldn’t find a personal website). He started with an overview of DevOps and 12-Factor Apps before introducing "Platform Engineering” as a field that unites DevOps, Developer Experience, and Product Management and the “Internal Developer Portal” as a central hub “for engineering teams to access up-to-date information about their developer ecosystem, improve quality of components, and speed deployment according to established standards.

Justin was a good speaker, and I appreciated the refresher on 12-factor applications. We could certainly take steps to make our deployments smoother, but he took a hard turn into “tools and processes” with the Platform Engineering and Internal Developer Portal. Our team tries to work in the original spirit of agile, and one of the key value statements there is “individuals and interactions over processes and tools.” I’d like to take a closer look at our deployment process in the context of the 12-factor app.

Gant Laborde: Hacking AI—How to Survive the AI Uprising

Gant presented on the various ways researchers (and regular people) have found to break or defeat AI agents.

The talk was interesting, but I thought the biggest takeaway was that given the potential for someone exploiting an AI feature and the data that could be exposed, we should think twice before “adding an AI chatbot for no reason.”

Ryan Edge: How to be a Productive Product Engineer in 2024

Ryan talked about the things that affect and how to increase developer happiness. He broke it down into feedback loops, flow state, and cognitive load. Basically you want to decrease feedback loops (the amount of time between making a change and seeing the effect of that change), increase flow state, and decrease cognitive load.

I was particularly struck by two examples Ryan mentioned as part of the cognitive load: incomplete acceptance criteria and testing setup and overhead. We’re a small team of five, and very often we’re writing and defining our own acceptance criteria. And very often we have mid-sprint confusion over it. We could do a better job writing our acceptance criteria. For testing setup and overhead, I don’t know what we could do to improve it, but writing tests (particularly for controllers) involves a lot of mock setup and can get quite cumbersome. Maybe we could better define interfaces for our controller dependencies to provide an easier mocking set up in our tests.

Mike Clement: Strategic Thinking in Software Architecture using Wardley Mapping

I discovered Wardley Maps several years ago and got really excited about them, but never got around to applying it (granted, I didn’t finish the book). I was excited to see a session involving Wardley Mapping and was happy that it was the bulk of the talk. Mike did a great job working through examples of mapping in both simple and complex spaces.

The key “aha” moment for me was that you start with the user and a user need. The maps always struck me as a finished piece, and I couldn’t figure out how to start, but Mike showed that you start with the user and a user need and then fill in the pieces needed down the chain. I’m excited to re-try reading the book and have an idea for a problem at work that I could try mapping out.

Guy Royse: Tracking Aircraft with Streams + Software-Defined Radio

My final session was Guy on software-defined radio. He used redis as an event stream store, but the biggest part of the talk was an overview of radio data formats and then an incredible demonstration where he connected an antenna to his computer, had a person hold it in the middle of the room, another person open the door to get a clearer signal, and found and tracked several airplanes above us from their radio beacons.

I thought this was awesome. I love seeing a solution that isn’t immediately “well, just hook up a computer to wifi…”. The idea of radio waves as data transmission is just so cool to me.