GraphQL is a flexible, strongly-typed query language. It's useful because it gives front-end developers the ability to query the database without many changes to the back-end. In this episode, David Sanchez explains how to design and build GraphQL APIs in Rails.
If you’re wondering how to make sense of all these frameworks, you’ve come to the right podcast. In this episode, the Rogues dive DEEP into the pros and cons of Stimulus, Hotwire, Turbo, React, Rails, and more; why certain communities are divided amongst each other (and how to fix it); and what tools you NEED to try in 2022.
Kevin Newton works at Shopify. He is specifically assigned to the Ruby and Rails Infrastructure Team. He returns to the show to talk about building Parsers in Ruby since he is working full-time on a new Ruby parser called "Prettier Ruby Plugin”. Prettier works with the majority of editors and support different languages. He shares his journey on how he was able to create it. He also talks about "exreg", which is a Ruby regular expression engine that he created.
Today on the show, Máximo Mussini shares how your front-end framework can benefit from integrating rails models and routes concurrently. Topics they discuss today include everything from complex structures with serializers to generating JS from rails routes.
Imagine a tool that lets you write templates that can generate code, but also parse that code back into the initial variables. Depending on how flexible your templates are, it can even parse code that has been modified by hand after generation. Today on the show, the panel interviews Lucas Luitjes, creator of Monocle, the tool that allows for this kind of integration.
Wouldn't it be great if ActiveRecord didn't make you think about eager loading and it just did the "right" thing by default? Lazy loading is extremely helpful when the list of associations to load is determined dynamically. Today on the show, Charles and Luke interview Evgeniy Demin, Principal Engineer at Toptal. They discuss how you can speed up your processes by lazy loading your N+1 queries, plus various tools to optimize your workflows.
In recent years, researchers have explored component-based synthesis, which aims to automatically construct programs that operate by composing calls to existing APIs. However, prior work has not considered efficient synthesis of methods with side effects that update a database. Today on the show, Sankha Guria shares about his research in this area, introducing a new approach to type and effect-guided synthesis tools for Ruby.
How do you develop remotely in new ecosystems such as when you are on vacation, in a coffee shop, or traveling for business? The panel today discusses various strategies on how to manage these environments to achieve the most efficient outcomes.
Unfinished technology, unfinished products, unfinished gems, unfinished concepts, unfinished code, unfinished libraries, and more. In software development, everyone has those projects that never get finished or ever get started. Luke and Valentino banter about the various aspects of unfinished business, specifically technology ideas – from creating to implementing to fixing to scrapping.
John Epperson and Luke Stutters discuss developer tools - whether those are the IDEs or Text Editors we use, the gems/libraries we include in our projects, or the OS we make use of. We talk about How we decide to replace our tools, and we talk about a number of tools that we use, the ones that we like and the ones that we wish had better replacements.
Andy Maleh joins the show today to share his opensource desktop development library app for Ruby, Glimmer. Enjoy hearing about why and how Andy created Glimmer, specific applications for implementation, comparison to other apps, DSL framework, using widgets within Glimmer, feature additives, testing, and various compatibilities.
Is it a class? Is it a hash? No, it's Ruby Struct! Brooke Kuhlmann joins the Rogues to explore this often-overlooked object. We extend simple structs with refinements, use pattern matching to compress complex logic and close the door on OpenStructs. Brooke talks about the challenges and rewards of introducing busy teams to advanced techiques, software craftsmanship and the transformational philosophy of alchemists.io.
It's not every day that you learn a new approach to error handling for Ruby. Today Abiodun Olowode shares her insights with railway oriented programming (ROP), a functional programming technique that allows sequential execution of functions, not necessarily synchronous. The key concept is that each function can only accept and return Container of either Success or Failure. They also dive into the topic of dry monads, the gems that helps you achieve railway oriented programming in that it helps bind your methods together and give you a success or failure result.
GraphQL is a flexible, strongly-typed query language. It's useful because it gives front-end developers the ability to query the database without many changes to the back-end. In this episode, David Sanchez explains how to design and build GraphQL APIs in Rails.
David Heinemeier Hansson (DHH) creator of Ruby on Rails joins the Rogues to discuss the successor to the asset pipeline and webpacker that's coming in the next version of Ruby on Rails.
He talks through the differences between the asset pipeline, webpacker, and propshaft and talks about the reasons you may or may not want to use each solution.
Ever feel like your code isn’t “Stylish” enough? Us too. In this episode, the Rogues sit down Benito Sandoval, the author of the Ruby tool Styler that’ll help you customize your UI and keep things running smoothly.
“My goal was to create something that allowed you to compose classes and use them in your templates.”
- Benito Sandoval
If you think all audits suck, think again. In this episode, the Rogues sit down with Jeremy Smith, a developer and writer who’s ready to show us the RIGHT way to implement audit logs in Rails.
“I want to be cautious about how much I bring into a code base. As gems grow, they accumulate more functionality.”
- Jeremy Smith
Interested in state machines? We’re not sure you should be…but it depends. In this episode, the Rogues discuss the merits of state machines and how to know if you actually need one…or if you just need to do some soul searching. They lay out the KEY to organizing your code, how automobile analogies will help you simplify your situation, and what to know about callbacks, records, and controllers this year.
Rails 7 is HERE and we’re pumped. In this episode, the Ruby Rogues discuss all things migration, including the BEST method for a safe move, why you NEED to learn about “Turbo Frames” to streamline your Rails 7 experience, and everything you need to know about gems to help you stay on track.
If you feel like Ruby could use a makeover, you’re not alone. In this episode, the Rogues sit down with Kevin Newton, a Ruby aficionado who’s got some exciting news about Ruby in 2022. They talk about how “prettier Ruby” will make you pivot in your approach, how YJIT is going to make Ruby “crazy fast” this year, and the GIANT reason why rewriting in C is becoming less common than in Ruby.
“There’s always gonna be the purist in the back of your head…and then you have your deadline. Just write the dang parser!”
- Kevin Newton
You keep hearing the phrase “Top End Dev”, but in the real competitive world, what does it take to be the best of the best? In this episode, the Rogues get real and lay it all out, including the real way to test your chops in the marketplace, the big “C” to break out of your comfort zone, and why joining the top 5% comes down to THIS step.
Well, comments may not be satanic, but they CAN be a nuisance if not used carefully. In this episode, the Ruby Rogues sit down with Matheus Richard to discuss why he isn’t a fan of comments. They unpack the WHY behind “use code, not comments”, tools to help you sort through variables and avoid “shotgun surgery”, and an alternative to magic numbers, TODOs, and notes.
“Use code, not comments.”
- Matheus Richard
If you’re wondering how to make sense of all these frameworks, you’ve come to the right podcast. In this episode, the Rogues dive DEEP into the pros and cons of Stimulus, Hotwire, Turbo, React, Rails, and more; why certain communities are divided amongst each other (and how to fix it); and what tools you NEED to try in 2022.
Ready to COMMAND your command line? Then listen up! In this episode, the Ruby Rogues sit down with Adam Gordon Bell, a software developer and host of the CoRecursive podcast. The guys discuss the tools that every developer MUST know in 2022, what users of Jekyll and Ruby can expect this year, and why Adam believes that JQ will save you hours from Google and Stack Overflow.
“I remember when I used to chase the “shiny new thing”, but now, I want to find the tools that last.”
- Adam Gordon Bell
Vlado Cingel recounts his story where he needed common table expressions within SQL for a project he was working on and wrote a patch to AREL and ActiveRecord which he submitted to the Rails Core. Since it hasn't been accepted, he's supporting it as a gem.
Vlado explains what Common Table Expressions (CTEs) are, how they work, and where they're used.
Kingsley Chijioke wrote an article breaking down the way that Ruby finds methods and determines which version of a method to run. The Rogues approach the internals of Ruby and discuss the implications of how this comes together and where the listeners may have seen this and point out any gotchas that arise.
Ulysse Buonomo ran into an issue in the application he works on where the Heroku applications were taking up more and more memory. He began tracking down memory growth in the applications to keep the applications fast and keep the bills small.
Riaz Virani joins the Rogues to discuss how to thrive at your first Dev Job. He has five main ideas that when applied will help you as a new developer fit in and learn quickly on a development team.
The Rogues chime in with their experiences. They also discuss how not-so-new developers can apply these ideas either as mentors or as learners themselves.
Jeremy Evans joins the Rogues to discuss the way he builds Ruby programs and the practices he put into his latest book "Polished Ruby Programming."
The Rogues dive into Jeremy's opinions. They push back on some, applaud others, and ask deeper questions about the rest. Join this deep dive by experienced developers into the how and why of organizing Ruby in deeply practiced ways.
Cameron Dutro joins the Rogues to discuss RUX, a system for managing your View Components in Rails in a similar way to how React uses JSX to manage its Component views. He discusses how it works, how it goes together, and what inspired it.
Huzefa Biyawarwala joins the Rogues to discuss developer tooling around Docker and how it's used with Ruby and Rails. The Rogues join in and discuss the ways they've used Docker in their own setups and how they deploy apps using Docker and how Docker is used on their own development environment.
Michael Orr joins the Rogues to discuss how to move applications into Docker for development and production environments in Kubernetes. He walks the panel through the process of orchestrating a Rails setup in Kubernetes that you can run in the cloud.
Maxwell Anselm discusses the options that he's found to build multi-platform mobile applications. The panel chimes in on different options.
Maxwell also goes into how he uses Ruby in non-Ruby codebases.
Dave Kimura, John Epperson, Luke Stutters, Darren Broemmer, and Valentino Stoll talk about their experiences in setting up a maintainable development environment and discuss considerations when deploying to production.
Alex Dunae joins the Rogues to discuss his experience introducing types into an existing codebase using the Sorbet gem and how it saved him and his company time, money, and effort. The conversation covers libraries and tools for working with types in Ruby.
Hans Schnedlitz joins the Rogues to discuss how you can use ActionCable to get feedback on ongoing tasks in the commandline by connecting to a websocket.
His solution is written entirely in Ruby and provides some interesting options for people building CLI's for their applications.
Milap Neupane joins the Rogues to talk about how to know how robust your Rails apps are.
Sometimes you forget to optimize database queries or network calls for performance during development, which impact the load that the application can support and when its performance begins to degrade.
Milap breaks down how to determine where these moments occur and what to do to get better performance from your applications.
Fabio Perrella joins the Rogues to discuss debugging Ruby programs and how to find problems across your code and your dependencies.
The panel shares their stories and experience to dive into debugging tools and techniques they've used that have worked out well in the apps they maintain.
Jeremy Evans, author of the Roda framework, joins the Rogues to talk about how to use Roda to build Ruby web applications.
Roda is a super lightweight framework that adds features through plugins to give you the power you need when you need it to build your applications. This allows you to bring in only what you need in order to get fast and easy to maintain code.
Jason Dinsmore went spelunking through the changelogs for Rails and pulled out the latest features for the most popular Ruby web development framework.
Jason and the Rogues go through the changes and discuss the upcoming changes in Rails 7.
The Ruby fiber scheduler is a powerful new feature in Ruby that we brought Wander Hillen along to discuss with us. Ruby fibers are a way of managing threading and concurrency within Ruby.
This episode explains uses that can come from the fiber scheduler and what it offers in doing work outside the main process to increase efficiency.
Jake Yesbeck joins the Rogues this week to talk about how to handle models and data migrations in your Ruby on Rails applications. He and the Rogues discuss the pros and cons of including models in your Rails migrations and the strategies for migrating data as part of migrating your database structure.
The panel then dives into Jake’s year of contributing to open source each day. What he learned and what he gained from making a contribution every day of an entire year to open source.
Masafumi Okura is the organizer of Kaigi on Rails and the author of the Alba--a JSON serializer library. The Rogues dive in and get the details on Kaigi on Rails and discuss how to serialize data into JSON within your application.
They also discuss why we need another JSON serializer library and which options Alba offers.
Dave Kimura and Luke Stutters talk with Mark Hutter about Active Storage and his experience building a large image driven application. We talk about some of the issues and workarounds when implementing Active Storage.
This is a repeat episode of Ruby Rogues. Here's the original link https://devchat.tv/ruby-rogues/131-rr-how-to-learn/
We discuss the value of bootcamps and whether new developers should consider them. We also touch a little bit on related topics like interviewing.
Richard Feldman - author of Elm in Action - joins the Rogues to discuss the advantages of Functional Programming and using Elm. Elm is a programming language that is a functional programming language built for the front-end that compiles to JavaScript. Due to its set of enforced assumptions, it leads to clean code and powerful programming constructs.
Onboarding and leveling up Junior developers can be tricky. Emily Giurleo joins the Rogues to discuss the process for creating autonomous, competent developers when you hire someone who doesn't have as much experience. She walks us through setting expectations for the new hire, giving feedback, and assessing their performance.
Hilary Stohs-Krause addresses the things that we have strong emotional reactions to as developers that maybe we shouldn't worry about them. She also leads a discussion with the panel around when fear is a good thing.
Paul Zaich from Checkr tells us about a critical outage that occurred, what caused it and how they tracked down and fixed the issue. The conversation ranges through troubleshooting complex systems, building team culture, blameless post-mortems, and monitoring the right things to make sure your applications don't fail or alert you when they do.
Jesse Spevack tells us about a conference topic he gave where big mistakes were made at his company. Having lived through the choices that they made, we chat about the lessons learned.
In this episode of Ruby Rogues, Chelsea Troy teaches us to hone our debugging skills to a razor-sharp edge. We learn how to actively improve debugging skills, train troubleshooting instincts and practical strategies for tackling brain-bending bugs.
In this episode of Ruby Rogues, Eric Hayes joins us with the story of his journey into the dark, undocumented depths of Arel, ActiveRecord’s private API. We learn why writing custom SQL queries in 2020 can make sense and how to unlock the more powerful features of modern databases without resorting to SQL strings. Eric tells us how he manages the potential pitfalls of using Arel and achieves massive performance wins for difficult queries on large databases.
In this episode of Ruby Rogues, Joe Santos Garcia from CodingPhase joins the panel to talk about how to successfully get into coding and grow into a coding career. He talks about growing his YouTube channel, membership site, and deciding where you want to land in your career.
React on Rails version 12 brings major improvements for hot reloading and bundle splitting. Justin Gordon talks about creating a great developer experience with React and Rails, the best way to manage your webpack configuration, simplify server and client-side rendering and avoid shaving those yaks!
Episodes
Different doesn’t need to be worse. Dmitry Tsepelev tells us how to make the most of using GraphQL with Rails, the advantages over REST-based API queries and best practices for security and schemas.
In this episode of Ruby Rogues, guest Jonathan Reinink joins the Rogues to talk about what Inertia.js is and why Rails developers would want to use it.
In this episode of Ruby Rogues, we talk with Ufuk about how Shopify made the transition to using Sorbet and about the benefits they felt they received from implementing it. Ufuk also reveals a little bit about how Shopify transitioned to fully remote and about how that will be the default moving forward.
In this episode of Ruby Rogues, the panelists discuss the progress, problems, and strategies for implementing JIT in Ruby for the Ruby 3×3 goal all while being humbled a bit as Takashi improves our understanding around the subject.
In this episode of Ruby Rogues, we talk to James Dabbs as we explore a number of subjects and topics around refactoring
Tricia Ball talks to the Rogues about diversity in tech. We discuss the declining numbers of women in tech (and the rest of STEM) since the 1980s, reasons why women are leaving mid-career and how we can help reverse this trend. Tricia gives practical actions that can be taken to improve company culture, recruitment and retention of under-represented groups.
Kyle d'Oliveira (Clio) shares his survival tips for dealing with tens of thousands of commits, massive migrations and the very limits of databases. We discuss the lessons learned from Rails megaprojects and how to use these tips in your own projects to reduce technical debt and tools to keep your monolith majestic when the code won't stop coming.
In this episode of Ruby Rogues guest, Dylan Andrews (GoNoodle) shares his journey from pro-drummer to junior developer to successful senior software engineer. Dylan and the rogues talk about on-boarding junior developers and building up confidence.
Episodes
In this episode of Ruby Rogues, James Thompson, a Software Architect at Mavenlink, delves into how to address errors in a service-based system and how to prioritize what errors to fix. He goes into how to recognize the errors when they are creeping in and so much more.
Lee Richmond is one of the primary developers behind the Graphiti library for Ruby. Lee describes Graphiti as the spiritual successor to ActiveResource. It provides a convenient way to provide an API that understands the object graph in your application without needing to resort to GraphQL.
Joel Hawksley is an engineer at Github who works on some of their Rails architecture. He is one of the authors of the view_component gem. He walks the Rogues through the genesis of the project and the pros and cons of using a library like view_component and how it adds testability and easy management to Rails views.
Episodes
Dee Dee Lavinder talks with the Rogues about how we can create space for introverts to participate in discussions, thereby getting their input in situations where we otherwise would not. She provides some tips for extroverts to invite the input, Luke brings his patented sarcasm to the table, we discuss some pitfalls and Dee really brings some fantastic advice to the table for those trying to moderate discussions as well as for those of us having small discussions with our colleagues.
Dave Aronson joins the Rogues to talk about Mutation Testing in Ruby. The conversation starts with a discussion of what mutation testing is. They discuss the benefits and approaches before diving into implementation details.
Ivan Nemytchenko is a freelancer. He's a speaker and conference organizer. Ivan spoke at RailsConf about abstract Object Oriented programming ideas and how they can be expressed with pictures. The discussion goes into learning processes and how to create visual representations that help people understand Ruby, Rails, or other concepts.
Sean Marcia organizes Ruby For Good—an organization for building technology to solve the world's problems and an in person meetup held online this year. Sean talks about founding Ruby For Good and some of the projects it has been responsible for creating.
This episode is a roundup discussion about what the podcast hosts have going on these days. John talks about going freelance working on Ruby, Rails, and React Native. John and Chuck riff on the pros and cons of React Native. Luke then jumps in and talks about a crash-and-burn he ran into with building reports. John sympathizes based on his past experiences. The rest of the show comprises the panel filling in with what they're working on or learning.
Daniel Colson, from Thoughtbot and maintainer of Factory Bot, joins Dave Kimura, Luke Sutters, Tom Rossi, and John Epperson and discuss the transition from a Music career to a development career. We also dive into Factory Bot and its use cases.