initial commit

.gitignore

@@ -0,0 +1 @@
+public/

config.toml

@@ -0,0 +1,21 @@
+# The URL the site will be built for
+base_url = "softwaresessions.com"
+
+title = "Software Sessions"
+description = "Practical Conversations about Software Development"
+
+generate_rss = false
+
+# Whether to automatically compile all Sass files in the sass directory
+compile_sass = true
+
+# Whether to do syntax highlighting
+# Theme can be customised by setting the `highlight_theme` variable to a theme supported by Zola
+highlight_code = true
+
+# Whether to build a search index to be used later on by a JavaScript library
+# build_search_index = true
+
+[extra]
+# Put all your custom variables here
+twitter = "@jertype"

content/about/index.md

@@ -0,0 +1,10 @@
++++
+title = "About"
+template = "page.html"
++++
+
+Hi, I'm Jeremy Jung. I've been doing this software development thing for a while now but I still have a lot to learn.  I think things are still harder than they should be.
+
+I'm having conversations with folks to hear their practical experiences and stories.  I plan to make my guest's knowledge accessible with show notes, transcripts, and articles. It's too easy to forget something you only hear in audio form.
+
+If this is helpful to you or you have any suggestions, please [let me know](mailto:[email protected]).

content/episodes/2019-09-13-rust-in-production-with-armin-ronacher/index.md

@@ -0,0 +1,82 @@
++++
+title = "Rust in Production with Armin Ronacher"
+
+description = "Armin Ronacher talks about getting into Rust, when to use it, writing Rust extensions for Python, building web applications with actix, creating debugging libraries, and the Rust ecosystem."
+
+[extra]
+episode_url = "https://media.transistor.fm/d60c954f.mp3"
++++
+
+Armin is the creator of the Flask web framework, the Jinja2 template engine, and many other open source projects. He's currently the Director of Engineering at Sentry.
+
+### 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](mailto:[email protected]) or [twitter](http://twitter.com/mitsuhiko).
+
+This episode is part of the [Rustacean Station](https://rustacean-station.org/) feed.  Check it out if you're interested in hearing more about Rust.
+
+### Armin Ronacher
+- [Personal Site](http://armin.ronacher.eu/)
+- [@mitsuhiko](https://twitter.com/mitsuhiko)
+
+### Sentry
+- [Building Sentry: Symbolicator](https://blog.sentry.io/2019/06/13/building-a-sentry-symbolicator)
+- [Symbolicator](https://www.github.com/getsentry/symbolicator)
+- [Semaphore](https://github.com/getsentry/semaphore)
+- [Milksnake](https://github.com/getsentry/milksnake)
+
+### Other Links
+- [Actix](https://actix.rs/)
+- [Rocket](https://rocket.rs/)
+- [Wasmer](https://wasmer.io/)
+- [Existential Types](https://github.com/rust-lang/rfcs/blob/master/text/2071-impl-trait-existential-types.md)
+- [Tokio Tower](https://github.com/tower-rs/tokio-tower)
+- [RFC to add Backtraces to standard error in Rust](https://github.com/rust-lang/rfcs/blob/master/text/2504-fix-error.md)
+- [Future](https://doc.rust-lang.org/nightly/core/future/trait.Future.html)
+- [Erlang](https://www.erlang.org/)
+
+### 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
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.

content/episodes/2019-09-16-how-http-works-with-julia-evans/index.md

@@ -0,0 +1,53 @@
++++
+title = "How HTTP Works with Julia Evans"
+
+description = "Julia Evans explains all things HTTP, the need for intermediate level educational materials, the importance of fundamentals, writing to an audience, the zine format, and working on education professionally."
+
+[extra]
+episode_url = "https://media.transistor.fm/c5d70ee3.mp3"
++++
+
+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](https://wizardzines.com/zines/http/).
+
+### Julia Evans
+- [Personal Site](https://jvns.ca/)
+- [@b0rk](https://twitter.com/b0rk)
+
+### Zines
+- [HTTP: Learn your browser's language](https://wizardzines.com/zines/http/)
+- [Wizard Zines](https://wizardzines.com/)
+
+### Other references
+- [Mozilla Developer Network](https://developer.mozilla.org/en-US/)
+- [netcat](http://netcat.sourceforge.net/)
+
+### 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
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.

content/episodes/2019-09-27-how-to-teach-programming-with-felienne/index.md

@@ -0,0 +1,49 @@
++++
+title = "How to Teach Programming with Felienne"
+
+description = "Felienne discusses teaching programming to kids by saying code out loud, the user experience of spreadsheets, the role of a computer science education, and her experience as a professor, conference speaker, and podcaster."
+
+[extra]
+episode_url = "https://media.transistor.fm/515168b3.mp3"
++++
+
+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)](https://perl.liacs.nl/) in order to study the best ways to teach programming.
+
+### Felienne 
+- [Personal Site](https://www.felienne.com/)
+- [@Felienne](https://twitter.com/Felienne)
+- [Publications](http://www.felienne.com/publications)
+- [Software Engineering Radio Podcast](https://www.se-radio.net/)
+
+### Strange Loop Keynote
+- [How to Teach Programming (and other things?)](https://www.youtube.com/watch?v=g1ib43q3uXQ)
+
+### Related Research Papers 
+- [How is Programming Taught at Code Clubs](http://perl.liacs.nl/2019/09/26/how-is-programming-taught-at-code-clubs/)
+- [The Effect of Reading Code Aloud on Comprehension: An Empirical Study with School Students](https://pure.tudelft.nl/portal/files/52671807/Paper_camera_ready_final_withLink.pdf)
+- [Code Phonology](https://www.felienne.com/archives/5947)
+- [Why Minimal Guidance During Instruction Does Not Work](http://www.cogtech.usc.edu/publications/kirschner_Sweller_Clark.pdf)
+- [Cognitive Architecture and Instructional Design: 20 Years Later](https://link.springer.com/article/10.1007%2Fs10648-019-09465-5)
+- [Papers by Brianna Morrison](https://www.brianamorrison.net/papers)
+
+### Bonus
+- [St. Louis City Museum](https://www.citymuseum.org/)
+
+### 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
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.

content/episodes/2019-10-10-pod-hunt-and-side-projects-with-mubashar-iqbal/index.md

@@ -0,0 +1,48 @@
++++
+title = "Pod Hunt and Side Projects with Mubashar Iqbal"
+
+description = "Mubs shares strategies for building successful side projects, how they differ from professional projects, and explains how he built Pod Hunt, an app for discovering podcasts."
+
+[extra]
+episode_url = "https://media.transistor.fm/b7aa45ba.mp3"
++++
+
+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.
+
+### Mubs
+- [Personal Site](https://mubs.me/)
+- [@mubashariqbal](https://twitter.com/mubashariqbal)
+- [List of Projects](https://iworkedon.com/@mubashariqbal)
+
+### Side Projects
+- [Pod Hunt](https://podhunt.app/)
+- [Hacker News Day](https://hackernewsday.com/)
+- [Will Robots Take My Job?](https://willrobotstakemyjob.com/)
+
+### Pod Hunt Stack
+- [Laravel](https://laravel.com/)
+- [Laravel Forge](https://forge.laravel.com/)
+- [Tailwind CSS](https://tailwindcss.com/)
+- [VueJS](https://vuejs.org/)
+- [MySQL](https://www.mysql.com/)
+
+### 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?
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.

content/episodes/2019-10-24-how-the-ruby-runtime-works-with-aaron-patterson/index.md

@@ -0,0 +1,44 @@
++++
+title = "How the Ruby Runtime Works with Aaron Patterson"
+
+description = "Aaron Patterson introduces Ruby runtime internals including details on its virtual machine, global interpreter lock, JIT compiler, and the complexities of building a compacting garbage collector."
+
+[extra]
+episode_url = "https://media.transistor.fm/75a2a696.mp3"
++++
+
+Aaron is on both the Ruby and Rails core teams.   He's best known for making puns, teaching others, and his contributions to Ruby internals.  Lately he's been focusing on a compacting garbage collector for Ruby.
+
+This episode originally aired on Software Engineering Radio.
+
+### Aaron Patterson
+- [Personal site](https://www.tenderlovemaking.com)
+- [@tenderlove](https://www.twitter.com/tenderlove)
+
+### Related Links
+- [Ruby Under a Microscope](https://patshaughnessy.net/ruby-under-a-microscope)
+
+### 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
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.

content/episodes/2019-11-06-building-scalable-systems-safely-in-ruby-with-samuel-williams/index.md

@@ -0,0 +1,72 @@
++++
+title = "Building Scalable Systems Safely in Ruby with Samuel Williams"
+
+description = "Samuel explains the difference between concurrency and parallelism, the dangers of writing multithreaded code, how languages like Node, Go, and Erlang safely handle parallelism, and his efforts to improve the Ruby concurrency ecosystem."
+
+[extra]
+episode_url = "https://media.transistor.fm/710f68e5.mp3"
++++
+
+Samuel is a member of the Ruby core team.  He's working on making it safer and easier to write concurrent applications in Ruby.
+
+### Samuel
+- [Samuel's website](https://www.codeotaku.com/index)
+- [@ioquatix](https://twitter.com/ioquatix)
+
+### Conference Talks
+- [Fibers are the Right Solution](https://www.youtube.com/watch?v=qKQcUDEo-ZI)
+- [The Journey to One Million](https://www.youtube.com/watch?v=Dtn9Uudw4Mo)
+
+### Related links
+- [Asynchronous Ruby](https://www.codeotaku.com/journal/2018-06/asynchronous-ruby/index)
+- [Fibers Are the Right Solution](https://www.codeotaku.com/journal/2018-11/fibers-are-the-right-solution/index)
+- [Early Hints and HTTP/2 Push with Falcon](https://www.codeotaku.com/journal/2019-02/falcon-early-hints/index)
+- [2019 Ruby Association Grant](https://www.ruby.or.jp/en/news/20191031)
+- [Source with comments on why the Global VM Lock exists](https://github.com/ruby/ruby/blob/master/thread.c)
+
+### Ruby gems
+- [Async](https://github.com/socketry/async)
+- [Falcon](https://github.com/socketry/falcon)
+
+### 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
+- 64:55 - Reasons for the CRuby Global VM Lock
+- 67:13 - Guilds as a solution
+- 69:14 - Sharing state across threads
+- 71:33 - Limitations of Ruby GC at 10-20K connections
+- 72:00 - Sharing state across processes
+- 73:12 - Handling CPU bound tasks with threads and processes
+- 77:42 - Which dependencies are messing with state? (Check memory allocations, sockets closed)
+- 85:00 - Async in production
+- 87:17 - Wrap up
+
+---
+
+## Transcript
+
+Transcript for this episode is coming soon.