Does Not Compute

Sean, Paul, and Rockwell get together for the first – and last! – time to wrap DNC. There's a walk down memory lane, discussion of overarching themes throughout the run, a mini-topic about spaced repetition, and looks towards the future.

Sean expounds on his newfound love of front-end testing with Cypress, and Rockwell rants entirely too long about subdomains.

Drew Clements returns to talk with Sean about leveling up over the years, project estimation and velocity, tech stacks, and what it means to graduate from the title of junior developer.

Sean and Rockwell talk about building ridiculous projects for run, Prisma in production, JS hot-takes, improving the successful odds of side-projects and work projects, emergent design, PAGNI, and a few tales of production woes.

Sean and Rockwell talk about leveraging TypeScript and React to write library-grade interfaces, Sean's latest most-productive web stack, exploiting the low barriers to entry of new languages, an update on Rodinia, and the rules of the wave.

Sean and Rockwell discuss project estimation: taking risk into account, planning for the unknown, building versus buying features, and accepting the reality that every estimate will be wrong.

Sean and Rockwell search their souls about putting bounds on learning time, blogging, and using code challenges to step outside your comfort zone.

Sean welcomes back Anthony Campolo to talk about the latest from Redwood.js, Stepzen, front-end meta-frameworks, thoughtfully picking new tech to learn, and grunge.

Sean and Rockwell discuss LiveView, React.rb/Reactrb/Hyper-react, web tech that's blurring the client-server boundary, more on Balena, and an outstanding bounty for our listeners.

Sean and Rockwell talk about gradually converting JS to TS, dependency war stories, learning to play nice with code reviews, and a first look at balenaCloud.

Rockwell discusses tools and strategies for testing in Elixir, and Sean talks more about the pros, woes, and hidden traps of TypeScript development.

Rockwell reviews his new ZSA Moonlander keyboard, and Sean talks about getting back to the roots of the Web with the new framework Remix.

Paul and Thomas join Rockwell to talk about their experience in the Ludum Dare 48 game jam: how they developed a complete multiplayer game with artwork, music – and every piece in between – in just 72 hours.

Rockwell talks agout gaining velocity at DockYard, then Sean shares his experience with coaching his team members on being more autonomous, and adopting the Zettelkasten method of note-taking with Obsidian.

Rockwell talks about adjusting his work style during his first week at DockYard, resurrecting a nearly-abandoned iOS app, and Sean talks a stab at replacing Webpack with Vite.

Sean and Rockwell talk about change for change's sake, rebalancing develoment priorities as projects mature, divining tech stacks for fun and profit, and whipper-snippers.

Sean and Rockwell talk about the challenges of normalizing data for APIs, Sean rewriting his app for Firebase, the tradeoffs of choosing a backend-as-a-service, and some big news on Rockwell's job front.

Sean and Rockwell talk about solving ham radio problems with Elixir and OTP, hot takes on the Ionic framework, fleshing out features in an Electron app, and a trespassing chicken.

Sean and Rockwell talk about adding personal flair and staying motivated with side projects, the challenges of theming and testing UIs, and super-yachts.

Sean and Rockwell talk all about pull requests: the value and utility of PRs in a team environment, chunking up work to prevent blockers, rebasing versus merging, and making time to wrangle it all.

Eric Normand joins us to discuss the origins, contents, and process of writing his first book, Grokking Simplicity. Topics include identifying and isolating side-effects, organizing code into layers with stratified design, and comparing styles and languages.

Sean and Rockwell discuss pragmatic JavaScript, navigating increasing tooling complexity, and TypeScript's utility types.

Sean and Rockwell talk about Pocket Operators, managing people instead of code, tracking down new code conventions and opinions, 3D printing, and the correct pronunciation of "doge".

Sean and Rockwell discuss building an Electron app using SQLite and Webpack, keeping personal documentation, and learning and sharing amongst your development team.

Sean and Rockwell discuss IntelliJ's Rails support, using Docker for development, and AWS Aurora. Sean starts a new Electron app, and Rockwell christens his new standing desk with a spilled beverage.

Former DNC host Paul joins Rockwell to catch us up on the past couple years, focusing on the technical underpinnings, challenges, and a release date (!) for his new iOS game, Booster's Big Neighborhood.

Sean and Rockwell talk about the importance of taking time off, then Sean shares his experience with React Query, and Rockwell finally tries out IntelliJ.

Greg joins Sean and Rockwell to talk about what he's been up to this past year. They dive into the Firebase/Ionic stack that drives his newest app, ReadRally, and Greg imparts his wisdom on getting products out the door.

Anthony Campolo (@ajcwebdev) joins Sean and Rockwell to talk all about Redwood.js: its inception, principles, tooling, deployments, and much more.

Rockwell give his first impressions on rebuilding an iOS app with SwiftUI, then Sean and Twitch chat share their goals for 2021.

Sean and Rockwell discuss Hotwire, serverless applications, React server components, and some important show announcements!

Sean and Rockwell review some Apple devices, talk about Sean's sudden shift in workload, react-query, stripping out unncessary (?) complexity from your application, and Apple Fitness.

Sean and Rockwell talk about Firebase document stores, Next.js and API routes, envisioning serverless applications, and RFC 1149.

Sean and Rockwell talk more about Sean's increasing duties, 1Password, the difficulting in naming things, project tools, and Sean thoroughly reviews his new Moonlander keyboard.

Sean and Rockwell talk about their respective M1-based Macs: RAM constraints, binary compatability, and trade-offs.

Sean and Rockwell discuss the new M1 Mac Mini, hacking on hardware with Python, standing up simple web services with TypeScript, and being the no-because-the-API-endpoint-doesn't-even-have-that-feature-man.

Sean and Rockwell talk about performance bottlenecks in Elixir and JS, Sean's journey managing his workload and introducing new processes, codifying CSS themes, and a walk down JS memory lane.

Sean and Rockwell discuss the native app development and potential tradeoffs of React Native, a host of text editors including Onivim 2, work catch-up, and a very special snack challenge.

Sean and Rockwell talk about the promise of Starlink, refactoring an overengineered Rails app, TypeScript testing frameworks, and when TypeScript is – or isn't – worth the overhead.

Sean and Rockwell discuss applying design patterns across languages and frameworks, Prisma.js, developing against an in-development library, CSS hacks, and the most boring modern Web stack you've ever heard.

Sean and Rockwell talk about streaming video games with WebRTC and OBS, exposing DBs to the web with a couple of niche tools, writing code for today instead of tomorrow, and reigniting that creative spark.

Sean and Rockwell talk about Rails and gems from the past, integrating Rails and JS with Inertia, deploying to Dokku and DigitalOcean, mocking web services with Mirage.js, and battling scope creep with extreme prejudice.

Sean and Rockwell talk about managing time as a manager, evaluating performance based on results, some follow-up on JS MVC frameworks, and the Cult of Done.

Sean and Rockwell discuss jumping between two dev machines, if MVC is still relevant in the JS ecosystem, and comparing the flexibility of frameworks to fully-custom solutions.

Rockwell talks about splitting Electron apps up for performance gains, .NET 5.0, and UDP packet fragmentation. Then Sean provides updates on settling into this new job, plus some new video game talk.

Sean and Rockwell talk about developing new hardware and software protocols for some old communication methods, the evolution of guitar pedals and effects, Setapp, and defending your time estimates as an outlier.

Sean tells us more about his new job: agile methodologies, some new tech to learn, job responsibilities, and Watson taking his Zoom-meeting spotlight. Rockwell provides updates on his Nuxt-powered homepage and revamping a 20-year-old project.

Sean and Rockwell talk at about Sean easing into his new job, TypeScript, building a simple static site with Nuxt, and why you shouldn't always bet on JavaScript.

Sean and Rockwell talk about vacation backlog, Sean's new job (!!!), transitioning to the new position, a retrospective of his time at DK, and learning new skills through spaced repetition.

Friend of the show Thomas Eckert joins Sean to talk about Site Reliability Engineering (SRE) at Microsoft, a side gig with some persistence problems, keeping creative goals in mind when surveying new tech, and some casual nuclear science.

Sean and Rockwell talk about working during natural disasters, keeping your team on the same page, dealing with support and feedback, what makes a good boss, and different styles of job interviews.

Sean and Rockwell shares war stories from the launch of SideDoor, Laravel features like caching and collections, and comparing Laravel to other web development ecosystems.

Sean talks about SideDoor's official launch, getting mad at his technology, and plans for it going forward. Rockwell discusses SAX XML parsing and using Notion as a public knowledge base.

Rockwell and Sean talk about a Project Loon sighting, dealing with unpredictable APIs and file formats, and a new creative outlet with game development in Unity.

Sean and Rockwell discuss the woes of bulk data imports, human problems vs. code problems, Windows as a development environment, the VS Code Remote plugin, and instilling fear into tennis balls.

Sean and Rockwell talk for a long time about learning Python, PHP, and React.

Sean and Rockwell ruminate on WWDC hardware and software announcements, deploying applications on Dokku and Netlify, and walking the fine line between bike-shedding and productivity.

Sean and Rockwell talk about SideDoor's looming launch date, Ruby Encoder on the Raspberry Pi, deploying Phoenix applications on DigitalOcean, and the new HEY e-mail service.

Sean and Rockwell discuss modern tooling and techniques for React and Redux. Other topics include wrangling spreadsheets for import, Statamic 3, more on the Second Brain, and Ben & Jerry's ice cream.

Rockwell wraps up the ham radio contest saga for the summer, Sean talks about picking React back up for a job interview, and then they follow up on how the Second Brain has helped their development processes.

Rockwell and Sean talk ham radio contests, roadmaps to becoming a modern developer, efficient note-taking tools so you don't forget things, and the pain of setting up development environments.

Sean and Rockwell share their strategies for coping with stress and burnout, what it's like to live-stream and where that whole thing is headed, announcements from Microsoft Build, and the correct pronunciation of "Nevada".

Sean and Rockwell talk about the Coronavirus time warp, first impressions on learning Python, advancing side projects with manageable chunks of time, and de-stressing with video games.

Sean and Rockwell talk about Sean's shifting role within his company, dealing with high-maintenance customers, developing Swagger Open API specifications, and an important PSA for summer.

Sean and Rockwell record their first live show on Twitch and talk about Microsoft technologies and conferences, being insanely productive with Laravel, and fighting with with Vue mixins.

Sean and Rockwell reflect on Sean's recent interviews. Then we learn how PHP and Laravel have wormed their way into DK's stack, and the reasoning behind that decision.

Sean talks more about learning Go, and what it's like building your own tools. Plus, Vue.js 3.0 beta is out, and Rockwell proselytizes Sean into a Minecraft religion.

Sean and Rockwell discuss video games and their soundtracks, before launching into Sean's premiere Go project - the many design decisions to be made, the libraries and tooling surrounding it, and unique language features.

Sean and Rockwell discuss Apple's crackdown on PWAs, pesky permissions dialogs, Zoom and other working-from-home tools, breaking an amateur radio record with Vue.js, and tales of IT woe.

Rockwell and Sean discuss the journey of reviving an 8-year-old iOS app, accepting user feedback without taking it to heart, more Postgres power-tools, and some California livin'.

Sean and Rockwell talk about the realities of working from home, implementing recursive structures with Postgres features like Common Table Expressions and Materialized Paths, and convincing Rockwell to start playing Minecraft again.

Sean and Rockwell discuss the Pomodoro technique, (re-)writing a billing system from scratch, some more practical applications of LiveView, and using gradual technological improvements to concretely advance your business.

Sean and Rockwell discuss code organization for front-end applications, leveling up in SQL development, and a baby Rustacean's first impressions.

Sean and Rockwell give their first impressions on the Tailwind UI Early Access: the value proposition, how it jives with existing tooling, and its impact the web front-end development scene.

Jason Lengstorf of Netlify joins Sean to discuss problem-solving tips, work-life balance, impostor syndrome, Twitch streaming, and learning to grow your skillset by working a little outside your comfort zone.

Sean and Rockwell talk about two new greenfield projects they've been working on, leveraging Tailwind and Vue to create customizable, reusable form components, Netlify deploys, and the new Oban UI beta.

Sean and Rockwell discuss LiveView ups and downs, iOS development woes, scaling your application's archecture for solo/small teams, and unsolicited beef jerky.

Sean and Rockwell follow up on a dying MacBook Pro, reminisce about gaming, share productivity tips, and walk through Sean's JetBrains journey to rediscover the enjoyment of coding.

Insomnia creator Greg Schier join Sean to talk about Go, how side projects are important to developer happiness, maintaining positive habits, and becoming a supple leopard.

Sean and Rockwell talk about using Domain Driven Design to decouple the procedures for keeping Design Kollective's Elasticseach store in sync, the challenge of following programming patterns to the letter, and Rockwell's new Macbook Pro.

In episode 205 of Does Not Compute, Sean and Rockwell discuss their goals for 2020 and how they plan to achieve them. They also talk about keystone habits as learned in the book The Power of Habit, learning Go (lang), and recovering from burnout.

In episode 204 of Does Not Compute, Sean and Rockwell look back at this year's achievements and struggles, and plans for the next decade.

In episode 203 of Does Not Compute, Sean and Rockwell discuss some life updates, web crawling, and scheduled jobs

In episode 202 of Does Not Compute, Sean and Rockwell have Stefan Schackow on to discuss Azure's App Services at Microsoft Ignite 2019.

In episode 201 of Does Not Compute, Sean and Rockwell have Dan Roth on to discuss .Net's Blazor at Microsoft Ignite 2019.

In episode 200 of Does Not Compute, Sean and Rockwell have Nik Molnar on to discuss Visual Studio Online at Microsoft Ignite 2019.

In episode 199 of Does Not Compute, Sean and Rockwell discuss leveraging Electron with Raspberry Pi's, doing things the Vuex way, and the power of GraphQL.

In episode 198 of Does Not Compute, Sean and Rockwell have Noah Labhart on from Veryable to talk about his secret to productivity.

In episode 197 of Does Not Compute, Sean and Rockwell discuss Erlang Telemetry, application layering, and code refactoring.

In episode 196 of Does Not Compute, Sean and Rockwell discuss WebAssembly, migrating to Tailwind, and hitting deadlines during power blackouts.

In episode 195 of Does Not Compute, Sean and Rockwell discuss solar powered laptop developement, productivity tools, and leveraging Nuxt

In episode 194 of Does Not Compute, Sean and Rockwell discuss planning feature releases as a team and leveraging Ecto streams.

In episode 193 of Does Not Compute, Sean and Rockwell discuss leveraging Ecto more, when not to use Phoenix LiveView, and a new app idea.

In episode 192 of Does Not Compute, Sean and Rockwell discuss integrating Phoenix LiveView into your existing applications.

In episode 191 of Does Not Compute, Sean and Rockwell finish their Elixir Conf 2019 recap with a deep dive into LiveView.

In episode 190 of Does Not Compute, Sean and Rockwell discuss Lumen for Elixir and other news from Elixir Conf 2019.

In episode 189 of Does Not Compute, Sean and Rockwell discuss mechanical keyboards, when refactoring is a good thing, and job queues with Oban.

In episode 188 of Does Not Compute, Sean and Rockwell discuss what a junior dev is and the power of Elixir pipelines and modules.

In episode 187 of Does Not Compute, Sean is joined by Drew Clements to talk about breaking into development as a designer and giving back to the community.

In episode 186 of Does Not Compute, Sean and Rockwell discuss handling failed job queues, building your own queues, and adventures into Laravel.

In episode 185 of Does Not Compute, Sean and Rockwell discuss various code editors and finding productive uses of the iPad

In episode 184 of Does Not Compute, Sean and Rockwell are joined by Bryan Joseph of Revelry Labs and The Big Elixir Conference to talk about Elixir boilerplates, using Elixir in an agency, and design thinking.

In episode 183 of Does Not Compute, Sean and Rockwell discuss Elixir's fault tolerance, rate limiting, and authentication integrations.

In episode 182 of Does Not Compute, Sean and Rockwell discuss the complexities and pitfalls of authentication and authorization libraries.

In episode 181 of Does Not Compute, Sean and Rockwell discuss database design, refactoring interfaces, and CRUD apps.

In episode 180 of Does Not Compute, Sean and Rockwell talk about their pair programming processes and the benefits of a team knowledge base

In episode 179 of Does Not Compute, Sean and Rockwell talk about their codifying process.

In episode 178 of Does Not Compute, Sean has Dave Lucia on to discuss distributed Elixir, scaling your Phoenix application, and Javascript choice paralysis.

In episode 177 of Does Not Compute, Sean and Rockwell discuss big picture planning, different hiring processes, and handling outages on a small team.

In episode 176 of Does Not Compute, Sean and Rockwell discuss growing a development team, how best to document your code, and the benefits of conferences.

In episode 175 of Does Not Compute, Sean and Rockwell discuss Tailwind CSS with custom colour schemes and Phoenix LiveView

In episode 174 of Does Not Compute, Rockwell has Mikhail on to discuss all the big announcements from Build 2019 including .Net 5, React Native on Windows, and the new Windows Terminal

In episode 173 of Does Not Compute, Sean and Rockwell discuss working with functional CSS in VueJS and the complexities of JavaScript modules.

In episode 172 of Does Not Compute, Sean and Rockwell discuss adjusting to Ruby after Elixir, building internal tools, and exploring strongly typed languages

In episode 171 of Does Not Compute, Sean and Rockwell interview Dave Lucia about how he integrates Rust with Elixir, creating a CMS at The Outline, and the power of good documentation.

In episode 170 of Does Not Compute, Sean and Rockwell discuss using Git for software releases, Netlify Dev, and using Grafana for monitoring performance.

In episode 169 of Does Not Compute, Sean and Rockwell discuss choosing a tried and true tech stack vs. choosing a cutting edge tech stack, and the benedfits and drawbacks that come with each.

In episode 168 of Does Not Compute, Sean and Rockwell discuss email templates, log monitoring, and dealing with downtime.

In episode 167 of Does Not Compute, Sean and Rockwell discuss performance monitoring, GraphQL dataloader, and Erlang Observers.

In episode 166 of Does Not Compute, Sean and Rockwell discuss Alfred workflows, WebRTC and Electron apps.

In episode 165 of Does Not Compute, Sean and Rockwell discuss WebRTC, debugging blackboxes and how to update your dependencies.

In episode 164 of Does Not Compute, Sean and Rockwell discuss growing tech complexity, single use tools, and a big shipping rewrite.

In episode 163 of Does Not Compute, Sean and Rockwell discuss the benefits of Gridsome and why the JAM Stack is so popular.

In episode 162 of Does Not Compute, Sean and Rockwell discuss handling large datasets, premature optimizations, and leaving this better than you found it.

In episode 161 of Does Not Compute, Sean and Rockwell discuss microphone and location access hiccups, streamlining your on-boarding, and Vue tips.

In episode 160 of Does Not Compute, Sean and Rockwell discuss how they make product decisions; from technical details to overall project strategies.

In episode 159 of Does Not Compute, Sean covers some practical advice on how he manages large projects and Rockwell discusses a big Remote Ham Radio release.

In episode 158 of Does Not Compute, Sean and Rockwell talk about adjusting to the West Coast, the best way to start new projects, and time tracking.

In episode 157 of Does Not Compute, Sean and Rockwell talk about lit-vue, Vue single file components, and CES 2019 – Flying cars, animal food bowls with AI, and even a desk with a computer built into it.

In episode 156 of Does Not Compute, Sean and Rockwell do their year-end reviews of 2018, and what they look forward to in 2019.

In episode 155 of Does Not Compute, Sean and Rockwell talk about testing the frontend vs the backend, file streams, and some survival tactics.

In episode 154 of Does Not Compute, Sean and Rockwell talk about their developer origin stories, performance improvements, and slowly integrating GraphQL.

In episode 153 of Does Not Compute, Sean and Rockwell talk about adjusting to remote work, the importance of bug fixes, and an interesting PostgreSQL bug.

In episode 152 of Does Not Compute, Sean and Rockwell talk about hardware upgrades, making the TouchBar productive, and development on an iPad Pro.

In episode 151 of Does Not Compute, Sean and Rockwell talk about the importance of customer experience, code gardening, and application specifications and requirements.

In episode 150 of Does Not Compute, Sean and Rockwell talk about coupon codes, a DevOps adventure, and the benefits of purpose built services.

In episode 149 of Does Not Compute, Sean and Rockwell talk about the benefits of low-tech solutions, pricing flexibility, and discuss the meaning of clean architecture.

In episode 148 of Does Not Compute, Sean and Rockwell talk about the complexities of user accounts, keeping data in-sync with external parties, and Refactor Fridays.

In episode 147 of Does Not Compute, Sean and Rockwell talk about learning when you're most productive, improving things incrementally, and Rockwell's new side gig doing DevOps.

In episode 146 of Does Not Compute, Sean and Rockwell talk about learning programming languages, building apps to scratch your own itch, and Sean's reminder tool Bethink.life

In episode 145 of Does Not Compute, Sean and Rockwell recap more talks from Elixir Conf 2018, as well as talk about code editors versus IDEs, and updates to NuxtJS and macOS.

In episode 144 of Does Not Compute, Sean and Rockwell recap a few talks from Elixir Conf 2018, as well as talk about project management tools, Phoenix LiveView, and Elixir Typespecs.

In episode 143 of Does Not Compute, Sean and Rockwell talk about working with customer email subscriptions, reducing operational costs, and how Discord handles 2.5 million WebRTC users.

In episode 142 of Does Not Compute, Sean and Rockwell talk about mechanical keyboards, replacing Vuex with custom controllers, and implementing GraphQL with Dataloader.

In today's episode of Does Not Compute, Rockwell narrows in on front-end performance issues and mutation side-effects while Sean works out some Vuex kinks.

In episode 140 of Does Not Compute, Sean and Rockwell talk about migrating away from jQuery, implementing Vuex's Dynamic Registration, and TailwindCSS with utility classes.

In episode 139 of Does Not Compute, Sean and Rockwell talk about building out GraphQL queries, pattern matching Elixir Maps, and DataLoader.

In episode 138 of Does Not Compute, Sean and Rockwell talk about integrating external APIs, the benefits and downsides of bolt on GraphQL server providers, and the power of PostgreSQL.

In episode 137 of Does Not Compute, Sean and Rockwell talk about the difficulties of estimating software projects and accountability, how Rockwell designs hardware for Remote Ham Radio, and tracking your daily productivity.

In episode 136 of Does Not Compute, Sean and Rockwell talk about application downtime, removing complexity from functions with pattern matching, and websocket memory usage.

In episode 135 of Does Not Compute, Sean and Rockwell talk about ham radio, Erlang Term Storage (ETS), and choosing a language.

In episode 134 of Does Not Compute, Sean and Rockwell talk about handling app dependencies, deployment pipelines, and debugging memory leaks.

In episode 133 of Does Not Compute, Sean and Mikhail talk about deploying your own apps, handling user data, and Nuxt.

In episode 132 of Does Not Compute, Sean and Paul talk about Apple's declining hardware quality, the Web as a platform, and user privacy.

In episode 131 of Does Not Compute, Sean and Paul talk about completing the migration to Nuxt, improving separation of concerns, and developer ergonomics.

In episode 130 of Does Not Compute, Sean and Paul talk about the states of refactoring, separation of concerns, and leveraging Vue and Nuxt.

In episode 129 of Does Not Compute, Sean and Paul talk about the benefits of remote development, managing quality of features developed, and changing opinions of Javascript apps.

In episode 128 of Does Not Compute, Sean and Paul talk about working on the road, finding their strengths on a team, and working with non-technical colleagues.

In episode 127 of Does Not Compute, Sean and Paul talk about the importance of documentation, exploring Docker, and dealing with imposter syndrome.

In episode 126 of Does Not Compute, Sean and Paul talk about visiting Vermont, learning docker, and talking control of your servers.

In episode 125 of Does Not Compute, Sean and Paul talk about moving slow and considering things, building features that work around existing user behaviors, and using Google's natural language API.

In episode 124 of Does Not Compute, Sean and Paul talk about software architecture and design patterns, learning through adversity, and how empathy can help you make better software.

Re-Air: 02 - In the second episode of Does Not Compute, Sean and Paul discuss different options for managing image assets within a Rails app, Sean's favorite new way to package a rails app for deploying to production, and how you might not even need to build a Single Page Application with all of those fancy (and expensive) new tools.

In episode 123 of Does Not Compute, Sean and Paul talk about learning to feel fulfilled throughk your work and how changing the world with technology isn't always a good thing.

In episode 122 of Does Not Compute, Sean and Paul talk about the benefits of pair programming, and how a little introspection each day can keep you motivated.

In episode 121 of Does Not Compute, Sean and Paul talk about switching priorities from tech based things to people based things, building software for the user on the other side, and learning to see past the mountain in front of you through experience.

In episode 120 of Does Not Compute, Sean and Paul talk about camping and national parks, writing functional feature specs for an application, and some practical examples of elixir's pattern matching and guard clauses.

In episode 119 of Does Not Compute, Sean and Paul talk about rethinking separation of concerns, building reusable components with Vue.js, and how relying on some simple Elixir conventions can replace the need for external libraries.

In episode 118 of Does Not Compute, Sean and Paul talk about Paul's first full week on the road, avoiding fire ants and spiders, and about pairing down your belongings to a few quality items.

In episode 117 of Does Not Compute, Sean and Paul talk about music they're into lately and the insecurty that comes with letting someone into a codebase you've grown from the ground up.

In episode 116 of Does Not Compute, Sean and Paul talk about rethinking Sean's approach to organizing Ecto Schemas, learning and growing from incorrect assumptions, and digging into a new Nuxt.js app for Design Kollective.

In episode 115 of Does Not Compute, Sean and Paul talk about Phoenix contexts, refactoring a production Elixir app, and learning how to be CTO's past the MVP phase.

In episode 114 of Does Not Compute, Sean and Paul talk about Paul's first week at Design Kollective, vscode, learning how to work with a new code base, and how Phoenix 1.3 encourages good code organization by its design.

In episode 113 of Does Not Compute, Sean and Paul talk about Paul's new job with Design Kollective, developer workflows, and about becoming the person you want to be one decision at a time.

In episode 112 of Does Not Compute, Sean and Paul talk about hippo dentistry, GraphQL, and Absinthe (the Elixir GraphQL implementation).

In episode 111 of Does Not Compute, Sean and Paul talk about Paul's new job, Combat Jiu Jitsu, and implementing GraphQL with Elixir's Absinthe library

In episode 110 of Does Not Compute, Sean and Paul talk about Tacos and Affogatos, UFC 220 and the importance of fundamentals, and about keeping a journal for personal and professional growth.

In episode 109 of Does Not Compute, Sean and Paul talk about Sean's broken iPhoneX, Phoenix Contexts, and how sometimes you just gotta use a library.

In episode 108 of Does Not Compute, Sean and Paul talk about Meltdown and Spectre and Paul's journey into Elixir.

In episode 107 of Does Not Compute, Sean and Paul talk about living in an RV in San Francisco and boiling web apps down to data input and output.

In episode 106 of Does Not Compute, Sean and Paul talk about the importance of HTTPS and VPNs, 1Password and RememBear, and using PostGIS to build location aware features for into your app.

In episode 105 of Does Not Compute, Sean and Paul talk about wireframing with Balsamiq, project management with GitHub and ZenHub, and how doubling down on sleep is always the right idea.

In episode 104 of Does Not Compute, Sean and Paul talk about streaming on Twitch, being at your desk vs. being present, F.lux/Nightshift, and the importance of a steady sleep schedule.

In episode 103 of Does Not Compute, Sean and Paul talk about Destiny 2, choosing a stack for an MVP, Nuxt.js, and sunsetting Coffeescript.

In episode 102 of Does Not Compute, Sean and Paul talk Whizzy Wheels, using Raspberry PI/Homekit to control your lights, how spreadsheets are often overlooked and under utilized, and the differences between relational and document based data bases

In episode 101 of Does Not Compute, Sean and Paul talk about Sean's recent launch of Design Kollective, JSON and Postgres, and Paul's RV progress.

In episode 100 of Does Not Compute, Sean and Paul talk about the perceptual cliff, Ecto.Changeset, ExUnit, and reflect on the past 100 episodes of the show.

In episode 99 of Does Not Compute, Sean and Paul talk about getting things for free with tools like Unity 3D and Unreal Engine, Apple's ARKit, and the future of Augmented Reality.

In episode 98 of Does Not Compute, Sean and Paul talk about checking out the county fair, NestNotes going live in the app store, and Basecamp 3's ios app architecture.

In episode 97 of Does Not Compute, Sean and Paul talk about building SSR Spas, how far the modern javascript workflow has come, five day bug fixes, and converting coffeescript to ES6.

In episode 96 of Does Not Compute, Sean and Paul talk about oAuth, email confirmation and users, and how sometimes choosing to use that big pacakge hurts you in the long run.

In episode 95 of Does Not Compute, Sean and Paul talk about surviving the thunder dome aka PUBG, M.2, the Logitech MX Master mouse, and using Nuxt.js to build both ssr/spa and pure spa apps.

In episode 94 of Does Not Compute, Sean and Paul talk about splitting JS into multiple bundles with Webpack, Nuxt.js community modules, and how they each approached authorization and permissions for their applications.

In episode 93 of Does Not Compute, Sean and Paul talk about using Ecto in comparrison to ActiveRecord to learn SQL, Postgres's Trigger Functions, SQL Views, and the importance of writing good documentation and developer guides for your app.

In episode 92 of Does Not Compute, Sean and Paul talk about Nuxt.js and PWAs, Pomodoro, using 1Password, and backup paranoia.

In episode 91 of Does Not Compute, Sean and Paul talk about Netlify CMS, Ecto and Postgres, and being paranoid about making money selling things on the internet.

In episode 90 of Does Not Compute, Sean and Paul talk about the differences in building apps when you have user data, 2 Factor auth with 1Password, microcosm, and Paul's upcoming RV move.

In episode 89 of Does Not Compute, Sean and Paul talk about trusting Stripe and Shopify to know what's best when it comes to payment forms and checkout, saving your time and sanity by delegating ops work to Heroku, and how making decisions because of a scale you don't yet have "but might someday" isn't a good idea.

In episode 88 of Does Not Compute, Sean and Paul talk about Phoenix 1.3, Contexts/BDD, and how sharing your code is as much for yourself as it is for others.

In episode 86 of Does Not Compute, Sean and Paul talk about wrangling the Touch Bar using BetterTouchTool, battling guilt while taking breaks from work throughout the day, and Paul's shiny new MacBook Pro.

In episode 86 of Does Not Compute, Sean and Paul talk about being disappointed by consumer products, using Bear Writer, and umbrella apps in Elixir

In episode 85 of Does Not Compute, Sean and Paul talk about the latest WWDC announcements, and Native/Web VR.

In episode 83 of Does Not Compute, Sean and Paul talk about how Paul wrapped his Vue.js app in a thin Cordova wrapper, shipping web based mobile apps to the App Store, and why focussing on the basics of usability for web and mobile apps is so important.

In episode 83 of Does Not Compute, Sean and Paul talk about Sean's new ultrawide monitor & recording interface, their new found addiction with the game Factorio, and using JSON Schema and JSONB to create flexible yet validatable data storage with Postgres.

In episode 82 of Does Not Compute, Sean and Paul talk about evaluating a new 2016 MacBook Pro, searching for a good external monitor, and doing things the idiomatic way instead of doing things the way you've always done them.

In episode 81 of Does Not Compute, Sean and Paul talk about using Codepen's projects feature for quick R&D projects, about remembering sIFR font replacement, and Sean's continued Elixir exploration.

In episode 80 of Does Not Compute, Sean and Paul talk about more about VR, how we might already be living in a simulation, and the cost of building a Windows machine vs. the cost of Apple hardware.

In episode 79 of Does Not Compute, Sean and Paul talk about using dependencies wisely, Paul's participation in Ludem Dare 38, and about how learning new things is such a great way to improve your existing skills.

In episode 78 of Does Not Compute, Sean and Paul talk about Paul's new game Microcosm, IDE's and Unity 3D, and strongly typed languages.

In episode 77 of Does Not Compute, Sean and Paul talk about foregoing DSL's in favor of more control over an Elasticsearch implementation, using MJML to build transactional emails with Rails, and using Docker to mirror your development environment with your production environmen

In episode 76 of Does Not Compute, Sean and Paul talk about exploring new languages in search of performance benefits, when it might be ok to re-write an app to boost performance, and how decoupling your application backend from the frontend can give you the flexibility you need to explore your options.

In episode 75 of Does Not Compute, Sean and Paul talk about using VPNs around the clock, API and Vuex implementation details, and about building reliable and boring appications

In episode 73 of Does Not Compute, Sean and Paul talk about taking a brief look at Go, using Nuxt.js in production, and using GitHub Projects to not only help keep you organized, but also to keep your team members in the loop

In episode 73 of Does Not Compute, Sean and Paul talk about Paul's API connected IOT alarm clock, Using Papertrail for setting up notifications from your app's logs, and using Nuxt.js to churn out server rendered Vue.js apps.

In episode 72 of Does Not Compute, Sean and Paul talk about Sean's new ventures in Elixir, and about how making hard decisions now will help you see benefits in the long term.

In episode 71 of Does Not Compute, Sean and Paul talk about using the Paw app to make app migration and deploys just a little easier with Heroku and using one GitHub "issues" repository for decoupled server/client apps.

In episode 47 of Does Not Compute, Sean and Paul talk about Paul's fancy new Amazon IoT button, Amazon Lamda, and Paul's new Unblog

In episode 69 of Does Not Compute, Sean and Paul talk about Google Sheet's handy feature called Explore, Heroku's Dataclips and a gem called Blazer for business intelligence, and why we disagree with the notion that if you can't do without tools then you're not a real developer.

In episode 68 of Does Not Compute, Sean and Paul talk about how you should check your data backups right this instant, Heroku Pipelines, Rails Form Helpers vs. Spas, and how changing your focus just a bit can bring you relief from Javascript Fatigue

In episode 67 of Does Not Compute, Sean and Paul talk about some basic rules for refactoring, how TDD can help you refactor with confidence, and when it might be time to reevaluate a tool in your toolbox

In episode 66 of Does Not Compute, Sean and Paul talk about the learning the hard way while being in the hot-seat, how leveraging the tools provided to you by a framework like Rails can save you time and frustration, and how Component is just a fancy word for Class

In episode 65 of Does Not Compute, Sean and Paul talk about NightBrain, why consistency is important in design, and applying the principles of learning on demand to non technology related fields

In episode 64 of Does Not Compute, Sean and Paul talk about deep work and battling distractions, applying Mise En Place to our trade as web developers, and about how much you can learn about yourself when you're in charge of your working schedule

In episode 63 of Does Not Compute, Sean and Paul talk about how keeping a simple Research file in your project can help you be more productive, how using pre-existing design guidelines can help you make more informed decisions, and about how they are adjusting to their new roles as Designer/Developers.

In episode 62 of Does Not Compute, Sean and Paul talk about Paul's new job and some of the challenges he faces in the upcoming year, how being present can be one of your most important tools, and documentation, documentation, documentation.

In episode 61 of Does Not Compute, Sean and Paul talk about some useful Rails gems for better sanity checking in development, Webpack and Hot Module Replacement, and how reading the docs is always better than just copying and pasting.

In episode 60 of Does Not Compute, Sean and Paul talk about Sean's new job, job interview preparation, and the importance developers providing customer support for the applications they work on

In episode 59 of Does Not Compute, recorded after the 2016 United States presidential election, Sean and Paul talk about a few ways people can protect their digital privacy over the next few years.

In episode 58 of Does Not Compute, Sean and Paul talk read receipts and email, why good communication skills are important for programmers, and how learning on demand can help tackle the age old imposter syndrome

In episode 57 of Does Not Compute, Sean and Paul talk about how your tools only matter if they save you time while maintaining quality, and how you can change your programming tools while not having to change your methodolog

In episode 56 of Does Not Compute, Sean and Paul talk about Visual Studio Code, JSON Schema, and how learning complicated tools like Redux and Vuex take up more time up front, but can empower you to build complex applications efficiently

In episode 55 of Does Not Compute, Sean and Paul talk some more about React, Redux, Vuex, and Vue, but also about how important it is to know that the important part of programming is thinking about how and why you're going to do something before you do it

In episode 54 of Does Not Compute, Sean and Paul talk about their desk preferences and cable management, React and Redux, and the importantce of specialization as the Front End industry continues to expand

In episode 53 of Does Not Compute, Sean and Paul talk about learning React, what's new in Vue 2.0, and how the future of JavaScript is bright and full of possibilities

In episode 52 of Does Not Compute, Sean and Paul talk about Vue 2.0 and the ecosystem surrounding it, utilizing presentational, container, and stateless components, and how developers absolutely should be involved in the discussion surrounding user experience design

In episode 51 of Does Not Compute, Sean and Paul talk about GitHub and GitLab's new project management features, GitHub's recent decision to use GraphQL, and if its ok to like ES5 over ES6

In episode 50 of Does Not Compute, Sean and Paul talk about life after finishing a long running project, the benefits of Functional CSS paired with a headless CMS, and an awesome tool for pair programming called Hyperdev

In episode 49 of Does Not Compute, Sean and Paul talk about keeping long running projects organized and the whirlwind that is a project launch

In episode 48 of Does Not Compute, Sean and Paul talk about Paul's new game Slappy, a realtime Node framework called Feathers, Hapi.js, and how much fun you can have by experimenting with new tools

In episode 47 of Does Not Compute, Sean and Paul talk about how scheduling your time can help you maximize your productivity while lowering lower your stress, and Sean's return to Hapi.js and introduction to MongoDB

In episode 46 of Does Not Compute, Sean and Paul talk about preferring simple tools over complex tools, how to keep your remote teammates in the loop, and Sean's migration from Sass to Functional CSS

In episode 45 of Does Not Compute, Sean and Paul talk about moving from CoffeeScript to ES6, some observations from the outside in about popular open source libs that are maintained by one or a few individuals, and how picking off low hanging fruit from an issue list frees up those maintainers to do more heavy lifting

In episode 44 of Does Not Compute, Sean and Paul talk about feels while being totally disconnected from the internet, the technical debt associated with micro npm modules, password managers and password security, and how the first step in educating users begins with us developers

In episode 43 of Does Not Compute, Sean and Paul talk about Vue 2.0, Sean's upcoming move across the country, and working remotely with an introverted personality

In episode 42 of Does Not Compute, Sean and Paul talk about using Apple's 12in MacBook for web development, GitHub using system fonts, Work In Progress Pull Requests for your sanity, and prerendering your JavaScript.

In episode 41 of Does Not Compute, Sean and Paul talk about Elixir and linked lists, the benefits of jumping into unfamiliar programming territory, and an interesting UX trick to make your users think your app is working

In episode 40 of Does Not Compute, Sean and Paul talk about simplifying functional programming by using some basic math properties, Elixir, Google's AMP project, and js.org

In episode 39 of Does Not Compute, Sean and Paul talk about how they approach setting personal and professional goals, address the age old question "How does one get started with programming these days?", and how learning a few things about yourself you can dramatically reduce the amount of frustration you'll experience.

In episode 38 of Does Not Compute, Sean and Paul talk about the power of simplicity when it comes to personal productivity and how that means different things for different people, and how going into situations in life with optimism will often lead to a better quality of life

In episode 37 of Does Not Compute, Sean and Paul talk about their origin stories and the path that led them to where they are today

In episode 36 of Does Not Compute, Sean and Paul talk about declarative design tools, Decent.scss, and the benefit of moving towards building apps in an API/Client bundle

In episode 35 of Does Not Compute, Sean and Paul talk about a hot new build tool (and tasty meal) called Brunch, using the CSS will-change property, and write more meaningful CSS

In episode 34 of Does Not Compute, Sean and Paul talk about remembering accessibility while building out UIs on a tight time budget, how using an html outliner can help you write semantic html, and how using tools like cssstats.com can help you keep tabs on your CSS before things become out of control

In episode 33 of Does Not Compute, Sean and Paul talk GitHub's unlimited private repos, how having your own playbook can save you time on repetitive questions and tasks, and how the right programming cookbook can accelerate your learning

In episode 32 of Does Not Compute, Sean and Paul talk about how taking a step back from the programming world often leads to perspective, and how to deal with being thrown into the deep end of a new language or framework

In episode 31 of Does Not Compute, Sean and Paul talk to Peter Cooper of Cooper Press about how they manage the sheer volume of tech news being shared each day, being able to adapt to new technologies by learning on demand, and the ever changing landscape of social media.

In episode 30 of Does Not Compute, Sean and Paul talk about building software for people, Sean's first dive into Node.js, and Paul's newfound fondness of functional CSS

In episode 29 of Does Not Compute, Sean and Paul talk about the importance of introspection and project postmortems as a tool for learning, as well as lay out a few tips for dealing with client questions that require you to research before answering

In episode 28 of Does Not Compute, Sean and Paul talk about using todo apps to get things done (or the lack thereof), and how they feel about the slack vs. email controversy

In episode 27 of Does Not Compute, Sean and Paul talk about the pros and cons to working remotely as a programmer and contempt culture - our intentions are not magic

In episode 26 of Does Not Compute, Sean and Paul talk about the new headless CMS fad, dealing with insecurities as a new lead developer, and Octopus' new SCSS utilities for building sites with Functional/Atomic CSS.

In episode 25 of Does Not Compute, Sean and Paul talk to Jon Gold about using Functional CSS to ship consistent interfaces with less code, when it's a good idea to introduce type safety to your javascript, and Jon's everlasting love of Vim

In episode 24 of Does Not Compute, Sean and Paul talk about the Montues, Epicurrence, and Fluent conferences, remembering to consider your users that don't have updated hardware or fast internet, and a few tips if you're on the hunt for a new job.

In episode 23 of Does Not Compute, Sean and Paul talk some more about Test Driven Development, how learning to read stack traces and the difference between error types will save you multitudes of time, and what Sean thinks about IDEs after another week of use.

In episode 22 of Does Not Compute, Sean and Paul talk about Sean's initial thoughts from venturing out of Sublime Text into IDE land, Paul's new open graph image tool called Motif, and how missing the latest web technology boat isn't a bad thing.

In episode 21 of Does Not Compute Sean and Paul talk about idea debt, creating a sense of purpose over urgency, how important it is to force yourself to rest, and how you can use Nightwatch.js to setup quick end to end tests for your app.

In episode 20 of Does Not Compute, Sean and Paul talk about JavaScript fatigue fatigue, diving deep into what actually interests you in tech, and the importance of toy projects - just have some fun! That's why we all got into this at the first place right?

In episode 19 of Does Not Compute, Sean and Paul talk about using Git while working with a team, GitHub Flow, what to look for in an open source readme, and some of the available options for deploying your website or webapp.

In episode 18 of Does Not Compute, Sean and Paul talk about the importance of getting involved with a coding community for beginners and experts alike, and how being intentional with your time and energy will have a huge impact on your productivity and ability to learn new things.

In episode 17 of Does Not Compute, Sean and Paul talk about the Ruby on Rails Doctrine, a few CSS and JavaScript refresher tips, and Otto by HashiCorp, automated development environments made easy (eventually).

In episode 16 of Does Not Compute, Sean and Paul talk about how to get started with webpack, JavaScript Modules, and the current state of modern JavaScript and the community surrounding it.

In episode 15 of Does Not Compute, Sean and Paul talk about Placem.at, Paul's new open source placeholder image service, FancySelect/Selectize and JS based select enhancements, and how you probably already know a few functional programming tricks.

In episode 14 of Does Not Compute, Sean and Paul talk about testing your JavaScript (the how's and when's), Paul's new imgix open source JavaScript tools Luminous & Drift, and ES6 as compared to Coffeescript.

In episode 13 of Does Not Compute, Sean and Paul talk about simple CSS grids, SVG vs. Gif and SVG accessibility, SVG vs. icon fonts, and a pretty awesome js based csv parsing tool called Papa Parse.

In episode 12 of Does Not Compute, Sean and Paul talk about Adobe Generator, 5 Active Record tips, Flexbox and CSS Calc for layout, and web accessibility basics.

In episode 11 of Does Not Compute, Sean and Paul talk about remote development setups via DigitalOcean and Coda, Javascript Closures and Promises, and how to be productive while learning new things.

In episode 10 of Does Not Compute, Paul and Sean talk about learning from your past code mistakes, Ruby 2.3 and POROs in Rails, Programming Idioms, and how simplifying down your methods often leads to cleaner, more readable code.

In episode 9 of Does Not Compute, Sean and Paul talk about how having empathy toward clients can help you stay motivated on long running projects, a few install tips for installing SSL on your servers, and how choosing convention over configuration can lead to greater productivity for you and your team.

In episode 8 of Does Not Compute, Sean and Paul talk about how to manage legacy data migrations safely with Rails, Metaprogramming in Ruby, and the difference in knowing the tools that you choose and being dependent on those tools.

In episode 7, Sean and Paul talk how developers can benefit directly by investing some time into learning design, Rails ActiveSupport::Concerns and Plain Old Ruby Objects, and how to deal with mental fatigue.

In episode 6 of Does Not Compute, Sean and Paul talk about programmer over-engineering, cowboy programmers, and the duct tape programmer. Also in today's discussion are the new Vue.js devtools, and how Drew Wilson built a mac app over night to scratch an itch.

In episode 5, Sean and Paul discuss a very helpful article entitled 10 tips for young programmers, how to use active model serializers in rails, and how to deal with programmer frustration.

In episode 4 of Does Not Compute, Sean & Paul talk about how to break down a new technique or idea into something manageable while on a deadline, how using keyboard shortcuts can significantly increase productivity, and how code is for people, not computers.

In the 3rd episode of Does Not Compute, Sean and Paul discuss being just plain worn out, and how burnout is a real thing that happens to everyone, and what to do if it's happening to you. They also talk about how you don't need to know everything to be a good programmer, and how it's important to get to you the tools that you use instead of switching to every new fad.

In the second episode of Does Not Compute, Sean and Paul discuss different options for managing image assets within a Rails app, Sean's favorite new way to package a rails app for deploying to production, and how you might not even need to build a Single Page Application with all of those fancy (and expensive) new tools.

In this episode of Does Not Compute, Sean and Paul discuss how not to use magic numbers in programming, how you can and should lint your code, utilizing slack communities for instant feedback from others, how asking questions is one of the best ways to learn to program, and how a technique called time boxing can help you focus your time and be more productive.

This is a test episode to get everything set up in iTunes and get RSS feed running smoothly. Until that happens though, you can listen to Sean and Paul talk about Javascript frameworks such as Vue and react, Web Components, and an experimental site navigation called Zoomable UI.