Software Sessions

Daniel is the Director of Product at HAProxy Technologies.

This episode originally aired on Software Engineering Radio.

Theme music is 12:30 AM by Crystal Cola.

Links

• HAProxy Community Edition
• HAProxy Technologies Blog
• @danielcorbett_
• Keepalived
• Linux Virtual Server
• Nginx
• Envoy

Timestamps and Transcript are coming soon.

Cassidy is a developer and instructor at React Training and the Director of Outreach at cKeys, a Seattle based organization that promotes learning electronics through mechanical keyboards. She previously worked at Amazon, CodePen, L4 Digital, Clarifai, and Venmo. However, she's probably best known for promoting diversity in tech, creating cool mechanical keyboards, and making memes.

Cassidy
Personal Website
@cassidoo

Current Work
React Training
cKeys

Keyboards
Follow your dreams (literally): How I designed and launched the Official Scrabble Keyboard
Astrolokeys (Collaboration with Amy Wibowo)

Notes App
Bear

Resources for new conference speakers
@CallbackWomen
You've got this!

Theme music is 12:30 AM by Crystal Cola.

Timestamps

• [00:36] Organizing and completing side projects
• [05:08] Choosing and quitting jobs
• [09:03] Joining React Training
• [12:31] Why Amazon was a poor fit and figuring out what's important
• [17:46] Leaving a company with a smooth transition
• [20:38] Sharing knowledge with your team
• [22:39] Working at an agency and asking the right questions
• [29:56] Teaching and learning React
• [38:29] How to start teaching and conference speaking

Samuel is a member of the Ruby core team. He's working on making it safer and easier to write scalable applications in Ruby.

Conference Talks:
Fibers are the Right Solution
The Journey to One Million

Posts:
Asynchronous Ruby
Fibers Are the Right Solution
Early Hints and HTTP/2 Push with Falcon
2019 Ruby Association Grant
Source with comments on why the Global VM Lock exists

Ruby gems:
Async
Falcon

Contact:
@ioquatix
Samuel's website

Timestamps:

• 0:51 - What's concurrency? What's parallelism?
• 5:49 - Piping commands between Unix processes provides easy parallelism
• 6:58 - Some types of applications abstract out threads/processes,
• 9:27 - Many Ruby gems have thread safety issues
• 10:44 - The CRuby Global VM Lock hides thread safety issues
• 11:24 - The problems with threads and shared mutable state
• 13:58 - Examples of mutexes causing problems in Ruby gems.
• 19:09 - What a deadlock is and how it causes problems
• 19:51 - Running separate processes to get parallelism and using an external database to communicate
• 21:01 - Lightweight process model used by Go and Erlang vs threads in Ruby
• 23:50 - Why async was created
• 24:38 - What is Celluloid? (Actor based concurrency for Ruby)
• 26:29 - Problems with shared global state in Celluloid
• 27:12 - Lifecycle management problems (getting and cleaning up objects)
• 28:19 - Maintaining Celluloid IO, issues with the library
• 29:43 - What's async?
• 32:00 - What's an event loop?
• 35:20 - How tasks execute in an event loop
• 37:29 - How IO tasks are scheduled with IO.select
• 39:41 - The importance of predictable and sequential code
• 41:48 - Comparing async library to async/await
• 45:23 - What node got right with its worker model
• 47:10 - How async/await works
• 48:35 - Fibers as an alternative to callbacks
• 51:10 - How async uses fibers, minimizes need to change code
• 56:19 - Libraries don't have to know they're using async
• 1:04:55 - Reasons for the CRuby Global VM Lock
• 1:07:13 - Guilds as a solution
• 1:09:14 - Sharing state across threads
• 1:11:33 - Limitations of Ruby GC at 10-20K connections
• 1:12:00 - Sharing state across processes
• 1:13:12 - Handling CPU bound tasks with threads and processes
• 1:17:42 - Which dependencies are messing with state? (Check memory allocations, sockets closed)
• 1:25:00 - Async in production
• 1:27:17 - Wrap up

Aaron is on both the ruby and rails core teams. He's best known for making puns, teaching others, and his contributions to the internals of ruby. Lately he's been focusing on a compacting garbage collector for ruby.

This episode originally aired on Software Engineering Radio.

Timestamps:

• 00:40 - What Aaron likes about Ruby
• 04:43 - Interpreted vs Compiled
• 07:00 - Why the ruby interpreter is written in C
• 11:00 - Other good languages to write virtual machines?
• 15:20 - Moving from an Interpreter (MRI) to Virtual Machine (YARV)
• 18:50 - Why there's no manual compilation step in Ruby
• 23:28 - Why compile to bytecode instead of directly to machine code?
• 26:34 - Stack based vs Register based VM
• 28:00 - Differences between Core and Standard Library
• 29:46 - Do you program more in ruby or C as a member of the ruby/rails core teams?
• 30:30 - The Global Interpreter Lock (GIL / GVL)
• 37:40 - Concurrency options in Ruby
• 45:55 - Just in Time Compilation
• 49:29 - Evolution of Garbage Collection in Ruby
• 53:40 - Compacting Garbage Collection
• 61:40 - Building a Compacting Garbage Collector without breaking C Extensions
• 65:20 - Ruby's future, resources for learning

Links:

• Blog
• @tenderlove
• Ruby Under a Microscope

Mubs is an amazingly prolific creator. He's built 85 side projects which are all listed on his website and was Product Hunt's Maker of the Year in 2016. His output is inspiring and he offers great advice on how to approach building side projects of your own.

Mubashar Iqbal

• Personal Site
• @mubashariqbal
• Projects

Projects

• Pod Hunt
• Hacker News Day
• Will Robots Take My Job?

Pod Hunt Stack

• Laravel
• Laravel Forge
• Tailwind CSS
• VueJS
• MySQL

Timestamps

• 01:14 - What's Pod Hunt?
• 03:42 - How are people using Pod Hunt?
• 08:42 - Why Pod Hunt isn't a native app yet
• 11:25 - How long to build the prototype?
• 15:50 - Pod Hunt's Stack
• 16:55 - Why Pod Hunt isn't a Single Page Application
• 22:18 - No CDN yet
• 23:24 - MySQL as the datastore
• 24:24 - Laravel Forge for hosting
• 28:13 - What's Hacker News Day?
• 34:06 - Choose a side project that solves your own problem
• 40:43 - The difference between projects for fun vs money
• 50:20 - Will Robots Take My Job?

Felienne is an associate professor at Leiden University who brings a unique perspective on programming education backed by scientific research. She also runs the Programming Education Research Lab (PERL) in order to study the best ways to teach programming.

Keynote at Strange Loop

• How to Teach Programming (and other things?)

Related Research Papers

• How is Programming Taught at Code Clubs
• The Effect of Reading Code Aloud on Comprehension: An Empirical Study with School Students
• Code Phonology
• Why Minimal Guidance During Instruction Does Not Work
• Cognitive Architecture and Instructional Design: 20 Years Later
• Papers by Brianna Morrison

Felienne

• Blog
• Twitter
• Publications
• Software Engineering Radio Podcast

Bonus

• St. Louis City Museum

Timestamps

• 00:56 - Spreadsheets as programming
• 04:57 - When do you build software vs use what's already there?
• 10:14 - Direct instruction vs independent learning
• 20:28 - How should you start teaching kids?
• 24:39 - Is teaching kids different than older students?
• 30:15 - Using rote memorization and saying code out loud
• 35:15 - What is the role of Computer Science education?
• 40:42 - Teaching IDEs, Git, Debugging, and Code Review
• 45:43 - Problems with teaching Open Source
• 49:12 - Incorporating live coding into university lectures
• 56:18 - Podcasting and conference speaking

Julia Evans is best known for her zines and blog posts that break down technical topics in a friendly way. She has written educational material on everything from Linux system calls to working with managers.

She joins us to talk about what she learned while writing her latest zine: HTTP: Learn your browser's language.

Timestamps:

• 0:50 - Why write a zine about HTTP?
• 1:21 - What's a header that could break your site?
• 2:50 - What does HTTP look like?
• 5:58 - What headers are most important?
• 8:39 - Response Codes
• 12:26 - Authentication
• 14:57 - Cookies
• 18:37 - Using browser development tools
• 19:46 - Caching and CDNs
• 25:46 - Referrer Header and Hotlinking images
• 27:34 - Resuming file downloads
• 30:00 - URLs
• 32:11 - Why webpages show different languages
• 34:34 - Same Origin Policy / CORS
• 43:42 - Compression / GZIP
• 45:58 - Intermediate Programming Education
• 49:35 - Picking topics for blogs and zines
• 57:10 - Picking an audience to write to
• 59:54 - Types of educational material (zines, books)
• 64:03 - Why Julia likes the zine format
• 65:53 - Working on education full time

Links:

• HTTP: Learn your browser's language
• Julia's blog
• Julia's twitter
• Wizard Zines
• Mozilla Developer Network
• netcat

Topics:

• Deciding when to use Rust
• Concurrency in Rust
• When to create a separate service
• Introducing Rust at Sentry
• Challenges of writing Python modules in Rust
• Creating Symbolicator, a Rust web service that processes debug files
• Using Actix to create Symbolicator
• Why Rust doesn't need a Django or Rails equivalent
• Concerns about the stability of the Rust ecosystem and the lack of shared solutions
• What's missing in the Rust ecosystem
• Why developers need better debugging tools

If you're interested in helping Armin build an open source debugging community, reach out to him via e-mail or twitter.

This episode is part of the Rustacean Station feed. Check it out if you're interested in Rust podcasts.

Links:

• Armin's Twitter
• Armin's Blog
• Sentry
• Actix
• Rocket
• Building Sentry: Symbolicator
• Symbolicator
• Semaphore
• Milksnake
• Wasmer
• Existential Types
• Tokio Tower
• RFC to add Backtraces to standard error
• Future
• Erlang

Show timestamps:

• 0:37 - What got you interested in Rust?
• 2:19 - Abstraction with good performance in Rust vs Python
• 4:11 - Rust doesn't need asynchronous code
• 5:31 - Building thread safe applications
• 6:26 - What excited you about using Rust?
• 8:20 - Sentry
• 11:02 - Introducing Rust to Sentry
• 13:10 - Anything easier to write in Rust vs Python?
• 16:14 - Writing extensions vs writing services
• 19:22 - Flow of sending a minidump to Symbolicator
• 21:56 - Symbolicator makes sense as a service
• 23:26 - Building a better debugging world
• 24:33 - More things symbolicator does
• 25:27 - What's Milksnake
• 28:04 - Other ways to embed Rust in Python
• 30:08 - Why use Actix for Symbolicator?
• 34:44 - Is it too early to write web applications?
• 37:30 - What would you do differently in hindsight?
• 42:20 - Don't want a Django or Rails
• 43:58 - When to write a web application?
• 47:34 - What do you wish existed in Rust?
• 49:57 - Game backends
• 51:44 - Anything else?
• 53:26 - Why companies aren't using Rust for web development
• 54:23 - Why async/await is not the only blocker for web development
• 56:43 - Resources for web development in Rust
• 58:24 - Wrap Up