Ski Slopes, Sorbet, and Copilot — Effective Learning with Ryan Caldwell
03/14/24 • 31 min
In this episode of Ruby for All, Andrew and Julie chat about their recent experiences, including a ski trip with challenges due to a storm, and discuss burnout and returning to regular podcasting. Special guest, Ryan Caldwell, a software engineer at GitHub working on Copilot, joins the conversation to discuss his work, particularly on chat-related features of Copilot. Ryan shares insights on programming languages, leaning into his transitions between Ruby, Java, and Go, and navigating the differences between dynamically and statically typed languages. The conversation covers the benefits and challenges of implementing type checking in Ruby with Sorbet, especially in large projects like GitHub. Ryan advocates for learning Ruby on Rails, praises its efficiency for staring profitable projects, and provides tips for using Copilot Chat effectively. Press download now to hear more!
[00:00:23] Julie fills us in on a recent skiing trip to went on in California, the huge storm they encountered and leaving early to avoid being stranded, the broken chain on their car, and a scary moment on a slope with her kids. Andrew shares he experienced burnout but sees improvement.
[00:02:47] Ryan Caldwell introduces himself and tells us what he does.
[00:03:53] Andrew asks Ryan about the programming languages used for Copilot, leading to a discussion about using Go for its REST API, the manageability of the project, and Ryan’s transition from Codespaces to Copilot after paternity leave.
[00:04:49] Andrew wonders why Go was chosen, and Ryan explains the team’s familiarity with Go and the language’s simplicity.
[00:06:12] Ryan reflects his first programming language and journey through JavaScript, Python, Java, and Ruby, highlighting his appreciation for Ruby. He talks about learning Ruby on the job, and his fondness for Rails.
[00:08:02] Ryan discusses the challenges of picking up new languages and his approach to learning through project involvement.
[00:09:24] Andrew asks about the shift from dynamic to typed languages, and Ryan shares his experiences transitioning from Ruby to Go.
[00:11:53] We hear about Ryan’s work on type checking with Sorbet at GitHub, and he shares that Sorbet helped find edge cases and bugs, improving the code by requiring changes to the structure to prevent these issues.
[00:15:09] Ryan feels the biggest benefit of Sorbet is enforcing developers to consider boundaries and contracts between classes, which encourages thoughtful coding and design. A downside he mentions is the time and confusion involved in the migration process, particularly for team members unfamiliar with the new syntax.
[00:17:11] Julie inquires if Ryan would do anything differently regarding Sorbet implementation. He reflects on the challenge of estimating the time required for implementing Sorbet, dealing with complex code, and the difficulty of refactoring legacy code without comprehensive tests.
[00:18:44] Would Ryan go back to Ruby/Rails without Sorbet? He states that he would for personal projects for speed but appreciates Sorbet in team settings for defining clear code boundaries.
[00:19:31] Ryan suggests that small teams should consider Sorbet if it solves a specific problem, rather than adopting it without a clear purpose.
[00:21:40] Ryan discusses his pride in streamlining the authentication process across different clients in Copilot, leading to a simplified codebase for the team. A tip he shares is to provide as much context as possible when using Copilot Chat to get better responses.
[00:25:35] Andrew talks about custom instructions for ChatGPT, like ensuring all output is in bullet points, and wonders if such a feature exists for Copilot.
[00:28:46] Ryan advises newer developers to be intentional about what they chose to learn in software development, emphasizing the importance of investing learning time wisely. And yes, Ruby on Rails is still worth learning in 2024.
[00:31:03] Find out where you can follow Ryan on the interwebs.
Panelists:
Andrew Mason
Julie J.
Guest:
Ryan Caldwell
Sponsors:
Links:
In this episode of Ruby for All, Andrew and Julie chat about their recent experiences, including a ski trip with challenges due to a storm, and discuss burnout and returning to regular podcasting. Special guest, Ryan Caldwell, a software engineer at GitHub working on Copilot, joins the conversation to discuss his work, particularly on chat-related features of Copilot. Ryan shares insights on programming languages, leaning into his transitions between Ruby, Java, and Go, and navigating the differences between dynamically and statically typed languages. The conversation covers the benefits and challenges of implementing type checking in Ruby with Sorbet, especially in large projects like GitHub. Ryan advocates for learning Ruby on Rails, praises its efficiency for staring profitable projects, and provides tips for using Copilot Chat effectively. Press download now to hear more!
[00:00:23] Julie fills us in on a recent skiing trip to went on in California, the huge storm they encountered and leaving early to avoid being stranded, the broken chain on their car, and a scary moment on a slope with her kids. Andrew shares he experienced burnout but sees improvement.
[00:02:47] Ryan Caldwell introduces himself and tells us what he does.
[00:03:53] Andrew asks Ryan about the programming languages used for Copilot, leading to a discussion about using Go for its REST API, the manageability of the project, and Ryan’s transition from Codespaces to Copilot after paternity leave.
[00:04:49] Andrew wonders why Go was chosen, and Ryan explains the team’s familiarity with Go and the language’s simplicity.
[00:06:12] Ryan reflects his first programming language and journey through JavaScript, Python, Java, and Ruby, highlighting his appreciation for Ruby. He talks about learning Ruby on the job, and his fondness for Rails.
[00:08:02] Ryan discusses the challenges of picking up new languages and his approach to learning through project involvement.
[00:09:24] Andrew asks about the shift from dynamic to typed languages, and Ryan shares his experiences transitioning from Ruby to Go.
[00:11:53] We hear about Ryan’s work on type checking with Sorbet at GitHub, and he shares that Sorbet helped find edge cases and bugs, improving the code by requiring changes to the structure to prevent these issues.
[00:15:09] Ryan feels the biggest benefit of Sorbet is enforcing developers to consider boundaries and contracts between classes, which encourages thoughtful coding and design. A downside he mentions is the time and confusion involved in the migration process, particularly for team members unfamiliar with the new syntax.
[00:17:11] Julie inquires if Ryan would do anything differently regarding Sorbet implementation. He reflects on the challenge of estimating the time required for implementing Sorbet, dealing with complex code, and the difficulty of refactoring legacy code without comprehensive tests.
[00:18:44] Would Ryan go back to Ruby/Rails without Sorbet? He states that he would for personal projects for speed but appreciates Sorbet in team settings for defining clear code boundaries.
[00:19:31] Ryan suggests that small teams should consider Sorbet if it solves a specific problem, rather than adopting it without a clear purpose.
[00:21:40] Ryan discusses his pride in streamlining the authentication process across different clients in Copilot, leading to a simplified codebase for the team. A tip he shares is to provide as much context as possible when using Copilot Chat to get better responses.
[00:25:35] Andrew talks about custom instructions for ChatGPT, like ensuring all output is in bullet points, and wonders if such a feature exists for Copilot.
[00:28:46] Ryan advises newer developers to be intentional about what they chose to learn in software development, emphasizing the importance of investing learning time wisely. And yes, Ruby on Rails is still worth learning in 2024.
[00:31:03] Find out where you can follow Ryan on the interwebs.
Panelists:
Andrew Mason
Julie J.
Guest:
Ryan Caldwell
Sponsors:
Links:
Previous Episode
Mastering Rails Callbacks – Deciphering the Secrets of Active Record
In this episode of Ruby for All, Andrew and Julie discuss the intricacies of callbacks in Active Record models. They talk about their experiences, the pros and cons of using callbacks, and the issues they faced. They also share some helpful use cases for callbacks, including user authentication, logging and auditing, custom slug generation, and the concept of “hooks.” Also, Andrew and Julie review their ways of dealing with callbacks testing and debugging in a Rails application. Press download now to hear more!
[00:02:32] Let’s learn about “callbacks” in Rails as Andrew explains what they are and uses an example of a blog post to explain how a callback might function when saving a post.
[00:03:56] Julie inquires if Tiptap can be used in a browser for apps and they discuss before-save callbacks in a post model and how they can be used to extract and save a title.
[00:06:19] Andrew elaborates on the three different types of callbacks: before, after, and around callbacks, and gives examples of each.
[00:10:06] They discuss practical uses for before-validation callbacks, such as setting default values.
[00:11:12] Andrew clarifies the concept of “hooks” in programming, comparing it to callbacks.
[00:12:18] Julie asks for examples of actions taken after validation versus before validation.
[00:13:19] Andrew talks about how a file upload, an after-create callback can be used for processing the file such as generating thumbnails or updating related resources. He lists examples use cases for callbacks like hashing passwords before saving to the database during user authentication, triggering email notifications after a comment is posted, and logging and auditing activities like user sign-ups or errors.
[00:15:57] Julie is curious about whether deleted accounts really remove all user data or just make it as inaccessible, noting some services offer a soft delete option with a time window to recover the account. Andrew has not yet encountered the fallback log issue he set up but explains how before-destroy callbacks could be used to implement a time-based soft delete system.
[00:17:19] Andrew describes using before-create callbacks for generating custom slugs for blog posts automatically.
[00:17:54] Andrew recalls a discussion at RailsConf about the diverse opinions on using callbacks, with some developers strongly against them and others in favor. He acknowledges that while callbacks can simplify complex operations, they can also make debugging difficult and can become problematic if used excessively or inappropriately.
[00:23:00] Julie asks Andrew where he stands on the use of callbacks, and he positions himself in the middle, closer to using them when appropriate.
[00:25:16] Andrew emphasizes being cautious with callbacks and explains that callbacks are useful when certain actions need to happen automatically without explicit instruction every time a record is saved.
[00:27:40] Andrew discusses the challenges of testing callbacks, as they can require additional setup in tests and slow down the test suite. He concludes that callbacks are an integral part of Rails, he advises against using them as the first solution and recommends weighing their pros and cons carefully.
Panelists:
Andrew Mason
Julie J.
Sponsors:
Links:
Julie J. Website
Active Record Callbacks
- (00:00) - Intro and Topic Overview
- (02:32) - Introduction to Callbacks in Rails
- (03:56) - Discussing Before-Save Callbacks and Tiptap
- (06:19) - Types of Callbacks: Before, After, and Around
- (10:06) - Uses for Before-Validation Callbacks
- (11:12) - Hooks vs Callbacks
- (12:18) - Practical Use Cases for Callbacks
- (15:57) - Soft Delete Options and Before-Destroy Callbacks
- (17:19) - Generating Custom Slugs with Before-Create Callbacks
- (17:54) - Diverse Opinions on Using Callbacks from RailsConf
- (23:00) - Andrew's Not an Expert
- (25:16) - Caution and Appropriate Use of Callbacks
- (27:40) - Challenges of Testing Callbacks
Next Episode
The State of Debugging in Ruby — A Puts-tastic Journey
In this episode of "Ruby for All," hosts Andrew and Julie take us through a journey of debugging, from dealing with weather-induced moods to squashing tricky bugs in their code. They touch on the challenges of debugging without audio guidance, leveraging logs for troubleshooting, and the logical approach to handling errors in Ruby or JavaScript. They dive into the variations of different debugging tools, such as Pry and the Rails Logger, and the complexities of transitioning to new debugging gems. Andrew recounts a perplexing bug only replicable in production and details his process and concluding the issue. As they navigate the intricacies of problem-solving, they contemplate the worth of fixing minor bugs versus prioritizing major ones, drawing on real-life examples from their experiences. Andrew wraps up with a reminder of the importance of teamwork in debugging, while they both acknowledge the reality that sometimes, a bug might just remain unfixed. Join them as they share insights and laughter, reminding us of the human element in the world of code.
[00:00:54] Andrew describes the bug issue he had and the difficulties of debugging it without audio in the screen recording, and Julie shares her own debugging challenges on her new team.
[00:02:00] Let’s talk about debugging, as Andrew explains different types of bugs and shares his process for understanding and reproducing bugs. Julie emphasizes the importance of understanding the product and the expected behavior to replicate and debug issues.
[00:03:31] Andrew describes his approach to getting unstuck during debugging, which includes revisiting the problem statement and using logs to trace the issue.
[00:05:14] Andrew asks Julie if she can replicate her bug in production and suggests using logs for troubleshooting. Julie talks about her approach to errors, which differs as she doesn’t typically see the red Rails error page in her work. They discuss how to deal with JavaScript errors and the importance of reading error messages.
[00:08:57] Julie inquires why some developers may overlook details in error messages, and Andrew suggest that assumptions and a form of panic might play roles and discusses when he’s more likely to Google error messages, especially regarding dependencies.
[00:13:22] Andrew explains why he prefers using the ‘Rails Logger’ over ‘puts’ for debugging. He also mentions using Overmind and tmux for viewing Rails logs.
[00:14:39] Julie draws a parallel between ‘puts’ debugging and JavaScript’s console.log debugging. Andrew confirms they are similar, and he shares his transition from using Pry to the official debug gem and the difficulty of changing old habits.
[00:16:30] Andrew clarifies that binding.irb now uses the debug gem by default in Ruby 3, he discusses the usefulness of Pry’s context-switching feature, and he outlines additional steps for effective debugging.
[00:19:52] There’s a conversation on using git for tracking code changes and git-bisect for isolating commits that caused issues, and questioning assumptions, reading documentation, and getting a second opinion or sleeping on the problem.
[00:23:17] Andrew discusses the mindset required for effective debugging: patience, persistence, and the willingness to step away and return to a problem. Julie describes a very specific bug affecting a small number of users questioning with her manager whether it’s worth the effort to fix it.
[00:25:43] Back to Andrew’s story about a bug that he couldn’t replicate in development, but could in production, and he details his process and realization that it was a display issue in the front-end.
[00:31:09] Julie relates to Andrew’s difficulty in replication bugs in development and suspects filtering differences in production. Andrew suggests troubleshooting methods for errors related to data discrepancies.
[00:33:11] Andrew shares a tip about using data to back up arguments when trying to convince others during decision-making, and Julie recounts realizing the low impact of the bug she’s working on and it it’s worth the effort.
Panelists:
Andrew Mason
Julie J.
Sponsors:
Links:
- (00:54) - Debugging Dilemmas: Screen Recordings ...
If you like this episode you’ll love
Episode Comments
Generate a badge
Get a badge for your website that links back to this episode
<a href="https://goodpods.com/podcasts/ruby-for-all-418618/ski-slopes-sorbet-and-copilot-effective-learning-with-ryan-caldwell-58054551"> <img src="https://storage.googleapis.com/goodpods-images-bucket/badges/generic-badge-1.svg" alt="listen to ski slopes, sorbet, and copilot — effective learning with ryan caldwell on goodpods" style="width: 225px" /> </a>
Copy