add all 2017 summaries

Adventures in VS Code_summary.txt

@@ -0,0 +1,48 @@
+• Ramya Rao's background and work at Microsoft, including her role in VS Code
+• How Ramya came to be involved with Go, specifically building the Go extension for VS Code
+• The architecture of VS Code, built on Electron and using Monaco Editor
+• Performance issues with other code editors built on Electron, such as Atom
+• Ramya's opinions on the performance of VS Code compared to other editors
+• Discussion of various editors (VS Code, Vim, Gogland) and their features
+• Users share their experiences with different editors and plugins (Vim plugin for VS Code)
+• Performance issues with some editors and the importance of a good extensibility model
+• Separate processes for extensions in VS Code to prevent performance impact on main editor experience
+• Troubleshooting issues with Vim plugin, including problems with switching between modes
+• General discussion of keyboard shortcuts and keymaps for different editors
+• Discussion of using VS Code extensions for other editors (e.g. Sublime, Atom)
+• Introduction to CodeLens capability in VS Code
+• Explanation of new features and contributions to Go extension (e.g. stubs, extract method)
+• Discussion of open issues and seeking help from contributors
+• Overview of writing code for VS Code extensions (using TypeScript or JavaScript) and Language Service protocol
+• Conversation about prioritizing features and user feedback
+• Ramya Rao's process for deciding which feature requests to implement in the Go extension
+• The importance of community feedback and upvotes in determining priority
+• Implementing features in response to changes in the core VS Code product
+• Managing technical debt by staying up-to-date with new features and APIs
+• Using snippets in the Go extension, including typing prefixes or using the command palette
+• Customizing snippet settings and mapping keyboard shortcuts
+• Ramya Rao's experience with her first open source project, including the challenges of triaging and keeping up with language changes
+• The importance of pacing oneself and releasing updates at a sustainable cadence
+• The difference between developing for an employer versus an open source project, where thousands of people have different priorities and expectations
+• Appreciation from strangers and users, which can be fulfilling in open source projects
+• New projects and tools mentioned, including Gonvim (a GUI frontend for nvim written in Go) and Draft (for determining application type and automatically generating Docker files and Kubernetes specs)
+• The VS Code Docker extension and its features
+• Open source philosophy of pulling request instead of creating an issue
+• The speakers discuss their struggles to keep up with the vast amount of conference videos available.
+• GopherCon is mentioned as an upcoming event in June, with the CFP for lightning talks currently open.
+• Ramya Rao announces her attendance at GopherCon and expresses interest in having a booth or meeting space.
+• Erik St. Martin teases some upcoming surprises for GopherCon, hinting at exciting developments behind the scenes.
+• High-Performance Go talk from FOSDEM is mentioned as an interesting video to watch.
+• The speakers discuss their favorite ways to consume conference content, including Just For Func videos and other online series.
+• DevOps Day is mentioned briefly.
+• Kelsey Hightower's talk at DevOps Days Austin and its emphasis on vulnerability and openness in sharing personal struggles
+• The importance of humanizing people in tech, particularly those who are often marginalized or underestimated
+• Ramya Rao's introduction to open source through VS Code and Go
+• Edward Muller's mention of Vim and VS Code being top two editors used by Go writers
+• Shoutouts to Kelsey Hightower for his talk and Jaana B. Dogan (JBD) for her work on performance improvements in Go and contributions to the Devex group
+• Discussion of #FreeSoftwareFriday, where the hosts recognize people or projects that make their lives easier in the open source world
+• Ramya Rao discusses her use of the `q` library for debugging in Go code.
+• Ramya gives shoutouts to contributors and developers who have helped with the Go extension.
+• Erik St. Martin gives a shoutout to Microsoft's contributions to the Go plugin and VS Code.
+• Johnny Boursiquot agrees with Erik and thanks Ramya for her work on the plugin.
+• The panel discusses and thanks various contributors, including those from Microsoft, before wrapping up the show.

All About The Go Compiler_summary.txt

@@ -0,0 +1,44 @@
+• Introduction of David Chase and his background in programming languages compilers and runtimes
+• Explanation of the components involved in a compiler and its phases (scanning, parsing, semantic analysis, etc.)
+• Description of the Go compiler process (characters -> AST -> SSA) and optimization
+• Discussion of escape analysis and its role in identifying memory allocation
+• Overview of contributing to the Go compiler (importance of benchmarks and starting with lowering code from generic SSA)
+• Clarification on the current state of the intermediate Go Assembler step
+• Discussion of compiler internals and recommended reading
+• Overview of various compiler books, including those by Andrew-Appel
+• Reference to the LCC compiler as a relatively small and easy-to-understand example
+• Explanation of the Go compiler's complexity due to its success and portability
+• Mention of potential improvements to the Go compiler, including lazy import and mid-stack inlining
+• Discussion of upcoming features for 1.10 and 2.0, including:
+	+ Improved debugging experience for optimized code
+	+ Cooperative scheduling enforcement within tight loops
+	+ Generational collection work and write barrier optimizations
+• Go language vs implementation discussion
+• Advantages of multidimensional slices in Go
+• Generics as a potential feature for Go
+• Compiler optimizations and speed considerations
+• Importance of simplicity and readability in compiler design
+• Formal verification of compilers and its challenges
+• Trusting Trust paper mentioned as relevant to compiler security
+• Verified code and testing
+• Compiler verification for different targets (e.g., x86/64, ARM)
+• Balance between compiler speed and optimization complexity
+• Potential for using LLVM as a backend for Go
+• Pie preferences of the Go compiler team
+• Discussion about pies and pie preferences
+• Recommendation for Emeril Lagasse's banana cream pie at his restaurant
+• Proposal to consider hosting GopherCon at a location with good food options, specifically including the pie mentioned earlier
+• Review of recent Go projects and news
+• Discussion of Oak game engine and its potential for use on PocketCHIP
+• Overview of PocketCHIP as a small, portable computer with Linux capabilities and discussion of its uses
+• Mention of new book "Concurrency in Go" by Katherine Cox-Buday
+• Discussion about a well-written post on cluster schedulers
+• Shoutouts for open-source projects and individuals, including Dave Cheney's Go blog and errors package
+• Review of GopherCon 2019 and its contributor day
+• Stats from Jess Frazelle on new open CLs
+• Thank you to Steve Francia and others who contributed to the GopherCon remote event
+• Discussion about MacPorts and its quality compared to Homebrew
+• David Chase shared his experience with a tech toolchain on a laptop 5 years ago
+• The setup included MacPorts, Track, Python, SQLite, Mercurial, Emacs in bash-mode, and code processing
+• The project was for a website that formatted code into a mathematical style
+• The conversation was part of the GoTime.fm podcast

Bringing Kubernetes to Azure_summary.txt

@@ -0,0 +1,70 @@
+• Celebrating the show's 50th episode
+• Kris Nova introduces herself as a Go programmer working with Kubernetes and Azure
+• Discussion on pronouncing "Azure" (with varying opinions)
+• Introduction of Kris Nova's projects, including Draft and Kops
+• Comparison of Azure and AWS feature-wise, with Kris Nova stating they are roughly analogous
+• Self-hosting within Kubernetes
+• Kubernetes components managed inside Kubernetes
+• Kops: an infrastructure management tool and deployment tool
+• Kops vs Kubeadm: comparison of scope and functionality
+• Refactoring the Kops codebase: experience with developer empathy and contributor engagement
+• Draft: a tool for local development and deployment to Kubernetes, automating rebuilds and redeployments
+• Support for six or seven languages using buildpacks
+• Sharing clusters with production systems for multitenancy and multiple developers
+• Draft's command to specify namespace for isolation
+• Kris Nova's work on Azure team, including Kubernetes functionality and internal projects
+• Kubernetes components and challenges in understanding their interactions
+• Containerizing applications, including legacy software like IE6
+• Challenges in adoption of containers due to misconceptions about performance issues
+• Deis acquisition by Microsoft and culture changes
+• Kubernetes and containerization
+• Comparison between containers and virtual machines
+• Kris Nova's experience working at Microsoft
+• Personal projects and interests (music)
+• Impressive impromptu public speaking skills exhibited by Charlie Nutter
+• Discussion of projects, news, and updates in the Go community
+• Introduction to Vecty, a front-end framework built on GopherJS
+• Presentation of GoPlay.space, an online playground for Go code with features like automatic doc retrieval and client-server integration
+• Review of additional features and tools available within GoPlay.space, such as Dark Mode and customizable tab width
+• Confusion about the month (June vs July)
+• GopherCon China video release
+• Vim-Go 1.13 key features (Keyify)
+• fsql project for filesystem SQL queries
+• Kubernetes-related discussion of CNI plugin development and CNI-Genie project
+• #FreeSoftwareFriday mention
+• CNI plugins
+• Calico
+• Flannel
+• cAdvisor
+• Network performance-based plugin selection
+• Multitenancy environments
+• Access control
+• Migration between CNI plugins
+• Huawei open-source project
+• Go language barrier
+• Rosetta Stone for Mandarin
+• #FreeSoftwareFriday shoutouts
+• Florin Patan's community contributions
+• Caroline Van Slyck's work on go dep
+• Windows subsystem for Linux (WSL)
+• Skype microphone issues
+• The group discusses their experience with Vim and how it has evolved over time
+• Brian Ketelsen shares his struggles with using Vim in front of an audience
+• Erik St. Martin recommends the book "Practical Vim" for learning advanced Vim techniques
+• The conversation turns to other text editors, including Gogland IDE and Emacs
+• Kris Nova discusses her use of multiple GOPATHs for different projects and coding modes
+• Using direnv to manage GOPATH and environment variables across different projects
+• Introducing kubectx as a tool for switching Kubernetes contexts
+• Sharing tools and workflows for automating workspaces
+• Discussing the idea of having a "tools episode" on the podcast to share automation techniques
+• Kris Nova sharing their experience with pushing their entire home directory to a Git repo
+• Customizing and sharing Bash aliases and shell scripts for personal productivity
+• Configuring Linux environments for individual preferences and habits
+• Using specific tools and software, such as i3, Xfce, and rofi, for window management and navigation
+• Tab completing machine names and hostnames using helper functions or scripts
+• Running applications within a terminal environment, such as links and VLC, and playing video content in the terminal
+• Release of ASCII versions of GopherCon videos
+• Discussion of the Star Wars Telnet server
+• Diving too deep into "the tool" on an episode
+• Introduction of Kris Nova as a guest and friend of Brian Ketelsen's
+• Wrap-up and goodbye from Erik St. Martin

Building Blocks_summary.txt

@@ -0,0 +1,54 @@
+• Jeff Lindsay's background and experience
+• Discussion of his current projects and goals
+• Comparison of US vs. European perspective on old buildings
+• Mention of various open source projects, including Flynn, Dokku, Envy, Docker, OpenStack, webhooks, DevjaVu, and localtunnel
+• Building sustainable self-running services with open-source infrastructure
+• The importance of empowering users to build their own automation and custom solutions
+• Critique of using artificial intelligence (AI) for automation, preferring basic techniques instead
+• Composable software and visual tools like Microsoft Flow and WebPipes for easy automation
+• Designing systems that balance high-level interfaces with low-level customization options
+• Infrastructure development for building distributed systems and cloud platforms, including Docker and Kubernetes
+• Frustration with platform-as-a-service complexity
+• Operator pattern for abstracting away Kubernetes complexity
+• Criticism of corporate interests influencing open-source projects
+• Analysis paralysis due to numerous options and features
+• Desire for a simpler infrastructure approach, such as running containers in Docker
+• Moving on from complex technologies like Kubernetes once they become mainstream
+• Evolution of event handling and serverless computing
+• Comparison of AWS Lambda and other services
+• Introduction to durable functions for workflow automation
+• Discussion of Go programming language and its philosophy
+• Critique of complexity in software development and need for simpler systems
+• Importance of interfaces and two-way conversations in software design
+• Hook-based extensibility in software composition
+• Issue tracking system integrated with versioning
+• Hook-based interface for component-oriented software development
+• Dependent injection and configuration
+• Com library (GliderLabs Com) for building component-oriented software in Go
+• Wiki example demonstrating the power of com library
+• Standard Com library for common components like daemon management, HTTP, sessions, and authentication
+• Console component for wrapping up authentication
+• Command.io rebuild as a goal using com library
+• Function as a service concept with command-line interface
+• Power of SSH protocol for building complex systems and protocols
+• SSH library for Go (GliderLabs SSH) and its ease of use
+• Comparison to HTTP/2 and other protocols
+• Using interfaces in Go to build abstractions and simplify code
+• File system implementations, including Afero and 9P protocol
+• Mounting 9P file systems directly in Linux kernel without extra daemons or extensions
+• Custom file systems using network file system API (e.g. 9P)
+• Designing APIs with interfaces in Go
+• The benefits of using interfaces for abstraction and decoupling
+• The importance of well-designed interfaces for reusable software
+• Discussion of the Go Commons project and its emphasis on starting with interfaces
+• Using custom resource definitions (CRDs) with Kubernetes to simplify monitoring and metrics collection with Prometheus
+• Docker development environments
+• Google Working Group GreaterCommons courses for learning Go
+• Shoutouts to contributors, including spf13 (Steve Francia) and Todd McLeod
+• Open source project management and collaboration through pull requests and merge processes
+• Show highlights from past episodes and discussing guest appearances
+• The podcast has 273 episodes and a producer who pulls the plug at around 2-3 minutes.
+• Scott Mansfield is mentioned as having been on the show twice.
+• Guest hosts are sometimes used when regular hosts travel.
+• Jeff Lindsay's projects and work were discussed.
+• The episode was wrapping up due to time constraints.

Container Security and Demystifying Complexity_summary.txt

@@ -0,0 +1,44 @@
+• Liz Rice introduces herself as an engineer and technology evangelist at Aqua Security
+• Discussion of the benefits of understanding containers as highly configured processes rather than lightweight virtual machines
+• Containers as a more secure option for microservices due to easier profiling and monitoring
+• Runtime profiling and alerting with container-level security gateways
+• Aqua Security's product covering image scanning, vulnerability detection, and runtime monitoring
+• The importance of explaining low-level concepts in a way that makes them accessible to others
+• Liz Rice's approach to understanding complex topics through experimentation and trying to replicate what she sees
+• The role of curiosity and questioning assumptions in learning about technical subjects
+• The value of visual aids and storytelling in making complex topics easier to understand
+• The importance of documentation, particularly for obscure or underdocumented areas such as the `/proc` directory
+• Discussing ideas for future blog posts or talks
+• Networking-related topics (CNI, Flannel, Calico)
+• Linux schedulers and their implementation in Go code
+• Concurrency and threading concepts (misunderstandings and best practices)
+• Locking strategies in programming
+• Poll idea to collect topic suggestions from listeners
+• Educating developers on systems programming concepts through accessible content
+• Using a router to track who is in the house
+• Discussion of why Go was not chosen for the project and recent advancements in language-agnostic serverless computing with tools like Apex
+• Kubernetes Security Benchmarking tool kube-bench and its features
+• Importance of Kubernetes security measures, including authentication, container image vetting, secrets management, and runtime profiling
+• AppArmor and SELinux for cluster security
+• Inconvenience factor in security implementation
+• Seccomp profiles for system call control
+• Automating syscall detection with tools like Aqua
+• Intrusion detection training and learning modes
+• Upcoming conferences: Container Camp, Container Shed, KubeCon, DockerCon
+• Powerline ported to Go by Just Janne
+• Discussion of Fish shell as an alternative to Bash and Zsh
+• Comparison of Fish's ease of use and customizability with other shells
+• Use of a custom touch bar button on MacBook Pro
+• Mention of Oni, an Electron interface over Neovim for IDE-like functionality
+• Expanderr: a command-line tool that adds error handling and return statements in Emacs
+• Michael Stapelberg: creator of i3 Window Manager and Expanderr
+• Jaeger: an open tracing collection system by Uber for distributed tracing
+• Open Tracing API: a standard for distributed tracing tools like Jaeger
+• Unison: a file synchronizer that is bidirectional and fast, unlike Rsync
+• Istio: side cars for buffer containerized services in microservices
+• Discussion of Istio and service mesh category
+• Birthday wish for Mark Bates
+• Commemorating Mark Bates' birthday with a Twitter storm or guitar-smashing video
+• ARM processors and assembly language tutorials by Azeria
+• Benefits of having surface-level knowledge of programming concepts, such as assembly language
+• Wrap-up and thank-yous to listeners

Dep, Cross-platform, and Getting Started_summary.txt

@@ -0,0 +1,39 @@
+• Carolyn Van Slyck's introduction to Go and her experience working on Dep
+• Her background as a C# developer and her observations about the divide between Windows and non-Windows developers
+• The importance of supporting multiple platforms, including Windows, in software development
+• The use of virtualization (e.g. VMware, Parallels) and hardware-based KVMs for managing multiple operating systems on a single machine
+• The discussion of random IE bugs in 2017 and the frustration of having to maintain compatibility with outdated browsers.
+• Discussion of old versions of Internet Explorer (IE 6 and IE 4) and their limitations
+• Story of how a listener of the podcast was hired for a job after being inspired by an episode featuring Micro, leading to the current guest, Carolyn Van Slyck, being on the show
+• Carolyn's background as a maintainer for the Dep project in Go and her experience contributing to open source projects
+• The convergence of events that led Carolyn to take time off work and focus on Dep, including encouragement from her previous employer and personal interest in the project
+• Discussion of how Carolyn became more involved with Dep and its community, including helping others and reviewing pull requests
+• Initial discussion about taking time off to focus on Dep and getting encouragement from Sam Boyer
+• Carolyn's background with Go, having coded back-end services and CLI tools, leading to a natural transition to working on Dep
+• Becoming an official maintainer for Dep, including starting with small contributions, receiving feedback from Sam, and eventually being asked to join as a maintainer
+• Importance of community involvement and giving back, with Carolyn's experiences at meetups and conferences
+• Founding Women Who Go in Chicago, a meetup group for women interested in Go programming
+• Carolyn Van Slyck shares her experience learning Go and applying it to her work
+• She recommends starting with small projects such as porting existing scripts or creating simple tools
+• Participating in open-source projects, especially those with beginner-friendly tasks, can be a great way to learn
+• Pull requests are a valuable way to get feedback on one's coding style and idioms
+• Contributing to others' projects, even if it's just small tasks, can help build skills and confidence
+• Sneaking in Go work during regular job hours can make learning easier and more enjoyable
+• Different types of employers: some want general engineering skills, while others require specific knowledge
+• Importance of having relevant experience when applying for a job in Go
+• Value of personal projects and "scratching your own itch" to gain experience
+• Carolyn Van Slyck's goal to work on cloud infrastructure in the open source space
+• Discussion of potential job opportunities at Heptio
+• Discussion of Philippo and his blog posts
+• Release of Go 1.9 RC 2 and its implications for developers
+• New dot-dot-dot syntax in Go 1.9 RC 2
+• Upcoming talk by Brian Ketelsen at Golang UK conference
+• Introduction to go-prompt and kube-prompt libraries
+• Discussion of CLI tool development using the standard library
+• Mention of other projects, including GoWorld and Vecty (GopherJS framework)
+• Discussion of GopherJS and its use in front-end development
+• Recommendation of a blog post on using GopherJS with Vecty
+• Introduction to Cobra, a Go library for building command-line applications
+• Shoutouts to the new Go Prompt and Captain Safia's work
+• Carolyn Van Slyck shares her inspiration from Captain Safia
+• Erik St. Martin discusses his experience with Visual Studio Code and its Go plugin

Dependency Management, Semver, Community Consensus_summary.txt

@@ -0,0 +1,57 @@
+• Sam Boyer's background as a Go programmer and his experience with package management
+• The problem of package management in Go and the complexity of the issue
+• The creation of GPS (Go Packaging Solver) library by Sam Boyer to address the issue
+• The development of the dep tool using GPS and its integration into the Go toolchain
+• The goal of obviating the need for multiple tools and providing a single solution for package management in Go
+• The representation from various tools on the committee developing the dep tool, aiming to solve all use cases
+• The motivation behind creating a library like GPS instead of another standard canonical tool
+• Approaching dependency management with multiple tools
+• Current limitations and future plans for dep
+• GPS (Go Package Specification) design choices and features
+• Converting existing tools to use GPS metadata
+• Trade-offs of incorporating on-the-fly conversion support in dep
+• Importance of using semver and tagging releases
+• Encouraging community adoption of standard practices through tooling and education
+• Discussion of the `release` command in GPS and its potential future functionality
+• Mention of UpSpin as a distributed storage system for tracking releases
+• Comparison to other package managers (npm, Crates, etc.) and their central registries
+• Trade-offs between decentralized systems like IPFS and the need for seeders
+• Introduction of dep tool as a reference implementation for GPS
+• Explanation of dep's unique feature: static analysis and constraint-solving for dependencies
+• Discussion of the importance of distributing dependency versioning decisions across the ecosystem
+• Discussion on the importance of community momentum and consensus for adopting a versioning standard in Go
+• Need for a tool that works well with semver to encourage adoption of tagging releases
+• Hypothetical use of a platform at GopherCon to promote change
+• Vendor directory structure and its potential replacement by an alternative implementation
+• Concerns about code generation and volatility of vendor directories
+• Roadmap for stabilizing the dep tool and merging it into the Go toolchain, with a goal of inclusion in Go 1.10
+• Upcoming release of GoDep
+• Roadmap and project management
+• Getting involved with GoDep and contributing to its development
+• Plans for stabilizing manifest and mod files
+• Future vision for the dep tool and its integration with Go toolchain
+• Community adoption and agreement on dependency management tools
+• Go 1.8 release and its impact on performance
+• SSA (Static Single Assignment) optimizations in Go 1.8
+• Bug fixes in Go 1.8, including ordering issues with dependencies
+• Upcoming Go 1.9 features, including interface optimization changes
+• New tools for HTTP manipulation and testing
+• Sourcegraph's code intelligence implementation and its benefits
+• Distributed storage and networking tools, including Rook and Meshbird
+• Discussion of Hamachi VPN
+• Fuzzing as a test and benchmark tool
+• Integration of fuzzing into the Go testing framework
+• American Fuzzy Lop (AFL) fuzzer
+• Static analysis tools in Go
+• Dependency management in Go
+• #FreeSoftwareFriday segment
+• Discussion about Node installation on Erik's machine
+• Introduction to gcli, a CLI generator tool written in Go
+• Overview of code generators and their benefits
+• Shoutouts to authors and contributors who write documentation for open source projects
+• Discussion about Helm, a project that creates guided installations for well-known applications on Kubernetes clusters
+• Mention of KubeApps, a platform for searching and installing Helm charts
+• Episode sponsors: Toptal and Compose
+• Importance of sharing the show with others
+• Links to social media platforms (Twitter, GitHub)
+• Invitation to participate in future episodes or suggest guests/questions

Discussing Imposter Syndrome_summary.txt

@@ -0,0 +1,53 @@
+• Impostor syndrome discussed as a psychological problem of self-doubt and lack of confidence
+• Importance of understanding that impostor syndrome is not just about technical skills, but also personal happiness and well-being
+• Comparing oneself to others' curated online presence can exacerbate feelings of inadequacy
+• Separating one's knowledge and abilities from the act of delivering a presentation or sharing expertise in public
+• The need to overcome fear and anxiety related to public speaking and sharing ideas with others
+• Personal experiences shared by panelists about struggling with impostor syndrome and overcoming their fears
+• The distinction between knowledge and public speaking skills
+• Impostor syndrome and its effects on confidence
+• The importance of practice and experience in becoming a confident speaker
+• The value of "baby steps" in building up to more challenging presentations
+• The need to be willing to learn and acknowledge areas of weakness
+• Impostor syndrome in public speaking and teaching
+• The importance of validation from others, but also the potential for it to be toxic
+• Self-taught individuals (autodidacts) feeling insecure around those with advanced degrees or more technical knowledge
+• The role of perception and context in feelings of inadequacy
+• Personal experiences and accomplishments as a source of confidence
+• Formal education vs. self-taught experience in relation to impostor syndrome
+• Impostor syndrome among programmers
+• The value of formal education in computer science
+• Legitimizing one's knowledge as a programmer
+• Self-teaching vs. traditional education
+• Social barriers to legitimacy in the tech industry
+• Hiring practices and job descriptions in the era of self-taught professionals
+• Impostor syndrome in public speaking
+• The value of learning something new vs. having a unique perspective
+• Audience expectations and forgiveness
+• Storytelling as a key component of effective presentations
+• The benefits of sharing passion and expertise through storytelling
+• Q&A sessions: potential drawbacks, including fear of being caught off guard and creating drama
+• Problematic Q&A sessions where some attendees monopolize the mic and others are intimidated from asking questions.
+• The importance of approaching speakers and engaging with them in a one-on-one setting, rather than putting them on the spot in front of an audience.
+• Strategies for overcoming fear and anxiety when approaching famous or admired individuals, such as taking it out of your head and focusing on shared interests.
+• Techniques for building connections with others at conferences, including finding common ground and being genuine.
+• The need to build confidence in giving talks, and the value of starting small and becoming more comfortable over time.
+• The terror and paralysis that comes with public speaking
+• Creating a safe space for community members to practice their delivery and receive constructive feedback
+• The importance of seeking help from others in the community to review and improve talks
+• The value of talking about topics one is passionate about, and using storytelling techniques to engage audiences
+• The benefits of sharing personal experiences and emotions when speaking publicly
+• Preparing and presenting a conference talk
+• Overcoming fear and impostor syndrome when public speaking
+• The importance of self-confidence and not comparing oneself to others
+• Receiving feedback on talks and presentations
+• Supporting and encouraging others in their own public speaking endeavors
+• A book recommendation: "The Imposter's Handbook"
+• Overcoming imposter syndrome
+• Breaking out of comfort zones and taking on new challenges
+• Sharing personal experiences with anxiety and Tourette's
+• Introduction to various software tools (Spectacle, Docker Playground, Polybar)
+• The importance of having supportive communities and resources for dealing with self-doubt
+• Discussing the idea of hosting a meetup with multiple lightning talks
+• Encouraging people to step out of their comfort zone and give presentations
+• Mentioning the potential for future episodes to feature topics related to impostor syndrome

Distributed Messaging and Network Clients_summary.txt

@@ -0,0 +1,38 @@
+• Wally Quevedo introduction and background
+• Overview of NATS project and its use cases
+• Purpose behind NATS in Cloud Foundry control plane
+• Resilience of NATS and why it's hard to crash
+• Transition from Ruby to Go implementation of NATS
+• Reasons for choosing Go, including performance and concurrency benefits
+• NATS is a high-performance messaging system that can be used for pub-sub, request-response, and RPC patterns
+• NATS has a "fire-and-forget" model, where messages are not persisted if clients are offline when they're received
+• NATS Streaming provides persistence and message redelivery capabilities, similar to Apache Kafka
+• The cost of durability in NATS Streaming is lower performance compared to regular NATS
+• NATS is highly flexible and can be used as a transport layer for microservices with libraries like Go Micro
+• There are numerous client implementations for various programming languages, including JavaScript, C#, Python, and more
+• Apcera uses NATS heavily in their own infrastructure, particularly in the control plane and service discovery.
+• NATS as a messaging system for low-latency communications
+• Benefits of using NATS (simple deployment, lower collective overhead)
+• Alternatives to NATS and when it's a good choice to use it
+• Performance improvements with new Go releases and NATS
+• Wally Quevedo's upcoming talk at GopherCon on Writing Network Clients In Go
+• Apcera's community-oriented culture and involvement in the Go community
+• Issue with MacOS 10.12.4 update breaking cgo-enabled binaries in Go
+• Call for proposals for Golang UK conference
+• GopherCon workshops announced
+• Go ERD tool for generating Entity Relationship Diagrams
+• Vim-Go 1.12 released
+• Emacs vs Vim discussion, including Wally Quevedo's use of Emacs and Domink Honnef's Go-mode
+• Discussion of NATS project, its evolution, and Wally Quevedo's involvement
+• Mention of a blog post by Nate Finch on his experience with Canonical and 500,000 lines of Go code
+• The speakers discuss how Go and its ecosystem have evolved over the past four years
+• They reminisce about the early days of Go when vendoring was not a concern and there were no external packages
+• Brian Ketelsen talks about his daughter's slime-making hobby and compares it to Oobleck
+• The discussion turns to #FreeSoftwareFriday, where they promote open-source projects, including Brian's work on Go Micro for microservices
+• They also discuss the increasing adoption of gRPC in communication protocols, including its use in Etcd and Kubernetes
+• The speakers briefly touch on NATS' plaintext protocol and their editors' preferences (VS Code vs Vim)
+• Carlisia has issues with Vim plugins not functioning correctly
+• Brian suggests trying different Vim plugins to resolve the issue
+• Wally recommends a Go utility called GHR for releasing NATS artifacts
+• Erik gives a shoutout to Kubernetes maintainers for their work on recent releases
+• The group discusses KubeCon in Berlin and related projects

Docker, Moby, Containers_summary.txt

@@ -0,0 +1,47 @@
+• Introduction of guests and sponsor
+• Solomon Hykes' background and history with Docker/DotCloud
+• Explanation of DotCloud's technology and pivot to open sourcing Docker
+• Discussion of containers vs VMs and the confusion around Docker's abstraction
+• The diversity of opinions within the Docker community
+• Challenges in getting different groups (developers, operators, beginners) to participate in the same community
+• The transition from a platform-as-a-service to an open-source project (DotCloud to Docker)
+• Market size and competition in the platform-as-a-service market
+• Customer demand for customization and flexibility
+• The "Lego set" approach of containers (vs. monolithic platforms) and the success of Docker as an open-source containerization platform
+• Docker's creator Solomon Hykes discusses why they chose Go as the language for Docker
+• The team initially used Python, but switched to Go due to its ease of adoption and ability to compile to a binary
+• Soloman cites reasons such as optimizing for contributions, avoiding tribal divisions in devops tooling, and wanting a language that was familiar to many people
+• He also mentions the early days of Docker, where it wasn't an obvious choice and they weren't seeing "hype" around Go at the time
+• The team's decision to use Go was met with some resistance, but Solomon successfully sold the idea to the team by explaining its benefits and potential for growth
+• The development of Docker came out of operational experience with Linux containers.
+• Early adoption of Docker faced pushback from "cranky ops" who were skeptical of new technologies.
+• Solomon Hykes, a C systems engineer, chose Go for Docker due to its combination of compiled language and high-level syntax.
+• Docker's early use of Go was seen as validation of the language, but it is no longer a unique selling point.
+• The lack of external libraries and standard library support for Go were initial stumbling blocks in its adoption.
+• Docker and LXC comparison
+• Standard library vs external libraries use in software development
+• Moby brand name and its relation to Docker
+• Docker community size, diversity, and reaction to the Moby change
+• Goals and implications of the Moby project for open source contributors and users
+• Docker rebranding to Moby
+• Concerns over lack of explanation for changes
+• Solomon Hykes admits making tactical mistakes during transition
+• Focus on two main groups: maintainers and mainstream users
+• Middle population (non-active contributors, non-developers) not prepared for change
+• Criticism from open source contributor community over company-driven vs community-driven approach
+• Reference to Docker 1.12 announcement as an example of discrepancy between project and product behavior
+• The Docker project was moved to a new repository (moby/moby) without changing its codebase, causing confusion among users and developers.
+• The name change caused a "backfire" effect, leading to a temporary disruption in Docker's production shipment and numerous broken dependencies for some users.
+• Solomon Hykes explains that the intention behind the move was to be more open and transparent with the community, but it ultimately backfired due to confusion over the name change and its implications.
+• Moby is being positioned as a separate entity from Docker, allowing for further componentization of the platform and breaking up Docker's monolithic codebase into independent projects.
+• The goal of Moby is to create a modular, open-source container platform where various components can be combined in different ways, promoting collaboration and innovation among developers.
+• Solomon Hykes acknowledges that Docker has learned from its experiences at large scale and has made changes to address issues raised by the community over the years.
+• Challenges of managing a large user base and extracting actionable feedback
+• Need for modular architecture and partnering with others to build missing pieces
+• Plans to simplify development by making tools more accessible and easier to use
+• Switch from REST API to gRPC as the underlying RPC layer for low-level interfaces
+• Roadmap for Docker/Moby API, prioritizing not breaking existing users and adopting new technologies like gRPC
+• Encouraging open source contributions to Moby and addressing concerns about joining a new community
+• Discussing the difficulty of making first-time open source contributions and efforts to make it easier
+• Explaining the name "Moby" and its connection to Docker's mascot
+• Mentioning resources for contributing to Docker, including documentation and events

Full-time Open Source_summary.txt

@@ -0,0 +1,49 @@
+• Introduction of guests and episode 58
+• Dmitri Shuralyov's introduction as @shurcooL on Twitter, GitHub, and his work in the Go community
+• Dmitri's background and experience in programming, starting with video game development at age 13 and working on experimental projects
+• His transition from developing tools to focusing on open source Go code full-time, self-funded by his own savings
+• Discussion of his endgame and goals for this break, including possibly finishing or taking existing projects to a higher level
+• Dmitri Shuralyov's endgame is to create tools that don't exist yet in the Go ecosystem.
+• He has an intermediate plan with step-by-step goals rather than a complete vision.
+• Conception was his original project, started as an IDE for C++, but evolved into an experimental platform for working with Go code.
+• The Conception platform was a 2D canvas with widgets that could be connected and updated in real-time.
+• Dmitri learned valuable lessons about existing systems and their strengths during the Conception project.
+• He is known for putting packages directly into GitHub Gists, but has since removed his own gists and encourages others to delete theirs.
+• Discussion of whether "gif" and "gist" are different words
+• Dmitri Shuralyov's open-source projects and priorities
+• WebAssembly and its potential for Go development
+• Current state of Go-to-WebAssembly compilation, with Gopher.js mentioned
+• GraphQL and its adoption in GitHub's API, with a new Go client project
+• Discussion around GraphQL and its adoption
+• Using Vecty for front-end development in Go
+• Need for reporting or visualization tools in Go
+• Example projects using Vecty, such as Sourcegraph and Go Play Space
+• Current state of Gotham Go conference and its talks (including Steve Francia's talk)
+• Comparison between Go and other languages with more mature ecosystems
+• Discussion about Go 2 and potential changes to the language
+• Preference for stability and simplicity over new features
+• Ross Cox's talk on the approach to Go 2 as a series of incremental, backwards-compatible updates
+• Importance of maturity and consistency in programming languages
+• Value of abstraction and layering in software development
+• Simplicity as a desirable outcome in programming language design
+• Generics as a feature that can hinder readability and understanding of code
+• Balance between features and simplicity in programming languages
+• Discussion of Scala and its features
+• Comparison of C++ and Go, including code density and maintainability
+• Dmitri Shuralyov shares his experience maintaining over 100,000 lines of Go code
+• Importance of readability in coding languages
+• Security releases for Go 1.9.1 and 1.8.4
+• Discussion of the Skylark project and its use in Bazel
+• Introduction to a new Lua interpreter written in Go
+• Embedding scripting languages in Go applications
+• Colly (Go web scraping utility)
+• Tyler Treat's talk on performance at StrangeLoop conference
+• Shoutouts to contributors and projects:
+	+ Byobu wrapper for tmux or Screen
+	+ Go documentation examples feature (godoc)
+	+ Brad's contributions to the Go team, including pushing for a security update patch release
+• GopherCI, a continuous code quality CI system for Go
+• Dmitri's appreciation for Bradley Falzon and his project
+• Open source aspect of GopherCI
+• VSCode plugin for Go development
+• Personal shoutouts to contributors, including Ramya and Glenn Lewis

Game Development and Rebuilding Microservices_summary.txt

@@ -0,0 +1,55 @@
+• Introduction of guest Luna Duclos, game developer at Avalanche Studios
+• Discussion of the game development stack, with Go being used on the server side for infrastructure such as web servers and game servers
+• Explanation of the architecture, including peer-to-peer multiplayer and a lobby-based system
+• Motivation behind using Go on the server side, including speed gains and reduced risk of breaking code
+• Benefits of migrating from Python to Go and App Engine to Kubernetes-managed VMs
+• Discussion of the Kube-Cert-Manager extension for Kubernetes and its use in managing SSL certificates
+• Explanation of the history and development of the Kube-Cert-Manager project
+• Using LetsEncrypt to issue SSL certificates on the fly in Kubernetes
+• Domain renewal emails and the problem of unused domain names
+• Instrumented SQL project, a wrapper driver for Go 1.8 database drivers
+• Open Tracing and Google tracing integration with Instrumented SQL
+• Configuration and logging options for Instrumented SQL
+• Game development libraries and engines for server-side work in Go
+• Consolidation of game development tasks on consoles
+• Steam handling infrastructure for game developers
+• Game engine discussion (UE4, Unity, Frostbite)
+• GopherJS discussion (Polymer bindings, frontend web development challenges)
+• Complexity and frustration with JavaScript ecosystem (module packaging formats)
+• Fragmentation in frontend development, with various ways of managing dependencies and assets
+• Criticism of JavaScript package management systems and dependency management
+• Comparison of Go's simplicity and vendor standard for dependency management
+• Discussion of HTTP/2 and its impact on bundling and asset pipelines
+• Asset hosting and distribution strategies
+• Introduction to the Goggles application for searching GOPATH
+• The use of Gallium and its impact on native app development
+• The potential for cross-platform compatibility with Linux and Windows
+• Release notes for GoKit 0.4.0 and its adoption of the inbuilt context library
+• Gobot's release of version 1.3, supporting BBC micro:bit and DragonBoard
+• Examples of using Gobot for hardware control, including barbecue controllers and drone programming
+• The Women Who Go initiative to send women developers to GopherCon and a crowdfunding effort to support it
+• Discussion about doing multiple events or regions for a project
+• Potential locations for future events: Sweden and Spain
+• New Go contribution guide released by Steve Francia
+• Arbitrary Precision Decimal Package for Go, discussed as a useful tool
+• Second sponsor break announcement
+• Personal discussion of what participants would be doing if not working on the project:
+	+ Luna Duclos: organizing conferences or working at a cloud provider
+	+ Erik St. Martin and Brian Ketelsen: jokingly discussing alternative careers (hitman, barbecue shop)
+• The origins of barbecue in poor areas where tough cuts of meat were slow-cooked to preserve them.
+• The evolution of barbecue from humble beginnings to a high-end culinary experience with expensive ingredients like brisket costing $700/pound.
+• Discussion of the hosts' hypothetical dream careers, including becoming an investor, working in information security, and inventing new technologies.
+• Shoutouts for #FreeSoftwareFriday, including Webpack for its excellent documentation and Goa for its code generation framework.
+• Struggling to manage GitHub notifications and pull requests
+• Discussion of Helm and its role in Kubernetes, including Chart packages for pre-packaged applications
+• Challenges with YAML configuration files and the availability of JSON file support in kubectl
+• Preference for statically-typed languages over dynamically-typed ones due to compile-time safety and runtime errors
+• Debate on whether Go needs generics, with one participant suggesting an alternative solution through code generation
+• Lighthearted discussion about a participant's experience with hunting alligators with a BB gun
+• Florida alligators and their population
+• Gator removal policies in Florida
+• Negative reinforcement therapy for gators on private property
+• Overpopulation of alligators in Florida
+• Hunting seasons for alligators in Florida
+• The show's off-topic discussion about the topic
+• Go programmers' reactions to the conversation about gators

Getting Better, Mentoring, Drawing Gophers_summary.txt

@@ -0,0 +1,61 @@
+• Introduction to Ashley McNamara and her work as a principal technologist at Pivotal and Go artist
+• Discussion of impostor syndrome and feeling overwhelmed by the amount of things to learn in technology
+• The impact of social media on self-comparison and feelings of inadequacy
+• Ashley's areas of knowledge gaps, including Kubernetes and microservices
+• The importance of community support and willingness to ask questions
+• Debate over whether there are "dumb" questions in learning
+• Discussion of basic life skills and the difficulty of learning new concepts
+• Brian Ketelsen's lawn maintenance needs and Erik St. Martin's teasing about his lack of knowledge on using a weed eater
+• Ashley McNamara's experience with bootcamp and open-source development, and her creation of resources for learning to code
+• The importance of in-person help, mentorship, and not feeling afraid to ask for assistance when learning to program
+• Strategies for solving problems and being comfortable with not knowing everything as a developer
+• The challenges of learning and growing as a programmer
+• Breaking down complex problems into simpler ones
+• Confidence in one's abilities and the importance of knowing when to start taking action
+• The benefits of working on new and challenging projects
+• The Go programming language and its applications at Pivotal
+• Making the Go community aware of Pivotal's offerings and contributions to the language
+• Sharing personal experiences and journeys with learning a programming language
+• Discussion on the value of sharing personal journeys and experiences in overcoming obstacles
+• Importance of having diverse perspectives and relatable examples for new programmers
+• Sharing failures and imperfections as a motivating factor for others
+• Proposal to create a mic drop gopher statue or toy for speakers
+• Origins and development of gopherize.me, including the creation of avatar generators
+• Gopherize.me future features: color picker for hair color and gopher color, customization options for T-Shirts
+• Ashley McNamara's OSCON talk on building command line applications with Go
+• Upcoming Craft Camp presentation on the same topic
+• Resources for kids to learn STEM topics
+• Discussion on industry equality and stereotypes, including a woman discouraging a female student from pursuing computer science
+• The importance of challenging these perceptions in younger generations
+• Sexism in STEM industries and its impact on women
+• Importance of perseverance and self-motivation in learning
+• The role of advisors and mentors in influencing students' decisions to pursue or abandon academic programs
+• The importance of sensitivity and empathy when dealing with issues like sexism and bias
+• The need for more people in tech fields, including a commercial promoting STEM education
+• The growing body of knowledge and the risks associated with losing specialized expertise
+• The abstraction of technological understanding from everyday life and its consequences
+• Surviving in a post-apocalyptic scenario
+• The importance of not relying on assumptions or knowledge gaps
+• Teaching children how to code and dealing with their interests and attention span
+• Success stories of getting children interested in programming
+• Discussion of new projects and news, specifically the Developer Experience Working Group
+• Go project news and updates
+• Ruby implementations in Go (Rooby and Goruby)
+• Discussion on a book about building interpreters in Go
+• Plush template language for Go Buffalo
+• Hugo's latest release with custom output formats
+• Caddy web server launching officially on April 20th
+• Discussion of stickers and merchandise
+• Mention of Zed Shaw and his teaching style
+• Tips on how to start a project: breaking it down and researching
+• Introduction to #FreeSoftwareFriday
+• Showcases of various open-source projects and contributors:
+  • Erik St. Martin's dashboard for Brian's barbecue project
+  • Carlisia Thompson's discovery of All Contributors
+  • Ashley McNamara's experience with Hugo
+  • Erik St. Martin's setup using Grafana, InfluxDB, Mosquitto, Telegraf, and MQTT
+• Casey's barbecue data is being tracked in real-time using MQTT and graphed
+• Erik wakes up his colleague to show him the data, interrupting his sleep
+• The group discusses their upcoming plans for GopherCon, including a band performance
+• Ashley mentions that she has been waiting weeks for her Denver Gophers shirt to arrive
+• The conversation turns to Adam's recording of the podcast and the need to wrap up

Go Developer Survey_summary.txt

@@ -0,0 +1,42 @@
+• Steve Francia's role as Go team technical program manager with an emphasis on external usage
+• Community management and product management responsibilities within his role
+• Dependency management issues in the Go community and efforts to address them through a working group
+• Collaboration between the community and Google team to improve tooling awareness of dependency management
+• Recent survey published on the Go blog from 2016 and its findings
+• Francesc Campoy's role as advocate for all of Go and Google Cloud
+• Peter Bourgon's leadership of the dependency management working group and Sam Boyer's implementation efforts
+• Creation and results of the Go survey
+• Insights gained from the survey on user needs and challenges
+• Importance of establishing a baseline to measure progress over time
+• Growth and adoption of Go in the industry, with many users now using it at work
+• Difficulty finding experienced Go developers due to its relatively young age
+• Role of community in attracting new users and solving supply vs demand problem
+• Analysis of survey results on community challenges, including dependency management
+• Need for better resources and support for new users to adopt Go effectively
+• Surprise finding from survey: many people consider Go their language of most experience
+• Go is being used as a first language for many developers, rather than just as a conversion point from other languages
+• Dynamic languages (e.g. JavaScript, Python) are common backgrounds for Go users
+• Web development is the largest use case for Go, but also has a steep learning curve and limited documentation
+• Package management and lack of generics are major challenges for the language
+• Steep learning curve and inadequate documentation are individual challenges faced by developers using Go
+• The Go community lacks a centralized location for case studies
+• Case studies would help demonstrate the benefits of using Go
+• The Go team is shifting focus from early adopters to mainstream users and decision-makers
+• Convincing people to use Go is challenging due to its unique characteristics
+• Reducing the learning curve and demonstrating value are key to adoption
+• Improving user experience, community engagement, and contribution processes for Go is a priority
+• Intimidation of contributing to the Go project due to feeling like one's contributions aren't needed or that they're not smart enough
+• Feedback as a learning opportunity, rather than personal attack or rejection
+• The importance of taking feedback constructively and being willing to make changes
+• A culture shift from focusing on speed over perfection to striving for quality and accuracy
+• Different entry points into the project for those with varying levels of technical experience
+• Appreciation for the Go team's approach, which prioritizes getting things right rather than rushing to completion
+• The importance of tone in feedback and communication
+• Challenges faced by new contributors when receiving direct and technical feedback from the Go team
+• The need for encouragement and constructive feedback to help people feel valued and supported
+• The Go team's efforts to improve their communication style and provide a clear path forward for contributors
+• Examples of projects and maintainers being recognized and appreciated, such as Fatih's Vim-go project and Mark Bates' work on Go Buffalo.
+• Discussion of Postgres and its consistency across command line tools
+• Future plans for supporting other databases (Cassandra, CockroachDB)
+• Preference for consistent database tools to reduce learning curve
+• Conclusion and thank yous from the host and guests

Go and Buffalo Live from Dunkin' Donuts_summary.txt

@@ -0,0 +1,45 @@
+• Introduction and panel discussion
+• Mark Bates' Dunkin' Donuts appearance
+• Discussion of the "big secret"
+• Announcment of Buffalo, a new web framework in Go
+• Explanation of Buffalo's purpose and features
+• Discussion of why Mark Bates created Buffalo, including its motivations and goals
+• Discussion about shaming Brian Ketelsen for not knowing frontend work
+• Introduction of asset pipeline and its use in Buffalo framework
+• Explanation of how Buffalo builds a single binary containing Go code, assets, and migrations
+• Mark Bates' experience with using Buffalo to develop websites and its benefits
+• Discussion of third-party libraries used in Buffalo, including gorilla-mux, go.rice, raymond, and pop
+• Overview of the features and packages included in Buffalo
+• Discussion of the "Evaluate" console tool
+• Overview of Grift library and its use in Go development
+• Mention of various Go libraries developed by Mark Bates, including Goth, pop, Buffalo, and fsnotify
+• Conversation about maintaining open-source projects and the need for contributors
+• Discussion of Migrate library issues and potential forks or alternatives
+• Discussion of Buffalo's future development features
+• Release of 0.7.0 and its build compatibility
+• Planned features for Buffalo, including generators, background jobs, and form builders
+• Validation feature and generator integration
+• Mark Bates' productivity and time management
+• Secret to his productivity: Dunkin' Donuts coffee and possibly Guinness beer
+• Release of Grumpy, a Go backend to a Python interpreter
+• Performance improvements with Grumpy (up to 1000% faster)
+• Discussion on why Google released Grumpy (for performance, not to boost Go adoption)
+• GopherCon 2017 CFP and registration now open
+• Changes to GopherCon format, including Community Day and workshop opportunities
+• PaperCall.io used for this year's CFP submission process
+• Experimentation with Buffalo versus Rails on the PaperCall platform
+• GopherCon security measures
+• Lightning talks at GopherCon
+• Go 1.8 release party organization
+• New tools and apps: Releaser, Mutagen, SyncThing
+• Backup and synchronization strategies (Dropbox vs. Git)
+• Discussion of the open-source profiling tool Prism
+• Comparison between Prism and pprof
+• Historical diff feature in Prism for viewing changes over time
+• #FreeSoftwareFriday shoutouts
+• Refresh library for Go projects, which rebuilds and restarts the binary when files change
+• Common mistakes and frustrations developers experience, such as rebuilding binaries manually or using host networking incorrectly
+• Dave Cheney's contributions to the Go community
+• The errors package not being in the standard library
+• Shout out for the Octotree plugin
+• Mark Bates' comedy routine and unexpected appearance on the show

Go at Walmart (and Scale)_summary.txt

@@ -0,0 +1,63 @@
+• Introduction and welcome to the guest Chase Adams from Walmart
+• Background on Chase Adams' history with Go and his role at Walmart Labs
+• Discussion of the Edge platform team's projects, including reverse proxy, CDN, and RAM system
+• Testing of Walmart's CDN via command line using `curl`
+• Size of the team and when they started using Go (around 0.8)
+• Hiring process for Go developers and challenges in finding talent
+• Overview of the stack used by the Edge platform team, including executables running in different places, Prometheus, NSQ, and no use of Docker or Kubernetes
+• Traffic volume through Edge services
+• Fully distributed team using Go
+• Challenges and solutions for communication in a distributed team
+• Tools used for distributed communication (Slack, GitHub)
+• Using Go at Walmart (production use case, internal evangelism)
+• CI/CD pipelines and experience with Jenkins and Go
+• Importance of developer happiness and productivity
+• Development of CI/CD (Continuous Integration and Continuous Delivery) processes at Electrode
+• Drift in developer tools and versioning issues when the speaker joined the team
+• Importance of stable code, tooling, and automation for developers' happiness and productivity
+• Clarification of CI/CD definitions and concepts
+• Ease of implementing CI with Go due to Docker and other containerization tools
+• Challenges of implementing CD at Walmart, particularly with a large team and complex environment
+• Difficulty in changing CI/CD processes while building products simultaneously
+• Discussion on mentoring and the importance of good mentors
+• The importance of mentorship and having a support system
+• The value of being intentional about mentoring and learning from others
+• Defining mentorship and the differences between a mentor and an acquaintance who provides advice
+• The benefits of technical mentorship, career growth, and personal development
+• Burnout and the need for pacing and self-care in tech professionals
+• Artificial stress and empathy in deadlines
+• Ad-hoc mentoring in the community
+• Importance of intentional mentorship and investing time in mentees
+• Personal growth and development beyond technical skills
+• Benefits of having a good mentor that can change one's life
+• Examples of individuals who have had positive mentorship experiences
+• The speaker mentions three individuals who have helped them grow as a developer: Dave Cadwallader, Shane Hanson, and someone they mention but don't name
+• Discussion of formal mentoring relationships vs informal advice from experienced developers in public channels
+• The importance of reserving private pings for questions that are difficult to ask publicly or require more personal guidance
+• Group chats like the Golang Newbies channel can be a good resource for asking questions and getting help from others
+• The value of one-on-one conversations with mentors for vulnerable topics like impostor syndrome and career concerns
+• Impostor syndrome is mentioned as a common experience among developers, especially when receiving job offers without formal interviews
+• Discussion on the role of resumes in the hiring process and how they can create unrealistic expectations
+• The panel discusses a "walk-on" job scenario where an employer offers a job without a formal interview.
+• Benefits and drawbacks of accepting a job offer without interviewing are discussed.
+• Erik St. Martin shares his experience meeting Brian Ketelsen in a similar "no-interview" situation, which turned out well.
+• Go news is covered, including the release of go-tracing and Go 1.9RC2.
+• The GoTime website now offers transcripts for each episode, making it easier to access and reference the content.
+• Alex Ellis' tutorials on Docker and Raspberry Pi
+• Shoutouts to women in tech and minorities in tech
+• iTerm2 terminal emulator and its features
+• GitLab software development cycle and review apps
+• Jessie Frazelle's project "Am I Contained"
+• Link to article about serverless technology (unresolved)
+• Emacs vs Vim
+• Orgmode capabilities in Emacs
+• Go language support in various editors (Emacs, VS Code)
+• Donation options for contributors (Ramya, Fatih, Dominik)
+• WebAssembly and Go interpreter projects (Wagon, Go-Interpreter)
+• Mat Ryer's Vice project (Go channels with message queues)
+• Baby Elle's nap time
+• Guest's experience recording for podcast
+• Reaction picture of guest's family watching the episode
+• Discussion on listening to one's own voice on a podcast
+• Promotion of subscribing to and contributing to the podcast through GitHub
+• Closing remarks and invitation to follow on social media.

Go, Jocko, Kafka_summary.txt

@@ -0,0 +1,54 @@
+• Travis Jeffery introduces himself and his background in programming
+• Motivation for creating Jocko: to simplify Kafka setup and configuration, and eliminate dependencies on JVM and Zookeeper
+• Explanation of what Kafka is and its use cases (message queue, commit log service)
+• Discussion of the benefits of using Kafka as a system of record and data hub
+• Examples of using Kafka in a streaming data workflow for analytics events
+• Implementing a distributed system using Go, with workers reading from Kafka and producing output
+• Designing a dependency graph management system for decoupling services
+• Similarities to goroutines and channels in Go
+• Using consumer groups to handle concurrent data processing
+• Feature-complete implementation of the system, with remaining work on replication and consumer group support
+• Performance comparison to Java, with potential limitations due to lack of zero-copy networking
+• Simplification by removal of Zookeeper requirement in Kafka protocol
+• Implementation of storage layer for Jocko, using Kafka's log-structured merge tree design
+• Use of Raft consensus algorithm and Serf service discovery in Jocko implementation
+• Google releases Shenzhen Go app for graphically designing concurrency and data flow in Go
+• Discussion of Go-Call-Vis project for visualizing call graphs of Go programs
+• Mention of Subgraph OS, an operating system using Go for memory safety
+• Uber's Cherami library for queuing systems and its similarities to NSQ
+• Comparison between Cherami and NSQ, including durability and ordering guarantees
+• Introduction to Ponzu CMS, a content management system with API access
+• Ebiten 2D game library for building old-school style games
+• Influence of GoldenEye on their youth
+• Discussion about Go Resolutions for 2017 and potential implications for future versions of the language (Go 2.0)
+• Package management in Go, including frustrations with current tools and desire for improvement
+• Use of vendoring tools in Go projects, specifically discussion of Go Vendor and godeps
+• Discussion of an article that sparked anger in Brian Ketelsen
+• Importance of addressing sexual harassment in the industry, with a potential future episode on the topic
+• GopherCon conference and its Code of Conduct (COC)
+• Incident at GopherCon where someone violated the COC
+• Promotion of GopherCon's Call for Papers (CFP) and importance of submitting proposals early
+• Discussion of the gops project by Google, a tool to list and diagnose Go processes
+• Reminder that the CFP for GopherCon ends January 31st
+• Submission guidelines for talks at GopherCon
+• Qualifications for speakers and how to demonstrate expertise without revealing identity
+• Benefits of submitting a talk, including mentorship and travel compensation
+• Variety of presentation formats available, including tutorials and workshops
+• #FreeSoftwareFriday segment featuring projects or software recommendations
+• Discussion of specific open-source projects, such as oklog and OpenOCD
+• Redis 4.0 release candidate is out
+• Travis Jeffery discusses his experience with Redis and its uses
+• Brian Ketelsen shares his use of goa/gorma for designing APIs first
+• Discussion about using Go frameworks for web development vs standard library
+• Buffalo framework is mentioned as a popular choice for Go web development
+• Eric St. Martin mentions writing web applications without using a framework
+• Discussion of a Docker-backed web terminal and issues with WebSocket upgrades
+• Tradition at GopherCon of taking the first ticket purchaser out to dinner
+• Request to discuss the standard logging interface in Go
+• Proposal for a single interface for logging in Go, inspired by Java's Log4j
+• Concerns about current logging packages in Go, including lack of log levels and structured logging
+• Discussion of potential compiler changes to improve logging performance
+• Show wrap-up and thank-yous to listeners
+• Shoutouts to sponsors: StackImpact and Backtrace
+• Recap of show participation: Travis, Carlisia, and Erik St. Martin 
+• Promotion of GoTime.fm resources: Twitter handle, email newsletter, and GitHub ping for guest suggestions

Go4 and Contributing to Go_summary.txt

@@ -0,0 +1,68 @@
+• Go's growth and specialization within Google
+• Internal vs external community work on Go
+• Brad Fitzpatrick's role as public face of open source Go
+• Process for contributing to Go project
+• Upcoming changes to contribute process (pull requests, etc.)
+• Codenames for Go releases ( proposal from Brian Ketelsen)
+• Discussion about adding GoTime to the website
+• CL (change list) 41146 and its approval process
+• Proposing changes to the standard library, including requirements for proposals and submitting code without a strong use case
+• Adding code to GitHub instead of the standard library for flexibility
+• Domain name registration and management, including tips for purchasing domains
+• Discussion about the Go 1.9 release and plans to get the community more involved in bug triage and code review
+• Gardening tasks and triaging bugs
+• Organizing a shared presentation for meetups on contributing to projects
+• Exploring the concept of "Bugmash" or collaborative bug-fixing events
+• Improving the contributing process and documentation for Go project contributors
+• Using tooling to accept GitHub pull requests and convert them into Gerrit changes
+• Discussion about the _Help Wanted_ tag in GitHub for Go and its limitations
+• Challenges of labeling issues as "beginner-friendly" due to varying difficulty levels
+• Alternative approaches to labeling, such as bite-sized tasks or time-chunks
+• Brad Fitzpatrick's hobby project involving home automation and motion detection using Go
+• Use of OpenCV and FFMPEG in the project
+• Generating GIFs from video footage and sending them via Telegram
+• Ideas for improving the project, including object recognition with Google Vision API
+• Sony MiniDiscs with unknown music content
+• Difficulty accessing old floppy disks and digital storage devices
+• Nostalgia for early computing experiences, including dial-up internet and cassette tapes
+• Discussion of the TV show "Halt and Catch Fire" and its portrayal of the 1970s and 1980s computer industry
+• Mention of the HBO series "Silicon Valley"
+• Introduction to Camlistore (Perkeep) as a personal storage system and its development in Go programming language
+• Brad Fitzpatrick discusses his past involvement with Camlistore and his current role in reviewing contributions from another developer
+• The development of Camlistore's LetsEncrypt integration is explained, including its impact on ease of use and security
+• Brad mentions the potential for subdomain rate limiting issues with LetsEncrypt and plans to address this issue
+• Go team burnout and frustration with repetitive tasks are discussed, as well as motivations for a potential Go 2.0 release
+• The idea of goroutines being Go's unique feature is expressed, and concerns about other languages copying them are mentioned
+• Brad mentions Crystal language, a Ruby-like language that has adopted goroutines and channels, but notes it still needs work on its standard library
+• Discussion about language features and how they compare to Go
+• Goroutines and channels as a key aspect of Go's design
+• Other languages experimenting with lightweight tasks or goroutines, but struggling to implement them effectively
+• Crystal language's attempt to incorporate Go-like features, but ultimately falling short
+• The importance of code readability in Go and its impact on productivity
+• Why people might be hesitant to try Go due to its perceived complexity
+• Projects attempting to create runtime environments for other languages (e.g. Python in Go)
+• Prospects for adding Generics to the Go language
+• Ian Lance Taylor's efforts to design a proposal for Generics, and potential plans for a Go 2 release
+• periph.io as an alternative to Gobot for GPIO and I2C/SPI
+• Dave Brophy's code generation tool at github.com/dave/jennifer
+• React bindings for GopherJS at github.com/myitcv/react with Preact support
+• Discussion on removing items from the Go standard library, including HTTP
+• Potential changes to the Go language around the 10-year mark
+• The Go team's decision to include HTTP in the standard library and its implications
+• Debate over what should be included in the standard library and how it affects usability and adoption
+• Discussion of promoting external libraries versus maintaining internal ones
+• Concerns about maintenance, fragmentation, and the need for better package discovery tools
+• Ideas for analyzing and optimizing the Go ecosystem, such as using GitHub data and machine learning
+• Proposal to make bigints automatic and efficient
+• Removing `new` keyword from Go language
+• Simplifying declaration of slices and arrays
+• Getting rid of naked return statements
+• Changing string and byte slice handling in Go to reduce confusion and overhead
+• Introducing a "view of memory" type to accept both strings and byte slices, with read-only access.
+• Free Software Friday segment on the podcast
+• Shoutouts to open-source projects: Changelog website and GoTime website's search feature, Buffalo for web development in Go, GopherCon and GopherAcademy websites
+• Discussion of production use cases for Buffalo in Go
+• Mention of previous production environments used on the show (Caddy, Hugo)
+• Code review and shipping code discussed
+• Shoutouts to contributors to libraries for sensors and Arduino projects
+• Easter pig project and barbecue data streaming mentioned

Gobot, Hardware, Gatekeeping_summary.txt

@@ -0,0 +1,46 @@
+• Introduction of Ron Evans, the king of Gobot
+• Overview of the Hybrid Group and their work with hardware companies
+• History of Ron's involvement in open source software for hardware, including his experience with Ruby Arduino Development and Flying Robot
+• Creation of Gobot and its evolution over time
+• Discussion of Go's simplicity and how it has made it easy to learn and use for Ron Evans
+• Story about Rob Pike helping Ron reorganize the Gobot codebase at a community hack day during GopherCon
+• The importance of kindness and community in the Go language and its ecosystem
+• Update on Gobot's popularity, including its GitHub stars and contributor count
+• Discussing community involvement in open source projects
+• Comparison of R2 (Ruby), Cylon.js (JavaScript), and Gobot (Go) implementations
+• Design patterns for building hardware-oriented applications
+• Go's advantages for IoT and device programming (performance, concurrency, portability)
+• Opportunities for improvement in Go for hardware and IoT (Bluetooth 4.0 support, RTOS support, OpenCV integration)
+• Low-level hardware interfaces for Go
+• Raspberry Pi Zero W release and its capabilities
+• Gobot's performance and adoption metrics (including controlling BBQ equipment)
+• Upcoming Hardware Hack Day at GopherCon and potential new projects
+• Efforts to make hardware more approachable with tools like Gobot
+• Difficulty of a task is not a measure of its value
+• Democratization of knowledge and accessibility through open source
+• Hardware development should be made more accessible to developers like software development
+• Open source can facilitate innovation and progress in the Internet of Things (IoT)
+• Contributing to open source projects requires confidence and support from the community
+• Familiarity with customs and idioms in hardware and software development is necessary for effective communication and collaboration
+• The negative impact of using words like "easy" and "simple" in tutorials and documentation
+• Impostor syndrome triggered by such language
+• The importance of confidence and willingness to approach problems with uncertainty for mastery
+• The pressures and expectations placed on programmers, likened to an Olympic cognitive level
+• Burnout and the need for mental health support in programming
+• The emotional highs and lows of coding and the potential for addiction
+• Gobot's development history and philosophy
+• Open-source software as a means to improve human condition through incremental solutions
+• Future plans for Gobot, including stabilizing external interfaces, improving core implementations, and adding new hardware interfaces (GPIO, SPI, UART)
+• Importance of professional development practices in IoT devices
+• Tooling and packaging for connected devices using Go and Snapcraft
+• Consumers should be willing to pay for products that include online technical support and updates.
+• Companies need to build products responsibly and prioritize consumer control over data collection.
+• The proliferation of web trackers and connected devices is creating a surveillance society with perverse incentives.
+• Licensing models or micropayments approaches may be needed to give consumers control over their data.
+• Technology should focus on reducing environmental resource utilization, not just selling more stuff.
+• Gobot room at conferences (GopherCon)
+• Ron Evans' collection of TSA notices and solutions
+• Community day at GopherCon with hardware jam session
+• Hardware lending library and sharing of ideas
+• Beginner-friendliness of Gobot and ease of use
+• Ron Evans' "Santa Claus complex" giving away hardware

GopherCon 2017 A Retrospective_summary.txt

@@ -0,0 +1,42 @@
+• GopherCon conference recap
+• Purple hair as a conversation starter at GopherCon
+• Community band performance at the welcome party
+• High energy and excitement at this year's GopherCon
+• The importance of recognizing people's hidden talents and hobbies outside of work
+• Introvert exhaustion after attending large conferences
+• Growth of the conference community despite increasing size
+• Diversity efforts and increased number of women at the conference (60+ attendees)
+• Scholarship program for diverse backgrounds and its success in bringing in new faces
+• Community events such as the Women Who Go dinner and buddy system
+• International travel to Denver, with over 30 countries represented
+• Fundraising efforts, including selling leftover swag for next year's diversity initiatives ($12k+ raised)
+• Brad Fitzpatrick is expecting a baby and the panel sends well-wishes
+• GopherCon Community Day event, specifically the Contributor Room, where attendees could submit contributions to the Go project with mentor help
+• The room led to 40+ submissions in one day, and many more since then
+• Panel discussion on how to make contributing to Go easier for new contributors
+• Importance of having mentors and a supportive environment to overcome barriers to entry (CLA submission, etc.)
+• The GoCon event and its various rooms and activities
+• Community Day at the conference hotel, where attendees can collaborate on projects and attend talks
+• Specific projects that gained momentum during Community Day, including Dep and Kubicorn
+• Notable talks from GopherCon, including "Understanding Channels" by Kavya Joshi and "Go Anti-Patterns" by Edward Muller
+• A talk about the future of Go by Russ Cox, which sparked discussion about potential changes to the language
+• Go 2.0 is discussed as a future direction for the language
+• The Go team has been focused on implementing and improving existing features rather than changing the language itself
+• Feedback from the community is being solicited to help shape the direction of Go 2.0
+• Concrete examples of problems with the current language are needed to inform design decisions
+• A talk by Liz Rice about system calls was well-received for its clear explanation and delivery
+• Other notable talks included one on implementing containers in Go and another on SSA (Static Single Assignment)
+• Favorite talks from GopherCon conference
+• Discussion of Ashley McNamara's emotional talk
+• Mention of Kris Nova's popular talk that is spreading quickly online
+• Advanced testing in Go with Mitchell Hashimoto's talk
+• New Era Of Go Package Management and Dep with Sam Boyer's talk
+• Forward Compatible Go Code with Joe Tsai's talk
+• Organized listing of talks on GopherCon repo created by Daniela Petruzalek
+• Advice to community members on getting involved and contributing
+• GopherCon after-action discussion
+• Announcements for upcoming Go conferences (Golang UK, GothamGo, DotGo, GopherCon Brazil)
+• Speaking engagements for Brian Ketelsen and other guests at various conferences
+• Thank yous to the community and contributors
+• Shoutouts to Chairô from Brazil for a generous gift
+• Wrap-up discussion on open source contributions and community involvement

GopherCon 2017： A Retrospective_summary.txt

@@ -0,0 +1,78 @@
+• Introduction to Go Time podcast
+• Eric's new purple hair and fan feedback
+• GopherCon conference recap: overall thoughts and feelings about the event
+• Highlights of the welcome party:
+	+ The band that played at the opening party
+	+ Community members who sang and played instruments later in the night
+• Discussion of the energy level, excitement, and happiness at GopherCon
+• Discussion of past KoforCon events and memories
+• Observations on community dynamics and growth
+• Mention of a "band" event at KoforCon with impromptu performances
+• Reflections on introversion and social pressure
+• Comparison to Katrina Owen's introverted behavior as an example of a good introvert
+• Personal anecdotes about exhausting oneself at conferences and needing time to recharge
+• Meeting at Stout Street Social for a long dinner with multiple groups of people
+• Observations on diversity efforts and increased number of women attending the conference
+• Scholarships for attendees from diverse backgrounds and opportunities to apply for future conferences
+• Donations and fundraising efforts, including selling leftover swag to fund next year's diversity initiatives
+• International attendance at the conference, with 33 countries represented
+• Breakfast event led by Andy Walker and the buddy system for first-time attendees
+• The speaker is impressed by Nathan Youngman's weight loss and wants to organize a group to support each other in achieving health goals
+• A previous attendee, Brad Fitzpatrick, is expecting a baby and the group sends congratulations
+• There is discussion about planning topics for the next con, with one option being to organize talks in chronological order but ultimately deciding to stick with free-form conversation
+• The contributor room at community day was a success, with many people contributing to the Go project and receiving help from mentors
+• A dashboard with points for different types of contributions was mentioned
+• Contribution process for Go
+• Go for Con workshop experience
+• Replicating the workshop format for others
+• Importance of having organizers and helpers during the contribution process
+• Intimidation factor of contributing to Go codebase due to complexity
+• Value of immediate feedback and guidance during the contribution process
+• Challenges of submitting CLA (Contributor License Agreement)
+• Barriers to entry in contributing to projects
+• Importance of setting up contributors with resources and support
+• Success of GoCon 2023, including packed rooms and engaging activities
+• Community Day initiatives, including the contributor room and round tables for collaboration
+• Increase in attendance at Community Day compared to the previous year
+• Community Day is a popular event where people stay for the whole day and contribute to projects.
+• The "debt" project saw significant contributions from many people.
+• Kubicorn had a successful release and Chris Nova was praised as a leader.
+• Talks mentioned include:
+	+ Understanding channels by Kavya Joshi
+	+ Go anti-patterns by Edward Mueller
+	+ Future of Go, which was criticized for being too vague or teasing about the possibility of Go 2.0.
+• Discussion of the Go language's future (Go 2.0)
+• Importance of feedback from the community in shaping the future of Go
+• Need for concrete examples of problems to be solved, rather than feature requests
+• Value of communication and building consensus when discussing changes to a project
+• Statistics on the number of Go programmers worldwide
+• Overview of various talks at the event, including Liz Rice's presentation on system calls
+• Liz gave a talk about containers in Go and made them seem less "magic"
+• Ashley McNamara's talk about community and help made everyone cry
+• Keith Randall talked about SSA, which is related to assembly and compilers
+• Chris Nova's talk was missed by several people who want to watch it later
+• The speakers mentioned have great delivery and deep technical knowledge
+• The speaker notes that Chris's talk has been widely discussed and is making its way around the internet.
+• Mitchell Hashimoto's talk on advanced testing was mentioned as being informative and having good takeaways.
+• The Vault project's testing feature was discussed, but it didn't work out well for the speaker's team due to import issues.
+• Sam Boyer's talk on Go package management was mentioned, covering its history and potential future directions.
+• Joe Size's talk on forward-compatible Go code was highlighted as being educational and informative.
+• The speaker apologizes to speakers who weren't mentioned by name.
+• They mention that the talks are listed on the Go for Con repo and thank Daniela Petruzilek for creating a comprehensive page with links to all the talks, slides, and videos.
+• The conversation then shifts to how the speaker got involved in these types of projects, emphasizing the importance of taking initiative and starting small.
+• The hosts discuss how they got involved in community initiatives and encourage listeners to start looking for opportunities to contribute.
+• They mention that the talks from a recent conference received amazing feedback, and everyone did an outstanding job.
+• Upcoming conferences are mentioned, including GoLang UK, Gotham Go, DotGo, and GopherCon Brazil.
+• The hosts discuss their own speaking engagements at these conferences.
+• A shoutout is given to Jairo from Brazil for bringing them a gift of wine.
+• Host is signing off due to a hard stop
+• GopherCon was successful and attendees are thanked
+• Community involvement is highlighted as the main focus of the event
+• Discussion about future conferences, including potential attendance by Brian and Carlicia
+• Challenges of coming up with content for speaking engagements are shared
+• Invitation to join the GoTimeFM Slack channel and participate in real-time discussions
+• Upcoming show schedule (Thursdays at 3 p.m. U.S. Eastern on changelog.com/live)
+• Community and Slack information (changelog.com/community)
+• Social media links (Twitter @GoTimeFM)
+• Special thanks to Fastly and Linode
+• Credits for episode editing (Jonathan Youngblood) and theme music production (Breakmaster Cylinder)

Gopherize.me, GitHub Stars, BitBar_summary.txt

@@ -0,0 +1,43 @@
+• Introduction to episode 33 of GoTime
+• Guests: Kelsey Hightower and Carlisia Thompson, with Mat Ryer as the main guest
+• Mat Ryer's backstory on how he started programming and discovered Go
+• Discussion of how Go has grown in popularity over the past few years
+• The role of sysadmins in adopting and promoting Go
+• Comparison of Go to Ruby and Rails, and how Docker may have played a similar role for Go as Rails did for Ruby
+• Conversation about future developments for building web applications with Go, including Go Buffalo
+• Docker's containerization revolutionized app deployment, making it more reproducible.
+• Go benefited from Docker and other serious projects, feeling more mature and stable.
+• The single-binary feature of Go made it appealing for rapid prototyping and development.
+• Mat Ryer's projects, such as Bitbar, demonstrated the value of abstraction and community engagement.
+• GitHub stars serve as a reliable indicator of interest and appreciation for projects.
+• Twitter likes vs. GitHub stars: while Twitter is used to acknowledge content, GitHub stars represent genuine interest.
+• Gopherize Me was created as a way to let users build their own personalized gophers
+• Mat Ryer built the initial version in less than 5 hours using Google Cloud Storage and AppEngine
+• The site has had over 15,000 users and has been improved with additional features and scalability enhancements
+• Go's ability to handle concurrent tasks and scale makes it a popular choice for rapid development and deployment
+• Mat Ryer attributes the success of Gopherize Me to its grassroots effort and community involvement
+• Importance of rewriting code and learning from mistakes
+• Benefits of Test-Driven Development (TDD) in software development
+• Go 1.8 features, including improved defer performance and clean shutdown
+• Use of minimalistic languages like Go to simplify coding and improve productivity
+• Value of knowledge gained through experimentation and prototyping over preserving original code
+• Discussion on providing resources for understanding new features in Golang
+• Review of notable changes in Golang 1.8, including mutex contention profiling and GC latency improvements
+• Packaging efforts and the release of a package management implementation for Go
+• Dependency management and the role of tools like "drop" in resolving dependencies
+• Introduction to The App Project, a framework for building GUI applications in Go
+• Discussion on the potential overreach of using a single language (Go) for all programming tasks.
+• The relationship between enjoyment and productivity when working with a programming language
+• Context-switching and the cost of learning multiple languages
+• Personal preference and habit in choosing a programming language
+• Language education and its impact on communication and community participation
+• The prevalence of using a dominant language or default language to avoid context-switching
+• Attempting to bring serverless functions to Kubernetes
+• Serverless is not just about functions as a service, but about focusing on the application and removing management of infrastructure
+• Event-driven programming is a key benefit of serverless architecture
+• Cloud-native software stack initiatives, such as CNCF, are important for fostering community and ensuring long-term project sustainability
+• Various open-source projects and tools were mentioned as being useful or noteworthy, including Visual Studio Code, Gqrx, GNU Radio, and the Go newsletter.
+• Discussion of a cool API and its potential uses
+• Gopherize Me service and personalized gophers on various products
+• Satire about the gophers taking over the world and creating too many combinations
+• Show closing and thank you to listeners, sponsors, and upcoming schedule

Hellogopher, whosthere_summary.txt

@@ -0,0 +1,49 @@
+• Introduction of guest Filippo Valsorda from CloudFlare
+• Discussion of hellogopher project to simplify Go development for non-Go developers
+• Problems with GOPATH: confusion around cloning repositories, contributing code
+• Success story of using hellogopher at CloudFlare to streamline development process
+• Guests' experiences with setting up Go environments and vendoring
+• Discussion on the limitations of the new default GOPATH feature in Go 1.8
+• Custom GOPATH setup and compatibility with existing tools
+• Vending tool agnosticism and compatible vendor management
+• Whoami SSH server demo, using public keys to gather user information
+• Discussion of potential information leakage via SSH authentication
+• Filippo Valsorda's work on TLS 1.3 implementation in Go and its deployment on CloudFlare sites
+• CloudFlare uses a mix of NGINX and Go for reverse proxying, but the Go stack can take over connections with TLS 1.3 enabled.
+• The crypto/tls package in Go is considered to have a better security track record than OpenSSL, but it's less battle-tested and may be slower or more CPU-intensive.
+• TLS 1.3 offers improved robustness by removing unnecessary features and one less round trip for connection establishment compared to TLS 1.2.
+• Filippo Valsorda works on the Crypto team at CloudFlare and has given talks about Go, cgo, and TLS 1.3, including a talk at 33c3 and blog posts on Gopher Academy Advent list.
+• Discussion of Go binaries being reproducible
+• Introduction of a side project by Filippo Valsorda on binary transparency and reproducibility
+• Explanation of CT (Certificate Transparency) and its application to build servers
+• Mention of Debian's struggle with reproducible builds
+• Details on the importance of latency profiling in Go
+• Discussion of latency vs throughput optimization in Go garbage collection
+• Plans for Filippo Valsorda to present on latency profiling at GopherCon India
+• Discussion about Filippo Valsorda's keynote at GoLab and its recording
+• Introduction of new project Gopherize and its features
+• Request for a GoTime logo T-shirt design
+• Explanation of the codebase behind Gopherize and its connection to Google's Turkey Doodle
+• Mention of chromedp, a tool that uses the Chrome debugging protocol to steer browsers
+• Discussion about Camlistore content-addressed storage
+• Introduction of pre-alpha dep tool and GPS library
+• Plans to have Sam Boyer on the show to discuss the dep tool and its features
+• Makefiles and GNU make
+• PHONY declarations in makefiles
+• Using PHONY to manage dependencies
+• Gopher avatars and online culture
+• Out Of The Loop Subreddit
+• Kubernetes plugin called Mate
+• Sourcegraph code navigation tool in general availability for Go language
+• Sourcegraph features for clicking to definitions in open-source code
+• Play With Docker: a project allowing embedded Docker terminals in the browser
+• #FreeSoftwareFriday: shoutouts to open-source projects and maintainers making life easier, including:
+  • Ponzu CMS and Buffalo website combination
+  • Static Check by Dominik Honnef
+  • ZIM by Matt Hamilton
+• Discussion of Zsh shell and its features compared to Bash
+• Release announcements for Go 1.7.5 and Go 1.8rc3
+• Preview of upcoming changes in Go 1.9 and discussion of Go 2.0 proposals
+• Mention of a possible JVM backend for Go
+• Brief history of the Go cross-compiler and gccgo
+• Embarrassing moments from past GopherCon events

Hellogopher, whosthere？_summary.txt

@@ -0,0 +1,93 @@
+• Introduction to Go Time podcast
+• Sponsorship by Stack Impact and Arden Labs' series of Go Training
+• Guest introduction: Filippo Valsorda, Cloudflare employee working on Go projects
+• Hello Gopher project explained:
+  • Simplifying the process for non-Go developers at Cloudflare
+  • Solving issues with GoPath and repository setup
+  • Providing a straightforward way to bootstrap a project without needing to set up GoPath
+• Discussion of common confusions and challenges with GoPath and contributing to repositories
+• The user is happy with the adoption of a tool or feature
+• A user reported an issue that was resolved by referring to documentation
+• Brian and Carly haven't had a chance to try out the tool yet
+• GoPath is mentioned as a solution for setting up development environments in Go
+• It's discussed how GoPath solves one problem but not all, especially for contributing and Git cloning
+• Hello Gopher is introduced as a drop-in replacement that works with normal Go projects
+• Hello Gopher is compatible with existing Go structures and doesn't interfere with colleague's settings
+• The tool is agnostic to the vendoring tool used
+• The speaker discusses the demo "WhoAmI" which uses public SSH keys from GitHub
+• WhoAmI uses the GitHub API to collect and match public keys with their corresponding user profiles
+• The tool logs in users via keyboard-interactive login, even if they don't have any matching public keys
+• It then attempts to find a matching username and surname by cross-referencing the matched keys with a database
+• The speaker runs into issues trying to test the demo on their own machine due to multiple SSH keys being used
+• They discuss potential uses of the tool, including exposing information leakage via SSH login
+• Implementing TLS 1.3 protocol
+• Using CryptoTLS instead of OpenSSL for TLS implementation
+• Cloudflare's deployment of TLS 1.3 stack in Go
+• Fallback system for TLS 1.2 in case of failure
+• Comparison of security and bug tracking between CryptoTLS and OpenSSL
+• Recommendation to use Go's native TLS implementation instead of OpenSSL
+• TLS 1.3 offers improved performance and robustness over TLS 1.2
+• TLS 1.3 cuts an entire round trip of communication with the server
+• This results in significant latency reduction, especially on mobile networks
+• The Cloudflare crypto team's work includes deploying code to the world and researching secure protocols
+• A talk by Filippo (or George Dunkesley) discussed the black magic of Sego and how to make it tolerable
+• There is a talk on TLS 1.3 given at 33C3, but no published material on the Go part
+• Discussion of an attempt to SSH into an HTTP server, highlighting the differences between protocols
+• Introduction and advertisement for Stack Impact, a performance monitoring service for Go applications
+• Filippo's work on crypto and TLS at Cloudflare and his interest in Caddy
+• The reproducibility of Go binaries, allowing for identical builds across different machines
+• The concept of binary transparency, where builds are logged to prevent backdoors from being hidden
+• The challenges of achieving reproducible builds with other languages and projects, such as Debian
+• Go supports multiple architectures and operating systems
+• The resulting binary would change for different platforms (Windows, Linux, ARM)
+• 32-bit Spark is not supported on a Raspberry Pi
+• Go can run on mainframes and other legacy systems
+• Latency profiling and Camly Store are being discussed in the show document
+• Latency profiling tools are not as well-surfaced or publicized as CPU profiling tools
+• GoTracer provides profiles for blocking, I/O, network, and scheduling poses
+• Recordings of past talks or conversations
+• GoTime logo design
+• Gopher Eyes website and its features
+• Chrome DP project and its capabilities
+• Camlistor archiving system
+• Various mentions of community projects and contributions (Gopher avatar, custom avatars)
+• Implementing a headless browser for load pages and taking snapshots
+• Using Go to write scripts for steering a browser, clicking inputs, sleeping, and taking screenshots
+• Discussing integration tests using a browser
+• Shoutouts to pre-alpha dep tool and GPS library
+• Interviewing Sam Boyer about tools and rendering
+• HelloGopher's user flow goals and making sure users can build projects outside GoPath
+• Using make files as documentation for project workflows and recipes
+• Discussion about a makefile being reviewed and destroyed
+• Comparison of using a makefile to writing bash code, with the latter being more straightforward
+• Introduction of Arden Labs as a sponsor for their Ultimate Go training series
+• Explanation of the benefits and features of the training series
+• Joking about makefiles and phony declarations
+• Discussion about the "Gopherization" phenomenon on social media platforms
+• Route 53 DNS management and load balancing for Kubernetes services
+• Creation of named endpoints in load balancers and fixing DNS to point to those load balancers
+• Integration of Kubernetes load balancing and endpoints on AWS and GCP
+• Sourcegraph, a code navigation tool that allows browsing across repos and GitHub universe
+• Play with Docker project on GitHub
+• Embedding a Docker in Docker instance for web browser access
+• Multiple terminals embedded in web browsers with Docker support
+• Creating Kubernetes clusters within the web browser
+• Open source project discussion, including Ponzu CMS and Buffalo website integration
+• Free Software Friday shoutouts, including:
+  • Dominic Honef's static check tool (StaticCheck)
+  • Brian Kettleson's GopherCon website development using Ponzu CMS and Buffalo
+  • GoTime FM Patreon listing
+• Patreon discussed as a way to support Dominic's work
+• Benefits of Patreon for developers mentioned, including saving time and money
+• Discussion of VimGo and how the speaker donates an equivalent amount to what they would pay for a commercial IDE
+• Zim project introduced, a fast and feature-rich shell replacement for zsh
+• Go 1.7.5 and 1.8 RC3 releases announced and discussed
+• Go 2.0 discussions mentioned, including potential features like generics and JVM backend
+• GCC Go usage questioned, with the speaker wondering if it's still maintained or widely used
+• Invitation to Ian Lance Taylor to discuss GCC Go on a podcast
+• Embarrassing moment at Gopher Con with Dimitri
+• Discussion about the speaker's dinner and a particular question asked by Ian
+• Wrap-up of the show, thanking guests and sponsors
+• Announcement of upcoming shows, including Matt Ryer's appearance next week
+• Personal anecdote about running into Matt Ryer in Florence
+• Closing remarks and thanks to sponsors and team members

Honeycomb, Complex Systems, Saving Sanity_summary.txt

@@ -0,0 +1,48 @@
+• Charity Majors introduces herself and discusses her background with Go, specifically how she used it to rewrite Parse's platform
+• She explains why they chose Go over Ruby for the rewrite, citing performance bottlenecks and difficulties with Unicorn as major reasons
+• The conversation turns to using Go in production environments and how it compares to other languages like Ruby and Java
+• Charity discusses her recruiting strategy when choosing a language, prioritizing people who want to work with Go due to its perceived benefits
+• She emphasizes the importance of learning and adaptability in developers and shares her approach to hiring, focusing on potential rather than experience
+• The group talks about using Go at Honeycomb, with challenges around user adoption and driving interest in the product
+• Motivations for using containers and orchestration platforms
+• When to adopt containers or orchestration: based on cluster size, complexity, and team infrastructure
+• Complexity and trade-offs of adopting new technologies
+• The role of experimentation and innovation in development environments
+• Budgeting for new tech and bleeding edge innovations (e.g. "innovation tokens")
+• Introduction to Honeycomb's tool for debugging complex systems
+• Pre-computing and storing data in a column store for faster querying
+• Designing systems for interactive debugging, rather than batch processing
+• The increasing complexity of modern distributed systems and the need for better debugging tools
+• Capturing and correlating events across multiple systems to identify problems and predict issues
+• Using a common language and toolset for all stakeholders, including software engineers and DBAs
+• Writing user interfaces in Go and using JSON as a common format for data exchange
+• The target user for Honeycomb is developers who need to know how their services work and be able to own them from end to end
+• The first wave of DevOps focused on "DevOps people write better software" and "Message received", now it's time for the second wave which emphasizes developer ownership and knowledge of their systems
+• Honeycomb aims to fill a gap in current tools by allowing developers to understand what's happening now and recently across the organization and stack
+• Event-driven instrumentation in Go is easy and fun, according to a blog post written by Charity Majors
+• The conversation also touches on the importance of finding VCs who care about the product and mission, and using buzzwords such as "disrupt" and "revolutionize"
+• Charity Majors mentions that she used to hate repeating herself but has grown numb to it after founding her company
+• Cloud computing and its perceived lack of distinctiveness
+• Criticism of DevOps and security buzzwords
+• Full stack development and its limitations
+• The impact of startup culture on developer skills and expectations
+• Discussion of a project called Pixterm, which allows for images in ANSI terminals
+• Personal anecdotes about childhood experiences with TV
+• The podcasters discuss their upbringing in a homeschooling community that avoided modern society
+• A debugger series on Backtrace's blog is mentioned as a resource
+• Gobot 1.2 is released, allowing for easier hardware interaction with Go projects
+• Changes to the Go code of conduct are discussed, shifting from enforcement to guidance and support
+• The Go team releases version 1.8, featuring improvements such as graceful shutdowns, faster defer speeds, and mutex contention profiling
+• Release notes for Go 1.8
+• New features in Go 1.8
+• Eclipse Che web-powered IDE with terminal
+• VS Code editor updates and benefits
+• Dependency injection library by Naitik Shah
+• Go frameworks and content resources mentioned (Goji, Gorilla)
+• Kube-Lego project by JetStack for Kubernetes Ingress controllers
+• Let's Encrypt certifications through Kubernetes
+• ACME TLS certificates fetched automatically
+• Profit motive vs. security in managing vulnerabilities
+• Production setup and limitations of the show
+• Show format and behind-the-scenes explanation
+• Shoutouts to listeners, sponsors, and guests

Improved Improved Improved (i3)_summary.txt

@@ -0,0 +1,56 @@
+• The hosts discuss the i3 window manager with guest Michael Stapelberg, its creator
+• Background on i3 and its history, including why it was created and how it's used
+• Discussion of alternatives to i3, such as Divvy, and whether they are comparable
+• Michael Stapelberg's background in programming languages, including C, C++, Perl, and Go
+• Why he chose to use C for i3 despite having knowledge of other languages
+• His recent shift to Go as his favorite language, and why he prefers it over others
+• Discussion of the challenges and benefits of maintaining a large test suite like i3's
+• Go's simplicity and familiarity make it easy to learn
+• The language itself is not particularly innovative, but its features and ecosystem come together to create a compelling experience
+• Easy-to-read code makes it simple for developers to jump into new projects
+• Go's auto-formatter (gofmt) ensures consistency across the entire codebase
+• Most developers do not care about personal formatting preferences when using gofmt
+• The community has adopted gofmt as a standard, eliminating debates over formatting style
+• Configuring code formatting tools and their limitations
+• Discussion of desktop environments vs window managers
+• i3 window manager capabilities and customizability
+• Why i3 cannot be run natively on MacOS or Windows
+• Michael Stapelberg's work on gokrazy user space for Raspberry Pi
+• Custom Linux image with outdated base system was used on multiple Raspberry Pis
+• Desire for devices to auto-update and minimize attack surface
+• Gokrazy project provides a minimal, kernel-based Linux distribution with auto-updates
+• Project uses Travis CI for building and updating kernel and firmware
+• Automated testing and deployment of new images using GitHub pull requests
+• No dual BIOS functionality on Raspberry Pi hardware due to its limitations
+• Upgrading to higher-level development tools for faster development and lower costs
+• Using embedded devices with ARM architecture for hobby projects
+• Discussion of i3 (i3wm) window manager, its simplicity, and its potential drawbacks
+• Michael Stapelberg's job at Google working on the Go language in a capacity outside of the main team
+• Comparison between Google's internal software infrastructure and open source equivalents
+• Potential for open source to be influenced by or align with Google's internal tools
+• Michael Stapelberg shared his experience of requesting flash storage from an admin team and being surprised by their reaction
+• Google is following a trend of open-sourcing infrastructure, with recent releases including Abseil
+• The Go language team has a project to open-source part of the infrastructure, but specific plans are not yet clear
+• Kubernetes and other infrastructure tools have been made available as open-source alternatives to Google's proprietary offerings
+• The expanderr project provides automated error checking for Go code and is being integrated into various editors, including Vim
+• The speaker demonstrated a Go tool that expands whatever is under the cursor when invoked.
+• Error checking in Go is a hot topic and the speaker was unsure if others would like their tool.
+• The tool was well-received at a Go meetup in Zurich, with Robert Griesemer from the Go team present.
+• Speculation about adding a new keyword or syntax feature for error handling in Go.
+• Discussion of the benefits of explicit error handling in Go and its effects on end users. 
+• Introduction to some interesting projects and news, including the Space Gophers screensaver for Mac and security updates to Go.
+• The group discusses their experiences with Go programming and how they "graduated" from stages of learning the language.
+• They reference a blog post about the 7 stages of becoming a Go programmer, which pokes fun at common misconceptions beginners have when learning the language.
+• The stages include things like believing goroutines will solve all problems and eventually realizing that abstractions are complicated.
+• The group shares their own experiences with these stages and how they came to appreciate the simplicity of Go programming.
+• They also discuss the popularity of the Go gopher mascot and how it has become a symbol of the language and community.
+• The conversation concludes with a shoutout to Ashley McNamara, who is promoting open source contributions beyond just coding.
+• Contributions to open-source projects can be made with minimal technical ability
+• Triage and recreation of issues is an important part of contributing
+• Documentation contributions require less technical expertise than coding
+• Posting incorrect information can lead to helpful corrections from others
+• Non-technical individuals can help by tracking down issues or providing context
+• The Emacs package Magit was mentioned as a useful tool for Git front-end
+• The terminal emulator Alacritty was discussed, its features and installation process
+• Rust compilation stability was addressed, with suggestions for using Rust Up
+• Stapelberg's farewell

Infosec research and app security_summary.txt

@@ -0,0 +1,59 @@
+• Background of Aaron Hnatiw, including his transition from criminology to computer security and how he ended up at Security Compass as a security researcher
+• How Aaron got interested in Go and started using it for scripting and contributing to projects
+• Teaching experience with Go: how Aaron taught third-year programmers using the language and resources such as the Go Tour and "The Go Programming Language" book
+• Comparison of Go to Python for security-related tasks, including ease of use and availability of libraries
+• Difficulty in using Go for InfoSec due to lack of libraries and knowledge of standard library
+• Importance of development background in contributing to InfoSec with Go
+• Aaron Hnatiw's experience with Go and learning from scratch
+• Using existing Python libraries as a starting point for creating equivalent Go libraries
+• The "CIA triad" and importance of understanding how technologies work to exploit vulnerabilities
+• Fuzzing and reproduction of breaking points as key skills in InfoSec
+• Importance of creative thinking, problem-solving, and deep diving into technologies for success in InfoSec
+• Availability of resources for learning and practicing InfoSec skills, such as vulnerable virtual machines and challenge platforms
+• Capture the Flag (CTF) games as a way to learn about security
+• Bridging the gap between information security and development worlds
+• Challenges in cross-pollination between security and development teams
+• The importance of teaching security basics to developers, rather than relying on security experts
+• Making security easier for developers by simplifying complex concepts or automating security checks
+• Code security is nearly impossible to achieve unless it's extremely simple
+• Basic security measures include patching libraries, input validation, and output encoding
+• Key points:
+	+ Patching: keeping libraries up-to-date
+	+ Input validation: using a whitelist over a blacklist
+	+ Output encoding: preventing cross-site scripting
+• Additional important considerations:
+	+ Hardcoded credentials in API keys
+	+ Authentication and authorization
+	+ Encrypting data at rest and in transit
+• Blind SQL injection attacks
+• Automation and education as key to DevSecOps
+• SQLmap and NoSQLmap tools for automated vulnerability detection
+• DevSecOps concept and its focus on integration of developers, operations, and security teams
+• Polarization in cybersecurity terminology (red team vs. blue team)
+• The OWASP Top 10 list of most common web application vulnerabilities
+• Security scanners and tools for code analysis
+• OWASP top 10 resources for secure coding practices
+• Go-specific OWASP book on GitHub
+• Red teaming concepts and simulated attack methodology
+• Terms: red team/blue team vs. white hat/black hat/grey hat distinctions
+• Book recommendations: "Black Hat Go" and SD Elements software security requirements checker
+• The concept of "chaotic neutral" and the gray area between good and bad intentions
+• Hacktivism and the evolution of freelance security researchers to bug bounty programs
+• Bug bounty programs as a way for organizations to encourage vulnerability reporting in a legal manner
+• Concerns around the potential for organizations to take legal action against individuals participating in bug bounty programs
+• Discussion about attending GopherCon and personal commitments (marriage and giving birth) being considered acceptable excuses for missing the conference
+• Kubernetes 1.8 and 1.9 releases
+• ARM64 support in Go applications
+• Concurrent maps implemented in standard library
+• Go 1.8 now available in App Engine beta
+• GoRef package for invocation tracking and performance analysis
+• Upcoming conferences: GopherCon, GothamGo, DotGo, Golang UK, and GopherCon Brazil
+• #GopherConOrBust Twitter hashtag to encourage conference preparations
+• Brian Ketelsen's new job at an unnamed company (announced as Amazon Whole Foods in a later statement)
+• Discussion of Goman and other tools to generate man pages for open-source projects
+• Request for a tool to automatically generate Bash and Zsh completions
+• Shoutouts:
+  • Aaron Hnatiw's use of Visual Studio Code and its Go plugin
+  • Erik St. Martin's #FreeSoftwareFriday feature: K8GUARD, a Kubernetes monitoring tool
+• Discussion of editors and IDEs, including Visual Studio Code, Gogland, Vim, and their respective plugins
+• End of conversation

Loggregator, gRPC, Diodes_summary.txt

@@ -0,0 +1,46 @@
+• Introduction to Cloud Foundry as an enterprise platform as a service
+• Background on Pivotal and Cloud Foundry contributors Jason Keene and Andrew Poydence
+• Discussion of Loggregator, a log system for Cloud Foundry written in Go
+• History of Cloud Foundry's transition from Ruby to Go
+• Advantages of using Go, including simplicity and maintainability
+• How Go enables distributed teams to contribute to the project easily
+• Challenges of developing Loggregator in Go when it was less widely adopted
+• Rewrite of Loggregator code due to need for new features and scalability
+• Adoption of gRPC for messaging and its benefits (security, cost savings)
+• Scalability issues with large deployments of Cloud Foundry and Loggregator
+• Creation of "diode" ring buffer concept to prioritize message delivery
+• Use of HTTP/2 multiplexing in gRPC for efficient stream handling
+• Pooling connections and load balancing to manage scale and efficiency
+• Loggregator's goal is to have an opinionated log structure
+• Loggregator uses protocol buffers for strict messaging and enables generic consumers to pull data without knowledge of Cloud Foundry specifics
+• The system aims to distance itself from being specific to Cloud Foundry, with a v2 API that distills core metrics and messages
+• Bosh Deployment is used to manage Cloud Foundry deployments, including on laptops for development purposes
+• The team discusses the project's use of Go and whether Generics would be useful in implementing certain data structures
+• Compiler limitations and workarounds in Go
+• Generics discussion, including solicitation of use cases by the Go team and potential impact on readability and maintainability
+• Code generation and working around generic type issues
+• Use of gRPC for messaging, including native implementation in Go, ease of use, and compatibility with protobufs
+• gRPC upgrade paths
+• Deprecation timelines for software components
+• Trade-offs between fast deployment and stability in production systems
+• DevOps movement and balance between ops and dev responsibilities
+• Operations knowledge for developers
+• Site Reliability Engineering (SRE) principles and practices
+• Cloud Foundry deployment scenarios and on-call experiences
+• Reliability metrics and measuring success in distributed systems
+• Setting SLA and SLI levels and understanding tradeoffs between reliability and other goals
+• Measuring message reliability and using an "error budget" in a streaming service environment
+• Project releases, including Contour for Envoy-based Ingress Controller
+• GoTTY project for sharing terminal sessions through web pages
+• G.E.R.T project for running Go on ARMv7 systems
+• GoScan tool for scanning IPv4 subnets and discovering hostnames
+• Discussing Go programming language tools and libraries
+• Upcoming conferences: dotGo, GopherCon Brazil, and Women Who Go in Paris
+• Speaking engagements at conferences (Carlisia Thompson and Brian Ketelsen)
+• NVIDIA's nvidia-docker project for container support on GPU hardware
+• #FreeSoftwareFriday shoutouts to present tool from the Go team and Concourse CI
+• Concourse CI: discussed as a tool for automating pipelines and tasks
+• eBPF (extended BPF): kernel technology for high-performance monitoring, mentioned with Go bindings through gobpf
+• dep: discussed as a vendoring tool for Go projects, praised by several participants
+• Legacy source code management techniques, such as using Git submodules to vendor dependencies
+• Skype call issues and humorous discussion about having successful co-guests

Pachyderm, Provenance, Data Lakes_summary.txt

@@ -0,0 +1,52 @@
+• Pachyderm: a modern data lake built on containers
+• Version control for massive datasets
+• Data provenance: tracking changes to data and analysis
+• Applications in machine learning, particularly with EU's new regulations
+• Customer use cases include General Fusion (fusion reactor) and financial institutions
+• The system discussed is written entirely in Go and uses Docker containers.
+• Pachyderm's architecture includes a daemon (Pachd) written in Go using gRPC, and a frontend command line interface tool (Pach Control).
+• The motivation for choosing Go was due to the existing components being in Go and aligning with Google's internal use cases.
+• Pachyderm handles data orchestration, while users handle data processing within containers.
+• The system allows for complex pipelining of data sets and distribution across multiple containers.
+• Discussion about potential episode where a guest is assigned a mission to try out the system and return to discuss their experience.
+• Development of Pachyderm orchestration system in Go
+• Benefits of using Go in Pachyderm, including batteries included standard libraries and goroutines for concurrency
+• Scalability issues with large data sets (hundreds of gigabytes) and limitations of Docker containers
+• Future plans to handle larger data sizes (multiple terabytes)
+• Potential use cases for distributed file systems and discussion of existing projects like Minio and RADOS
+• Collaboration between Pachyderm and other open source projects, including support from the Minio community
+• Challenges of making money from open source software
+• Importance of aligning incentives for developers
+• Deploying open source products and navigating deployment costs
+• Case study: Pachyderm's decision to deploy on Kubernetes
+• Business models for open source projects (support contracts, hosted models)
+• Communicating vision and attracting community engagement through charismatic leadership
+• Role of project leaders in shaping the adoption curve
+• Charismatic but controversial leaders and their impact on the open source community
+• Discussion of Linus Torvalds and his role in creating a decentralized version control system (Git)
+• Critique of GitHub for being closed-source, despite its contributions to the open source community
+• Pros and cons of open source software, including the potential for centralization vs. decentralization
+• Gitea and Pachyderm as examples of open source projects challenging the status quo on GitHub
+• Vision for a decentralized data processing platform (Pachyderm) similar to GitHub's role in version control
+• Wuzz: a terminal-based HTTP request tool
+• Ozzo Validation: a Go validation package with separate rules and nested validation
+• Melissa Data: a data cleansing and validation service criticized for being outdated and using C
+• Dep: a dependency management tool in development to solve the Go dependency problem, with an article explaining its use and upcoming episode featuring Sam Boyer
+• Discussion about the math behind dependency chain and graphs in a tool called GPS (packaging solver)
+• Dependency management as a major problem in software development, with Go being no exception
+• Comparison of different programming languages' approaches to dependency management, including Rust's Cargo and Java's IDEs
+• Mention of the Gogland IDE from JetBrains as a high-quality, commercially-supported tool for Go developers
+• Discussion about the importance of good IDEs in increasing language adoption in the enterprise
+• Brief overview of other news and projects in the Go community, including Vim-go Debug and Jodosha's Delve integration
+• Francesc's video about Go 1.8
+• #FreeSoftwareFriday segment where the hosts give shoutouts to open-source projects that make their lives easier
+	+ NATS from APCERA and Derek Collison
+	+ HashiCorp, specifically Vault
+	+ gRPC from Google
+• Discussion of Pachyderm and its use of gRPC
+• Erik's hypothetical recommendation for password cracking with Hashcat
+• Show sponsors: Toptal and Backtrace
+• Reminder to subscribe to GoTime FM and follow on social media
+• Warning about using Pachyderm: don't flood your house with data lake
+• Episode release in a week and anticipated memes/gif responses
+• Official goodbye from hosts and guest

Periph.io, Drivers, Hardware_summary.txt

@@ -0,0 +1,43 @@
+• Introduction to Brian Ketelsen's 46th birthday and the podcast episode
+• Marc-Antoine Ruel introduces himself and his work at Google on Python projects, with a personal interest in Go programming
+• Discussion of healthcare systems and Canada's universal coverage
+• Introduction to Marc-Antoine's project Periph (Periph.io) and its origins as a driver for an infrared camera
+• Details about the FLIR Lepton camera and its use cases
+• Marc-Antoine's experience with writing code for websockets, SPI protocol, and learning from his mistakes
+• The development of dlibox, a project aimed at creating smart night lights for children's rooms using PWM LEDs
+• Controllable lighting with PWM and SPI bus
+• Driver for Raspberry Pi and other platforms
+• Periph library: device driver registry and discovery
+• Device driver registration and dependencies
+• Abstraction layers for hardware features
+• Automatic platform support and underlying host drivers
+• Dual-protocol devices (e.g. BME280, SSD1306)
+• Discussion of I2C and SPI communication protocols
+• Overview of Periph.io library's features, including 1-Wire support
+• Thorsten von Eicken's contributions to the project, including 1-Wire code and design of the Periph-tester board
+• Use of DMA (Direct Memory Access) for performance optimization in bit-banging
+• Comparison of DMA-based and CPU-based approaches for bit-banging and GPIO access
+• Explanation of what DMA is and its uses
+• Demonstration of Periph.io library's functionality on a Raspberry Pi
+• API functionality for various microcontrollers
+• Discussion of the PocketCHIP device and its uses
+• Comparison between the PocketCHIP and Raspberry Pi
+• Development of the Periph library and its history
+• gohci CI system and its purpose in testing hardware
+• Chrome infrastructure project and inspiration for gohci
+• The speaker successfully ran Caddy on a low-memory system using Docker
+• Periph.io is a project that abstracts away hardware-specific details for easier development
+• Outreach efforts were made to discuss collaboration with other projects, including Gobot and GoKrazy
+• Chrome OS's Container OS was used as a base for the speaker's experimentation
+• The future of operating systems may involve partitioned mechanisms like those in Chrome OS and Android for safe and simple upgrades
+• CoreOS fork by Jessie Frazelle for use as a desktop OS
+• ChromeOS feature request to run Docker images
+• Using a MacBook Pro due to multiple monitor support
+• Skolo project booting Raspberry Pi from network over NFS
+• Go client-server text editor experiment, using net/rpc and gob encoding
+• wi editor project in Rust, with JSON-RPC for communication
+• Discussion of gRPC as an alternative protocol
+• Separation of frontend and backend for more flexibility
+• Discussing the benefits of a web-based editor and server separation
+• Open-source projects mentioned: docopt, wxGo, Caddy, Shiny, hécate
+• Users discussing their experiences with these projects and how they've improved their development workflow

Presenting a Pragmatic Perspective_summary.txt

@@ -0,0 +1,50 @@
+• Cindy Sridharan discusses her background and experience as a programmer
+• She shares her perspective on not considering herself a good programmer, but instead striving to continually improve
+• The importance of being a generalist in software engineering, with a broad view of the landscape and willingness to adapt
+• Challenges of balancing depth vs breadth in expertise, and the pressure to be an expert in multiple areas
+• Cindy's current role at a startup, working as a software engineer on image processing, API development, infrastructure, and operations
+• Her recent transition to writing about her experiences and learning process, initially for personal benefit rather than public publication
+• Transition from programming to DevOps and sharing experiences
+• Resonance with others due to alternative viewpoints and perspectives
+• Focus on solving problems rather than just using technology
+• Importance of "from the trenches" stories and user experience in tool adoption
+• Writing process and time spent crafting blog posts
+• The speaker discusses writing a blog post and how it took several weeks to write due to learning new concepts and not being able to focus solely on writing.
+• The speaker contrasts this with other posts they've written, which were completed in a few hours, citing an example of a post about function length that was written in two hours.
+• Discussing the benefits of having different opinions and perspectives in the tech community, including challenging dogma and promoting empathy.
+• The conversation turns to the importance of solving business problems in professional software engineering, rather than just adopting new technologies for their own sake.
+• Examples are shared of over-adopting bleeding-edge technology and the need to balance innovation with practical considerations.
+• Prioritizing one thing over another is a common mistake
+• The importance of being cognizant of one's priorities, even when it comes to new and exciting technologies
+• Risks associated with adopting bleeding-edge technology, such as operational burden and difficulty in reasoning about failure modes
+• Importance of observability and monitoring in system design
+• Challenges of writing about abstract concepts, such as the author's experience with small methods
+• Value of explicitness in code, particularly in languages like Go that strive to make everything clear and simple
+• Trade-offs between following best practices and creating a good user experience for other developers
+• Importance of refactoring and breaking down large functions into smaller ones
+• Difficulty in building examples that demonstrate a single concept without creating contrived scenarios
+• Blurred boundaries between logical and programmatic concepts, making it hard to define "one thing" for a small function
+• Trade-offs between maintainability, understandability, and perfection in coding
+• Importance of building something "good enough" rather than striving for perfection
+• Perfection in software development is often short-lived and can lead to a waste of time and effort
+• Making tradeoffs too soon can be painful and difficult to adjust later on
+• Being "good enough" can get you a long way, especially for projects with longevity
+• Community Outreach Working Group aims to spread the love of Go throughout communities and help people learn Go
+• Recent news in Go includes:
+  • Release of Go 1.9
+  • Erik St. Martin's new job at Microsoft Azure
+  • Samsara blog post on running Go on low memory devices
+  • David Wong's walkthrough of Go code translation to internal Assembly language
+  • Minio's proposal for a standard for data at rest encryption and their Go implementation
+• Signal's encrypted profiles for public data
+• Go Working Group news announcement
+• Free Software Friday shoutouts:
+	+ Minio for S3-compatible file storage
+	+ Fabian Reinartz for rewriting Prometheus storage engine
+• The Cajun Army and their volunteer efforts in Houston
+• Envoy project, its potential integration with Kubernetes and Cloud Native Computing Foundation, and similarities to Google's internal system
+• Support for Envoy project from Google engineers
+• Current database supported by Envoy (MongoDB, DynamoDB, Redis)
+• Future potential support for other protocols (MySQL wire protocol, Kafka protocol)
+• CNCF project possibilities for Envoy
+• Podcast wrapping up and thanking guests and listeners

Race detection, firmware, production-grade Go_summary.txt

@@ -0,0 +1,55 @@
+• Kavya Joshi's background and work experience
+• Go language features and tools (race detector, vector clocks)
+• Importance of understanding how systems work under the covers
+• The challenge of making complex technical concepts approachable to various skill levels
+• Kavya Joshi's speaking engagements and articles
+• GopherCon and other conferences where Kavya has given talks
+• Importance of making technical content accessible to a wide audience
+• Sharing knowledge in an understandable way can lead to better systems and more interesting conversations
+• Assumptions about audience background knowledge can be a barrier to clear communication
+• Strategies for presenting complex concepts simply include considering the target audience, using analogies, and taking time to review and revise content
+• Concurrency in Go is a complex topic that requires background knowledge before diving into; resources such as the Go Docs, code examples, and open-source projects can be helpful for learning
+• Upcoming conference preparation is hectic, but worth it for a successful event
+• Kavya Joshi's talk on concurrency and channels in Go will be a deep dive
+• Article "How To Ship Production-grade Go" discusses best practices for Go development
+• Samsara company follows guidelines from the article, with some areas of improvement
+• Introducing new development practices can be challenging, requires careful planning
+• Using interfaces instead of concrete types is beneficial for program design and testing
+• Kubernetes' secret management feature allows secure configuration and environment handling
+• Implementing container orchestration and secret management in ECS
+• Discussion of Amazon's KeyMS service for master keys and encryption
+• Comparison of Kubernetes and AWS ECS, including costs and features
+• Deployment strategies using Amazon's test definition and services concept
+• Load balancing and service discovery with ALB and internal load balancers
+• HashiCorp tools, including Vault and Terraform
+• Cloud formation as a tool for infrastructure orchestration
+• Comparison between Terraform and other tools (Chef, Puppet) for infrastructure provisioning
+• Infrastructure as code concept
+• Firmware programming and writing firmware in Go
+• Constraints of firmware programming (power consumption, memory constraints)
+• Comparison between cloud world and firmware programming challenges
+• Hardware testing and assurance methods
+• Joint Test Action Group (JTAG) interface for communication with microcontrollers
+• Firmware development challenges, including hard faults and debugging issues
+• Resource constraints in IoT systems and how they influence coding practices
+• Data emission methods in IoT, including RF-based transmission and serial connections
+• Debugging and reverse-engineering hardware and firmware
+• Challenges of working with hardware, including power issues and glitches
+• Glitching power supply to extract firmware
+• Learning low-level hardware programming
+• Arduino boards and basic electronics projects
+• Raspberry Pi and I2C communication
+• Go language implementation details and design documents
+• GopherJS for running Go code in JavaScript environment
+• Transitioning from JavaScript to Go in a team with fluid roles
+• GopherJS and its role in converting JavaScript code to Go
+• Community news: released videos of GopherCon India 2017, upcoming meetup on Go's hidden pragmas, and JustForFunc episode on using the Context package
+• Recognition of community contributors and open-source projects for #FreeSoftwareFriday:
+	+ goreporter tool for code analysis and testing
+	+ ReviewDog similar tool for running checks on every commit
+	+ Robomongo GUI tool for MongoDB schema verification
+• GopherJS is mentioned by Kavya Joshi
+• Erik St. Martin discusses his project GNU ARM Eclipse, its purpose and benefits
+• Discussion of embedded development tools for ARM boards and interfaces with QEMU
+• Sponsorship thank you to Backtrace and DataDog
+• Closing remarks and farewell to listeners

Restic and backups (done right)_summary.txt

@@ -0,0 +1,49 @@
+• Introduction of guests and sponsors
+• Discussion of backup software, specifically Restic and Alexander Neumann's project
+• Comparison of Restic with other backup programs, focusing on security, speed, and usability
+• Why Alexander Neumann chose Go as a programming language for his project
+• Personal anecdotes about hacking and old computer systems, including Delphi and Trojan horses
+• Importance of separate specification for Go versions
+• Committing vendor directory for reproducible builds
+• Design and implementation of Restic's build script
+• Use case for Restic: backing up large directories with multiple revisions
+• Thread model for storing data on potentially untrusted servers
+• Detection of file changes using SHA-2 hash sums in pack files
+• Popularity of Restic and managing contributors and releases
+• Dealing with support requests from companies and users
+• New Restic release with improved S3 backend support
+• Reduced memory allocations by 98% using Minio's lower-level API
+• Discussion of deduplication in Restic and its benefits
+• Explanation of rsync algorithm for detecting file changes
+• Introduction to Rabin fingerprinting algorithm used in Restic
+• Implementation of Rabin fingerprinting in Go for efficient blob creation
+• Overview of how Restic stores and manages blobs, including encryption and hashing
+• Restic's ability to efficiently store snapshots of changed data
+• Fuse Mount feature for browsing snapshots and restoring data on demand
+• Importance of backups and detecting silent hard drive failures
+• Password protection and key derivation functions in Restic
+• Responsibility and guilt associated with open-source software development
+• Ease of use and simplicity of backup programs as a factor in users' willingness to back up their data
+• Borg vs Restic workflow and usability
+• Restic's use of Viper and Cobra for CLI and configuration
+• Concerns about config files and key management
+• Restic's design philosophy: simplicity and robustness over flexibility
+• Upcoming features: compression, new repository format, and caching
+• Repository versioning and backwards-compatibility
+• Go version compatibility and backup capabilities
+• Kelsey Hightower's DevOps Days speech and his keynote presentation on deploying a Kubernetes cluster with voice control
+• Releases of Go 1.8.2 and 1.8.3, including security fixes and other minor updates
+• Delve release candidate for version one
+• Visual Studio Code update with Delve integration and code lenses
+• Upcoming guest Ramya on the show next week
+• Discussion about missed episodes and catching up on news
+• #FreeSoftwareFriday pick: rofi-pass, an interactive input tool for shell scripts
+• Discussion of rofi-pass for password management
+• Introduction to barista, an i3 status bar written in Go
+• Shoutouts and recommendations:
+	+ Kelsey Hightower's talk
+	+ Visual Studio Code (by Matt)
+	+ Brendan Gregg's website and tools for profiling and performance tuning
+• Upcoming workshop by Brian Ketelsen on FlameGraphs at GopherCon
+• Ashley McNamara leaves the conversation to attend a meeting 
+• Conversation ends with goodbyes from Erik and Alexander

SPECIAL — Ask Us Anything!_summary.txt

@@ -0,0 +1,107 @@
+• Introduction to Go Time podcast
+• Sponsor for episode 45: TopTal
+• Guest not available, instead doing an "Ask Me Anything" Q&A session from a document of questions submitted by listeners
+• Discussion on types of questions allowed (no off-limits topics) and the format of the Q&A session
+• Starting to answer listener-submitted questions
+• Discussion on playing a game and props for trying
+• Mention of Fergulator, a Nintendo emulator written in Go
+• Ruby language being written in Go
+• Adam Stachowiak's introduction as editor-in-chief of Changelog and his experience with the podcast
+• Hints at Ruby being an interesting use case for Go
+• Discussion on the future direction of Golang
+• Vision for Go's growth, particularly in cloud and distributed systems development
+• Go language gaining popularity and expected to dominate server-side market
+• Comparison of Go and Java, with Go seen as easier to deploy and manage
+• DevOps and serverless movements fitting well with Go's single binary deploy feature
+• Discussion on the role of Rust versus Go in different contexts
+• Prediction that Go will take over space currently held by Java within 5 years
+• Plans for improving Go's onboarding process, including website updates and training materials
+• Gopher Review channel and code reviews available on Slack
+• Discussion of naming conventions in Go programming language
+• Personal preference for smoking meats (sirloin roast, pecan wood)
+• Discussion of mesquite wood's potency and regional preferences for local woods
+• Variations in flavor profiles due to available wood types (e.g., Texas has sharper flavors, South Carolina has sweeter flavors)
+• Regional barbecue styles and their relation to available wood types
+• Cuts of meat commonly used in American barbecue (brisket)
+• Comparison between American and Brazilian barbecue cuts and preferences
+• Discussion of differences in cuts of meat and terminology between countries
+• Difficulty in cooking brisket due to its tough muscle
+• Difference between working muscles and prime cuts of meat
+• Explanation of the importance of the "cupim" or hump steak cut
+• Discussion of Brazilian cuisine, including churrascaria restaurants and popular dishes like hump steak and injera
+• Description of eating Ethiopian food as a communal experience
+• TopTal is sponsoring the podcast and mentioned as a good platform for hiring developers/designers or freelancing as one
+• The discussion about Go's popularity in open source projects was initiated, with Adam Stachowiak mentioning single binary deploy and ease of understanding as factors
+• Readability is highlighted as a key aspect of Go, making it easy to read code in large complex systems
+• Carlicia shares her focus mode setup using i3 window manager and Vim, with background music playing while she codes
+• The concept of "focus mode" was discussed, referring to being highly productive while coding
+• Switching between text editors: Vim, Atom, and VS Code
+• Use of music for coding focus, including personal preferences and playlists
+• Importance of concentration mode with headphones on
+• Turning off notifications to maintain focus and productivity
+• Diverse focus modes depending on tasks (coding, designing, audio editing)
+• Recording and writing habits for sponsors
+• Focus mode: turning off notifications, closing non-essential apps, and silencing phone
+• Importance of music in work environment: listening to music helps with focus and productivity
+• Experiment on preferred music styles: majority prefers electronic dance music (EDM) but some prefer rock/metal/classic rock bands like Dream Theater, Guns N' Roses, and Led Zeppelin
+• The speaker's musical preferences are eclectic and influenced by their personal experiences, such as having a DJ father.
+• They enjoy music with complex beats and rhythms, citing Dream Theater as an example.
+• The speaker has difficulty concentrating on lyrics, making it hard to listen to songs with vocals while working or doing repetitive tasks.
+• Their favorite bands include Sepultura, Black Sabbath, Guns N' Roses, and Five Finger Death Punch.
+• They have a "bipolar music disorder" where they get bored with one style and switch to another, often listening to different genres for extended periods of time.
+• Discussing a party
+• Mention of Sepulveda and Guns N' Roses
+• Comparing music preferences with the listener
+• Introduction to a go podcast episode
+• Discussion on using Go as a tooling language for sysadmins
+• Benefits of using Go, including speed and simplicity
+• Critique of using Node for sysadmin tasks
+• Question about code review process and guidelines
+• Importance of code review with multiple reviewers for fresh perspectives
+• Benefits of having a mix of domain-experts and non-domain experts in code reviews
+• Limitations of relying solely on automated tools like linters for code quality
+• Value of human oversight in catching errors and inconsistencies that linters may miss
+• Discussion around coding style and the role of tools like Prettier in formatting code
+• Imposter syndrome and its effects on developers, with advice to "own it" and take action despite uncertainty
+• Discussion of Gary Vaynerchuk's motivational ideas
+• Importance of owning one's weaknesses and mistakes
+• Eminem's music as an example of authenticity and self-acceptance
+• Imposter syndrome and the fear of being judged or perceived poorly
+• The value of accepting constructive criticism and learning from it
+• Discussion of personal branding and social media presence (emojis, Twitter behavior)
+• Personal anecdotes about feeling like a "lurker" and struggling with imposter syndrome
+• Discussion of a previous question and answer about the person's favorite emoji or expression
+• Complaints about the "party parrot" emoji and other obnoxious emojis
+• Personal story about choosing an emoji that represents oneself, with the winner being a smiling face with two lines
+• Explanation of what the winning emoji means (being down but excited)
+• Job description as a trainer for companies using Go and Kubernetes
+• Announcement of a new online learning system for Go being launched soon
+• Discussion of a class with sharp students
+• Mention of Joe Shaw working at Fastly and being the speaker's coworker
+• Explanation of what Fastly does as a CDN company
+• Explanation of Content Delivery Networks (CDNs) and their benefits
+• Personal experience using Fastly for Changelog.com
+• Adam's job role and responsibilities, including sales and relationship-building with companies and developers
+• Systems architecture and IP-based delivery in cable division at Comcast
+• Replacing industry-specific hardware with software for multiplexing video streams
+• Software written in C++ and Go, with primary work in Go
+• Design and build of orchestration systems for deploying and failing over video streams
+• Talk given at KubeCon on project and leveraging Kubernetes and containers
+• Contributing patches to Kubernetes and Docker
+• Podcasting setup and equipment
+• Multi-channel audio processing for better sound quality
+• Working with low-quality microphones
+• Podcast editing and production process
+• Role of editors and producers in podcast creation
+• Difference between live stream and final produced episodes
+• Importance of polishing the show for easier listening
+• Importance of live interaction and community engagement
+• Discussion of Breakmaster Cylinder's intro music and its evolution
+• Shoutouts to unsung heroes behind the scenes at GopherCon
+• Acknowledgement of Sarah Adams' help with scholarship applications
+• Reminder about pending scholarship announcements
+• Thank yous to listeners, sponsors (TopTal), and guests
+• Sponsors mentioned: TopTal, Fastly
+• Episode edited by Jonathan Youngblood
+• Theme music produced by Breakmaster Cylinder
+• Closing and farewell to listeners

SPECIAL — Ask Us Anything!_summary.txt

@@ -0,0 +1,58 @@
+• The hosts discuss their Ask Me Anything format for today's episode, where they'll answer questions from the audience about Go, community, GopherCon, and personal lives.
+• Brian Ketelsen shares his experience port forwarding a TelNet prompt on his television to control it with a tiny Go program.
+• Erik St. Martin talks about a Nintendo emulator written in Go called Fergulator.
+• Adam Stacoviak mentions Rooby, the Ruby language implemented in Go, as an unexpected project.
+• The hosts discuss their roles and introduce themselves to new listeners.
+• The panel discusses their predictions for Go's future growth and adoption in the next 2-5 years.
+• Erik St. Martin believes Go will continue to grow in the cloud space and become more widely adopted due to its ease of use and scalability.
+• Brian Ketelsen predicts that Go will dominate the server-side market by 2025, replacing Java as the primary language for large-scale applications.
+• Carlisia Thompson agrees with Brian's assessment and notes that Go's modular design and ease of deployment make it an attractive choice for enterprise development.
+• The panel discusses the advantages of single-binary deploy in Go and how it will continue to drive adoption.
+• The conversation also touches on the potential for Rust to coexist with Go as a complementary language for specific use cases.
+• Gopher Review Channel awareness
+• Naming conventions in Go programming language
+• Barbecue preferences and wood types for smoking meat
+• Discussion of the toughness and texture of brisket meat
+• Explanation of animal anatomy and muscle groups in cows
+• Introduction to new cuts of meat, including "cupim" or "hump steak"
+• Comparison of eating styles in different cultures (Brazilian churrascaria vs. Ethiopian restaurant)
+• Return to main topic: discussion of the Go programming language and its popularity for open source projects
+• Explanation of the importance of readability in a programming language, especially in large codebases
+• Discussion of the developer experience and "focused mode" in development environments
+• The importance of focused mode or "being in the zone" for productivity
+• Setting up a conducive environment with tools such as i3 window manager and Vim editor
+• Personal preferences for music while coding, including house music and electronic music playlists like "brain food"
+• The role of comfort items, such as headphones, in aiding concentration
+• Turning off notifications and distractions to maintain focus
+• Using music to stay focused and in the groove
+• Discussion of personal preferences for music genres, including EDM, death metal, rock, and hip-hop
+• The role of distraction in working styles, particularly with ADHD
+• Favorite bands and albums mentioned (e.g. Dream Theater, Guns 'n Roses, Sepultura)
+• Varied tastes in music among the group members
+• Age and career as potential factors influencing musical preferences
+• Sepultura's age and popularity
+• Go as a tooling language for sysadmin/ops people
+• Code review process and best practices
+• Impostor syndrome and self-doubt in programming
+• The importance of human judgment in code review vs. relying on automated tools
+• Overcoming impostor syndrome by not letting fear of judgment hold you back
+• Owning your imperfections and being authentic
+• The importance of self-acceptance and not taking criticism personally
+• Personal branding and how to represent yourself online (emojis, etc.)
+• Day jobs and what the panelists do on a daily basis
+• Brian Ketelsen teaches Go and Kubernetes training, and is launching an online learning system for Go
+• Carlisia Thompson works at Fastly, a CDN company, and is rebuilding the TLS and DNS management system
+• A CDN (Content Delivery Network) reduces latency by replicating content and offers security features like DDoS protection
+• Adam Stacoviak's day job involves sales and building relationships with companies in the software development community
+• Erik St. Martin works as a systems architect at Comcast, replacing industry-specific hardware with software and designing an orchestration system for video stream deployment
+• Discussion of Kubernetes and Docker patches
+• Production process behind GoTime podcast
+• Technical setup for recording live episodes (WaveStreamer, Nicecast)
+• Post-production editing and sound design (Jonathan Youngblood's work)
+• Role of Jerod Santo in building the CMS and CDN
+• Differences between live and produced episodes
+• Discussion of live community engagement with the GoTime FM channel
+• Shoutouts to Breakmaster Cylinder for intro music and attention to detail
+• Acknowledgement of going overtime and deferring questions to a future episode
+• Recognition of unsung heroes behind GopherCon, including Sarah Adams' help with scholarship applications
+• Reminder about scholarship announcements and thanks to listeners and sponsors

Splice, Audio, Compassion_summary.txt

@@ -0,0 +1,58 @@
+• Splice is a platform that connects music producers with samples and loops
+• Matt Aimonetti co-founded Splice in 2013 and has a background in sound engineering and programming
+• He previously worked on Merb, a Ruby project, and later moved into the Go community
+• Splice's technical stack includes desktop clients, mobile apps, and web presence, all built with Go
+• The company handles large amounts of data (over 9 terabytes per day) and requires concurrency, which led to the choice of Go as the primary language
+• Creating an abstraction layer for multiple projects
+• Implementing lossless compression and deduping to reduce data duplication
+• Partnership with Pioneer DJ for hardware sampler integration
+• Developing a web-based beat maker and sequencer using Go
+• Using Go as the primary language, with TypeScript also being used
+• Addressing latency issues through proper context handling
+• Discussing performance benefits of using Go, including low memory usage
+• Comparing Go to other languages (e.g. Ruby) in terms of syntax stability
+• Hiring philosophy: prioritizing problem-solving skills and willingness to learn Go over prior experience with the language
+• The interview process at Aimonetti's company involves a coding test in frontend and backend, with the goal of discussing how candidates approach problems rather than grading their ability in Go.
+• The test is designed to assess problem-solving skills and willingness to learn, not expertise in Go.
+• Go is used for QA automation due to its fast compile language and good tooling, making it easier for non-technical team members to write code.
+• Aimonetti believes that Go is an accessible language for beginners and can be a good introduction to programming.
+• The community needs to focus on making Go more welcoming and inclusive for new users, rather than emphasizing its features or technical aspects.
+• Concurrency is not the only important aspect of Go, and other features such as simplicity and ease of use should also be highlighted.
+• Discussion of Go's concurrency features being overemphasized
+• Simplicity of the Go language for beginners
+• Use of Go in production environments with simple web services
+• Challenges of using Go for audio processing and real-time systems
+• Development of libraries for audio processing in Go to bridge the gap between Python and C
+• Comparison of Go's performance and ease of use compared to Python for audio analysis
+• The challenges of using Go for multimedia processing, including type conversion costs and missing tooling.
+• The need for basic libraries for audio and video processing in Go.
+• The potential for Go to be used for real-time multimedia processing with the help of C libraries.
+• The importance of having people motivated to write libraries for complex tasks like data science and multimedia processing.
+• Matt Aimonetti's personal experience writing his own libraries for audio and video processing and releasing them as open source.
+• The need for more freedom in the Go team to let contributors work on side projects and libraries.
+• Matt Aimonetti's recent blog post about a prison outreach program where he helped entrepreneurs-in-training with their pitches.
+• Defy Ventures' mission to give a second chance to inmates through entrepreneurship and programming skills
+• High recidivism rates in the US prison system (75-85% of inmates return to jail)
+• Success of Defy Ventures' program: 3% recidivism rate for graduates with a master's degree from a real university
+• Systemic issues in the US prison system, including racial bias and unfair sentencing
+• Importance of equal opportunities and access to resources for successful entrepreneurship and programming
+• Abstraction layers in modern life (e.g. technology) that can disconnect people and hinder meaningful relationships
+• Defy Ventures' programs are available in 23 prisons across the country
+• Importance of teaching social skills to engineers
+• Value of community service and volunteering for personal growth and team morale
+• Challenges of implementing community service in tech companies (e.g. vacation time, background checks)
+• Great American Teach-In program for parents to teach students about their work
+• Scott Lobdell's autopilot blimp project using Go on Raspberry Pi
+• Gokrazy all-Go userland for Raspberry Pi
+• Discussion on Gokrazy, a lightweight operating system for Raspberry Pi that runs Go applications
+• Features of Gokrazy, including web interface and security benefits
+• Mention of Matt Aimonetti's free online book "Go Bootcamp"
+• Explanation of Retool, a vendoring project for binaries developed by Twitch TV
+• Discussion on video processing in Go, with mentions of projects from Comcast and other companies
+• Shout-out to GitLab for their open-source community edition and alternative to GitHub
+• Shout-out to Ramya Rao for maintaining the Visual Studio Code Go plugin
+• Ramya's contributions to the Go extension in VS Code, including features like a better debugger and test generation
+• The importance of community support for her work, with 91 open issues that need help from users
+• Discussion of the Language Server Protocol (LSP) and its potential impact on IDEs
+• Comparison of Visual Studio Code's speed to other GUI editors, particularly Electron's role in optimizing performance
+• Erik St. Martin's #FreeSoftwareFriday announcement featuring React

Why WADL When You Can Swagger_summary.txt

@@ -0,0 +1,37 @@
+• Ivan Porto Carrero's background in software engineering, including his work on IronRuby, IronPython, and Scalatra
+• His experience with Scala and its limitations as a team-oriented language
+• His discovery of Go and its suitability for team development
+• The concept of Swagger (now OpenAPI) and its purpose in documenting API expectations
+• How Swagger can generate clients from API specifications and enable contract-first development
+• Generating Swagger API documentation from Go code
+• Using the Swagger binary to generate a Swagger JSON file and serve an HTML UI
+• Sharing documentation with team members using the generated Swagger JSON file or hosting it online
+• Integrating Swagger with Go routers and multiplexers (e.g. go-restful, Goa)
+• Swagger's presence in various projects (e.g. Docker, Kubernetes)
+• Managed Kubernetes offerings (e.g. PKS, AKS, GKE)
+• Kubernetes and its complexities
+• Istio and Envoy: latency and scalability concerns
+• Gossip protocols in distributed systems (e.g. Consul, Cassandra)
+• Challenges with decentralized databases and membership systems
+• PKS: an implementation of Kubernetes for distribution on VMware
+• PKS is a joint effort between Pivotal, VMware, and Google for Kubernetes on Cloud Foundry
+• PKS uses BOSH as a lifecycle manager for applications
+• PKS integrates with NSX-T for network overlays and security
+• Kubo is an open-source component that interacts with BOSH
+• PKS provides a managed version of Kubernetes with features like zero-downtime upgrades and automated operations
+• Release notes mention updates to Go 1.9.x and 1.8.x, including fixes for issues with go get on non-Git repositories
+• Ron will be speaking at GopherCon Brazil about GoBot and IoT
+• Discussion of Authaus, a potential user authentication system for Go
+• Comparison to other libraries such as Authboss
+• Introduction to grv, a command-line UI for Git
+• Installation issues with grv on Windows
+• Release of dep 0.3.2 with import support for gvt and gb
+• Writing a package manager
+• GoTracer and performance metrics
+• Channel behavior explanation by Bill Kennedy
+• Francesc Campoy's work for the Go community
+• gonum library and its potential for scientific projects in Go
+• The holiday season is approaching
+• GoTime is a suitable gift for friends and family
+• Subscription to the podcast is free
+• A humorous suggestion to subscribe on behalf of others as a gift

Why WADL When You Can Swagger？_summary.txt

@@ -0,0 +1,116 @@
+• Ivan Portacarero introduces himself and his background in software engineering
+• He discusses his experience working with various languages including C#, Ruby, Scala, and Go
+• He shares his work on IronRuby and how it led to him contributing to the Scala web framework
+• He explains why he switched from Scala to Go due to issues with the language and community
+• He expresses his positive experience with Go and its ability to support team development
+• The origin of Swagger (now OpenAPI) and its name
+• Common problems with APIs, including documenting inputs/outputs and evolving over time
+• Solution: creating a machine-readable API specification to formalize expectations and facilitate client generation
+• Features of Swagger, including:
+  • Generating clients for APIs
+  • Creating UI documentation that lives with code
+  • Allowing for contract-first development and server generation
+  • Marketplaces for accessing other companies' exposed APIs
+• Benefits of using Swagger, including:
+  • No longer needing to download client SDKs
+  • Ability to quickly test and play with API requests through the Swagger UI
+• Documentation comments for API routes and models
+• Using Swagger to generate JSON documentation files
+• Serving the Swagger UI using the binary or a hosted URL
+• Publishing the Swagger JSON file on GitHub or other platforms
+• Leveraging online tools, such as petstore.swagger.io, to view the UI
+• Integration of Swagger with APIs and hosting requirements
+• Kubernetes benefits for developers and infrastructure experts
+• Challenges of scaling with Kubernetes in smaller businesses
+• Importance of expertise in Linux and kernel facilities for effective use of Kubernetes
+• Concerns about latency and performance in distributed systems, particularly with Istio
+• Emergence of new projects like Istio, Envoy, and service meshes to solve distributed system problems
+• Unsolved problems in distributed systems and service meshes
+• Latency, points of failure, and debugging issues with version two and three implementations
+• Difficulty in choosing between different solutions (e.g., Istio, Envoy) due to rapid innovation and potential for future replacement
+• Need to balance adoption of new technologies with existing infrastructure and libraries (e.g., GoKit)
+• Potential difficulties in maintaining and updating distributed systems
+• Author's personal interests in decentralized databases and other unsolved problems
+• Improving gossip algorithms in distributed systems
+• Study of failure behavior in gossip-based membership systems (e.g. Cassandra, ACA)
+• Research on improving the stability and performance of these systems under various conditions
+• Development of a decentralized computing system using GoRapid
+• Submission of a paper to ACM SIGCOM on decentralized computing
+• Zookeeper usage: who uses it, Cassandra doesn't require it, Kafka does
+• Operational cost and overhead of Zookeeper
+• PKS (Pivotal Container Service) explained: implementation of Kubernetes for distribution on VMware
+• PKS joint effort between Pivotal and VMware, with some involvement from Google
+• PKS does not require Cloud Foundry, can be used next to it or standalone
+• Separation between hardware and workloads
+• Use of Bosch lifecycle manager for applications and infrastructure monitoring
+• Automated restarting of processes and recreation of VMs in case of failure
+• Management of unattended version of Kubernetes
+• Integration with VMware's existing tools, including NSX-T overlay network
+• Comparison to other solutions such as Flannel and Calico
+• NSX-T management plane translates policies into rules for Kubernetes
+• NSX-T has a centralized management plane for container interfaces, which Kubernetes takes advantage of
+• Integration between NSX-T and Kubernetes allows for security features to be applied at the network level
+• Kubo is an open-source tool that encapsulates source code, metadata, and monitoring information in a single package
+• Releases is a system that stores source code, metadata, and monitoring information for rebuilding releases from scratch
+• PKS (formerly Pivotal Container Service) makes it easy to set up Kubo in an environment with a UI and management tools.
+• Implementing Active Directory and RBAC in a project called PKS
+• PKS is a closed-source application
+• The team hopes to release the project by December
+• There's an exciting new project called Factory, which seems like a Sidekick successor but written in Go and supporting both Go and Ruby natively
+• The speaker is excited about playing with Factory and its potential for open source companies
+• Sidekick Pro model mentioned as a slick service
+• Transition from Ruby to Go
+• Updates on minor patch releases for Go (192 and 185)
+• Bug fixes for issues with Go Get on non-Git repositories
+• Release of Go Bot version 1.7.0 with OpenCV3 support
+• Additional drone and robot implementations using Go
+• Discussion of a project called Authouse, which is an open-source user authentication system for Go
+• Comparison to existing authentication solutions such as Authboss and Ruby's device and other libraries
+• Interest in exploring Authouse further due to its potential to simplify authentication in Go apps
+• Reflection on the growth and maturation of the Go language and ecosystem
+• Discussion about Authboss, a project that wasn't production-ready and had many broken things
+• Comparison of Authboss's 1.0 version to the speaker's expectations
+• Common issue in open source projects: vision vs reality
+• Excitement for GRV, with some participants having already tried it
+• Discussion of TIG, a CLI Git client
+• Description of grv as a command line UI for Git
+• Features of grv, including visual display of remote branches, commits, and tags
+• Installation process and requirements (CMake, libgit2)
+• Enthusiasm for using grv to manage Git repositories from the terminal
+• Discussion about using Linux and its GUI tools
+• Comparison of GRV with other tools (e.g., git-dash)
+• Review of DEP 0.3.2 release and its features (import support for GPT and GB, bug fixes)
+• Suggestion to play with DEP 0.3.2 for auto-import functionality from GVT or GB
+• Recommendation of a blog post about version management by Shane/Sam Boyer
+• Blog post name discussion
+• Dependency management problems and appreciation for those who solve them
+• Go Tracer tool introduction and its purpose
+• Go Tracer's lack of documentation and explanation
+• Go Tracer's features, including instrumentation and performance metrics capture
+• Discussion on better tools being visual and interactive
+• Performance issues with CPU time being taken up by one function
+• Mention of a video to watch for performance optimization
+• Bill Kennedy's blog post explaining channels and their usage in software development
+• Discussion of understanding channels and how they work
+• Free Software Friday segment is about to start
+• Explanation of the OSS maintainer segment on the show
+• Shoutouts to Francesc Campoy for his work in the Go community
+• Discussion of Francesc's podcast, blog posts, tooling, and documentation
+• Praise for Francesc's effort and dedication to the Go community
+• Mention of a specific repository for Go tools created by Francesc
+• Shoutouts to Bill Kennedy for a blog post on channels in Go
+• Discussion of Carlicia asking if anyone else wanted to be mentioned.
+• The guest talks about another person's tweets and online activities
+• They mention GoNum, a library for numerical computations in Go
+• The guest is excited about the potential of Python with NumPy in scientific regions
+• The growth of the Go programming language and its community is discussed
+• Shoutouts are given to Ivan for being on the show and to listeners
+• Mention of Twitter handle @gotimefm
+• Call to action to submit issues or suggestions on GitHub
+• End of episode and reminder to tune in live next Thursday
+• Discussion of holiday season and suggestion to "steal their phone" as a gift idea
+• Promotion of changelog.com/live for live show streaming and community engagement
+• The Breakmaster Cylinder is mentioned
+• It is described as mysterious
+• Mention of a previous episode or show
+• Closing remarks and thanks to listeners