add all 2016 transcripts

Asim Aslam on Micro, the Go Microservice Toolkit_transcript.txt

@@ -0,0 +1,327 @@
+**Erik St. Martin:** It's Go Time! A weekly podcast where we discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+Alright everybody, welcome back for another episode of Go Time. This is episode number eight. We have a special guest with us today, Asim Aslam, and he is going to talk to us about the Micro framework. And we also have Brian Ketelsen on the line, as always.
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And then we have the wonderful Carlisia Thompson also on the line.
+
+**Carlisia Thompson:** Glad to be here, hello.
+
+**Erik St. Martin:** Let's have everybody give Asim a warm welcome and if you could give us a brief introduction, a little bit of history about yourself and then we'll kind of roll into the whole Micro framework.
+
+**Asim Aslam:** Sure. So thanks for having me on the show, I really appreciate it. Basically, my background is that I spent the last ten years in London doing various kind of sys admin, SRE, engineering kind of roles. I worked at a startup, which later got acquired by Google. I spent a bit time at Google learning how to build systems that scale, which was really exciting to see from the inside. This was when Google Cloud was still actually in beta.
+
+Then I went to work at Hailo and helped build a global microservices platform back in 2013 when, you know, it wasn't really much of a thing. I think Netflix was the only one talking about it.
+
+Now I'm working on this thing called Micro. I realized everyone was really doing the same thing internally at companies, and it would be nice if there was a community project that was doing the same, where we could all contribute and kind of learn and benefit from it, and basically do this thing of simplifying, building and managing distributed systems. That's really where I am at the moment, just kind of building that and hoping people will want to use it.
+
+**Erik St. Martin:** So when I first saw Micro, I think, the thing that impressed me most and this was February of last year, it's been quite awhile; but the thing that impressed me most was the design decisions that you've made seemed to be - what's the word I'm trying to think... It encapsulates almost everything you need to get the job done and it's more of a full framework than a toolkit, to use frequent Go terminology; whereas, you know, the Gorilla toolkit is a bunch of things you can use to build websites, but Micro is pretty, relatively self-contained, and I really enjoy that. I think it's nice to have a strongly-opinionated framework like that in the microservices.
+
+**Asim Aslam:** Thanks. I guess the wording is always hard. You can kind of go back and forth and on what it should be, but learning from the experiences of building something within a company... A library does not suffice, a toolkit does not suffice. We essentially build platform as a service or microservices platform service for the company, and that meant providing everything to the developers who are our customers and letting them kind of focus on what they need to focus on.
+
+So when I built this, I really thought about what are the fundamental building blocks, how would you do if you built it open source first? So it needs to be pluggable... And it slowly evolved. I mean, it started as just Go Micro - the kind of core project - and now it's this bigger thing and I'm calling it an ecosystem and trying to build it really further and address every requirement, but also kind of saying, "Look, it's pluggable." We offload the hard things to the people and the tools that are really focused on those things. So service discovery - there's an interface for it, but if you want something that is consistent and distributed, you can use Console or Etcd or anything like that. It's the same for all the other kind of packages within there.
+
+**Carlisia Thompson:** \[04:25\] Before we geek out on Micro, Asim, it seems that you're working exclusively on Micro. Is that true? And if so, what is the financial sustainability plan for the project and for yourself?
+
+**Asim Aslam:** Sure. That's right, I'm working on it full-time. Basically, I quit my job at Hailo over a year ago, because I felt so strongly about this and I wanted to build this. At the time I was talking to some venture capitalists, so the plan was, "Hey, I' m gonna raise this money, build this team and we're gonna go off and do this." You know, the Silicon Valley way. And actually we were in London so no, we couldn't do it that way and I ended up kind of going it alone. Luckily, I had some savings, so I kept going, and eventually a friend of mine who was at Hailo, who is now at Sixt, the car rental company, he went there to build a platform and he saw what I was doing and we kind of worked out a deal and that company is essentially sponsoring the project so that I can continue to work on this full-time, which is really great.
+
+**Carlisia Thompson:** Very cool.
+
+**Brian Ketelsen:** Yeah, I always love to hear projects that work that way where people get sponsored to work on them full-time. Because I know a lot of people get really passionate about their open source projects and a lot of times they become abandoned when they move on to new places that no longer sponsor.
+
+**Asim Aslam:** It's really tough. I think I got very, very lucky in the sense that this friend of mine who I had worked with closely was going to this large enterprise company, and he could see the value and he knew exactly what I was planning to do and was willing to kind of help out in that way. And many people who build open source projects, very large open source projects, don't get that same benefit. It's really tough to see that. And I know there's a lot of people kind of working on ways to fix that, but we definitely need do better work there as well.
+
+**Brian Ketelsen:** So let's talk about adoption. Do you have any sense of the numbers or scale of companies that have deployed services with Micro?
+
+**Asim Aslam:** I set up a users page and there's about four companies listed there, a couple of which have gone to production. You can find that in the main repository in the Wiki. There are maybe about five or six other companies who kind of did a survey and said they would be on the way to production in next three or four months, but I'm still chasing to see if they want to publicly name themselves and what not.
+
+The growth is slow and nice. I think the nice thing is there's a Slack where everyone joins, individuals and companies come along and kind of talk about their uses, and people are using it without me even knowing. For some reason it's really taking off in China, which is really, really nice to see, and someone even translated the entire blog into Chinese, which is really cool.
+
+\[07:53\] Here in London I just met with a company called Kazoop, and they have essentially posted the first job listing including Micro. For me, that's really profound, that someone thinks so much of it that they wanna put it in a job listing and kind of say, "Hey, we're moving over to this framework and here's what we're gonna pay for someone to do it." So that's pretty cool.
+
+**Brian Ketelsen:** Are they looking for a developer with ten years of experience?
+
+**Asim Aslam:** \[Laughter\] No. They're looking for someone who knows Go and wants to build microservices and can kind of do this stuff. I think the awesome thing about microservices in general, these things are maybe less than a thousand lines of code. It's very domain-specific what you're building, so it doesn't require as much as you think to kind of build that stuff, which means people with six months experience, a year experience could really do this stuff.
+
+People learning Go for the first time could probably do this, because what really matters is the API at the end of the day, the interface to that application that you're communicating with. The code is irrelevant, because you could rewrite that anytime in the future.
+
+**Brian Ketelsen:** That brings up an interesting question - what do you feel philosophically is the delineation point between a Microservice and something that's bigger than a Microservice?
+
+**Asim Aslam:** That's a tough one. For me, what I found is it's whatever I can kind of keep in my head and still feels fairly simple, and having written a lot of Go in the last three or four years and actually having built a microservices platform, I would say a lot of the time it does fall into a thousand to two thousand lines of code kind of thing for Go specifically.
+
+You know every language has a different kind of syntax, therefore it's gonna come down to a certain numbers of lines. For Go it feels naturally like that, but you kind of know a lot of the time, because this is a philosophy - you know from looking at the code if it takes longer than a week to do something, then you know it's probably too big. If it takes you a lot of work to build that mental model as you're trying to change something, then you also know it's too big.
+
+**Carlisia Thompson:** That's an interesting measure, because I am thinking at the beginning when you're designing something - maybe that's what you mean - at the design/creation time how much you can hold it in your head; because for me as time goes by more and more and I'm working with the codebase... I mean, two years that I work with a codebase, I can hold a ton more than what I could in the first two months.
+
+**Asim Aslam:** Yeah, it's interesting... I mean, I agree in that the longer you go, the more you can kind of remember about it and kind of model in your head. But at the same time, if you leave the project for a little while and come back, how long does it take you to kind of build that model again? For me, it's the case of "Can I hold the entire model in my head? Can I make changes to that model in my head in a very, very easy manner and then put it down in code very, very quickly?"
+
+You can kind of generally get a feel for when it's not working. I think people coming from an MVC background, you know, Rails and what not - you get used to the modularity, so you'll have code bases that are a million lines of code and you somehow figure out how to code in the modular space. But in the microservices world I just think you kind of need to have a full scope of the service itself.
+
+\[11:48\] A lot of the time, we're hacking out services in the space of one or two days and shipping them to production, at least when I was at Hailo, but I would say there is no right or wrong. I think for everyone it's a different thing and you really have to go with what works for you and that's what I like about the philosophy, because there are a lot of tradeoffs.
+
+I think when a team comes together, they kind of figure how they'll work and what number of services work for them and what code bases, what sizes of code bases work for them.
+
+**Carlisia Thompson:** I agree. I think you have a very good point. I like that way of thinking. You might not even use it exclusively on your team, depending on how your team is made up, but you can definitely use it as a complement.
+
+**Asim Aslam:** Yeah. I think for me now the question I'm thinking more about is we've seen all this kind of stuff play out in organizations; what I wanna see is how this works in the open developer word. If we were to collaboratively build entire products with microservices just as general developers, would that work and on what scale could we actually achieve that?
+
+**Brian Ketelsen:** That's an interesting concept. I'd never thought of microservices outside of something that looks like an enterprise.
+
+**Asim Aslam:** So that's where I'm really going with this whole micro thing. I have done the organization thing for a long time; I think the tools that I build will be relevant to organizations, but at the same time I'm more interested in what we can collaboratively do as a developer community. GitHub's a great example of us collaborating on libraries and things like that, but what if we collaborated on microservices. So a person or two people write a microservice, then someone else consumes the API, then someone else builds another one and we kind of keep going like that. What could we actually build? And if we do that, then we start rebuilding the things that we used to build and we can start building new things, right? So we kind of shift software development forward entirely. I think that's really intriguing to me.
+
+**Erik St. Martin:** So you're imagining this more like the Linux landscape, right? Where there are a lot of small tools that can be combined easily. Nobody kind of rewrites each of those pieces every time, right?
+
+**Asim Aslam:** Yeah, exactly. Like, when's the last time someone rewrote grep or ls or cat or something like that. It's like once they're built, they're built.
+
+**Erik St. Martin:** Now, I think that's an interesting thought. But how does that look from kind of the operations perspective? Who is responsible for all of those? Are these microservices that are running out somewhere that you leverage, or are these microservices that you're downloading these versions of and installing within your own infrastructure? How does that look?
+
+**Asim Aslam:** Say all of us here on the call, we were all collaborating on some project. Now, how will we do it? We're building a side project. A lot of the time people will go find some hosting and start running some stuff there. But what if we could string together our disparate Digital Ocean kind of resources, creating network and then run microservices in there collectively? That's what I'm really thinking.
+
+I think it'd be kind of a shared responsibility between the people actually contributing to the network itself. I've built platform as a service for a very long time, so I think the part of automation really plays in and so you have to build self-healing automated systems that can kind of deal with this sort of failure.
+
+I mean, we're talking about distributed systems, right? So they have to be fault-tolerant. I think that kind of plays into it. It's really fun and kind of interesting when you get to a point where you bootstrap the platform and then everything is written as a service and even services that manage the infrastructure are microservices.
+
+So I think you can kind of get to a place where no individual, no actual human being is managing any of it, it's actually completely automated.
+
+**Brian Ketelsen:** \[16:12\] You've got big dreams.
+
+**Asim Aslam:** I have very big dreams, but I also have the time to do it, the luxury of time, so that's quite nice.
+
+**Brian Ketelsen:** So from a technical perspective one of the things I appreciate about the Micro framework is that you can interact with the framework. There are multiple different media, for example the Command Line tool, the bot, the API itself; designing that, what went into that? How did you design the services in a way that made it really easy to interact from so many different media?
+
+**Asim Aslam:** So I sort of cheated a little in that. At Hailo we had a lot of these things. We had the API that would convert HTTP to RPC, we had web applications as microservices, we had HUBOT and HipChat, which is where I kind of got the idea for the bot. And then we also had a shell or a CLI. I just took all those ideas, and I kind of knew that when you're building this stuff you need to be able to interact with it and you also need to be able to interact with it from a legacy standpoint and just a usability standpoint of, hey, if I have a CLI, it's really easy for me to see what's going on and query things. If I have an API that serves HTTP, it makes it very simple to kind of talk to these things via a browser or cURL or anything else.
+
+When you're serving, public-facing the APIs, obviously everyone wants rasters or something similar in the feature, I think. I want everything to move to RPC and I think that's really the dream of gRPC as well. I think they're talking about mobile first in doing that, but it was just that it didn't all happen at once either. It started with the command line, then it was the API, then it was the web UI and so on and so forth.
+
+That's the thing to remember with any of this kind of development - it's a slow, kind of progressive thing. You're not gonna have everything figured out, but it's also a layered architecture in the sense that you build exactly what you need at first and then rather than conflating that core thing, you build around it and continue to build around it and on top of it.
+
+**Erik St. Martin:** And now backing up a little about what the framework actually is, I don't think we've actually kind of stepped through what the framework does, like what's it's abstracting from you... We talked about pluggable components, but we should probably take a second to talk about what those pieces are, especially for people who might not be familiar with all the pieces that are part of a distributed system.
+
+**Asim Aslam:** Sure, that's a good point. Thanks for raising that. So I'll start with Micro - it's a toolkit that makes it easier to build managed microservices. At the core, there is this library called Go Micro, which is a pluggable RPC framework. The idea is that that core library provides you the fundamentals for building microservices.
+
+So when you think about microservices, it's this service-oriented architecture kind of thing. What do I need there? I need some sort of communication; I need message and coding; communication might actually be synchronous and asynchronous. I need be able to serve requests, I need to be able to make requests.
+
+\[19:50\] Those things are really addressed at the core and nothing else. It only addresses those fundamentals, because the other things that you think about - off monitoring, distribute tracing and things like those - you don't necessarily need those to just build microservices. So that was really the focus of the course, helping you build microservices.
+
+Then the kind of outer layer, the toolkit, as Brian mentioned, is the entry points. There's a CLI, an API, there's a web UI, there's a sidecar that provides an HTTP interface that has all the features of Go Micro, so if you want to write stuff not in Go, like if you wanna write in Python, Ruby, JavaScript whatever, you can just interact with the HTTP interface and kind of use it that way.
+
+It's similar to... Netflix has something called Prana which is their sidecar, Buoyant has something called Linkerd. These are kind of prominent, but the idea is really providing you with the fundamentals for actually writing microservices. I think many people are currently addressing that kind of runtime aspect. They're saying, "Here's how you run microservices. Here's the tools that you need on the infrastructure side." But I think people are still really struggling with "Well, how do I actually write microservices? Where are the tools for those?"
+
+And I think there are very few tools actually around for that.
+
+I know Netflix has a very, very good suite of tools to do it in Java, but we were sort of missing these tools in Go. And credit to Peter Bourgon who a year or more ago started working on Go kit and around the same time I started work on Go Micro as well. So there's some tools now kind of surfacing to help with this, but I think we're really focusing on the development side and other companies are focusing on how do we run them.
+
+**Erik St. Martin:** Okay, so that actually brings up a valid point and we have some people in the Slack channel who were kind of asking the same thing. How would you compare and contrast kind of Micro versus Go kit? Do you see them targeting different groups of people? The same?
+
+**Asim Aslam:** I think the community at large is the same, people who want write stuff with Go. But at the same time it's the thing that you have a preference to the way in which you're going to build applications. Everyone's going to look at libraries and services and things in Go... "Oh, I like this" or "I don't like this."
+
+The days of like "Should I pick MySQL or Postgres?" is the same kind of thing like "Should I pick this library or that one?" And I think Go kit, from what I see in the tagline, is a standard library for microservices or distributed systems. It's addressing quite a lot of various solid things and has huge kind of OSS contributions going on at the moment, so that's really great.
+
+From the Micro side, it's addressing the same kind of things, the fundamentals, but for me, I'm building based on my experiences. I'm building the tools that I didn't really see in the ecosystem, and I like very simple interfaces, I like a low barrier to entry. I don't want to care about the details when I'm actually writing services; I want very little boilerplate. And I need the entire toolkit. I want everything when it comes to writing microservices. I think they kind of differ a little bit and I think everyone has to look at them themselves and kind of see where the benefits are for them, because there are lots of people using Go kit. They really like it. They like those abstractions and that is a really a great thing. I think choice is very, very important.
+
+**Erik St. Martin:** \[23:53\] Yeah, and I think you bring up a valid point, too. Brian and I had kind of a similar situation at a prior employer that both of us worked at, the one we actually met at. So you have a lot of people who are interested in building these distributed frameworks and making the communication happen and making things fault-tolerant and service discovery, and then you have a lot of people who just work on business-related features. So at least from my understanding of the two projects, it seems like yours more targets being able to just write the service and not have to think about all the bits that make the services communicate between each other and allows you to just kind of focus on the business logic.
+
+**Asim Aslam:** You're dead on. When we built the platform at Hailo, the thing that everyone would say and the goal from the entire kind of platform team and those who were building this thing was, we don't want anyone to have to think about distributed systems. We want them to be able to leverage them, but we're building a business, and we need to write services for the business. And we don't really care about that kind of other stuff.
+
+And in the same way here, Micro - that's the goal. I don't want to have to care about all those details. Why should I? Like I just want to write software, I want to build my services. As I'm building this stuff, I'm thinking about, like, maybe even these things, some of these things are too low-level; maybe we need to find a way to go higher up, and I think over time we will.
+
+At the moment it's the thing of when you're writing microservices code, you end up kind of focusing on "Well, I'm going to call this service and I'm going to call this service and I'm going to take this data and I'm going to transform it and return it", and at certain point you think, "Well, what I really care about is like the information. I don't really care where it is, but I need..." It's kind of like, "Hey, give me all the geo-location information for this user. I don't care how many different services it sends, just give it to me", and then I'll gather this and I'll transform it and pass it back to the user.
+
+If you think about what Jeff Dean and Sanjay Ghemawat did with MapReduce at Google in the early days, it's the same thing. It's like reducing the amount of work you have to do to get that data you really care about. So I think that's where we're going.
+
+**Erik St. Martin:** Yeah. So I've looked at the docs a couple of times. Unfortunately, I haven't actually built anything with Micro, but it seemed pretty inclusive. I like the idea that you could change out your messaging brokers, you could change out your service discovery mechanisms and these are all pain points. Many of us who have built distributed systems have suffered through like, "Oh well, I like ZooKeeper for this, but hate it for something else", and you kind of go through these iterations where you switch out, and it's nice to just be able to swap those components out and try different things. Maybe people on your team know how to support, ActiveMQ or something, versus ZeroMQ and things that.
+
+**Asim Aslam:** Yeah. I think that was totally the point. I think the first reason was when we built the stuff at Hailo, we kind of baked everything in because we were on a kind of a deadline. And then when we thought about open sourcing it, we realized that everything is kind of hard coded in a way that it makes it difficult to strip it all out, and doing any kind of local development meant you have to run ten different things and all their dependencies to make it work.
+
+When I started to build this stuff, I knew that I wanted it to be pluggable, I wanted to minimize the number of dependencies that you needed to get started. And on your point, everyone has different skills, everyone likes different tools. I think it's important to be able to support that, while at the same time kind of using the same way of building software.
+
+\[28:00\] And then in the future, in five years from now, when we're using a different kind of backend technologies, then you want to be able to swap those out as well. The worst thing is when you've kind of built all these things and you're dependent upon some service and then you have to go rewrite your code everywhere to make it happen. With Micro, the idea is all you have to do is change the plugin, switch out on the command line and that's it. You're kind of done and you swapped out this entire thing.
+
+I was really thoughtful about it, and hopefully, my hope is that other people kind of respond to this and they write plugins as well. So I hope to see some stuff contributed from the community.
+
+**Brian Ketelsen:** So one of our listeners has a question and it almost relates to that. In terms of your plugins, how many of those can be used as components in other projects that maybe aren't even microservice related? Could you reuse the log package or service discovery or something like that in an unrelated project?
+
+**Asim Aslam:** You could totally do that. They are all kind of independent packages, so each package can kind of be used independently. There's only the thing of kind of at the top level within Go Micro we have this reference to a service that combines everything, but for the most part, if you want to use the individual things, you can. I think that's great benefit there as well.
+
+I've actually seen some people kind of start to use pieces of the Go platform, which is the higher-level tooling. They're using the log package or the matrix package or the key value stuff. It's pretty cool.
+
+**Erik St. Martin:** Right.
+
+**Carlisia Thompson:** Before we move on, I wanted to ask you, Asim, where can people find out more, how to get started, are there tutorials, where can they go to ask questions, do you have channel here on Gopher Slack? In other words, tell us how people can get started and get proficient using Micro?
+
+**Asim Aslam:** Sure, thanks for asking. You can go to the website micro.mu and that'll kind of take you to where you need to go. There's a blog which has the introduction, it has a getting started guide on how to write Go microservices. You can go to the GitHub repository and there's a Wiki and there's documents in every single kind of package that explains how things work, and each of them in the readme have a kind of getting started kind of guide and how to start with that.
+
+We also have a Slack channel dedicated to kind of Micro and microservices and distributed systems in general, so everyone can kind of self-invite and come join that and talk about this stuff. The reason I didn't actually set up one in the Gopher channel was because I knew that longer term, this wasn't going to be solely Go-focused. We're actually on the cusp of kind of having multi-language support. Sixt and some other companies have developed libraries in Java, Scala, someone else is independently working on Rust and I'm hoping for a JavaScript implementation as well. The hope is we open source these and we actually become a multi-language community, and the focus is just on building microservices.
+
+**Erik St. Martin:** That's great.
+
+**Carlisia Thompson:** Thank you.
+
+**Erik St. Martin:** So I think we have probably like 15-20 minutes left. One of the things we like to do with our guests is just kind of have like a fireside chat where we kind of talk about interesting kind of projects and news and other things that you have interest in. I know serverless is a big thing and we kind of touched a little bit on that earlier.
+
+**Brian Ketelsen:** Worst name ever. Ever.
+
+**Carlisia Thompson:** I totally agree.
+
+**Erik St. Martin:** Is it worse than the Cloud?
+
+**Brian Ketelsen:** \[32:00\] Yes, it's far worse than the Cloud. At least with the Cloud you've got some concept that there's something somewhere. Serverless is just... Somebody should be shot for coming up with that, sorry.
+
+**Carlisia Thompson:** Yes, it's completely misleading.
+
+**Asim Aslam:** On the term - yeah, the term sucks a little bit. I think you have to look beyond the name and the hype and actually see what the real value is there, like what they're saying to you. And what they're really saying to you is, "Hey, this is the second coming of Platform as a Service where you don't have to deal with infrastructure, and also things will only run when they need to be run, so the cost is like orders of magnitude less."
+
+**Erik St. Martin:** Is there a shorter name for that?
+
+**Asim Aslam:** Serverless. \[laughter\]
+
+**Erik St. Martin:** So I can totally get behind your description of it, but serverless just sounds so ridiculous.
+
+**Asim Aslam:** No... I guess the problem is you can't pick the naming, right? Once it takes off, it takes off. I mean you remember big data and you remember cloud and you remember DevOps and even microservices... It just happens and then it becomes the word and then there's nothing you can do.
+
+**Carlisia Thompson:** So, Asim, you seem to be very proficient with the concept of serverless. Why don't you tell everybody what it is? Because when we interviewed Travis Reeder, I had to actually go and look it up. I felt that I either wasn't getting it or I didn't see the big deal, because there is a server involved somewhere in the diagram, between the user and you and your codes. So what is it about it, please tell us.
+
+**Asim Aslam:** Sure. So from what I gather, the idea is that it's really about event-driven programming and there is no management of servers or anything at all involved and you don't have to manage anything yourself.
+
+You basically write snippets of code which look like functions, and you set them up and you kind of configure them along with an API gateway, and the API gateway essentially triggers your function - or the colt of the API gateway triggers your function based on something that's happening there, and then your function executes. A container spins up, the request is passed off to your function, it executes. The container goes away and that's really the end of it.
+
+The idea is you personally don't have to run anything. It's an automated system and it kind of switches the programming model a little bit, in the sense that you're focused on event-driven programming more so than anything else. And you can kind of imagine where this would work for analytics and consuming a certain type of data.
+
+But people are also using it for other things. If you have side projects and you're running your Digital Ocean node or something like that and you're spending $20 a month on this, and you're only running a bunch of websites, they were showing kind of the cost breakdown and they're saying that you can reduce the cost, orders of magnitude by using this kind of serverless model.
+
+\[35:33\] Your container or whatever it is, your code is only executed when someone actually calls it. Otherwise there is nothing running in the interim, and that's really the big thing about it. There's nothing running, it only runs when something calls it. I'm not sure if I see it working at scale yet. I mean, within organizations as a full-time thing for the entire code base; I'm yet to see kind of a way of doing that, because I think when you're writing essentially functions for your code, you could end up in a spaghetti mess. I think the frameworks are emerging to kind of make this a little bit simpler, but it looks interesting so far.
+
+**Carlisia Thompson:** So it sounds to me from what you are saying that I should be thinking about the serverless approach as microservices, but instead of a full-blown microservice, an API or an app, I have a function. With microservices, I would think how would I split my application into microservices, so now I have to think about how do I extract portions of my code into functions that I can then run with a serverless approach.
+
+**Asim Aslam:** Yeah. I think the goal is or the thing you should really think about is it's event-driven architectures. I think what they're saying is everything is asynchronous and so you're essentially building pipelines where things are triggered based on events. And the only synchronous action you may have is on the API side when some outside user is actually calling through an API gateway and then the pipeline kind of executes.
+
+Even for me personally, it's a shift in thinking in the way of building systems. I find that a lot of frontend engineers are very perceptive to this just because they come from a JavaScript world where it's event-driven programming. So I think for the rest of us we have a lot to learn, but I think the thing to take away is to kind of look beyond the hype, see that there is some value there.
+
+I want to say that maybe 70% to 80% of frontend projects and data pipelines will be in this kind of model in the next five to six years, just because of the sheer value from it. But it's going to be a little while. Amazon have their own version of this, Google has their own version, IBM has their own version... So we need a way to be able to work across all of these things.
+
+**Erik St. Martin:** So do you see this as kind of a major shift in development, like most development would be done this way? Or do you see this more for almost rapid prototyping, people trying to get things going on from the business perspective, like you need to get this live?
+
+**Asim Aslam:** I think it's hard to say. I think initially it's prototyping. It's the way most new trends come about or new systems appear and it's the thing of like firstly use it for your side projects, and then when you're doing a new project at your company, you kind of use it then and then some other company sees the successes and they decide to build everything using it or they move to it.
+
+So we'll see some cases where people move their entire architectures over to it, and in other cases where it is primarily focused on frontend or the API or data analytics, and we'll have kind of a split off from other kind of ways of developing software. I can't actually say whether it will be the dominant form of how to build software, because I like being able to write a certain amount of code, I like being able to write code a certain way, but I think for a lot of use cases it will be quite useful.
+
+**Carlisia Thompson:** \[40:01\] What do you know of products that are available to drive those serverless application developments for Go developers or developers in general?
+
+**Asim Aslam:** I think the first one that comes to mind is just serverless.com. That serverless project is the one that's been around the longest, it seems. It started out as a project called Jaws and now it's kind of taken off. It has over 8000 stars on GitHub.
+
+The other one is Apex, which seems to be doing really well and has multi-language support, along with Go. Even IBM open sourced their actual serverless project, it's called OpenWhisk, you can find it on GitHub. That will kind of give you a breakdown of how this stuff kind of works and you could even spin it up yourself.
+
+**Carlisia Thompson:** Thank you. That's a great list, it seems.
+
+**Asim Aslam:** There's a lot of people moving on this very fast. There's a lot of big companies moving on it very fast. If you look at it, AWS has Lambda, Google has Functions, IBM has OpenWhisk, so you can see them all very, very quickly getting involved in this, because they see the value in it.
+
+**Erik St. Martin:** I think it's definitely something I want to keep my eye on. I have my reservations about it. I think there's ideas of it that I think are really cool and I think I have some open-ended questions just from kind of experience and how situations are handled in the event like the... You don't get the golden path, everything doesn't work... Like, how do you debug something like that? But people way smarter than me are working on these things, so I'm interested to see how it progresses.
+
+I think we are getting close to time, so one think I do want to touch on before we close out the show is the 1.7 Beta release. I'd like if we just have a couple of minutes to kind of just chat about some of the stuff that came as part of that and encourage people to download the beta and start compiling the code against it and submitting bug reports, especially with the SSA compiler that's now in it.
+
+**Carlisia Thompson:** Let's do it!
+
+**Erik St. Martin:** Alright.
+
+**Brian Ketelsen:** One of the really interesting things I saw in there was the idea of subtests and sub-benchmarks, with the same setup and tear down for those testing packages. That's really nice because having to write that setup and tear down code over and over is annoying and being able to get that broken out is really nice in testing. I like that one.
+
+**Erik St. Martin:** Yeah. I think that's the hierarchical tests and the benchmark, so that way too. I think that's going be really cool. They did some performance improvements, mostly related to the strings and string conversion packages, crypto packages; the SSA I think is where most of it is coming along.
+
+I think they said that most of that stuff should workout, but if you see random errors in your code or things that don't work the way you'd expect them to with the compiler, there actually is a SSA=0 flag that you can pass under the compiler to get the old non-SSA backend and then submit an issue.
+
+**Brian Ketelsen:** I was just going to say we forgot the most important piece of Go 1.7, which is the context package making it into standard live. I don't think there's any bigger news than that.
+
+**Erik St. Martin:** Yes. Are you leveraging that, Asim, inside Micro, the context package?
+
+**Asim Aslam:** \[43:46\] Yeah, I am, actually. I think it's kind of become a staple among building services. At first, I didn't really understand it and then over time it started to make more and more sense. I think it makes a lot of sense that it's not part of the standard library.
+
+**Erik St. Martin:** Yeah. Well, Brian and I are both really excited about seeing that command, we've been using that for a while. And I have to admit, I haven't looked at this too deeply. I actually only saw it in the release notes. It looks like there's HTTP tracing associated with that context now, and I'm kind of interested to see how that works.
+
+**Brian Ketelsen:** So I read up on that this morning. It's kind of interesting, because it allows you to attach functions to events in an HTTP client. So if you were making a client request out to a site, you can have a function get fired when DNS is resolved, for example, and that allows you to do some really nice debugging in terms of where your performance hits are in your HTTP client, or to help you figure out what issues you're running into in production. So it looks to be very useful for debugging and tracking down problems with HTTP connections.
+
+**Erik St. Martin:** So this is more callback style?
+
+**Brian Ketelsen:** Correct. I don't use the callback. We're Go programmers, so it's all events that you can tap into.
+
+**Erik St. Martin:** I think you're tainted from your dislike of Node.
+
+**Brian Ketelsen:** Oh my God, don't get me started. This is a family show, Erik. \[laughter\]
+
+**Erik St. Martin:** Brian got really mad at me one time because - what was it, like a JSON Lint, or something that I had installed as a command line tool, and it came with Node. And he's like, "Are you serious? You're fired. You're fired. You made me put Node.js on my computer?" \[laughter\]
+
+**Asim Aslam:** I tentatively somewhat agree with Brian just a little bit from the use of it, but maybe it's a necessary evil.
+
+**Erik St. Martin:** Yeah, I haven't bought into it from a development perspective. I know people have their reasons for liking it, and I've always tried to be receptive to... You know, everybody uses what they feel comfortable with, so I try not to hate. But it's definitely not a platform or framework that I've used much outside of like it came with something.
+
+So anything else anybody wants to talk about before me close out the show? Because I think we are getting pretty close on time. Also Asim, if there's anything else that you would like to close with about Micro or serverless before we kind of wrap up the show?
+
+**Asim Aslam:** We can drop in some other topics that are on the list. I think the interesting one was CoreOS. It just came out with the distributed storage system which would be kind of cool to talk about quickly.
+
+**Erik St. Martin:** Yeah, Torus, right?
+
+**Brian Ketelsen:** Yeah. I'm super excited about that one.
+
+**Asim Aslam:** Yeah. This is interesting. What do you think Brian?
+
+**Brian Ketelsen:** I'm crazy excited about it. One of the biggest problems I've always had with any of the orchestration platforms - Kubernetes, Mesos, whatever - is storage. What do you do with storage when you've got a relatively small cluster and you don't have some sort of block storage, especially as an enterprise where you might not be running in the cloud, but you still need that distributive storage that each of your pods or each of your containers can get to you, so this I think is going to huge. It's one of the things I'm most excited about just in the last two years in container space. It's going to make a huge difference.
+
+**Asim Aslam:** Yeah. I'm excited to see them actually tackle this. I know it's going to be a hard one to get right, but having seen the work that they've done on Etcd, I believe they'll be able to do it and in time with people who have that kind of experience is going to be really good.
+
+\[47:54\] As someone mentioned, the Hacker News comments weren't very kind. I think we need to be optimist and we need to be supportive. I think this is really good for the entire kind of tech community as a whole. I think everyone's a little bit like "Oh, I wanted to write a distributed storage system. Why do they have to write it?" \[laughter\]
+
+**Erik St. Martin:** Yeah, I mean anytime something new like that comes out people, you know... And CoreOS kind of gets the brunt of it too, because they're trying to innovate and they're trying to do things differently and I think they catch some slack for it too, the whole rocket thing... Many of these things are fantastic and they have some really smart people working for them. It's like every year they are scooping up more people. You're like "Oh, this person is doing something cool" and it's like "Yeah, CoreOS just grabbed him." \[laughter\] But I'm interested to see how it comes along. I think that as people start to play with it, I think that they'll start to see its merits.
+
+**Carlisia Thompson:** I wanted to mention something super quickly. Tom Maiaroto was asking for a review on the Reviews channel on Gopher Slack of this tool, it's a young project called [Discfg](https://github.com/tmaiaroto/discfg) and it's a tool for a distributed serverless configuration tool for using AWS services. I'm not going to go over it, but he has a "Why another one?" section on his readme, which is actually quite so well documented, and you can read there why the reasoning for this tool. And maybe people can help him review it.
+
+**Erik St. Martin:** It's open source. Competition is good. That's why.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Alright. Did anybody else have anything they want to touch on? Any closing notes about Micro, especially? Because that's definitely one of the most exciting things we've talked about here.
+
+**Asim Aslam:** I'll just say, thanks for having me on the show and being able to talk about this. Please do try Micro if you're interested in building microservices. Come join the Slack and kind of talk about it. I'm looking for people to help contribute to the OSS kind of project. If you're interested in building the higher-level tools in the Go platform or if you want to contribute plugins, let me know.
+
+**Erik St. Martin:** And we're happy to have you on the show.
+
+**Asim Aslam:** Thanks.
+
+**Erik St. Martin:** And one of the things we'd like to do too is we like to kind of briefly kind of round table it and go around and thank an open source project we are thankful for, just because I think we all need to do a better job showing support and love to open source projects. And today you get to go show some love to Micro by pull requests, right? \[laughter\]
+
+**Brian Ketelsen:** Right. It's a good way to go. Alright, I'll start off with my \#FreeSoftwareFriday thank you. Mine's actually a bigger than a single open source project... I'd like to thank CoreOS for innovating and creating really unique solutions; CoreOS Linux specifically is probably one of the most amazing Linux distributions I have ever played with, and I truly enjoy using it every time I touch it. Etcd and all of the other projects that they do are fantastic and their business model is really solid in terms of open source. I appreciate the company and the philosophy behind the company in terms of OSS.
+
+**Erik St. Martin:** How about you, Carlisia?
+
+**Carlisia Thompson:** Well, today we talked about stateless computing and my pick is State Management for Go, a tool for Go backend applications. It's a tool by Luis Vinicius, it's called Godux. It's also a young project, but it seems promising. I'll definitely use it if I needed to manage states.
+
+**Erik St. Martin:** That's great. Asim, you can't cheat, you cannot say Micro. You can go with anybody but Micro.
+
+**Asim Aslam:** \[52:02\] It's good, I have one... This is a bit of a throwback, so this thanks to Postfix, the SMTP server.
+
+**Erik St. Martin:** Nice.
+
+**Asim Aslam:** Back in the day when I was a sys admin we used to do bulk emails. We were sending half a million emails an hour and I kind of managed upwards of a hundred instances of Postfix and it made it really easy to kind of configure and manage SMTP.
+
+So I'm really grateful for that piece of software, because it meant I didn't have to use Sendmail and if anyone has used Sendmail, you know how painful that is.
+
+**Erik St. Martin:** Sendmail - never. So for me I haven't really been using anything new that I haven't already mentioned, except VLC, so I'm going to give shout out to VLC, because that is making my life easier. I definitely would not want to write VLC. I don't think I'm quite qualified for that, either.
+
+Alright, so I think we've made it all the way around. I definitely want to congratulate the panel and definitely Asim, for coming on the show and talking to us about Micro and serverless. Time got away really fast. I wish we had more time to talk about this.
+
+We will definitely link to the project and the Slack and anywhere else we can find Micro on the internet for everybody in the show notes. They should be posted on Twitter, if not now in a little bit. They will be on Twitter for the live listeners and in the Slack channel. Come find us on Twitter @GoTimeFM. You can go to gotime.fm to subscribe and I think the first episode is there. We'll have more episodes coming soon. I think that's it. I'm I missing anything, everybody? No?
+
+**Carlisia Thompson:** You've got it.
+
+**Brian Ketelsen:** I think you did well.
+
+**Erik St. Martin:** Alright.
+
+**Asim Aslam:** That was great.
+
+**Erik St. Martin:** Thanks, everybody.
+
+**Brian Ketelsen:** Thanks, everybody.
+
+**Carlisia Thompson:** This was fun, thanks.
+
+**Brian Ketelsen:** Thanks guys.

Beyang Liu on Go at Sourcegraph and Writing Better Code_transcript.txt

@@ -0,0 +1,447 @@
+**Erik St. Martin:** Alright, we are back for another episode of Go Time. This is episode number 12. Here with me today is Brian Ketelsen...
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And I should say I'm Erik St. Martin, I always forget that. Unfortunately Carlisia is not here today with us. She's doing her first week at her new job, but she's here with us in spirit, and I know that she would love being here today, especially because she is a super big fan of our guest today, which is Beyang Liu from Sourcegraph. How are you doing?
+
+**Beyang Liu:** Doing great, great to be here.
+
+**Brian Ketelsen:** We're all big fans of Sourcegraph. You guys are famous for live-tweeting GopherCon.
+
+**Erik St. Martin:** That was so awesome.
+
+**Beyang Liu:** Thanks!
+
+**Erik St. Martin:** Are you guys doing that again this year?
+
+**Beyang Liu:** We gotta figure that out, actually. I'm actually not gonna be able to go to GopherCon unfortunately, and it's usually me that's organizing the live tweeting. But we do have Dmitri Shuralyov and Renfred Harper. You guys probably know Dmitri, because he's pretty prominent in the Go open source community, but they're both going and hopefully they'll organize something.
+
+**Erik St. Martin:** I didn't even realize that he worked for Sourcegraph, that's awesome.
+
+**Beyang Liu:** Yeah, he's been a member of the team for about a year and a half now, he's one of the more senior members, and he's awesome.
+
+**Brian Ketelsen:** We gotta get him on the show, too. Everytime I come up with some absolutely crazy Go project his name is on it. I don't' understand that.
+
+**Beyang Liu:** Yeah, you guys should really have him on the show. He's doing a lot of great stuff in the open source community and he's just a great guy in general.
+
+**Brian Ketelsen:** We'll get him on the schedule, too. But today it's you, so let's talk about all the awesome tools that you guys have dropped in the last couple weeks... Holy cow!
+
+**Erik St. Martin:** Yeah, no kidding.
+
+**Beyang Liu:** Yeah, we've shipped a lot of stuff in the past couple weeks. There's some new editor integrations and native stuff that I'm pretty excited about, that kind of gets the information that Sourcegraph provides just in your editor, and literally one keystroke or zero keystrokes away when you're programming.
+
+**Erik St. Martin:** Yeah, we were talking about that a couple episodes ago.
+
+**Beyang Liu:** I guess I should start by giving an intro... I assume most of your listeners probably won't have heard of Sourcegraph, so I should probably say a little bit about what we do, right?
+
+**Erik St. Martin:** Yeah, definitely.
+
+**Beyang Liu:** Sourcegraph's essentially a programming assistant that's built on top of the global graph of code. What I mean by that is the assistant part helps you answer a bunch of questions that pop up every single day, every single hour when you're coding. Things like, "How do I use this particular function? Who else uses it? Who should I bug if I have a more in-depth question that I need to ask?" and it does all that by building on top of this graph of code. Every single piece of code, every single definition, package type, whatever is a node in that graph, and the edges are essentially function calls or package imports. That's something that we do differently than a lot of other tools out there that essentially treat code as a blob of text. We actually understand, "This is a thing that calls a function over here", and because of that we're able to give you very high quality usage examples, jump to definition in the web browser, and really good code search.
+
+\[03:57\] So it's basically this all-in reference guide that lets you answer all these questions that arise over the course of the day. It helps you get the answer within seconds as opposed to minutes, and with a lot less mental energy than something like grep, or just googling for the answer. So that's kind of the sales pitch there.
+
+**Brian Ketelsen:** It's a pretty good sales pitch.
+
+**Erik St. Martin:** Yeah, a couple of big ones... The ones that we noticed - and see, Carlisia's like the encyclopedia here, because I will say we talked about it a couple episodes ago and she will tell me specifically which episode it was we discussed it... But we were talking about the new editor plugins and how awesome that was that as you're starting to type a function, you can actually see examples from real world projects on the usage. That's so fantastic. Does the GitHub plugin, or the browser plugin that works on top of GitHub - does that also show that? I remember showing documentation in references to other code, but does it show stuff in-line as well?
+
+**Beyang Liu:** It doesn't show anything in-line. With the Chrome extension it's a little bit more limiting, because we essentially had to build on top of a pre-existing UI, and that's a little bit tougher than building our own application. So we do our best to show all the information we can there, but it's still not as good of an experience as in the editor, and on Sourcegraph.com, unfortunately.
+
+**Erik St. Martin:** The other thing I noticed you guys did was you released SourceLib, which is the library behind doing the code parsing.
+
+**Beyang Liu:** Yeah, so basically in order to extract the information that we used to display great code search results and usage snippets to the user, we needed to actually parse the code and extract the simple table and do other sorts of static analysis. We do that across a couple of different languages now. We started with Go, but we now support Java and soon Python and JavaScript. So in order to do that in a language-independent fashion, we built this library called SourceLib that kind of shells out to language-specific analyzers, and then transforms the data they admit into a language-agnostic format that then is consumed by the application. So the application doesn't have to worry about the specifics of a particular language, it just has to deal with that one data format.
+
+**Erik St. Martin:** Have you seen anybody using that for any interesting projects? Everytime I see that I'm like, "I wanna build something with that", but I haven't come up with a fun use case. But I say the same about all static code analysis. I'm like, "I feel like I could do something useful here", I just don't know what that is.
+
+**Beyang Liu:** Yeah, actually the impetus for our editor plugins and integrations came from the community, from people building on top of that and saying, "Hey, this information is useful. I just wanna jam it in my editor, which is where I spend a lot of my time." So we kind of looked at that and said, "Hey, we can help out with that" and in addition build in kind of like full-on support for that experience. So it's not just this hacky thing, it's actually like a first-class citizen in the experience that people get from Sourcegraph.
+
+**Brian Ketelsen:** I played with the Vim extension - actually in NeoVim, I don't know if it makes a difference, but I played in the Vim extension, I guess it was last week or the week before, and I was blown away. I cannot believe how freakin' cool that was.
+
+**Beyang Liu:** Awesome, thank you.
+
+**Brian Ketelsen:** Yeah, I turned it off, because it was just a little bit slow, sorry... But I think all of that is just internet latency, but it was really impressive.
+
+**Beyang Liu:** Yeah. I mean, performance is a big thing that we're hammering on right now, and we're actually gonna ship a native desktop client soon. That should hopefully help with the latency things, so... Kind of a sneak peek at that.
+
+**Erik St. Martin:** \[07:57\] Yeah, that's gotta be hard too, like Brian said, with the network latency. It's much easier to do that stuff when all the code exists locally, than it is to do it remotely.
+
+**Beyang Liu:** Yeah, and what we'd like to do in the future is really connect the code that's on your local machine to this global graph that exists out there in the ether, the cloud, because that's really where a lot of the magic can happen. You have access to this dictionary and index over all the possible open source code that you can use in the world, and at the same time you're changing just like a tiny bit of that graph locally, in the stuff that you're doing in your individual editor. And it would be awesome just to understand in real-time how the semantics of the code are changing. You change a function here, and that's gonna change how many callers of this particular open source function there are, or that's gonna have an impact on someone else on your team who is changing the same code, a related piece of code, and a big push for us in the future is just bringing more of that experience natively, so that we can have access to the graph, the bits and pieces of the graph that are changing in real-time as you're kind of typing in your editor.
+
+**Brian Ketelsen:** That's kind of crazy. Can you give us an idea of what the request flow looks like when I'm typing in Vim? What's happening behind the scenes?
+
+**Beyang Liu:** The architecture... We try to do things in ways that are as scalable as possible, in the sense that we wanna support a bunch of different editor plugins without a lot of deep custom work for each editor. So what each plugin does is essentially there's kind of like an API that Sourcegraph exposes specifically for the editor plugins.
+
+For example, one of the things that the plugins do is anytime your cursor is hovering over a token in the code - let's say it's a function name - what it will do is pull up documentation and user examples for that function in Sourcegraph in your web browser. And what it does there is essentially in the editor it extracts the token name, as well as some contextual information from the editor and then makes an API call to Sourcegraph.com saying, "Show me the documentation for this particular token" and "Here's some more contextual information, like the repository URL and other language-specific stuff." That just hits the API. Sourcegraph then goes and finds that definition in the global graph index, populates it with documentation and looks up some usage snippets and then sends that back over the wire, and that's it, basically.
+
+**Brian Ketelsen:** So the whole process is wickedly fast when you describe it that way. What kind of data storage are you using on the backend? I like the hardware stuff. What databases, what indexes are you using?
+
+**Beyang Liu:** We kind of have a custom graph storage system that's built on top of Postgres and Google Object Store right now. So it basically uses Google Object Store for all the detailed meta data. Once you know you're looking for data for a specific definition, specific function or package, then you look up the detailed meta data in the object store, and then we use Postgres for some of the more... Things like search queries and listing definition subject to a particular set of search criteria. That's actually gotten us surprisingly far. I think most people when they think of writing something like a search engine over all the code in the world, Postgres is probably not the first thing that comes to mind. But we've been impressed so far with how good full tech search support in Postgres actually is, and it scales pretty well, too.
+
+**Erik St. Martin:** \[12:16\] Did you have to build a spider to index all that data?
+
+**Beyang Liu:** Yeah, so the way our crawler works is anytime it indexes a library, it looks at the dependencies, because we actually extract the dependencies of that particular library, and then it just goes and indexes the dependencies. So it just kind of crawls the graph of code, the dependency graph.
+
+**Erik St. Martin:** Have you guys been doing anything with the new BigQuery dataset that went out?
+
+**Beyang Liu:** That's been really interesting. I personally haven't played around with it yet. It's actually interesting, because that is kind of like a text-based approach to searching over code, and a lot of the answers you can get from that setup, you can actually kind of get from Sourcegraph already. So if you're looking for all the callers of a particular function, in BigQuery you probably write a regular expression that runs over the entire set of code that GitHub has put up, and it might be a little bit noisy because regular expressions aren't perfect at parsing code. But with Sourcegraph you just go to a definition and every single usage snippet there is kind of 100% accurate because it operates at the parser level.
+
+**Erik St. Martin:** Right, because the BigQuery stuff, a lot of people were writing regular expressions, where you've kind of tokenized the stuff as you were crawling it, so it's much easier for you to look for specific things. "I want a function named this", rather than having to write a regular expression to match a function definition.
+
+**Beyang Liu:** Yeah. I will say that stuff is really cool, though. One of the things that people don't realize enough, I think, is code is just another form of data. It's not just this... People often tend to think of code as a form of text that you write in an editor, or a doc, or something like that, but it's really very highly structured data, and when you think about a lot of the stuff that we do as programmers/software engineers, it's really exploring this dataset and making changes to this dataset. So I think what that data dump did, along with the BigQuery queries that went along with it is it showed the power that you can tap into once you start to treat code as more of a dataset.
+
+In the future, you can imagine more senior members of the team, who care about overall code quality and maintainability of the codebase, and they worry about things that more junior engineers might be doing to shoot themselves in the foot, they can actually issue queries against a dataset - the global graph of code or the graph of code inside your company - to look for patterns and anti-patterns like that, and make sweeping changes... As opposed to the old way of doing things - or the current way of doing things - which is single person, single editor, single machine, making changes one at the time.
+
+**Brian Ketelsen:** Interesting.
+
+**Erik St. Martin:** So is that kind of what's next for Sourcegraph, building some team tools for looking for things like that?
+
+**Beyang Liu:** Yes. You know, the individual use case stuff, the search and the snippets is really valuable for every programmer in terms of the day-to-day stuff that you do, but I think that the real value is just gonna be in the way that we can change how teams work together to build software. So it's things like issuing queries like that to discover anti-patterns in the code... It's also more explicit forms of collaboration, where if you have a question about the code right now, more likely than not you either go and ask the person in person, or maybe you drop them a message in chat. \[16:20\] In both cases, the answer to that question that you asked is lost to time, almost as soon as it's answered. That kind of sucks, because if you have that question, chances are someone else on your team is probably gonna have that same question or a very similar question later on, and wouldn't it be nice if the tool that you use could actually attach discussion messages to specific pieces of code, and those stay with that particular function or package as the lines of code change over time.
+
+We think a lot about the impact that we're gonna have on team productivity, because I think that software engineering is still in the early days in terms of software engineering methodology and best practices.
+
+It's astounding to me that in 2016 a software project like healthcare.gov is not a trivial thing to do. You can't just take a team of 4-5 programmers and implement that. And I think a lot of what we wanna do is address the pains that software teams have that prevent them from executing on projects like that.
+
+**Erik St. Martin:** That's interesting. So on top of this stuff that you have globally, you guys offer on-premise installs of Sourcegraph too, right?
+
+**Beyang Liu:** Yeah. We're kind of limited in who we go on-prem with right now, just because we're still a small team and on-prem is a bit of a larger commitment. Our main on-prem customer right now is Twitter, and we're kind of holding off on on-prem for smaller customers at the moment, but we do offer an on-prem solution.
+
+**Erik St. Martin:** Yeah, I mean all of that comes with support and keeping people up to date, and all that jazz. So talk to us a little bit about your usage of Go at Sourcegraph. Is most of this stuff primarily written in Go?
+
+**Beyang Liu:** Yeah, most of the application stack is written in Go. Basically, everything except the frontend, which of course is JavaScript, and the language analysis stuff, which is more polyglot. But everything else is basically written in Go. Go has been amazing for two reasons. One, it's just a really solid tool to build on top of the... It's a very no-nonsense language, there are very few surprises that you encounter when building a web application with it. The tooling around it is great, and that kind of leads into the second reason why Go has been great. It's kind of been an inspiration actually for a lot of the concepts that we wanna promote with Sourcegraph.
+
+I think the tooling around Go is so solid that it really lets you think of code more as this form of data that you can modify with other tools, not just by handcrafting it, hand typing it in. Things like go generate, for instance... All the metaprogramming that is enabled in Go would be much tougher in other languages without as strong tooling, and that just leads to incredible productivity gains, when you're able to just generate a bunch of code that does what you wanna do, as opposed to having a human just type all that stuff out.
+
+**Brian Ketelsen:** Oh, absolutely. I couldn't agree with that more.
+
+**Erik St. Martin:** Just make Brian type it all out. He's got this.
+
+**Brian Ketelsen:** \[20:04\] No, I'm the king of code generation. If you can generate it, I'm your guy.
+
+**Beyang Liu:** Yeah, it's great. And then there's also... Alan Donovan has done such great work with Go oracle. I think the talk that I was most looking forward that I'm sad I'm missing at GopherCon is the talk he's gonna give on the Go Guru, which is kind of like an extension of the Go oracle that he's designed for editor integrations and things like that.
+
+**Brian Ketelsen:** Did you know that we're live streaming GopherCon this year?
+
+**Beyang Liu:** I did not.
+
+**Erik St. Martin:** Well, part of it, the morning.
+
+**Beyang Liu:** I will probably tune in.
+
+**Brian Ketelsen:** Yeah, we're live streaming the morning shows at twitch.tv/gophercon.
+
+**Beyang Liu:** Nice.
+
+**Brian Ketelsen:** So if you just tune in to twitch.tv/gophercon, if I can make the whole streaming thing work... I mean, I'm an old guy, I don't know. This whole Twitch thing is for the young kids. But if we can make the streaming work then you'll be able to catch that talk at 9:35 AM on the 11th.
+
+**Beyang Liu:** That's awesome. I have to say, the two GopherCons that I've gone to have been just top notch. Thanks for all the work that you guys put in to make that happen.
+
+**Erik St. Martin:** Thank you.
+
+**Brian Ketelsen:** Thank you, it's our love, the community.
+
+**Erik St. Martin:** It's fun and it's stressful, but I think the kind of reward from it is better than the stress we get from it. But yeah, we're a few days off from it. Actually, Brian hops on a plane tomorrow morning...
+
+**Brian Ketelsen:** I am.
+
+**Erik St. Martin:** And then I follow him the next morning. So it's coming up.
+
+**Beyang Liu:** How has it been to watch that thing grow along with the Go community over the years?
+
+**Erik St. Martin:** I think it was mostly mind-blowing.
+
+**Brian Ketelsen:** Do you want the truth? \[laughter\] The first year was the craziest obviously, because we didn't know what we were doing, and we learned a lot the first year. Last year we had some ideas, but we grew into the Convention Center, which changed the rules for everything. That made it a much, much bigger concept.
+
+This year, it's our second year at the Convention Center, so we have a better idea of what we're doing, but the Go landscape is changing a little bit. We have a different set of sponsors this year, or a portion of them... We always have some of the same people come back over and over and we truly appreciate that, but we do have a different group of sponsors this year. As Go matures, the target of our sponsorship will change, too. That has been different for us.
+
+**Erik St. Martin:** Yeah, I mean we're still learning each year, too... How technical the talks should be, whether we should do multi track or single track... We're still kind of experimenting a little bit to figure out what the exact format is, but people still keep coming, so we're doing something right, I guess.
+
+**Beyang Liu:** Yeah, that's interesting. Any broader trends you've noticed in the Go landscape? Like who is using Go, who is coming to the conference?
+
+**Erik St. Martin:** I think Brian and I - we continue to come back to this whole... Most of the new distributed systems tools are all being written in Go, we just continuously see that. Every new distributed systems tool that comes out is written in Go, and I don't know whether it's because Go is the best language for that or whether people who use Go also love distributed systems. I'm not really sure, but I'm happy that it works, though.
+
+**Beyang Liu:** Yeah, that's really interesting.
+
+**Brian Ketelsen:** I think the thing that's surprised me most this year is the fact that we're seeing registrations from really off-the-wall places. There was an auto parts store that registered a couple employees two or three weeks ago.
+
+**Beyang Liu:** Really? That's crazy.
+
+**Brian Ketelsen:** It is. And when that email hit my inbox, I thought, "That's a big adoption point for Go." It's not a tech company, it's not some VC-funded startup somewhere, they're not cutting edge, whatever, it's just an auto parts company. To me that felt like an inflection point for Go.
+
+**Beyang Liu:** \[24:02\] I think that speaks to one of the broader trends, not just in Go but in the software world in general, which is more and more you're seeing companies that you don't think of as traditional tech companies becoming highly depending on the software they're able to build.
+
+Have you guys seen the new GE ad campaign, where the tagline essentially is "GE is a digital company that happens to do infrastructure", and the whole point of it is to appeal more to software engineers and convince people that GE is kind of a software-first organization.
+
+**Erik St. Martin:** It's almost impossible to have any business without software anymore. We depend on it so much for just about everything.
+
+**Beyang Liu:** Yeah, totally. Business logic has been a term that has existed for a long time now, and often been misused, but now it's like more and more the logic of your business is in the business logic of your code.
+
+**Erik St. Martin:** And it's safer there, too. \[laughter\]
+
+**Brian Ketelsen:** It depends on who's writing it. You see, there's a big competitive advantage for some companies if they have software systems that allow them to provide whatever their goods or services are faster. I think of Walmart as the shining example of a company that uses really cutting edge software to cut their margins down drastically. They've got all this just-in-time inventory; they see a weather forecast coming in for a hurricane and they start shipping water bottles to Florida before the hurricane even hits, because they've got these really strong IT systems. I think that's a good example of how software is changing all business, not just traditionally technical companies.
+
+**Beyang Liu:** Yeah, and as that shift is happening, I think Go is pretty good because the tooling is so good around it, but in a lot of other language ecosystems I really think that the tooling is kind of lagging behind all the places where software is becoming critical. Take a look at a typical, large, non-technology company that tries to do software, more often than not those projects are over budget, overtime, they under-deliver on features.
+
+Something that we think about a lot is how can we build the tooling ecosystem and the programming assistant or individuals and teams that enable organizations that are not necessarily steeped in software development methodology, so they need better tools to efficiently build things and deliver things on time. I think that's gonna be a big question the industry has to address in the next couple years, otherwise we're gonna see more things like healthcare.gov and things of that nature.
+
+**Brian Ketelsen:** Well, that's actually a really good transition into our discussion about our sponsors; speaking of people who build great tools to help you ship your software.
+
+Equinox, one of my favorite tooling companies, Equinox.io, helps you package and distribute your Go applications. You can package and release CLI and on-premise software using Equinox, and I think my favorite part about using Equinox is the native packages and installers for Mac, Windows and Linux. So you get the msi, you get the pkg file, you get Debian files, rpms, yums, all of that good stuff. It's really easy to create an application and then let Equinox ship it to your customers in a self-updating format.
+
+We use Equinox at Backplane, and I think Beyang you mentioned that you had used it before, hadn't you?
+
+**Beyang Liu:** \[28:03\] Yeah, we've used it for on-prem stuff at Sourcegraph, and I just have to say it's so easy... If it's your job to manage on-prem or native installers for a Go-based application, and you're just worried about the headache that that entails, then you should definitely check out Equinox. It makes your life so much easier. It pretty much works out of the box, and it's just really great.
+
+I'd also like to give a shout out to Equinox's creator, Alan Shreve. He's just a great guy. He's prominent in the Go open source community and he has just done so much great open source stuff.
+
+**Brian Ketelsen:** That's awesome. We probably talk about ngrok at least once an episode.
+
+**Erik St. Martin:** Yeah, that's exactly what I was gonna point out. If you haven't heard of Equinox, you certainly have heard of ngrok.
+
+**Beyang Liu:** He also gave a talk at this year's dotGo. Basically he wrote a program that makes it much easier to read through functions in Go code. Basically what it does is it strips out all the boilerplate. So when you're reading through a function, trying to understand how it works, you really wanna concentrate on what is it doing. You don't wanna think about logging statements or error handing or anything like that. He wrote a tool that kind of strips out all that other cruft and just shows you the part of the code that is probably what you wanna see when you're reading through something. So if you haven't checked out that talk, I would highly recommend that.
+
+**Erik St. Martin:** That's interesting.
+
+**Brian Ketelsen:** That is slick.
+
+**Erik St. Martin:** What's the project called?
+
+**Beyang Liu:** I don't know what the name of the project is, but I think it was at dotGo. If you just search 'dotGo alan shreve' I think the talk will come up.
+
+**Brian Ketelsen:** That's awesome. Well, you can support Alan and his company Equinox by going to Equinox.io/gotime. Equinox is free for community and personal projects, and very inexpensive for companies to release their tool, so go check it out. We love them.
+
+**Erik St. Martin:** I'm sure he'd be perfectly happy with bags of money too. \[laughter\]
+
+**Brian Ketelsen:** Well, I have to pay for my ngrok subscription, because I love it so damn much. I use it every single day.
+
+**Erik St. Martin:** Yeah, I'm constantly using ngrok.
+
+**Brian Ketelsen:** So Alan's getting two sponsorships for the price of one today. \[laughter\] The double-double.
+
+**Beyang Liu:** I'm curious to hear, in addition to things like ngrok and Equinox, what other tools do you guys rely on day to day, that you find really useful.
+
+**Erik St. Martin:** Well, that's interesting. I mean, so many of them are probably abstracted away from me now with Vim Go, I don't run them myself. But a lot of the stuff that comes in gometalinter I use quite a bit, which I almost feel like I should turn off for a little bit, so that I visually catch these things now, and I don't just sit here and write code. I'm like, "Yeah, it will catch it."
+
+**Brian Ketelsen:** My answer would be the same as Erik's, just because I use Vim Go and I have absolutely no idea about the seventeen binaries that are running in the background, managing my code for me. I love them all though, thank you.
+
+**Beyang Liu:** Nice. That's awesome.
+
+**Erik St. Martin:** At prior places we used some stuff like ffjson and SQL C. I'm trying to think about some of the other tools we used for some of that code generation.
+
+**Beyang Liu:** Yeah, what parts of code do you guys auto-generate in your code base?
+
+**Brian Ketelsen:** Generate all the things... All the things. \[laughter\]
+
+**Erik St. Martin:** Yeah, so Brian's mostly been on a Goa kick lately, so generating all the API stuff from kind of a specification of the API.
+
+**Beyang Liu:** Oh, nice.
+
+**Brian Ketelsen:** \[32:01\] Yeah, I'm giving a talk at Abstractions.io - I'm in Pittsburgh whenever that is, August something - about generating all the things. I'm really excited about that. Because one of the fun things about Goa is that it's got this DSL engine in it that means that you can create your own DSL to parse whatever you want to parse, and then tick the meta data out of that and generate whatever you want to generate. So it's not just generating APIs. If you spend a few hours writing some code, you can generate Kubernetes configurations or Docker files, or whatever it is that you need to generate. That's kind of been my burning mission for 2016, to really just generate everything and have that DSL be the single source of truth for me.
+
+I really like that a lot, because you're generating the code and it becomes very easy to make changes to your system, and the DSL is very self-documenting, so you understand what you're doing and why.
+
+**Beyang Liu:** Yeah, that's awesome.
+
+**Erik St. Martin:** I've seen some polls going out about dependency management tools and stuff like that that are favored. I'd be really interested to see what tools people use regularly for Go development. I'm willing to bet there are probably a lot of popular tools in there that I don't use and I should.
+
+**Brian Ketelsen:** I'm sure there are.
+
+**Beyang Liu:** Yeah, that's the thing. I feel like every other week there's some new tool that someone mentions and I'm like, "Oh wait, that would be really useful. Why am I not using that yet?"
+
+**Erik St. Martin:** Florin in the GoTime channel just said 'Delve'. How did we forget about Delve?
+
+**Brian Ketelsen:** Yeah, how could we possibly forget about the best debugger ever? Although I don't ever debug, so maybe that's why I forgot about it, because I don't ever debug. My code just works. \[laughter\]
+
+**Beyang Liu:** Are you a printf man?
+
+**Brian Ketelsen:** I think I used Delve about twice, and I found it to be impressive.
+
+**Erik St. Martin:** Yeah, I'm not always a debugger person. It depends on how intricate the issue is that I'm trying to diagnose and how much I need to pay attention to the overall state of the application, stuff like that, versus whether this particular block of code is getting hit and what values within that scope are. So I guess a lot of times I'm probably a print person, but occasionally I do need to break out a debugger. How about you at Sourcegraph, what are you guys using over there that we might be interested in stealing from you?
+
+**Beyang Liu:** Well, the thing I use the most is probably Sourcegraph itself, just for exploring code and finding user examples. Other than that, before I used the Go Emacs plugin, because I use Emacs as my editor. I've since switched to the Emacs Editor plugin that we shipped recently.
+
+**Erik St. Martin:** You know, Brian and I are gonna try not to hold that against you.
+
+**Beyang Liu:** Yeah. For like the day-to-day "I'm programming, I need to look up information", I mostly rely on Sourcegraph for that these days. For the metaprogramming stuff, we generate a lot of things. We wrote this tool called gen-mocks that automatically creates mock structs for testing purposes. So you have a struct that represents some sort of service that you wanna call, gen-mocks will generate a mock for that that lets you easily mock every endpoint of that service.
+
+We use gRPC gateway to generate the API to the application that the UI and the editor plugins hit.
+
+**Erik St. Martin:** Yeah, gRPC is another one I've used heavily. Gen-mocks looks interesting.
+
+**Brian Ketelsen:** \[36:03\] I haven't seen that one.
+
+**Beyang Liu:** What looks interesting?
+
+**Erik St. Martin:** The gen-mocks that you were talking about.
+
+**Beyang Liu:** Oh yeah, gen-mocks. It's a pretty small tool, pretty straightforward, check it out.
+
+**Erik St. Martin:** It looks like it just kind of takes an interface and kind of generates mock structs for you, that implement that interface
+
+**Beyang Liu:** Yeah. I wish Dmitri were here actually, because he could speak to a lot of the tools that we use and all the stuff we do to maintain good quality code as the application progresses.
+
+**Erik St. Martin:** Can we get like the "Who wants to be a millionaire" phone friend? \[laughter\] Can we get that going?
+
+**Brian Ketelsen:** We'll just have a show just for Dmitri. That would definitely be another interesting show.
+
+**Beyang Liu:** Yeah.
+
+**Brian Ketelsen:** We can talk about his gist code imports.
+
+**Beyang Liu:** \[laughs\] Yeah.
+
+**Erik St. Martin:** I forgot about that. So I guess we're probably getting shorter on time here. Do you guys wanna talk about any interesting news and projects?
+
+**Brian Ketelsen:** I have a couple interesting things to talk about.
+
+**Erik St. Martin:** I know which one you're gonna say.
+
+**Brian Ketelsen:** Which one am I gonna say? Just tell me which one am I gonna say first.
+
+**Erik St. Martin:** Twitch. It's gonna be Twitch.
+
+**Brian Ketelsen:** Yeah, that blog post that Twitch put out a couple days ago - we'll put a link up on Twitter and in the show notes - about the garbage collector latency; that was just an amazing blog post. I love that. Really good post. I read it twice.
+
+**Erik St. Martin:** And I think this speaks to Beyang's point, the tooling and just the way the community interacts, too. I love watching the journey here of kind of how they work together on continuously improving this. Did you see that post?
+
+**Beyang Liu:** No, I haven't seen it yet. I'm definitely gonna check it out, though.
+
+**Erik St. Martin:** Yeah, so it's basically Twitch walking through starting their release with 1.2 of Go, and their chat server implementation and the GC pauses, and the evolution of discovering what those latencies are and working with patches on their side and working in parallel with the Go Team and getting some of that stuff implemented and changed in the garbage collector.
+
+It was insane. It went, in total, from like 10 milliseconds...
+
+**Brian Ketelsen:** It was tenths of seconds down to one millisecond.
+
+**Erik St. Martin:** Yeah, it was insane.
+
+**Brian Ketelsen:** It was crazy in garbage collection pause times, and it's just an awesome story for Twitch and their engineering team, and a great story for Go too, to show just how much Go has improved over the years, too.
+
+**Erik St. Martin:** Yeah, maybe the Go Team doesn't get as much love as they should for some of these things that happen behind the scenes, that most of us aren't even aware of. We see the end result, like "Oh yeah, garbage collection times went down", but we don't see the insane pain that some companies suffered, and engineers from their teams and Go kind of working together to collaborate and make it better for the rest of us.
+
+**Beyang Liu:** I'm really looking forward to the Go Guru talk at GopherCon. I hope that it's like a follow-up blog post, and I'm looking forward to using it, too. That looks awesome. I think the Go Team again there is doing great work, pushing forward not just the state of Go tooling, but also... Like, what other language has just a tool that works out of the box and provides as much information about the code as the Go oracle does?
+
+**Brian Ketelsen:** I agree. It's almost like they have parallel paths of performance and tooling. They're marching down two different directions of making Go as fast as it can possibly be, but then creating this amazing ecosystem of tools that really make our lives as developers better. We heart the Go Team.
+
+**Erik St. Martin:** \[40:06\] There's some really interesting talks this year that I really wanna see, some deep dives. One of the ones that I find most interesting is the packet injection one. I think that one's gonna be a lot of fun, because it's totally different. They're doing packet capture and analysis with Go.
+
+**Brian Ketelsen:** But you know, we're live streaming, Erik. You can watch it at home, if you go to Twitch.tv/Gophercon \[laughter\]
+
+**Erik St. Martin:** I can watch it at home...? Can I hide at my hotel room to watch it?
+
+**Brian Ketelsen:** Awesome. "Anybody seen Erik?" "Nope." \[laughter\]
+
+**Erik St. Martin:** So the sad thing is we always have to wait until the videos come out. We don't really get to see the talks until afterwards, but we get something completely different out of it, so it's a lot of fun. What else do we have going on? I know there's been a couple of releases... Kubernetes 1.3 came out, which is awesome.
+
+**Brian Ketelsen:** Yeah, big release.
+
+**Erik St. Martin:** ...which kind of had some of the Ubernetes stuff in it, which is the kind of the cluster federation. They bumped up the max size too, it's like two thousand node clusters and fifty or sixty thousand containers.
+
+**Brian Ketelsen:** Yeah, I saw a tweet a couple hours ago about sixty thousand pods. I don't know if that's correct, but it certainly seems like the addition of etcd 3.0 allowed them to scale quite a bit. I know that the etcd release was big, yeah many [`minikube`](https://minikube.sigs.k8s.io/docs) is really awesome.
+
+**Erik St. Martin:** I think that they're mostly compatible now with the OCI and CNI stuff, or rocket. I haven't checked out the new dashboard, but I'm looking forward to that, too. But yeah, it seems like some cool stuff there. There was another project that hit 1.0.2...
+
+**Brian Ketelsen:** Traefik. Traefik.io the load balancer.
+
+**Erik St. Martin:** Yes!
+
+2. That looks like a big release for them. And then Glide was released at 0.11 this week. It looked like they had a lot of very nice features added there. But I think mostly it was a pretty quiet week. I think everybody's holding all of their big releases for GopherCon next week, and I don't blame them, because it is the big event in the Go community, so we expect all the big news to come next week.
+
+**Erik St. Martin:** I think mostly the past week has been all the BigQuery stuff, which I'm sure... You've been reading most of the posts with that, right Beyang?
+
+**Beyang Liu:** Yeah, I've been following along.
+
+**Erik St. Martin:** Yeah, so that's mainly the big thing. And you are ahead of the curve, because you guys have been doing code analysis on all the Go projects on GitHub for quite some time now.
+
+**Beyang Liu:** Yeah.
+
+**Erik St. Martin:** Do you guys do any metrics now? Are you building any statistics internally about commonly used packages and things like that?
+
+**Beyang Liu:** Yeah, we have a lot of those statistics internally. We're still working on the product version of that. What sort of statistics would you guys like to see on Go projects?
+
+**Erik St. Martin:** I think that should be fun, I think we should make a call out for people, too. Let's create a list of stats people would be interested in.
+
+**Beyang Liu:** The things that we're thinking about are... Some basic statistics you can already get from the site are how many times is this function called in the Go universe? How many other repositories reference it? How many times do they call it for each repository? Who are the authors that use this function in some way or another? There's a lot more statistics we could actually show the user, it's just a question of what's the most important thing... What are the most important pieces of information to show a user when they're trying to navigate a library or figure out how to use something, or determine whether this library is the best one to use for the job at hand.
+
+**Brian Ketelsen:** I would love to see how many external dependencies there are. Does this library have 47 other dependencies?
+
+**Beyang Liu:** Like how many things depend on it, or how many things it depends on?
+
+**Brian Ketelsen:** \[44:03\] How many things it depends on. Is there a left pad coming up in my future?
+
+**Beyang Liu:** \[laughs\] Yeah, totally.
+
+**Erik St. Martin:** I guess I would be really interested to see the effects of importing a project. If I'm gonna import this package for something I need it for, how many packages and maybe how many lines of code in general am I importing just to get whatever that function is that I want, and maybe I use that as the determination of whether or not I should just make a copy of this one function or whether I should import the project itself. I think stuff like that might be valuable. And we should put a call out though too, to anybody who has interesting ideas. Should they shout at you at your Twitter account, should they email you? File tickets?
+
+**Beyang Liu:** You can either tweet at Sourcegraph, @srcgraph, or just email hi@sourcegraph.com
+
+**Brian Ketelsen:** Nice.
+
+**Erik St. Martin:** I always like those hi@ email addresses.
+
+**Brian Ketelsen:** They're very friendly.
+
+**Erik St. Martin:** We need a hi@gophercon or a hi@gopheracademy. Well, I guess we can't say hi at Gophercon, because now it has a different meaning, with all the new rules...
+
+**Brian Ketelsen:** Especially in Colorado, yeah. Very different.
+
+**Erik St. Martin:** It might be taken incorrectly. So what else do we have going on?
+
+**Brian Ketelsen:** Well, I think it's time for \#FreeSoftwareFriday.
+
+**Erik St. Martin:** Oh yeah, how can we forget our \#FreeSoftwareFriday?
+
+**Brian Ketelsen:** We can't, it's in my blood.
+
+**Erik St. Martin:** Do you know about \#FreeSoftwareFriday, Beyang?
+
+**Beyang Liu:** No, enlighten me.
+
+**Erik St. Martin:** So Brian started a couple months ago now this whole thing to do hashtags on Twitter for a \#FreeSoftwareFriday, so basically show love to open source projects or maintainers that are making our lives easier. Because I think we often forget to say anything to project maintainers until we're unhappy, so as part of the show we've tried to incorporate that so that we're encouraging other people to do so. So before we kind of finish out the show, we like to go around the panel and thank some project that is in some way making our lives easier, or has made our lives easier.
+
+**Beyang Liu:** Cool.
+
+**Erik St. Martin:** So you can feel free to do one yourself, or not, because we're kind of blindsiding you with it. Brian and I both have one for today.
+
+**Brian Ketelsen:** Yeah, I'll kick it off with GoKit. You know, we've got this API training class on Sunday before GopherCon, and one of the last topics we hit is code generation, and I remembered as I was writing the slides for it that I wrote a code generator for GoKit last year... Probably this time last summer, a year ago. So I've dusted it off, cloned it from GitHub, pulled it down locally and I ran it. It generates a GoKit service based on using JSON in coding for a GoKit API service. I was blown away, because the code generator that I haven't touched in a year was generating code that compiled against today's GoKit, and that's API stability that you cannot buy anywhere else. I was really, really impressed. How many other projects have you seen where you can not touch something for a year and it compiles against the current version of that project. I was impressed, so shout out to GoKit and their team, and Peter, for API stability. Rock and roll!
+
+**Erik St. Martin:** That's awesome. For me this week... I was struggling to think of something big, and it's always the little tools we miss, so I'm going back to the basics here. The Silver Searcher - I've been using this for a few years now, instead of ack and grep when I'm just trying to search around directories. The output's a lot cleaner, and the speed that you can grep through a directory is just insane.
+
+\[47:58\] One of the coolest things I love about it is it also adheres to your htignore and gitignore files. So when you're searching for something inside of your source repo, it will ignore searching through files that are already in your ignore list, and then it has its own .agignore that you can use at a global level, to tell it to ignore files with extensions or in certain paths, and all that stuff. So if you're still using ack and grep, I highly suggest trying out the Silver Searcher.
+
+**Beyang Liu:** Nice.
+
+**Brian Ketelsen:** Nice, there's a good Vim plugin for that, isn't there?
+
+**Erik St. Martin:** Yes. And it took one less key, because it's ag to search, using Silver Searcher. And yeah, there's a plugin for Vim, so that you can do a ;ag and use it within your...
+
+**Brian Ketelsen:** Not that Beyang would need that, because he uses that other thing.
+
+**Erik St. Martin:** I know. I need to use Sourcegraph more.
+
+**Beyang Liu:** Yeah. Check it out, send us feedback, tell us how we can make it better. Yeah, I think the project I wanna call out this week is actually a project that's not released yet publicly, but it's something that we've been using internally. It's something that's written by Matt Holt, who is the author of the popular Caddy HTTP server. He wrote this library called Checkup. It's essentially this uptime monitor. It's kind of like all these services that do uptime monitoring already, but what it does is it has a really nice configuration format for just quickly specifying a bunch of URLs that you can hit. One frustrating thing for me with a lot of uptime monitors is that the UI is just so clunky and you have to go and manually update it and then something changes; you gotta go navigate through the UI and update that again. It would be nice to just describe all the key endpoints that you wanna hit just in code, so those can change as the code changes, and then you can deploy this thing to any server, any AWS or GCP node and it just kind of works; it gives you pretty graphs for how uptime is going and it's super easy to use, it feels very native to the Go ecosystem - no nonsense, no cruft, just write out a list of things that you wanna monitor uptime for and you're good to go. So shout out to him, he's done so much great work for the community.
+
+**Brian Ketelsen:** Absolutely.
+
+**Beyang Liu:** I was actually googling around for it, I couldn't find any public mention of it, but we've been using it internally.
+
+**Erik St. Martin:** So if we get all two of our listeners and us to beat at Matt, maybe we can get it released.
+
+**Beyang Liu:** Yeah, tweet at him. Tweet, I say! \[laughter\]
+
+**Brian Ketelsen:** Go on, Matt!
+
+**Erik St. Martin:** I don't even know how many people are listening live right now. Maybe Matt's listening right now.
+
+**Brian Ketelsen:** \[51:08\] All six of them are listening.
+
+**Erik St. Martin:** I think we're probably out of time... We're a few minutes over, but this has been a lot of fun and I wanna thank everybody who's on the show. I wanna thank all the listeners, I wanna thank our sponsors, Equinox (equinox.io/gotime) definitely hit them up, share the show with other programmers... If you haven't subscribed already, you can go to GoTime.fm and subscribe to our upcoming weekly email newsletter, follow us on Twitter, and we are GoTimeFm on the Gophers Slack channel as well. I think with that said, goodbye everybody, and we are out next week because of GopherCon. All these conferences get in the way of podcasts.
+
+**Brian Ketelsen:** \*sigh\* But don't forget - if you're listening live, don't forget that we're live streaming GopherCon. Twitch.tv/gophercon. Did I mention that already?
+
+**Erik St. Martin:** Good morning, sunshine... You did.
+
+**Brian Ketelsen:** Okay, good.
+
+**Erik St. Martin:** Yeah, catch us there and if you are at GopherCon, come visit us. We will have T-shirts... And I think that's it. Thank you for being on the show too, Beyang, it's been a lot of fun.
+
+**Beyang Liu:** Thank you so much for having me, this has been awesome.
+
+**Brian Ketelsen:** That's a wrap.

Bill Kennedy on Mechanical Sympathy_transcript.txt

@@ -0,0 +1,337 @@
+**Erik St. Martin:** Alright everybody, welcome back for another episode of Go Time, it's episode number six. I'm Erik St. Martin, today here with me we have Brian Ketelsen. Say hello, Brian.
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And we have Carlisia Campos, say hello.
+
+**Carlisia Thompson:** Glad to be here. Hi, everybody.
+
+**Erik St. Martin:** And we have a special guest with us today. Bill Kennedy from Ardan Labs and GoBridge is here with us today. You might also know him from all of his workshops that he does in like the world now, right Bill?
+
+**Bill Kennedy:** Yeah, I’ve been lucky enough to get into Europe a couple of times this year.
+
+**Erik St. Martin:** It's crazy, it's like every day we see you somewhere else. I don't know how the planes arrive in time for your workshops.
+
+**Bill Kennedy:** \[laughs\] Scheduling is difficult sometimes for sure.
+
+**Erik St. Martin:** I mean, what's your mileage look like? Your frequent flier miles.
+
+**Bill Kennedy:** I think I'm at like a hundred and thirty thousand miles right now.
+
+**Erik St. Martin:** Geez, I don’t envy you.
+
+**Brian Ketelsen:** Diamond elite?
+
+**Bill Kennedy:** On American I am now Platinum on my way to Executive Platinum.
+
+**Brian Ketelsen:** Nice.
+
+**Bill Kennedy:** But yes, these are not goals that you should want to achieve.
+
+**Erik St. Martin:** Do you have your favorite soap and shampoo that comes in the small bottles?
+
+**Bill Kennedy:** I've leveraged whatever the hotel has to the extent that I can.
+
+**Erik St. Martin:** So today we're gonna be talking with Bill about Mechanical Sympathy. I think this is gonna be a really interesting topic; before we get into that, let’s talk news and interesting projects. Anybody have any interesting they want to talk about before we get into it with Bill?
+
+**Brian Ketelsen:** You know, it was a pretty quiet week in Go news from my perspective. But I did find two relatively interesting projects. The first one I thought might be a winner in the best hack of the year award. In the show notes you'll find a link to the blog post from Acksin, acksin.com, where they hacked together a way to send StatsD type metrics to Google Analytics, which seems like an interesting shoehorn and it looks like it works pretty well. So you get a nice free StatsD monitoring for your servers using Google Analytics inappropriately. I approve completely of this plan.
+
+**Erik St. Martin:** You know, but the interesting thing about that though is that you can see it alongside metrics that you are already collecting in Google Analytics. And how some of those things might impact your funnel. I can’t think of any specific uses I'd use it for off the bat, but I think it has potential to be valuable.
+
+**Brian Ketelsen:** It was interesting, to say the least. I'm not sure I would put it in production on a useful system. What if Google decided that they could figure out that traffic and start tossing it?
+
+**Erik St. Martin:** Yeah, I think I'd prefer Grafana, or something like that.
+
+**Brian Ketelsen:** Datadog all the way.
+
+**Erik St. Martin:** Datadog is good stuff, too.
+
+**Brian Ketelsen:** So the second interesting project I found is one in the multitude of vendoring projects. This one's called Manul, and you'll find a link to that in the show notes. It's another one that does vendoring with Git submodules this time, and it looked to be one of the better vendoring packages that supports Git submodules. So it had some very nice commands and utilities with it.
+
+**Erik St. Martin:** \[03:54\] I’m interested to see though how they solve some of the drawbacks from using submodules, because a lot of people have reservations about using Git submodules. There’s kind of some inherent flaws with the way it works. Number one would be that you’re still relying on that repository to exist in the future. So if it went down or somebody decided to delete their project - because that totally never happens -
+
+**Carlisia Thompson:** Or you can just rename it.
+
+**Erik St. Martin:** ...you still wouldn’t have access to the code, but some of it also comes in the way submodules work. So if I pulled down your project and I needed to do a Git submodule update to update my local versions of those submodules, but if I don’t do that, I’m still running with my prior versions of those submodules. So by checking out your code it doesn’t move my submodules with it, so I can accidentally commit my older versions of your stuff, and those lines are really easy to miss. There’s a couple issues too with the way those things that are kind of merged too, so I’m interested to see how that's solved. Because people step on each other's submodules all the time. You see it where I pulled down your changes but I didn’t notice you had submodule updates, but then I commit my commit and my submodule versions are different than yours, and I just kind of step on yours. But I mean, these are problems that people were having years ago, so maybe there's some stuff in Git now that accounts for... Maybe the tool accounts for it a little bit too. I guess if you did it on like a commit hook or something, you could probably... But yeah, it’s interesting though... Submodules can be valuable and they can also be a pain, but I guess everything in programming can be, right?
+
+**Brian Ketelsen:** Always.
+
+**Erik St. Martin:** Have you guys used submodules before, anybody?
+
+**Bill Kennedy:** Not me.
+
+**Carlisia Thompson:** I have, I have. I did not run into any problem with it. Didn’t do anything crazy, just dropping a submodule there to access it.
+
+**Erik St. Martin:** Yeah, I’ll find a link surrounding some of those pitfalls, and we'll drop it in the show notes before this is released. This has been a couple of years, so I can't remember a name of one off the top of my head, but I know people were having a lot of weird issues. So anything else we want to talk about?
+
+**Brian Ketelsen:** That's all I had.
+
+**Carlisia Thompson:** I don’t have anything.
+
+**Erik St. Martin:** I know what we do want to talk about.
+
+**Brian Ketelsen:** Mechanical Sympathy?
+
+**Erik St. Martin:** Exactly.
+
+**Brian Ketelsen:** Yes!
+
+**Carlisia Thompson:** First things first then - where did this name come from? We were talking about this earlier, but I wanna hear it from the horse's mouth.
+
+**Bill Kennedy:** It didn’t come from me. This is a term that I think I got from Martin Thompson, who, if you watch any of his videos, he says he got it from a racecar driver.
+
+**Erik St. Martin:** Yeah. Jackie Stewart was a Formula1 driver and I think during an interview he had said something along the lines that you don’t need to be an engineer or mechanic to be a racecar driver, but you need to have Mechanical Sympathy. Basically he was just implying by having some level of understanding of how the machine, the car worked, that it made you a better driver. And I think as Bill kind of pointed out, Martin Thompson started applying that to programming. So Bill, would you like to fill us in a bit on how you think that that concept applies to programming?
+
+**Bill Kennedy:** Yeah. I mean, I only have a perspective on it from the Go side, and it's something I really focus in the training. I kind of focus on two things in the training: data-oriented design and Mechanical Sympathy, and trying to show how the language Go itself is very in tune around these two ideas. And I really, really believe that if you don’t understand the data that you’re working with, you do not understand the problem that you’re trying to solve. It all starts there, like everything, every problem that we're trying to solve is really a data manipulation problem in some fashion, in some way. \[08:03\] So it all really starts with the data, and it's this idea that if you don’t understand the data you're work with you don’t understand the problem, and if you don’t understand the cost of solving that problem, you can’t really reason about solving it. And to be able to reason about the cost you have to have some understanding of what every line of code is doing and how that's affecting the operating system and the hardware, which is there to execute those instructions that you're spending time writing to begin with. So I think it's that relationship that I’m really interested in and think about in terms of what Go is doing to help us.
+
+**Brian Ketelsen:** So when you talk about Mechanical Sympathy, you’re talking about things at the physical level, like the discs, the caches, the CPU, electrical things. How much of that as a programmer do we have to care about?
+
+**Bill Kennedy:** I really focus it around the data that you're working with. One of the things that I’ve learned is that the hardware that we’re working on today, our processors are now multicore processors and every core has their own sets of local caches; that L1 and L2 cache in many cases belong to each core. Cores could then share an L3 cache and you just don’t have access anymore directly to main memory. So if you’re writing code where the hardware cannot predict access to the data you're working with and you're going to have these cache misses that can cost you hundreds of clock cycles. In one architecture that Scott Meyers uses in one of his talks it’s 107 clocks cycles every time you have a cache miss. Now, that’s gonna change from hardware to hardware, but if you could imagine employing some sort of linked list data structure, or on every iteration you’re accessing a different node in the list and every node in that list is not sympathetic with the caching system or doesn’t exist on the same cache lines, you could be chugging through memory without even realizing it, without even understanding why it’s as slow as it is.
+
+**Erik St. Martin:** So let's back up here just a second too, because a lot of people come from dynamic languages - Ruby, Python, and even Go abstracts these concepts from you. Let’s take a second and talk about CPU caches and what those are, because I would argue that probably a lot of people aren’t even familiar with what a CPU cache is.
+
+**Bill Kennedy:** So we've got to talk about this at a very high representative level, because hardware is really different. But in essence, we're dealing with a piece of hardware that has caches in, and from our perspective it can be all the same. The idea is that that hardware needs to have the memory that we're working with as close to it as possible, and what’s going to happen today is if you need any, even a byte of memory that's sitting out in main, it’s got to move from main memory into let’s say the L1 or L2 cache for it to be used. And these caches get pulled in and out on cache lines, and the default cache line today is the 64-byte cache line. So the idea now is that if you have instructions that are working with data, which is what we do, right? I mean, this is what we do all day - we’re reading memory, we're writing to memory... This memory has to now get into the caching system in order for us to be able to use it. This state has got to be moving on these 64-byte cache lines from main and back in. And so, one of the things that we can do to be sympathetic with the hardware is try to work with data in as contiguous blocks as possible. The more contiguous our data is, you usually then at that point are probably iterating over that data. And iterating over data can create predictable access patterns to that data that the hardware today can pick up on.
+
+\[12:12\] So if we really want to give the hardware its best opportunity to take advantage of everything that's in there, we've got to be sympathetic with it. We've got to try to look at data in a way of, what are our working sets of data? Can we lay data out contiguously, work with data contiguously and can we create predictable access patterns around that, so the hardware can pick up on what are the next cache lines that are probably in play or will definitely be in play, and pull those into the caches before those next instructions need them.
+
+**Carlisia Thompson:** How does somebody learn about what predictable access patterns look like? And what can they do to achieve that?
+
+**Bill Kennedy:** From today's perspective, it is the array that is really the most important data structure from the hardware perspective, because it is the array that allows you to create contiguous blocks of memory.
+
+**Erik St. Martin:** Well, I guess structs are aligned that way too, right?
+
+**Bill Kennedy:** Say that again, I’m sorry.
+
+**Erik St. Martin:** Structs are also aligned contiguously.
+
+**Bill Kennedy:** They are, but if I was gonna create a user struct and I was gonna create a hundred thousand of those and I didn’t lay that out contiguously... You know, I created just a link list of these particular user values and they laid out all over in memory almost randomly, and you started walking down that link list, the hardware's not gonna be able to pick up on any pattern there, and you're basically gonna be chugging through memory, because every access is gonna be a cache miss. So we're trying to eliminate that by trying to keep all of the data that we can as close together as possible and the least number of cache lines as possible.
+
+**Erik St. Martin:** Right, because over the years processors, even though they haven’t got significantly faster, they've become much better at multi-tasking. So while the processor may be performing a math calculation, in the same cycle it can be making the next stride and pulling the next cache line in, so that the next iteration the data's already there and it’s basically for free.
+
+**Bill Kennedy:** If it can predict what that next cache line is, then it absolutely can do that. But if we’re not being sympathetic in helping it to be able to predict these things, then it can’t pull that cache line until it knows exactly, "Now this is where the data is that I need." But it's...
+
+**Erik St. Martin:** Yeah, and..
+
+**Bill Kennedy:** I’m sorry?
+
+**Erik St. Martin:** I was just gonna say, so the access patterns, how you talk about it being important thinking about the data and how you’re working with it... I guess that the two main points that I can think of is basically temporal and spatial locality right? Working with things that are located next to each other in memory or working on the same pieces of data at the same time, right? Kind of to your point where you can minimize the number of cache misses.
+
+**Bill Kennedy:** Yeah, and hopefully... I mean, you’re not gonna avoid cache misses altogether, but if you have a working set of data that you're gonna be doing a lot of processing on, once it gets pulled in now it’s there you can leverage it. If you're bouncing around memory all the time and it’s somewhat random, you're just gonna chug through it.
+
+**Erik St. Martin:** So let’s give an idea of bouncing around memory.
+
+**Bill Kennedy:** A linked list to me could be a scenario where you have a node of data, that node of data points to another node of data, and that node of data points to another node of data. Depending on how and when that data was created, that could be almost anywhere in the heap, depending on how that's getting created and when and how it’s getting hooked up.
+
+**Erik St. Martin:** Right.
+
+**Bill Kennedy:** So you can’t guarantee in that case that every single node is on the same cache line, or even in cache lines that are next to each other.
+
+**Erik St. Martin:** \[15:55\] And I guess another example would be like a multidimensional array, right? Iterating over row-based versus column-based.
+
+**Bill Kennedy:** Yeah, we actually have some examples in the training with that over benchmarking, where you actually see a significant difference in performance. If you go row based you see it’s much faster than if you go in column based... Kind of breaking, you know, going against the grain.
+
+**Erik St. Martin:** Yes, so it’s interesting though, because we typically think about memory for free, right? You know, we're like, "Yeah, it’s on a RAM. RAM is fast. At least I don’t have to go to disc for it", right? But doing something like column first or row first iteration over an array like that, it really demonstrates the point how much slower it is to go to RAM than CPU cache. And it really shows its head the bigger that it grows.
+
+And there’s other things, too... Even just because we use... Typical operating systems have the - I always mess up this name - the transaction lookaside buffer, I think that’s what it’s called, where it basically maps the address or memory your program has to the real memory, physical memory address. And that has pages too that you can blow out and it kind of has to load back in, and that's expensive, right? So every time you blow that out because you’re not working with memory that’s located next to each other.
+
+**Bill Kennedy:** You know, my interest in this actually started to develop when I came into Go. Because before that I was in C\# and we had lists, we had keys, we had stacks, we had data structures, right? And even C++ gave us all these data structures. And when I came into Go, I was like, "Where are all my data structures? I don’t understand this." I'd just see an array, I'd see a slice which I honestly didn’t understand at that time, and I'd see maps. And it’s really silly, because I didn’t really understand what slices were. I just thought that they were really just arrays, and back in school we were really taught that arrays are difficult to work with. And I actually avoided slices for the first couple of months working in Go using linked lists, because I honestly didn’t understand why we didn’t have data structures, and eventually at some point I realized that everybody is using slices and the language is pushing you towards slices, and I figured out I had to really learn what this is.
+
+Now when you step back and you look at it from this point of view, the underlying data structure for the slice is an array, right? The slice is the most important data structure in Go. And as I peel this onion every month, more and more about Go, all I keep seeing is how Go is pushing us towards writing sympathetic code. Go is pushing us towards doing the right things without anybody realizing it. Go wants us to work with these slices because then we're really working with arrays and contiguous memory, and it's giving us our best opportunity to have these sympathies without even realizing that we’re being sympathetic with the hardware. So Go to me is just an incredibly fascinating language when it comes to that.
+
+And other areas of the language too, where you see that you're really being sympathetic with the operating system scheduler on the concurrency side, without even realizing it. Just these idioms and these things that we tell people to do all the time, they’re based not on just, “Hey, we want you to do this”, they’re based on real things around performance, simplicity, readability, those types of things. It all kind of comes full circle.
+
+**Erik St. Martin:** Yeah, I think there’s a lot of programming idioms that can be followed to help. But I think you’re right... Like I said, I never really considered some of the language functionality, that it’s abstracting the way these things and making our programs more sympathetic by default, right? And channels are a good example too, right? You know, you’re passing pieces of data over between threads, so that the data can stay locally on the cache or that particular thread.
+
+**Bill Kennedy:** \[19:54\] So what about the reference type, your slice, your maps, your channel values, right? We’re always told, "Do not share this. Everybody can get a copy of these values." And what that's doing is that it's allowing us to not put pressure on the GC right? Like, we get to leverage the stacks to the fullest extent because everybody can get a copy of this slice.
+
+The thing that's being shared underneath is what let’s say necessary has to be on the heap, just that. And all these little objects that we need to pass values around across these program boundaries, we get to leverage the stack, right?
+
+Because there's gonna be two areas where we gonna want to focus around performance. One will be I think around data-oriented design and are we being sympathetic with the hardware and the caching systems, are we working with data the best way we can? And then the other side is gonna be, can we reduce pressure on the garbage collectors so it doesn’t have to run as much, right?
+
+These are two areas where I think we can focus just day one around performance when we’re not getting enough of it. But I tell everybody in my classes all the time, I go, "Don’t become paralyzed by all this stuff. You have to get whatever it is your working on, working first. And then you can profile and measure what’s working." The profiling tooling is amazing, right? You can see the low hanging fruit and then look at where you can spend real time. Where does your time need to be? And then these things kick in to help you understand, "How can I get some better performance here? Am I not being sympathetic with the caching system? Am I not being sympathetic with the operating system? Am I not being sympathetic with the garbage collector? It’s all just allocating too much stuff here when I don’t need to."
+
+**Carlisia Thompson:** How about the data-oriented design? I understand we don’t want to maximize performance ahead of time before you know what you need to optimize and even where you need to optimize. How about the concept of data-oriented design?
+
+I can totally see you designing your software in a way that is not data-oriented, and it's to make it work, and you might or might not have performance issues. But let’s say you do want to change things around. It seems to me if you didn’t start out thinking about data-oriented - that way of doing it - the changes would be so great, the redoing would be so great, versus if you had started out thinking in that way and should we be doing that... Not so much in terms of, "Let’s try to optimize performance too early", but are there payoffs of starting out with data-oriented design that go beyond performance. Maybe just code readability, maintainability, that kind of thing.
+
+**Bill Kennedy:** So Go is an object oriented programming language, but I don’t want people writing object oriented programs in Go. I think that’s the line, I think if your writing object-oriented software, you’re not thinking about the data first, you’re thinking about all of those relationships, and object-oriented programming designs tend to create linked lists at the end of the day. I mean, that’s what they’re doing. They're to me not sympathetic with the way the hardware works today. So for me, this is about separating where you can the data that you’re working on and then the behavior that’s going against that data.
+
+And I’m a big fan of functions, I love functions. One of the things that was so great when I got into Go was I had my functions back. Not everything had to be on a method on a class. And I think functions can also help reduce a huge amount of your code when you’re using them in a sense where, "Here's my state and here’s some behavior." I mean, methods play a huge role in Go, I’m not saying that you’re not gonna have methods, but for me it’s about not thinking about architecting things in terms of an object-oriented design or pattern, but really thinking about, "This is the data, these are the manipulations, this is the input, this is the output and how do I do that with the least amount of code?"
+
+**Erik St. Martin:** \[24:04\] And now the data-oriented design concept came from the game programming world, I believe.
+
+**Bill Kennedy:** Yes.
+
+**Erik St. Martin:** And a lot of their problems were similar, right? They needed things to happen fast because they need high frame rates, so they tried to start organizing their code in a manner so that the data that they were working with was spatially located, so they'd group the data they worked with commonly together to pass around, versus working with objects.
+
+**Bill Kennedy:** Yes, right. They have to do N number of things in X amount of time, and time is not changing, right? So they have to make that happen. So yeah, they started to learn that they had to be even more sympathetic than anyone else.
+
+But I think the slice, the idea of being able to leverage the slice as much as possible, when it is practical and when it is reasonable, is giving you a lot of this without you even realizing it.
+
+That’s one of the things I love about Go, is that Go has given us the things that we need and is pushing us towards these things by saying, "Well, I’m not gonna give you any other data structure. I’m giving you maps, I’m giving you slices." And even maps are a leveraging contiguous memory underneath. And then with all the reference type values, if we’re not sharing them, passing them around, everybody gets a copy... You’re just getting these things. But yeah, I think I heard the term first from Mike Acton on a talk from 2014 where he goes into lower-level detail, and some of it I can’t even understand, about how he’s leveraging data-oriented design in that gaming systems that he’s building.
+
+**Brian Ketelsen:** So when we were researching this show I found the term 'false sharing'. How does that fit into this whole picture?
+
+**Bill Kennedy:** Yeah, so now we’re getting really deep inside the hardware a little bit. But the idea is that because every core is going to be loaded with cache lines, if you have let’s say two threads, each running on a different core, working with the same data that happens to be on the same cache line, you now technically have two copies of that data: one in the cache for core one and one in the cache for core two. And even if each thread is working with a different byte on each cache line, you don’t have a concurrency issue here, you don’t have a data raise issue. But you do have a situation where the same data is now duplicated inside of a cache for two different cores.
+
+Now, the false sharing comes in because of that. From your perspective you're not really sharing data, but from the hardware perspective this data is being shared. The problem with false sharing doesn’t come from reading, because if you're reading data... It’s when that data gets mutated, because as soon as one thread on one core mutates any data in that cache line, all other copies of that cache line in all other cores now have to be considered dirty. And when that other thread goes to do something on that cache line - its own copy of the cache line - and it's dirty, you don’t have to wait for a new version of the cache line to come in. And so that can create performance problems.
+
+An example Scott Meyers uses is that somebody has created a global array of counters. So all of these counters, let’s say there's sixteen counters all in the same cache line, and you launched sixteen threads, each thread getting its own index of a counter on this cache line, and all sixteen threads getting their own core; you now have sixteen copies of these cache line of these counters in every single core, and every time one thread writes, increments its counter, all other fifteen other caches now have to be marked as dirty. And your chugging through memory because every thread that does a ++ on their counter is causing every other thread now to have to wait for their copy of the cache line to get updated. So that’s really what 'false sharing' is all about.
+
+**Erik St. Martin:** \[28:22\] So an example of that would be if you had a single backing array holding all of your counters?
+
+**Bill Kennedy:** Yeah.
+
+**Erik St. Martin:** We see stuff like this all the time, right? So in your package, if you had a publicly exported array - or slice, for that matter - that just isn’t appended to - well, even when it is appended to... But for example you have an array of 8-byte integers that you’re using as counters, so your example would be if each one of the threads using those were scheduled onto different CPUs or cores, that incrementing any one of those would cause all of the caches to be blown out for that particular cache line.
+
+**Bill Kennedy:** That's right. Because from your perspective you're not caching, but from the hardware perspective you are. Because every core has its own copy of that same exact cache line.
+
+**Erik St. Martin:** I guess this kind of echoes back to your data-oriented design right? Because if you’re keeping all the data locally that you’re working with, they wouldn’t be grouped together somewhere else, right? Because the counters don’t make sense together, they make sense in their individual...
+
+**Bill Kennedy:** So the solution to that is, since every Go routine’s stack in the stack frame - in that particular case for any Go team - is going to be on its own unique cache line, the solution to something like that would be to perform your counters on a local variable. That would be on your cache for each thread in that case, and therefore every time each thread performs a ++ it's on a unique cache line. And at the end of that algorithm, you might perform one last write to the global, and that’s not gonna hurt you. That’s a one-time boom-boom-boom-boom. So data locality, when we’re talking about not just reading but writing, can also add a huge help in terms of being sympathetic with the way the caching system works.
+
+**Erik St. Martin:** So if you had to pick just a couple takeaways for everyone, things to be cognizant of when developing, to start at least a journey of being more sympathetic to the hardware, what would those be?
+
+**Bill Kennedy:** I tell everyone, if you’re not sure how to do something, ask the question around what is the most idiomatic way to do this in Go. Because many of those answers are already tuned to being sympathetic with the operating system of the hardware.
+
+The next thing I tell people is if you’re working with data, try to work with slices of values as your initial load of data. You can share different elements of those slices, but the core data you’re working with, we try to keep it as contiguous as possible. It’s not going to be perfect because you're going to have strings, and you're going to have reference types of high pointers to things, but the compilers are tools; it’s gonna do its best that we work with it to help us there. And try to think about if you're working with very large sets of data, what are the working sets that you might be working with at any given time? Try to keep that together and really try to avoid, when you can and when its practical, things like linked lists that are not gonna really help you create predictable access patterns. There are times where whatever you’re doing, the algorithms that you’re trying to build are just not gonna be practical for arrays and linear traversals and things. That is what it is. But I think a lot of times you can lay that data out in a way and work with in a way where you can gain these sympathies that still implement the algorithms that you're trying to implement.
+
+**Brian Ketelsen:** \[32:00\] So what about laying out your data at a lower level? I know when we talked about this a few months ago when you came to visit us in Tampa, you talked about the size of the structs and keeping them within word boundaries. How does that affect processing speed?
+
+**Bill Kennedy:** I’m not really sure if I said that... If the struct is data - to me when I look at a struct, I look at it in two different ways. What I'll ask is: Does this struct represent my pure data or is it a struct that’s gonna be some sort of concept like a pool of goroutines? I’m creating a pool of goroutines. I’m gonna create multiple instances of this thing. It's managing goroutines just let me do work. That’s one thing. But if the struct is gonna be pure data, then the size of that struct is what it needs to be, whether it’s 4k or its 24 bytes - it is what it is. But what I’m looking at then is the concept of padding. If it’s pure data where I’m gonna create a hundred thousands of these structs and even lay them out contiguously in memory, I don’t wanna lay the fields out in such a way where I’m going to get extra patting bytes in between, that’s gonna cause me now to have to use more memory than I need to. But that’s only when the struct, in my view, the struct is really pure data. Other than that, I wanna lay fields out on a struct that makes sense organizationally to what that struct is doing.
+
+**Erik St. Martin:** I was just gonna say, so one of the things that I think might come into play there if you look at structs, is if the struct is large enough where it doesn’t all fit in a cache line, if you’re using properties at the top of it and at the bottom of it, you could keep blowing out the cache line, as you're just doing typical work. So I think sometimes it might come into play to organize your struct in a manner so that the things that are often used together are grouped together to ensure that they align properly, but this gets into like going in-depth into performance optimizations, and sometimes it’s a little too far, right?
+
+**Bill Kennedy:** That could be a level of micro-optimization. If these structs, let’s say they do spend over 64 bytes, they're still being laid out across two cache lines, right? And the next one might be laying into the next one, so you still might see the same sympathies anyway. If you start mutating these things, then we go back to the 'false sharing' issues.
+
+You know, the hardware today is designed to copy data really, really fast too. And so I tell people don’t panic because you think you’ve got a struct that’s too large to copy and now we're just gonna start sharing it everywhere. Until you do some performance profiling you don’t really know. So I’d rather the code be really reasonable around what we’re trying to solve and not start thinking about performance as you’re writing the code. We can always go on performance and profile it later. And then we just make the side that "You know what? Yeah, this was too large to make copies of based on how we're using it, and it was better performing and sharing this across these program boundaries."
+
+**Carlisia Thompson:** What are some easy things to do, some easy rule of thumbs that can help people achieve this data-oriented design, thinking about grouping data that you’re going to use together in the same place? When you set out a program, how do you think about these things?
+
+**Bill Kennedy:** I really believe that every problem we solve is a data problem with some data manipulation. So the very first thing I’m doing on projects is I’m asking what is the data that we’re working with? What is my input? And what is it that we’re trying to achieve? Where are we trying to get to? Here’s my input, here's my output and then we could start thinking about how we’re gonna get from here to there. \[36:02\] And sometimes these are really complex problems. We've got to break them down into really, really small attainable smaller data transformation prompts, and for me that's when I start thinking about what does this data look like, it's some of these pure data, it's some of this more constructs around how we wanna do the manipulations, and then things like Eric and Brian were already saying - well, we know that this is gonna go across maybe multiple cache lines. Is it pretty large data? Can we group the working sets together? These types of things.
+
+I don’t get completely paralyzed over it, because we have to solve the problem. If you don’t get something to work, almost you can’t do any of these. You gotta get something to work first. But I think what's brilliant is Go is pushing us in the direction to do things fairly right the first time if we follow the idioms, if we work with slices of values, if we’re doing things the way that, as a community over the last few years, we’ve been directing people to do.
+
+**Brian Ketelsen:** So do you have any resources for us to kind of go out and start exploring these concepts?
+
+**Bill Kennedy:** Oh, yeah. On the Go Training GitHub repo under Arden Lab/GoTraining. I actually have a folder in there called Reading where I've got a ton of links that I've kind of pulled out for people to read, and there's a whole section there around CPU caches and the Linux operating system and how the scheduler works and things like that. I made it throughout the training material for each section. There’s a ton of links and resources to learn more. So everything that I know comes from these videos and articles and I’m always re-reading them as well. Cause there’s so much there... It takes me sometimes a couple of months to absorb some stuff and then I’ll go back and read it again and get more. So yeah, it’s all out there and I’ve tried to create a good collection of this stuff, and it’s all there in the training repo.
+
+**Erik St. Martin:** Alright, I have a little bit of a change of subject. There’s a grassroots movement going around. I’m not sure if you’re aware of it, but there are several people that are talking about cosplaying as you this year as GopherCon. Did you know about this? Could you give them some advice on maybe on where to find the hat?
+
+**Bill Kennedy:** Say that again, they want the hat?
+
+**Erik St. Martin:** They're looking to dress up as you this year at GopherCon. Several people have mentioned it.
+
+**Bill Kennedy:** The hat is too expensive to be played in that game. \[laughs\]
+
+**Erik St. Martin:** Alright. I’m gonna put this out there, free beer for anybody who comes dressed as Bill Kennedy.
+
+**Bill Kennedy:** Oh my god. \[Laughter\]
+
+**Bill Kennedy:** Free drink tickets all night.
+
+**Erik St. Martin:** I will even steal the real hat and give it to you. \[Laughter\]
+
+**Carlisia Thompson:** If that's all you're missing.
+
+**Erik St. Martin:** Oh, that’s priceless.
+
+**Brian Ketelsen:** So we know you’re a busy guy, Bill. You’ve got workshops going on at GopherCon, you’ve got the book going on... Is there anything you wanna tell us about any of those things that you've got going on other than your training?
+
+**Bill Kennedy:** The trainings are always really exciting and I’m really excited to be doing a [NATS workshop on the 3rd day of GopherCon](https://www.meetup.com/Denver-NATS-Cloud-Native-and-Microservices-Messaging/events/231095092), but I think one of the things I’m really excited about right now is Carlisia and I through GoBridges started the remote meet up platform, and we’re putting an all-star lineup of speakers together right now that will start speaking in June and July. It's gonna be awesome because it doesn’t matter where you live, everybody's gonna be able to come together, and the BigMarker platform is really amazing in terms of being able to have a collaboration. The real goal for us right here is not for GoBridge to have a remote MeetUp but for anybody, no matter where they live, to be able to start their own MeetUp, to be able to find the speakers and the things that they're interested in and have a MeetUp even if they're the only person that lives in this small town or remote area of the world. Start a MeetUp, find people who have similar interests, find your own speakers and start to meet. You know, I’m really hoping that we can see another 10 or 15 Go MeetUps by the end of the year, all being driven around this idea of a remote MeetUp.
+
+**Brian Ketelsen:** \[40:19\] That’s neat idea.
+
+**Erik St. Martin:** Yeah, Brian and I commonly don’t make it out to the Tampa one. I mean time gets the better of you, so...
+
+**Bill Kennedy:** Right, I know so many people that come to me and they get... Even me, when I am in Miami and San Francisco’s holding a MeetUp with people that I wanna hear and I can’t get out there, it can be depressing sometimes. But what’s great about this is you're gonna be able to really start your own MeetUp and speakers from all around the world can come in and you don’t have to feel like you’re missing out. And I love the Go community. You can reach out, anybody can reach out to Brian and say "Brian, can you give a talk for a MeetUp?" and Brian’s gonna say yes. He will say yes, I will say yes. So many people..
+
+**Erik St. Martin:** You're saying yes on his behalf.
+
+**Bill Kennedy:** I can’t get Erik to say yes, but we’re gonna get Erik to say yes one day, too.
+
+**Brian Ketelsen:** One day.
+
+**Carlisia Thompson:** Bill, do you wanna mention some other people that have already agreed to do a MeetUp?
+
+**Bill Kennedy:** Yes, so we have... I hope I pronounce her last name right - Butow Tammy from Dropbox, we scheduled a talk, I haven’t published this yet. Kelsey Hightower has agreed to give a talk, too. So I’ll be publishing that very soon on the days that are there. And we've reached out to a few more people, I haven’t got confirmations yet, but hopefully they're gonna be coming in soon and we’ll publish that on our MeetUp page and we'll tweet that out. We're really like excited about that.
+
+**Brian Ketelsen:** That’s really awesome.
+
+**Carlisia Thompson:** Yes, and I suggest people to sign up. There is a limit of a hundred attendees, so when you see the tweets going out, just go and sign up. You don’t wanna be left out.
+
+**Bill Kennedy:** And I have to say Compose.io is sponsoring our plus account that gives us the hundred people. We're really excited that they've stepped up and they're supporting the Go community.
+
+**Carlisia Thompson:** Absolutely.
+
+**Brian Ketelsen:** That’s great. They're also GopherCon sponsors, so double props to them.
+
+**Bill Kennedy:** Yes, so that what I’m kind of focusing on now with the little time I have, trying to get enough speakers set up and really show people the power of the platform so others will come in and start their own MeetUps. At the end of the day, that's what I would love to see.
+
+**Erik St. Martin:** I don’t think you're quite busy enough, Bill. \[laughter\] It’s not like you travel, or anything. I mean...
+
+**Bill Kennedy:** Nah... Well, you know, I have a long time on planes. \[laughter\] I can't sleep on them.
+
+**Erik St. Martin:** Oh, I can’t sleep in cars, I can’t sleep on planes... In general I can’t sleep, I guess. \[laughter\] I guess we’re running out of time here, but typically the way we close out the show is we like to thank open source projects that have kind of made our lives better and easier, just to show appreciation. So we'll quickly go around the virtual room here and everybody can give a quick shout out. Bill, if you’ve got one handy, you’re welcome to join.
+
+**Bill Kennedy:** The one that I’ve been working, on because I do some work on the CORAL project, which is an open source project, it's [anvil.io](https://anvil.io) which is providing authentication and authorization. It’s all written in Node, but we've added some Go support on the client side and it’s a really cool platform.
+
+**Erik St. Martin:** Awesome. Brian?
+
+**Brian Ketelsen:** So, one of the projects that I wanted to shout this week was Go Validator. The link will be in the show notes, but if you've ever had to validate inbound data, you know how painful it is to write that regex for email validation or credit card validations. This is a project by Alex Saskevich, that collects all of the important validations that you might need to do for incoming data, and it's just a treasure trove of good validations. Even if you're against dependencies, this is one you wanna have because they're a very nicely organized list of things to validate your data.
+
+**Erik St. Martin:** \[44:19\] Excellent. Carlisia?
+
+**Carlisia Thompson:** I wanna give a shout out to Joe Fitzgerald - I can’t pronounce it properly. He is the one who does all the Go packages for Atom and he does an amazing job. He has go-plus, autocomplete-go, go-metalinter, tester-go... A bunch of packages. I use them all the time. He’s amazing. He's frequently on the editor channel on Gophers.slack.com, and very helpful. I love the things that he's doing for Atom. Thank you, Joe.
+
+**Erik St. Martin:** I didn't even know there's an editor channel. These channels pop up too fast. It’s like, "Wait, there’s a channel for that? Is there a barbecue channel? There is now!"
+
+**Brian Ketelsen:** There is a barbecue channel. \[laughter\]
+
+**Carlisia Thompson:** There is.
+
+**Brian Ketelsen:** Yeah, that's a silly question.
+
+**Erik St. Martin:** So this is funny, this is kind of sidelining here... But somebody made a comment about needing a barbecue Gopher. They were like, "We should totally see whether the Ardan guys will create one for us." And there, apparently, already exists one. There is already a gopher standing at the grill, or - I forget what it looks like now.
+
+**Brian Ketelsen:** He's standing at a grill, he’s got a cowboy hat on, he’s got an apron and he’s got the barbecue tongs, and I can tell you that the shirts have already been ordered.
+
+**Erik St. Martin:** Where's mine?
+
+**Brian Ketelsen:** It's in the mail, Erik.
+
+**Erik St. Martin:** Sweet. So for me, I’m gonna thank HashiCorp. Particularly I’m using their LRUcache this week, that they have available, but many times before, Brian too - Vagrant, Vault, Consul... There’s so many of their tools that are useful, so I’m just gonna blatantly say HashiCorp.
+
+So we encourage everybody else to thank their open source projects through Twitter or any other social media. Reaching out is often just a good thing as Brian spoke to in I think episode one... Just getting that comment from people makes all the difference sometimes.
+
+So with that said, I think we are out of time unfortunately, but it has been quite a fun episode. We definitely want to thank Bill for coming on the show with us. I know myself I’m gonna be digging through more of the stuff he's got in the training material, because I’ve got tons of free time, too. Right? All of us?
+
+\[laughter\]
+
+**Bill Kennedy:** Exactly. And thanks for having me on this, it’s been a lot of fun.
+
+**Erik St. Martin:** I definitely want to thank Brian and Carlisia for the panel. I think this has been one of my favorite episodes. I thank everybody who's listening; Adam told us that there's like 25 plus people listening this week live. That’s crazy.
+
+**Bill Kennedy:** Yeah, that’s great. It’s growing.
+
+**Erik St. Martin:** Yeah. We also released our first episode, which is both good and terrible. \[laughter\]
+
+**Brian Ketelsen:** Scary.
+
+**Erik St. Martin:** Yeah, definitely scary. But you can get it, so GoTime.FM will redirect to Changelog's site where our first episode is hosted while the CMS is completed. By popular demand, we have started releasing episodes before the CMS is completed. So you'll find that there, and probably within the next week some more episodes will be dropping, for everybody who's impatient.
+
+I don’t know whether the newsletters sign up is on that site, but if it’s not, it is there or will be here soon. So keep checking back to the GoTime.FM to sign back up. iTunes will drop I think in about a week and a half, something like that, because they get forever to approve... Unless they tell us for some reason they don’t like our show. \[laughter\]
+
+**Brian Ketelsen:** \[48:05\] Not approved.
+
+**Erik St. Martin:** So we are on Twitter @GoTimeFM when you are listening live, GoTime FM channel on Slack, you can also socialize with us. And did I miss anything? Did we get it all?
+
+**Brian Ketelsen:** No, it was a busy episode.
+
+**Erik St. Martin:** Alright, awesome. So with that, thanks everybody for being on the show and we'll see you next week.
+
+**Brian Ketelsen:** Bye.
+
+**Carlisia Thompson:** Goodbye.
+
+**Bill Kennedy:** Bye.

Building a startup on Go_transcript.txt

@@ -0,0 +1,473 @@
+**Erik St. Martin:** We are back for another episode of GoTime. It is episode number 21. Today's show is sponsored by Linode and Code School. On the show today we have myself, Erik St. Martin, we have Carlisia Thompson, say hello, Carlisia...
+
+**Carlisia Thompson:** Hi, everybody.
+
+**Erik St. Martin:** And Brian Ketelsen...
+
+**Brian Ketelsen:** I love that when you say "Say hello, Carlisia." It sounds like we're trained animals. \[laughter\]
+
+**Erik St. Martin:** And then our special guest today is a true OG (Original Gopher), Blake Mizerany. How are you, Blake?
+
+**Blake Mizerany:** Good, how are you?
+
+**Erik St. Martin:** Doing good. So you've been around since 2009-2010 I think, you started with Go?
+
+**Blake Mizerany:** 2009, yeah, when Google released Go... I immediately took notice, and haven't really looked back ever since.
+
+**Erik St. Martin:** And these days you're doing all Go, right?
+
+**Blake Mizerany:** Yes, correct.
+
+**Erik St. Martin:** I'd love to hear how you've seen both the usage of the language and the demographic of the community change over time, because you've been around since... It was first released and there were people poking at it, until now, which is almost everything being done, the distributed systems world is being built with Go.
+
+**Blake Mizerany:** Yeah. Early on when I first saw Go, I took notice as I was working at Heroku, where we were working on a lot of distributed systems, and the appeal to me was mostly because everything we had done up until that point at Heroku and continued to do after that was a lot of Ruby, and it wasn't really holding up for us as well as we hoped; we'd spend most of our time fighting fires with it and not getting the performance out of it that we had hoped we'd be able to achieve, and Go really struck me as this language that would solve a lot of the problems.
+
+In fact, my colleague at the time - he's also an OG - Keith Rarick and I really started playing with Go together. Just before it was released, we both went to one of the founders of Heroku and said, "We really probably should start looking into building a language for distributed systems", which was really dumb for a startup to really be thinking about. But we were excited at the idea, and then two weeks later Go came out. We looked at it and we were like, "Well, I guess we don't have to do this anymore." \[laughter\]
+
+**Brian Ketelsen:** Timing is everything.
+
+**Blake Mizerany:** Yeah, so we started using it pretty heavily after that. It took Heroku a while to adopt it, but Keith and I definitely used it for a lot of stuff.
+
+**Carlisia Thompson:** These stories always fascinate me. When I found out that tests in Go were running so much faster than same-size apps in Ruby - because I also came from Ruby and Ruby on Rails - that was what got my interest. I'm wondering with you, when you looked at Go, what "looked at Go" means? Did you do a dry run, or did you just jump in and hoped for the best and it worked out? If it was the first case, did you do a benchmarking? How did your decision-making go more specifically?
+
+**Blake Mizerany:** Well, we didn't have to do any real formal benchmarking. Writing a quick little *Hello World* in Go, compiling and running it was... I mean, just a few little pokes at it with a browser; if it was a web server it was an obvious night and day difference from anything that we had written in Ruby.
+
+\[04:08\] It was pretty obvious at that point that that was the direction that we wanted to go, to start using Go.
+
+**Erik St. Martin:** I wanna say at that time, in 2009, to just hit an endpoint in Ruby on Rails was still three-digit response time; it was like 100-115 milliseconds, so the dropdown to single digits meant the world.
+
+**Blake Mizerany:** Right, yeah. I was working on a small project at Heroku at the time when I really started to use Go, and one thing I noticed was that we needed some sort of a service discovery and we needed some configuration management, so Keith and I picked up the Chubby paper that Google had put out, and we worked on implementing our own multi-Paxos implementation, since the only one that was really out there at the time was Zookeeper; in fact, I think that was the only one that was open sourced. Well, no, there were others, I think... A couple out of Berkeley, but we immediately looked at the design of Paxos and Go's concurrency and how it all just seemed to meld together really well.
+
+We were able to crank out a basic multi-Paxos implementation relatively quickly. I remember after we did that I immediately reached out to Rob Pike, sent him an email and said "Hey, we built a multi-Paxos implementation in Go. We'd love it if you'd come take a look, let us know what you think." So he came by -- I don't know where I'm going with this; I think I'm more excited about the fact that Rob showed up when I emailed him. \[laughter\]
+
+That really spoke to the power of the language. You can work on some pretty hard problems in it and come up with some reasonably simple solutions. The language really allows for that.
+
+**Brian Ketelsen:** I have a confession... It was Doozer that got me hooked into Go. I played with it when it first came out in 2009, but I didn't really see the vision for Go yet. Then I saw Doozer and it blew me away. I realized that we could build all kinds of crazy stuff with it, and that's actually how Erik and I met. I fell in love with Go because of Doozer, and then hired Erik to do Go. It's kind of all downhill from there... \[laughter\]
+
+**Erik St. Martin:** Yeah, Doozer was a lot of fun to play with in the beginning. For anybody who's not familiar with it, it's a lot like Zookeeper and Etcd and Consul of this generation. There was a lot of functionality that it had that Zookeeper didn't, which was one of the reasons that we liked it. I wanna say it had something to do with the way the paths were watched at a specific version, or something like that.
+
+**Blake Mizerany:** Right, we used the persistent data structure to be able to track changes, so you could pick up where you left off during a disconnect or after a disconnect, which was pretty nice.
+
+**Brian Ketelsen:** Yeah, so you could start watching a path at a certain point in time, which was really cool.
+
+**Erik St. Martin:** It was awesome for us, because we were doing some service discovery stuff in distributed systems, and when you looked at that, if you did Zookeeper, you would have to resync periodically; if you lost your session, you'd have to reconcile the differences. And you see that mirrored now in things like Etcd, or whenever you get a listing of a path, you get back a specific version and that way you can start your watch from that point on.
+
+**Blake Mizerany:** Right. There's always that chance that you'll miss the window. People offline for too long will have to resync, but it's more of a performance optimization. But it's still pretty cool.
+
+**Erik St. Martin:** So with that project, how much Ruby baggage do you feel like you brought along? Because that kind of turns out to be the thing whenever you adopt a new language.
+
+**Blake Mizerany:** \[08:02\] Right... One of the first things Keith and I wrote was an assert package for the testing suite. Not long after that we implemented a small Sinatra-style router called Pat, and within probably three to four weeks after creating both of those we ditched them and just never used them again, and continued to use the standard library. Although I think Pat continues to be pretty successful; I haven't looked at it in a really long time, but I think Gorilla adopted it at some point. But I avoid a lot of those frameworks. I'm not really familiar with where they are... But to speak to that, yes, we brought a lot of stuff over from Ruby earlier on.
+
+I remember looking for certain things to exist in Go that I was used to having in Ruby and it took me a while to break that habit. Once I did, everything got better.
+
+**Erik St. Martin:** I feel like for some of the open source projects you release into the world, there's some of them I feel like I should go back and change the readme to be like, "I no longer use this, neither should you."
+
+**Blake Mizerany:** Yeah, I did. If you look at the Pat readme, I think it literally says "I don't use this anymore." \[laughter\]
+
+**Brian Ketelsen:** One of the first questions that almost everybody asks when they come to Go is "Which web framework should I use? Which framework should I use for this? Which framework should I use for that?" and it's really a strong question that we get, especially in the Gopher Slack channel, every day. I know you're kind of anti-framework... What would your suggestion be to a new Gopher coming in and wanting to write something? When it comes to just using the standard library, that's kind of a hard message to tell.
+
+**Blake Mizerany:** Yeah... I don't really have a go-to answer for that. I think everyone has their own goals when they come to the language. It really depends on what they're trying to do. If someone wants to write a simple web app, they can certainly get away with just using the standard library. The standard library will take you extremely far. In fact, I've never had to, or felt the desire to need a framework, and I've built some pretty big web apps.
+
+I think some people are also looking for, you know, "I've got a checklist of things I need out of the box so that I can get started today", and I don't have an answer for them on that, but I hear things about Gorilla or Martini or things like that. To answer your question... I don't know, I don't have an answer. \[laughter\]
+
+**Carlisia Thompson:** I don't know how it is with the Python community or other communities, but with the Ruby community the message was so strong, "Don't reinvent the wheel. Don't write things yourself if there is a library out there. Use it." Also the message of "Extract your code into a gem and use that, and also share it with other people so they can use it." So I can see how people coming, at least from Ruby, would be immediately looking for a library or a framework. Not so much because they don't wanna write code, but because that was such a strong message.
+
+**Blake Mizerany:** Right. Usually what I advocate in those scenarios is I go look for something that does what you're looking for and then copy and paste it into your code. Obviously, you can give attribution as well, but usually what I see when people ask that is that they're looking for a quick fix, for something that's already... How do I phrase this...? I think they're assuming the solution to their problem is going to be much harder and much more complicated than it really is. That's why people will reach for something...
+
+\[12:07\] Not to point fingers to anyone, but I've seen libraries where people have written an entire library to do exponential backoff. To me, that's a really simple four-loop and a random sleep; it's nothing too complicated. What I see in those libraries also is that what they wind up doing is you wind up with something that's much harder to use and requires more code to use that thing than if would had you just implemented it yourself. Usually that's what I see. Just really dissect the problem down to what it really is, and try to come up with the simplest solution. A lot of times it can be solved with a four-loop.
+
+**Carlisia Thompson:** That is a very good point. I started writing a greenfield app that I know is going to be in production sometime soon, and of course my being new to Go, my first reaction was "Well, let me look for some libraries that do this stuff that I haven't done, since I worked with Java." I haven't done codes that directly access a database for ages, because I had been working with Ruby and I have libraries that do that; Rails itself did that. So I was looking for the framework just to give me a little bit of an edge, so I didn't have so much of a learning curve; like, I'm learning things in Go still, and I don't wanna be looking into all of that at the same time. But now that I'm very comfortable with what I'm doing, I'm thinking "The next project I do, I don't even want to use the libraries." I want to focus more on using the standard library, learning what the standard library offers and be more intimate with that, because I think it's going to be to my benefit knowing that, and also using idiomatic Go, and not depend so much on what framework is out there. It might be that this framework would be good for this, that framework would be good for that... No framework is going to be good for everything, and you might as well just know how to do it.
+
+And like you said, I think your point is so good, because it ends up not being that hard. Now, after I looked at it, I was like, "Okay, this is not that complicated."
+
+**Blake Mizerany:** Right.
+
+**Erik St. Martin:** I think you hit on it a little bit at a talk you did - I believe it was a DotGo a couple years ago... You talked about pre-determinism. When you attack a problem and you think you already know what you need, and for most of us, especially when you come from Python, Django or Ruby with Rails, you feel like "Okay, I need to build a web app... I need a framework, because that's what I'm used to having when I build one", instead of kind of starting to build it and figuring out what you need as you go along.
+
+**Blake Mizerany:** On the other side of that, I wouldn't recommend implementing your own database driver, or cryptography library, or bucketed rate limiting. Those types of things aren't something you just kind of throw together pretty quickly and then be done with it; they require a little bit of thought. The nice thing about those is that they have very specific problems that they solve, rather than trying to solve every single problem.
+
+**Erik St. Martin:** That's a fair point.
+
+**Blake Mizerany:** That's generally when I start bringing things in, and bringing dependencies in is when it's something like that.
+
+**Erik St. Martin:** If it's a problem that is only ever explained in formal papers, you probably want a library for it.
+
+**Blake Mizerany:** Right. I implemented the first Postgres driver for Go for the database SQL package, and I'm here to tell you that it's not something you just wanna do. I had to do it at the time, because nothing existed, but I would have preferred someone else did it.
+
+**Erik St. Martin:** \[16:08\] That's a good question, too... Because you came in so early and there weren't a lot of libraries existing already, so you kind of had to pave the way anyway. Do you feel like that kind of influences your desire to just kind of write it from scratch most of the time? Or is it really just you don't want the overhead of pulling in ten thousand lines of code to save yourself one four-loop?
+
+**Blake Mizerany:** It depends on what we're trying to do... When I say "we", I mean us at Backplane. We're trying to get something done by the end of the week; there's no problem with bringing a dependency in, but we'll definitely reevaluate it pretty quickly. But there is this strong urge a lot of times where I just want to go off and say "Oh, I'm just gonna do this myself, it sounds like fun", but then I have to stop myself, because a lot of things that people work on are hard problems. A lot of these packages out there, it's not worth rewriting. Does that answer your question?
+
+**Erik St. Martin:** Yeah, I definitely think it does. There's a "not invented here" syndrome that people can get wrapped up into, but like you said, you just kind of have to be pragmatic about your decision of whether or not to pull in a dependency or rewrite it yourself.
+
+**Blake Mizerany:** And be self-aware as well, just to make sure you're not doing it just to do it.
+
+**Erik St. Martin:** Unless you want to, for fun.
+
+**Blake Mizerany:** Right, exactly. There is some context needed there. If you want to do it for fun, then by all means, you're trying to get something out the door, put something into production.
+
+**Brian Ketelsen:** I know we've only got a few minutes left with you because you've got a hard stop in a few minutes here, but my big question for you is around building a startup in Go. What advice do you have for other entrepreneurs who are considering using Go for startups?
+
+**Blake Mizerany:** I think they should, but again, also depending on what it is they're trying to do. For us, it's been a real boom, we're extremely productive. We're working on a lot of distributed systems-y things here, and Go suits us extremely well and helps solve a lot of the problems with relative easy, while also maintaining a lot of performance. I don't know, it's a tough question. Do you have any more context you can give me around your question?
+
+**Brian Ketelsen:** No, I was just curious, now that you've had almost a year in Go as a CEO of a startup, is there anything that you would change? Are you having a difficult time finding developers? Is the talent pool big, is the language mature enough? Those are all questions that investors and entrepreneurs want to answer before they start to commit to something like a language.
+
+**Blake Mizerany:** Right. I think what's great about Go is that it's easy to learn, so if you're having trouble finding people that aren't as senior as you might hope, the great thing about it is that people can learn extremely fast. I did spend quite a bit of time - probably I spent too much time early on trying to find extremely seasoned Go engineers, and they're extremely hard to come by and they're in very high demand. You don't have to go after those people; you can easily find people that are extremely intelligent and extremely willing to learn and who are extremely hungry and want to learn and they learn really fast when they're in that mindset. So don't try to go find the rockstars all the time. If you can get them, great, but the language lends itself to be learned very easily.
+
+**Brian Ketelsen:** \[20:18\] Very good. Alright, we know that you've gotta go quickly, so we will say our thanks and goodbyes. We appreciate you coming on the show today.
+
+**Blake Mizerany:** Thank you for having me.
+
+**Erik St. Martin:** It's been a lot of fun.
+
+**Carlisia Thompson:** Thank you, bye.
+
+**Blake Mizerany:** Take it easy.
+
+**Carlisia Thompson:** What a bummer that he had to leave so early.
+
+**Brian Ketelsen:** I know...
+
+**Erik St. Martin:** Why do we all have to have jobs?
+
+**Brian Ketelsen:** And now, who wants to work? \[laughter\] The good news is there's a lot of interesting stuff going on in the Go community, so we can talk a lot about all of the exciting things that have been happening. I've seen a thousand cool Go projects this week.
+
+**Erik St. Martin:** Before we jump on this, why don't we talk about one of our sponsors? Because this is a nice, clean break, and then we can jump into some interesting Go projects and news.
+
+**Break:** \[21:05\]
+
+**Erik St. Martin:** You had mentioned too that all of the new Changelog stuff is hosted on Linode - which, if anybody has not seen yet, you should go check out the new Changelog site and the new GoTime.fm site. Adam and Jerod and the team have been working tirelessly on this for I don't know how many months, and it is finally here and it is fantastic. Also, it's backed by Fastly's CDN, which Carlisia's working for right now.
+
+**Brian Ketelsen:** Yay, Fastly!
+
+**Carlisia Thompson:** Fastly's awesome.
+
+**Brian Ketelsen:** I'm excited because it's written in Elixir and Phoenix, and I would love to see the code. I know that in their blog post they mentioned that they planned on open sourcing it, so I'm really looking forward to seeing an implementation of a serious system in Phoenix, so that I can get a better idea of what that looks like. It's on my to-do list for this year to play with Elixir and Phoenix, because they seem like interesting technologies.
+
+**Erik St. Martin:** Yeah, actually an interesting point that I forgot to mention is that they're releasing all of this open source, so if you plan on running your own podcast or a series of podcasts, you've got the hookup from Changelog.
+
+**Brian Ketelsen:** Yeah.
+
+**Carlisia Thompson:** But any CMS in general... This is a CMS that they podcast content on top of.
+
+**Erik St. Martin:** That's true. You could just use it as a CMS. Adam in the GoTime FM channel is saying they're still polishing some things up in the readme and stuff, but it won't be long. If you're subscribed to Changelog Weekly, you will see when it's announced.
+
+**Brian Ketelsen:** If you're subscribed to Changelog Weekly, you'll see it at the top of the coolest GitHub repository list. Oh, that's the Changelog Nightly... Never mind. That's my trigger to go to bed, did I ever mention that? Changelog Nightly comes out at midnight every night, and I'm like "Oh shoot, it's time to go to bed." \[laughs\]
+
+**Erik St. Martin:** \[23:56\] See, I get all these newsletters and there's always cool things in there and I don't have time, so I'll typically have multiple browser windows open, which are kind of like context, work and non-work, and the non-work one is always full of all the tabs that come from these emails and Twitter, and people sending me direct links. And they hang out there, there'll be 30 tabs, and then I'll look at two or three of them and eventually I abandon the rest, because they've been hanging out there too long. I just leave Brian to curate it for me. He tells me what the good stuff is.
+
+**Brian Ketelsen:** Well, that's a problem... I've been so busy lately I haven't even looked at most of the good stuff. I have a giant list of things that look interesting to touch, and I haven't played with them at all, which makes me sad. Although I did do something pretty cool this week that's kind of funded. If you follow me on Twitter, you'd have seen it. I embedded a term.js terminal inside Go's present tool, and hacked up the present tool to understand a syntax to open and create and attach to a Docker container, so that you could have a live terminal embedded in your presentation. That was probably the most fun hack I've done in months and months. It was so cool.
+
+**Erik St. Martin:** When you open source it, is it gonna have Hightower in it? Because it helps facilitate giving live demos, like Kelsey.
+
+**Brian Ketelsen:** \[laughs\] I don't know. I've been trying to think about a name for it, and... I wanted something with Frankenstein in the name for it, because it's just this giant ball of spaghetti garbage code right now. At this point, I'm calling it Present Term, but who knows... Names accepted.
+
+**Erik St. Martin:** I think it was Brad that called you on that, that he did it at the first GopherCon.
+
+**Brian Ketelsen:** I saw that this morning, I was so mad. Here I was, thinking I was trailblazing; Brad did it in 2014. Thanks, Brad. Shut me down!
+
+**Erik St. Martin:** There are no great inventions. Somebody else has already done it before you.
+
+**Brian Ketelsen:** I know... Cranky.
+
+**Erik St. Martin:** So let's talk about some other news and projects that everybody's run across this week. Carlisia, have you got anything for us?
+
+**Carlisia Thompson:** I do, actually. I work a lot with APIs, and some time ago I googled... You know, I have this JSON, I have to write a struct for it. Maybe there's a way to convert the JSON to structs, because you know, I'm lazy... And there was. I could not believe it, and it has such a nice UI. When I looked at it, it was made by Matt Holt. Frankly, it's unbelievable how many things Matt does, and everything he does is so well done. I really love it.
+
+It's JSON-to-Go... We'll put a link on the show notes. Basically, you drop some JSON and it magically transforms that into Go structs for you. This cannot get any easier.
+
+**Brian Ketelsen:** It's magical, I've used it dozens and dozens of times.
+
+**Carlisia Thompson:** Yeah, right? Because you do this all the time. You're pinging an API, and you need to receive a struct. It's so handy to have that... You basically just copy the struct and put it in your code, and voila! In the same way, he has a curl-to-go tool, where you paste a cURL, let's say a call to an API, and it will give you the Go client to make that call, and you place it in your code and it will work. It's like magic. So thank you, Matt, for doing those tools.
+
+**Brian Ketelsen:** \[27:55\] Those are great, good call.
+
+**Erik St. Martin:** I've got a fun one that I ran across, it was created by Nate Finch. I wanna say it's pronounced Gorram. It's really cool, it's like a command line application where you can specify a package, a method and parameters that you wanna call, all on the command line. It's like writing single-line Go apps from the command line, which is just ridiculously cool. I've started writing some shell scripts using it, because it's easier to do than Bash.
+
+**Brian Ketelsen:** Yeah, it's crazy. You can call any standard library function, and it will do all of the smart stuff to convert your Bash parameters into the correct types to make that call. I think I said on Twitter, it's one of the coolest hacks I've seen in forever. It's really neat. Shout out to Nate!
+
+**Erik St. Martin:** Yeah, I'm interested to see the motivation behind creating it. That's always the fun part for me... You run across these projects that are really cool and you start playing with them, but I want to understand what was going through somebody's head, what was the problem he was trying to solve with this.
+
+**Brian Ketelsen:** Let's get him on the show.
+
+**Erik St. Martin:** We should.
+
+**Carlisia Thompson:** We should.
+
+**Erik St. Martin:** Nate's done a whole bunch of staff.
+
+**Brian Ketelsen:** Noted. Nate Finch, on the show. If you're out there, Nate, we're looking for you.
+
+**Erik St. Martin:** No is not an acceptable answer.
+
+**Brian Ketelsen:** \[laughs\] I've got another one... I think it's Bjørn Erik Pedersen that released React in Go today, his Go React library for GopherJS. I played with it way back in December of last year, when it was really brand new, and it wasn't quite ready for primetime yet, and he's still kind of couching, saying that it is still not production-ready. But the fact that he released it to the public means it might be. If you're not familiar with GopherJS, it's a Go transpiler that emits JavaScript, lets you use Go on the frontend. The Go React is a GopherJS wrapper around React, so you can write react apps without writing any JavaScript. That, my friends, is a win.
+
+**Erik St. Martin:** That's really interesting, because that typically is the way I'm doing web apps these days, kind of thick client with React and Go on the API side. So it would be interesting to see writing the React in Go. But I'm not always a big fan of that, because even in the Ruby world - and Carlisia and Brian, you guys probably both remember this... Remember RJS?
+
+**Brian Ketelsen:** Mm-hm.
+
+**Erik St. Martin:** I don't know whether it's still there, but it was pre three... There was something called RJS, where basically you wrote your JavaScript functionality calling into your app in your templates using Ruby, and it generated JavaScript on the outside. I was just never really a big fan of that.
+
+So it's kind of like doing the same thing and you wonder how much you wanna cross into the other side, but I'd be interested to see what the API for it looks like, because it may...
+
+**Brian Ketelsen:** It looks very Go-ish, and it's really not bad. The fundamental problem I have with it is that you have to understand React before you can use Go React, and in order to understand React you've got to learn from all of the tutorials and places out there that are using the JavaScript version, or the JSX version, or whatever those are called. So there's a mental disconnect when you're reading these tutorials on how you're going to implement that on the Go side of things, and that makes it a little bit harder. If you know React really well already, then it's probably not a big deal. But learning to use a transpiler like that gets complicated.
+
+**Erik St. Martin:** \[32:10\] I think that falls into the leaky abstraction category, where you're trying to abstract some concept but you still have to have some deep understanding of the thing you're abstracting.
+
+**Brian Ketelsen:** Yeah.
+
+**Erik St. Martin:** Alright, what else do we have?
+
+**Brian Ketelsen:** DigitalOcean just released a library called go-qemu, and I've never known how to pronounce qemu, but it allows you to interact with the virtual machines from Go. You can launch VMs from either the host machine or over TCP across the network. You can start them, stop them, get information about them... If playing with VMs is in your to-do list, there's a really nice Go wrapper for qemu from DigitalOcean that was just released today.
+
+**Erik St. Martin:** Alright, interesting. I have not seen that at all.
+
+**Brian Ketelsen:** It's interesting to me, because I have been looking at ways to spin up VMs really quickly, and what timing!
+
+**Erik St. Martin:** Alright, so that is now in one of my many tabs.
+
+**Brian Ketelsen:** \[laughs\] Yet another tab. It's like a to-do list that never dies.
+
+**Erik St. Martin:** One thing I did wanna touch on too is a new repo that Cory LaNou has been working on, which is kind of like this recipe for starting a Meetup group. I think that's really awesome, because we really need more of these happening around the country. It's great to share our knowledge and to get more people interested in the language we love and to give people a forum to dip their toes into public speaking and things like that. So I highly suggest everybody check that out if there's not a Meetup group in your area.
+
+**Brian Ketelsen:** Where's the repo for that?
+
+**Erik St. Martin:** I will drop it in the GoTime FM channel. It's [corylanou/go-meetup](https://github.com/corylanou/go-meetup)
+
+**Brian Ketelsen:** Awesome.
+
+**Carlisia Thompson:** Yes, this repo is really fantastic. I haven't seen better suggestions for running a Meetup than here.
+
+**Brian Ketelsen:** No, it's really the Meetup bible. I pointed somebody at it maybe two days ago. It's good stuff. Go, Cory!
+
+**Erik St. Martin:** Yeah, I might need to help expand this too, because I've had a goal since 2014, maybe even a little earlier, to consolidate a lot of the lessons learned that Brian and I have learned from organizing conferences too, and maybe help people with a recipe to start smaller regional events to help. More stages is a good thing.
+
+**Carlisia Thompson:** Now that I'm looking at it, just one comment I have for you Cory - I know you are on the Slack right now... Not every Meetup has to be people presenting. For example, the Meetup we do in San Diego, we don't do presentations; we get together and code as groups, and that is amazing. Everybody loves it. At least, I have not seen anybody say I would prefer presentations. Everybody loves this format, so it's another option, too.
+
+**Erik St. Martin:** I think Brian and I are guilty of that too, because the Go Tampa Meetup... I don't think we've had a Meetup in a while, and it's mainly because we feel like it's hard to prepare presentations; we're always so busy, so trying to make the time to create presentations gets difficult, and then we don't end up scheduling a Meetup. But really, I think people just wanna hang out and talk Go, so I think we need to do a better job of doing stuff like that - just get everybody together and help each other with projects and problems that we're working on... Or even if it's just beers and socializing and talking about Go, I think that there's still value in that. I need to connect with that myself, that there doesn't have to be a presentation ready to run it.
+
+**Carlisia Thompson:** \[36:10\] And I stand corrected - there is a section on that repo that talks about options other than having speakers. And I agree with you, Erik. I see people struggling to find speakers sometimes, so it's nice to know that you can do other things as well.
+
+**Erik St. Martin:** We had a Ruby Meetup here that was doing a really cool thing. I forget what frequency they were doing them on, but basically what they would do is they would pose a small problem, almost like the exercism.io problems, and everybody would submit them anonymously to the Meetup organizers, and then in order to attend you had to have submitted, and then basically everybody would kind of sit there and together, collectively code review all of the submissions in kind of like this anonymous fashion. Nobody had to feel guilty that people were saying something about them personally, or would know that they made some silly mistake, or something like that.
+
+It was actually a really cool idea. It wouldn't be bad to try that in the Go world too, where people submit even exercism.io problems and we get together in person and talk about it.
+
+**Brian Ketelsen:** That's a great idea. When we talked to Katrina, she mentioned that one of the things that she really needed was reviewers, so we could actually do a Reviewathon as a Meetup topic, and sit down together and use groupthink to think about the best way to attack a problem.
+
+**Erik St. Martin:** That's true... Not even have to have their own submission; just collectively, as a group, review other things. That's cool.
+
+**Brian Ketelsen:** Yeah, that's a good idea.
+
+**Carlisia Thompson:** With Exercism you do have to do a submission for the exercise before you are able to comment on that exercise, so at least one person would have to. But I also see the benefits of everybody working on the exercise, submitting it and then doing a review. This person can add comments separately, but as a group.
+
+**Brian Ketelsen:** Yeah, that's a great a idea. I like this.
+
+**Erik St. Martin:** Yeah, just have everybody who's showing up as a prerequisite to submit this.
+
+**Carlisia Thompson:** But you can also do that during the Meetup, because a lot of times we don't feel motivated... "Oh, that's an extra thing that I have to do", but if you're in a Meetup with a group of people and everybody is doing the same thing, it's more motivating. Just a thought.
+
+**Brian Ketelsen:** A good one.
+
+**Erik St. Martin:** Yeah, definitely something to play with. Alright.
+
+**Brian Ketelsen:** I found another package that I bookmarked... I'm just going through my GitHub stars to remind me of interesting things. This one is called go-conv, and it's by cstockton on GitHub. It does reflection list conversions from Go's native types. You can convert a byte array to a string, or the word "true" to a boolean, and it does it without reflection. It promises to be faster than the other kinds of things like that that do it with reflections. I'm interested in seeing whether that is a useful package. I haven't played with it yet so I don't have any opinions, but it's something we do a lot of, these conversions, and doing them well is never easy. It would be an interesting one to take a look at.
+
+**Carlisia Thompson:** I saw the headlines for that... Can we get a link please, Brian?
+
+**Brian Ketelsen:** Yes, I will drop it in the Slack. It's github.com/cstockton/go-conv. It looked interesting.
+
+**Erik St. Martin:** Yeah, I have to take a look at that, and think of use cases where I don't typically just use strconv, or whatever. Everybody has different pronunciations of these standard library packages. I'd love to get a list of just... Because you don't really say these things, right? Everybody now knows it's fumt (fmt), right? \[laughter\] But nobody knew that before.
+
+**Brian Ketelsen:** \[40:15\] I don't think everybody knows that still. The 1,500 people at GopherCon were all shocked the first time they heard that.
+
+**Erik St. Martin:** Yeah, I think people call it stirconv... I used to pronounce it string.
+
+**Brian Ketelsen:** Yeah, I don't know... I 've had several strange moments where people pronounced package names and I thought, "I don't say it that way..." \[laughter\]
+
+**Carlisia Thompson:** I will never forget the first time I heard fumt, it was from Katrina, and I was stumped.
+
+**Brian Ketelsen:** You were stumped by fumt? \[laughter\]
+
+**Carlisia Thompson:** It was pronounced fumt. I'm like, "Really?" \[laughs\] I would never guess.
+
+**Brian Ketelsen:** Yeah, I'm with you on that one.
+
+**Erik St. Martin:** Also, I don't think that it would be an episode of GoTime without me mentioning another database that I have found written in Go. This one's called SummitDB.
+
+**Brian Ketelsen:** Oh, I saw that.
+
+**Erik St. Martin:** It looked like it was built on top of BuntDB, which I think we may have mentioned before on the show. It's basically backed by a Raft consensus algorithm, but it has wire compatibility with Redis. Some of the cool things with it is spatial indexing, and that tends to be something that I look at a lot, because people are doing more and more stuff like that, with bounding boxes and trying to find things that fall within, overlapping... Geospatial indexing is really cool, and can be useful in different types of projects. I thought that was cool.
+
+I think it uses Otto, which is a...
+
+**Brian Ketelsen:** ...JavaScript interpreter?
+
+**Erik St. Martin:** Yeah, and you can bridge between JavaScript and Go, and I think that's how they're using it for queries under the hood. In my defense, I have not dug in too deep, but I knew that it does have Redis compatibility too, so I think that's really cool. And it's all in memory.
+
+**Brian Ketelsen:** Yeah, that's pretty slick, and they claim ACID compliance, which is interesting. I wonder how fast it is, if it's got Raft and ACID at the same time. Those two together sound kind of mutually exclusive. Fast + Raft? You have to have consensus between machines, but you're getting consistency and an ACID database... There's gotta be a tradeoff there. Maybe the tradeoff is no disk writes.
+
+**Erik St. Martin:** Right. For anybody who's listening live, there's two ways you can get these links... We tried to do our best while we're talking about these things to either drop the link in the GoTime FM Slack channel, and on Twitter. So if you're following along on either of those, you should be able to find these links as we're talking about them.
+
+**Brian Ketelsen:** @GoTimeFM on Twitter?
+
+**Erik St. Martin:** Yes, @GoTimeFM. Okay, so I think that it's about time for another sponsor break. What do we have?
+
+**Break:** \[43:06\]
+
+**Erik St. Martin:** But still, regardless of the history of Code School and who now owns it, their training has always been really cool. I've just pulled up their site too, and they've got a bunch more training stuff, like Surviving APIs with Rails, Rails for Zombie Outlaws...
+
+**Carlisia Thompson:** I subscribed to their courses for a long time when I was doing Rails. I'm looking forward to checking out this Go course.
+
+**Brian Ketelsen:** Yeah, they've got great production quality, so it's good stuff.
+
+**Erik St. Martin:** Here we go, my brother is serving as your memory right now. He just messaged me and said he thinks the other one you were thinking about in Orlando is Treehouse.
+
+**Brian Ketelsen:** No. No, I was definitely thinking about Envy.
+
+**Erik St. Martin:** Okay, so he is wrong.
+
+**Brian Ketelsen:** But Treehouse is where Joe Steele worked, so now we're talking about Tampa people. \[laughs\] Sorry.
+
+**Erik St. Martin:** So if you're from Tampa and you know Joe, you know who we're talking about.
+
+**Brian Ketelsen:** Shout out to Joe.
+
+**Erik St. Martin:** Moving on to \#FreeSoftwareFriday. Who wants to go first this week.
+
+**Brian Ketelsen:** I do, I do, I do! Pick me! Pick me, please!
+
+**Erik St. Martin:** Carlisia...? \[laughter\]
+
+**Carlisia Thompson:** Go, Brian.
+
+**Brian Ketelsen:** So I wanna shout out to the folks at CoreOS. I've been all over the place this week, doing training materials and spinning up Linux machines, and I realized that pretty much everything I did had a CoreOS component in it at some point this week. So shout out to all the folks at CoreOS and the people who helped maintain CoreOS - Linux, Etcd, Fleet, Flannel, and all of the great tools that CoreOS has been putting out in the open source community. We appreciate it.
+
+I know that they're building a commercial product on top of Kubernetes called Tectonic, but I'm happy that they work so hard to give back to the open source community while they're still trying to make a buck. I think that's a great business model. So thanks, CoreOS.
+
+**Erik St. Martin:** It's surprising when I look at the stuff that they put out. The amount of their own projects they're contributing, and you said there's even more that you haven't mentioned. They had Clair, which does vulnerability scanning on containers. There are so many things they're putting out, but they're also contributing back to Linux Kernel, systemd, all these things... And it's hard to believe that this is actually a company that is for-profit. It seems like everything they do is just free to the world and helping out.
+
+I think that we owe them a ton of gratitude for all the things that they're doing in the Go world and in the container and orchestration space.
+
+**Brian Ketelsen:** \[48:00\] Yeah, and we didn't even mention Rocket and how much work they've done in Kubernetes... Good folks over there at CoreOS.
+
+**Erik St. Martin:** Yes. How about you, Carlisia?
+
+**Carlisia Thompson:** I wanna give a shout out to coffee... Nah, I'm just kidding. I'm not, but... \[laughter\]
+
+**Erik St. Martin:** And its delightful alternative, Red Bull.
+
+**Carlisia Thompson:** It's amazing what two cups of coffee can do, I tell you. Anyway... I wanna give a shout out to this repo that is called Stability Badges. Basically, it gives you SVG badges for Node projects, but I can't see why this couldn't be used for any project. The badges are things like Experimental, Unstable, Stable, Frozen and Deprecated. It would be super nice if project maintainers could add badges to their repo, so people would know "Hey, this is deprecated" or "This is active, stable" or "Experimental."
+
+**Erik St. Martin:** Oh, that is pretty cool.
+
+**Carlisia Thompson:** It is, isn't it?
+
+**Brian Ketelsen:** I like that. Is there one that I could put on all of my projects, that says "Warning! Don't touch!" \[laughter\] Oh, there is... Experimental. Yeah, I'll just leave it there.
+
+**Erik St. Martin:** I'm looking for the one that says, "I wrote this a really long time ago. I barely knew Go. It kind of worked. I'm doing other things now."
+
+**Carlisia Thompson:** "I'm better now."
+
+**Erik St. Martin:** "I'm better now and I don't use this."
+
+**Brian Ketelsen:** "Stability status: don't judge me!" \[laughter\]
+
+**Carlisia Thompson:** Exactly.
+
+**Erik St. Martin:** I like that one.
+
+**Brian Ketelsen:** I'm making my own badge.
+
+**Carlisia Thompson:** There is always a PR. That's only a PR away.
+
+**Brian Ketelsen:** That's true. My first pull request, "Don't judge me."
+
+**Erik St. Martin:** Alright, I'm gonna pull up the link for mine real quick, so we can kind of get a headstart for anybody who wants to look at this while we're talking about it, because it does a lot.
+
+**Brian Ketelsen:** This is crazy!
+
+**Erik St. Martin:** Yeah, so mine for today is called My Looking Glass, which is kind of abbreviated, myLG. It's actually really cool because it's one tool and this is all written in Go, but it does ping, traceroute, you can do BGP and look up routes, whois, port scanning, you can look at peering information, DNS... I'm trying to think of everything else that this does. I think it does layer two discovery, traceroutes, tcpdump...
+
+**Brian Ketelsen:** I did an mDNS discovery on my network with it a week ago, trying to find a device that I couldn't find an IP address for. It's awesome.
+
+**Erik St. Martin:** Yeah, it's really cool because it also has an interactive console that you deal with, and it's kind of all in one place. I find it interesting because many of the tools that we use for these have been kind of set in stone for so many years, you just kind of lean on them all the time, so it's interesting to see people reapproaching that. I find it even more cool that it's all written in Go.
+
+I'm trying to break my habit, because I'm just used to typing "dig" or "nslookup", "nmap", or things like that, so I'm trying my best to be like "No!"
+
+**Brian Ketelsen:** netstat...
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** I swear I use netstat 16 times a day. netstat-lntp. Who the hell is listening on that port?
+
+**Erik St. Martin:** And you look at the man page for netstat 20 times a day.
+
+**Brian Ketelsen:** No, because I only use it for one thing, to find out who's listening on the damn port I'm trying to open.
+
+**Erik St. Martin:** \[51:53\] One of my all-time favorite Linux commands is *lsof* List Open Files. That's awesome, to be able to see who has a port or a file open, or to see what files your process has open. You can go the other way around, too. I think that's pretty cool.
+
+**Brian Ketelsen:** Yeah, that's where I've used *lsof* - trying to move binary from one machine to the other, and call *lsof* to see which shared libraries it's using or where it finds its configuration. That was another thing I used it for. "Where is the damn configuration file for this?" You call *lsof* and "Oh, there it is."
+
+**Erik St. Martin:** The only other command I've used a ton this week is *strace*.
+
+**Brian Ketelsen:** You're on your own there.
+
+**Erik St. Martin:** You're either using it for a lot of fun or a lot of pain. \[laughter\] I had a weird issue with Docker. The container taking ten times the amount of time in a sleep; consuming ten times the amount of time on the CPU during a sleep call, whether or not it was running in the container or out, and then it turned out to be that it's something in the set comp profile, one of the sys calls. So you run it unconfined or in privileged mode - problem disappears.
+
+**Brian Ketelsen:** Did you phone a friend and called Jess Frazelle?
+
+**Erik St. Martin:** I did, I did...
+
+**Brian Ketelsen:** Awesome!
+
+**Erik St. Martin:** ...and it still wasn't able to track down... It's gotta be another system call being called by another system call. I eventually gave up.
+
+**Brian Ketelsen:** If anybody knew about set comp and Docker, it would be Jess.
+
+**Erik St. Martin:** Yeah, I told her I knew she had fun with stuff like that. I didn't think she thought "fun" was the proper word for it. \[laughter\] It can be fun to dig into these things sometimes, because you always come out the other side learning a lot more. On the other hand, when you have deadlines to meet, you end up more stressed than anything.
+
+Okay, so did we have anything else we wanted to talk about before we close out the show for today?
+
+**Brian Ketelsen:** I can't think of anything.
+
+**Carlisia Thompson:** Me neither.
+
+**Brian Ketelsen:** We were all over the map today, good show.
+
+**Erik St. Martin:** It's been fun.
+
+**Brian Ketelsen:** It's the ADHD edition of GoTime FM.
+
+**Erik St. Martin:** It's the "I forgot to take my Adderall" edition. \[laughter\] With that, I want to thank everybody who's still on the show, and Blake, if you listen to this when it's recorded, I wanna thank you again for coming on the show. Thanks to everybody who's listening live and interacting with us through Slack, and thank you to all the listeners who will be listening once this episode is released.
+
+Huge shout out to our sponsors Linode and Code School for making this happen. Especially Linode, for being the provider of our new Changelog system. Again, if you have not seen that site, please go look at it because it is awesome and everybody worked really hard.
+
+We should put in the show notes links to people's Twitter handles so everybody can thank all the people responsible for making it happen.
+
+**Brian Ketelsen:** And don't forget Fastly, for their awesome CDN and for making the wise decision to hire Carlisia.
+
+**Carlisia Thompson:** \[laughs\]
+
+**Erik St. Martin:** That's our favorite part of all, that they hired Carlisia.
+
+**Carlisia Thompson:** Well, I wanna say that I put the GopherCon Brazil website on the Fastly networking, which by the way, they are comping, so it's free...
+
+**Brian Ketelsen:** Wow...
+
+**Carlisia Thompson:** And there's this site called webpagetest.org where enter your URL and you get grades for different aspects of your website - it mostly hast to do with speed - and it went from an F to an A. It was amazing. I didn't even tweak anything on the Fastly site, because there were a lot of things I can tweak; I just added the CDN. So there we go, Fastly is awesome.
+
+**Brian Ketelsen:** \[56:03\] Wow... I'm testing GopherCon.com right now, because I've gotta know.
+
+**Carlisia Thompson:** Test all the things, this is awesome.
+
+**Brian Ketelsen:** That's cool.
+
+**Erik St. Martin:** Alright, so where did I leave off?
+
+**Brian Ketelsen:** You were congratulating the panel and thanking the listeners.
+
+**Erik St. Martin:** Yes, and if you have not subscribed already, gotime.fm, you can subscribe. Eventually, we're going to get a weekly email going out, so make sure to sign up there, follow us on Twitter if you're not, we're @GoTimeFM. If you want to be on the show or have suggestions for topics or guests, please submit an issue on our GitHub repository, which is github.com/GoTimeFM/ping, and I think that is it. Thanks again, everybody.
+
+**Brian Ketelsen:** Thank you.
+
+**Carlisia Thompson:** Thanks everyone, bye.

Creating a programming language_transcript.txt

@@ -0,0 +1,485 @@
+**Erik St. Martin:** Alright everybody, we are back for another episode of GoTime. This is episode \#28. It is our last episode before a two-week break for the holidays. Our show today is sponsored by Backtrace and StackImpact.
+
+Today on the show we have myself, Erik St. Martin, Brian Ketelsen is finally back from traveling, so he is also on the show...
+
+**Brian Ketelsen:** Wait, I'm back? Hello...?
+
+**Erik St. Martin:** You're back!
+
+**Brian Ketelsen:** I'm back?
+
+**Erik St. Martin:** Well, you can leave again if you want... I mean, we're getting used to this whole Brian being gone thing.
+
+**Brian Ketelsen:** Is this live? Wait a minute... \[laughter\]
+
+**Carlisia Thompson:** You forgot everything, Brian.
+
+**Brian Ketelsen:** \[laughs\]
+
+**Erik St. Martin:** And we also have Carlisia Pinto on the call, as well.
+
+**Carlisia Thompson:** Hi, everybody.
+
+**Erik St. Martin:** Today's special guest is Thorsten Ball, who many of you may have seen a recent book that came out by him, "Writing An Interpreter in Go."
+
+**Thorsten Ball:** Hello there!
+
+**Erik St. Martin:** So do you wanna give everybody maybe a little bit of a background on who you are and the stuff you work on?
+
+**Thorsten Ball:** Yeah, of course. As I said - or you said - my name is Thorsten Ball. I'm a software developer from Germany and at daytime I develop with the Web stack, I work on web applications in the backend and the frontend at a startup, and at night-time or in the early mornings, because I'm a morning person, I like to deep-dive into certain computer programming topics like UNIX operating systems... And since one and a half years or two years I've been digging into interpreters, compilers, programming languages and so on.
+
+I've written a book about it on how to build your own programming language and self-published it four weeks ago. I'm really excited about all of this, I'm excited about the book, I'm excited about programming languages and I'm excited about understanding how they work and how to implement them yourself.
+
+**Erik St. Martin:** So is this something you do as part of your career? Is this a passion project?
+
+**Thorsten Ball:** No, no... I wish I could do this as part of my career, but as of today nobody tapped me on the shoulder and said, "I want you to invent a programming language." I'm still hoping, fingers crossed... Yeah, this is purely a passion project. I have this weird thing where I discover a black box in programming and I go, "But how does this work?" and I start to dig deep into it; it all looks like magic in the beginning. I don't even begin to understand how this works. Then I dig deeper and I dig deeper, and down in the rabbit hole you learn a lot of things. And I love coming back up for air and blogging about it, or writing a book about it.
+
+**Erik St. Martin:** So this is the callout - if anybody needs a programming language written, contact Thorsten.
+
+**Thorsten Ball:** \[laughs\] Shoot me an email, right.
+
+**Brian Ketelsen:** I have to say, I got early access to the book and did some read-throughs on it, and it is an amazing book. If you haven't yet picked up a copy, it's well worth the read. I learned a million things and I've only made it through maybe four chapters... It's really good.
+
+**Thorsten Ball:** \[04:03\] Thank you.
+
+**Erik St. Martin:** We'll link to it in the show notes.
+
+**Brian Ketelsen:** Yeah, it's as deep of a dive as I can possibly handle and I loved it.
+
+**Thorsten Ball:** Thank you very much.
+
+**Brian Ketelsen:** It's a good read.
+
+**Erik St. Martin:** For anybody listening live, it's at interpreterbook.com.
+
+**Thorsten Ball:** Right.
+
+**Erik St. Martin:** It's actually really interesting... The language that's in it - is this a language you kind of created on the spot, or is this like a reference language that people use for creating mock interpreters and compilers? Where did the language come from?
+
+**Thorsten Ball:** The language is actually made up. It's called Monkey, and I made it up on the spot, basically. The idea for the language - if you go to interpreterbook.com you can see what it looks like, and it looks like a cross between C and JavaScript and Rust; that's the syntax. And it behave like a Lisp or, let's say, JavaScript, because it has first-class functions, it has closures and so on. The thing is, the idea for this language and why it looks the way it looks is twofold. The first reason is building a language like this, like a Lisp, with first-class functions and so on, and dynamic, and dynamically typed - it's really easy to get started. If you want to build a statically compiled language with static types, that's gonna be much more complex.
+
+So that's the first reason, because it's easy to do. The other reason why it looks the way it looks, with the curly braces and so on, is because before I started thinking about writing the book I was frustrated by tutorials that only show how to implement a programming language that looks super easy, or it looks like a Lisp... Like, parentheses... The introductory paragraph in the blog post is, "Let's skip syntax for now, let's skip parsing for now... Just use an array." I was like, "Stop, wait a minute... I wanna know how parsing works, I wanna implement this." Then you read about how parsing works with a really simple syntax, and I thought "No, no, no. Wait, I want my language to look like this, and I want to know how to do this." So that's the reason why it looks the way it does, with curly braces and so on - because I wanted it to look like a real programming language. If you learn how to build a monkey interpreter, you actually learn how to parse JavaScript, or C, or Rust. I think that's really valuable.
+
+**Brian Ketelsen:** So you just kind of half-answered one of the questions I was gonna ask... What's the value of learning about compilers and interpreters? Where does that take you as a programmer, and then what do you gain from coming away from this knowing more? Where's the take-home benefit?
+
+**Thorsten Ball:** To be completely honest, for me the biggest takeaway would be that it's super fun. As I said, I work with web applications all day, and if you develop locally, you have to spin up your server, your database, you have to make external requests and so on and so forth. If you develop a programming language, you don't need anything. You only need the standard library, and that is super enjoyable. So that's the first thing - it's a lot of fun, and I think -- I wrote this on the landing page of the book... This is for people who enjoy programming. You don't get a certificate, and I don't know if an employer will care if you say you read this book; the focus of the book is fun. If you love to dig deep, if you love to understand topics and to better understand them, this book is for you.
+
+\[08:13\] The other thing is, if you learn how to implement your own programming language, you learn how other languages work, right? And you start to understand why interpreters are the way they are, and you start to understand how Brendan Eich could implement JavaScript in ten days, or something like this. I think that's really valuable, because at the end of the day, a programming language is just a tool you use to get a job done, ideally. This is a tool you use, and I'm of the opinion the better you know your tools, the better you can wield them.
+
+I'm a big fan of understanding the abstractions you work with, so if I'm building a web page, I think you should know how HTTP works; maybe not in the beginning, but to get the most out of it, you should know one level of abstraction beneath the one you're working on - that's always the phrase I use. I don't know who said it, I've tried to find out one time, but couldn't find the original author.
+
+I think understanding the level beneath the one you're working on gives you a lot more leverage further up, and it gives you a lot more power further up, because you suddenly understand better how the pieces fit together. That's why I think if you know how compilers work and interpreters work, you can use them to a greater extent, and maybe not only use them, but to be completely honest, I think a big part of a software developer's job is debugging - as sad as that is, but you have to debug and understand problems, and this helps you a lot. This helps you to understand parser errors, this helps you to understand memory leaks, this helps you understand how an object system is implemented, this helps you understand how Ruby and JavaScript differ in certain things, and so on.
+
+**Erik St. Martin:** It's interesting, because many of the things that we use are meant to be abstractions, and so many of them actually turn out to be leaky abstractions, where when you get into these cases where something doesn't work the way you expect it to, it's typically when it becomes a leaky abstraction, and now you need to actually understand more of what happens that one layer down, which is why there's value in that.
+
+I learned a lot more about software by learning about hardware, too. When you start to understand a Crystal and the clock ticks and things like that, and that when you're sleeping for some amount of time, it's actually some sub-division of clock ticks, and it's not exactly that amount of time. You can only get a close enough resolution to it based on the clock frequency and things like that, and you start to gain an appreciation for some of these things and why things that you may think are behaving erratically, or something is just doing exactly what it's supposed to do - that's kind of where your abstraction layer is drawn.
+
+**Thorsten Ball:** I totally agree. Before the show started we had a little chat in the chatroom about IDEs, and I'm hesitant about IDEs. I use Vim, I'm a big fan of it... The things is, with IDEs - my problem with them is you're on such a high level in the abstraction pyramid... You're up there in your IDE and you press a button, and something happens further down; if something further down blows up, then you suddenly don't know what it is and how it works and why it blew up. If you understand the lower levels, you can handle these problems better.
+
+**Carlisia Thompson:** \[12:04\] Yeah, that part I didn't really understand, because I don't see the difference between pressing the button on an IDE and pressing a key or a combination of keys on a Vim or Emacs. I don't know... I'm not sure what you meant.
+
+**Thorsten Ball:** Okay, what I meant is it's not Vim or IntelliJ themselves, but if you use Vim - and you're probably gonna use Git on the command line, and you're gonna use a curl on the command line, and so on. If you know those tools and how to use the tools themselves, you probably understand them better than a Git hidden behind a graphical UI and hidden behind three layers of IDE. Does that make sense?
+
+**Carlisia Thompson:** Yes, it makes sense, but I'm not sure if it's more like memorizing the commands versus not memorizing the commands, because you have the visual right there... I don't know, maybe you can still understand the concepts without using the commands.
+
+**Thorsten Ball:** This is like a pet topic of mine... There's this book (or essay) by Neal Stephenson, and it's called In the Beginning was the Command Line. He talks about his computing history; he started with the Mac and then he went to Windows, and PC, and BIOS, and then (I think the book is 15 years old now) he switched to Linux. He talks about the command line, and he said "It was in the beginning", and in the end he ended up there again because he felt it gives him the greatest amount of power.
+
+I don't know, maybe my argument is the same one - if you can see what you're working with, if you can see more lower levels, you can use them to your advantage. I have the feeling that some software IDEs have to - they make things simpler, but they hide complexity. And the question is, if you hide complexity, how much power is lost and how much understanding is lost?
+
+**Carlisia Thompson:** I think I see your point, because for example with Git I don't use any visual graphical interface because it slows me down a lot. The reason is with the command line I can do things a lot faster, and because I can do things a lot faster, I can do more things more quickly, so I get to actually learn more commands because they're useful and they're fast enough that it's a big payoff.
+
+**Thorsten Ball:** That's true.
+
+**Carlisia Thompson:** By learning more I think I get a greater understanding of what the thing is, so I think there is that aspect of what you're saying.
+
+**Erik St. Martin:** I think the line comes between usage and implementation. If you use something that's GDB or Git tied into your IDE, you understand the principles from a usage standpoint, but not necessarily the implementation details. So when things go wrong, the implementation details are usually what matter in trying to diagnose and troubleshoot the problem. We could say this about any technology... A database, for example MySQL. Most of us just use it, but when things go wrong, having an understanding of how databases work is without a doubt going to help you, and I think it's just a tradeoff of the time involved in learning the tool at that level, versus the productivity that you need. So things like Git or something like that are maybe a slight learning curve, but it's not the same level as learning how a database is actually implemented at the disk layer.
+
+\[16:09\] For most of us there's not a lot of value in that, but there can be a lot of value in understanding the operating system at least at like a surface level, and command line and things like that. It's just kind of a constant trade, I guess.
+
+**Brian Ketelsen:** I wanted to bring up almost the same point, but from the opposite direction. I've only ever done Git from the command line, and I was in Windows the other day and needed to do a Git operation, and I had the GitHub client, GitHub Windows application, and I opened it up and I couldn't understand how to use it.
+
+**Erik St. Martin:** I've been in that boat, too.
+
+**Brian Ketelsen:** All I wanted to do was merge master into my branch so I could make sure that it worked, and I clicked buttons but I could not figure out how to just merge master into my branch, and I was getting really frustrated. So it's almost as if those layers of abstraction take away the power of the tools that you're using; I definitely agree with your point.
+
+**Carlisia Thompson:** And everybody who designs a visual tool has his visual aesthetics, and each visual tool is going to be different and you have to learn it, whereas with the command line, usually the commands have a certain commonality, like UNIX-themed, and you can sort of figure out the commands from one tool to another.
+
+**Thorsten Ball:** Yeah, I'm not against graphical interfaces. Some are vastly superior to their command line equivalent. They give you a much better understanding. The best example would be viewing your Git commit history. In a graphical interface, that gives you a much greater understanding and a lot more power, and so on.
+
+I think you also have to really draw the line somewhere, because if you keep digging and if you keep breaking open those black boxes, I don't think you're gonna come away super healthy, right? \[laughter\] You're never gonna get done, and...
+
+**Erik St. Martin:** All I need to do is send an email, but I need to understand how a NAND gate works. \[laughs\]
+
+**Thorsten Ball:** That's right, yeah. Look, one and a half years ago, two years ago I tried to understand how CPUs work. Then you dig into CPUs and you understand kind of what they do, and they fetch instructions, and they decode them, and then they execute them, and they talk to memory, and I/O devices and so on. And then you peek below this level and you realize, "No, wait a second... They're actually executing five things at the same time? And then they're caching stuff and then they're pipelining stuff and they are programmed too and they're super complex and I have no clue what's going on anymore?" and you have to draw the line somewhere. Like, "Alright, this is the API, this is the level of abstraction I'm gonna work with", because you're gonna run out of time. It's the saying "It's turtles all the way down." If you keep digging, you're gonna find another level, and another level, and another level, and another black box.
+
+**Erik St. Martin:** There's just not enough time to learn all of it either.
+
+**Carlisia Thompson:** And that brings up a good point, too... I was like this earlier in my programming life, trying to just use one tool for a particular thing, and there's absolutely nothing wrong with using multiple tools; there's nothing wrong with using a couple IDEs, one to do most of the stuff and one to do other things that they do better. For example, I use a graphical Git tool to see a history, like we were talking about, but I cannot figure out -- even if I wanted to use it to merge stuff... I've tried it before and I'm like, "I don't know how this works, I don't understand it." But for looking at history it's perfect, and looking at diffs.
+
+**Thorsten Ball:** \[20:03\] That's certainly true, yeah. That's exactly what I meant. As I said, you have to decide what to look into, and you have to decide how much time you're gonna spend. What I'm saying is if you're trying to understand those levels below you, and even if they at first might not seem related to what you do in your day job, I think there's gonna be a payoff if you understand them better. That's what Brian said at the beginning, that a better understanding of hardware gives you a better understanding how in the end software is gonna work on it.
+
+**Erik St. Martin:** Yeah, and I think it's important to choose your battles, too. We've only got so much time and mental capacity to learn these things, so I think it's okay to take the easier abstractions on the things that you don't care about so much, but maybe don't on the things that are going to help you succeed directly at your job, or your task at hand.
+
+**Thorsten Ball:** Yeah.
+
+**Erik St. Martin:** I think it's about time to take a break, and when we get back we really wanna start talking a little bit more about your book, and all that good stuff. So let's take a quick break.
+
+**Break:** \[21:15\]
+
+**Erik St. Martin:** And we are back, talking to Thorsten Ball about his interpreter book, Writing an Interpreter in Go, which has been really interesting.
+
+**Carlisia Thompson:** Thorsten, I was looking at the blog post from Steve Yegge, the Rich Programmer Food blog post that you mentioned, and it's absolutely fascinating. I haven't gotten to the end yet, but he talks in detail in a very funny way about why the need for learning about compilers. He also mentions that not everybody -- even people who have a CS degree, they haven't taken a compiler class because it's optional in a lot of places. It was true for me, and I remember debating... I felt like I wanted to take a compiler class because it was thoroughly -- I was very focused on design and language, but compilers were totally out of my focus, so that was attractive to me. I thought, "Well, every compiler is there. If you're programming, you're using a compiler, so it has to be useful to learn." But in the end I didn't take it. I thought it would be too niche. I thought that in practical terms I'm not gonna be building compilers, so maybe it's not going to be so useful, and I so regret not taking it... I wish I knew better.
+
+With that, I wanted to start talking about what exactly is an interpreter and a compiler, how they work and why are they the building blocks, and what makes it such a big deal and useful for us to know about them?
+
+**Thorsten Ball:** \[23:47\] Yeah, that's exactly the point you make. I think it's really funny because a lot of people, they... What you said is absolutely correct - the market of compiler writers is a small one. You don't see many advertisers or recruiters sending out emails like "Do you wanna write a compiler?" But a compiler is hugely complex, it's interesting, it has a lot of parts, and if you understand how they work, you can take those parts and use them in other places. If you look at those parts, you can recognize patterns and then use those patterns again.
+
+The basic idea behind a compiler is it takes input, which is programming code or code, and it takes this input, transforms it and puts out something the computer can understand and execute. You take puts "Hello World" and give it to a compiler, and the compiler outputs machine code. This machine code is much longer than puts "Hello World" and it contains all the machine code instructions that tell the CPU and the computer how to display Hello World on your screen. It does this by having certain stages... You always talk about stages and passes with compilers. Source code comes in on one end, and on the other end comes out machine code, or some other form of code. I don't wanna escalate this conversation, but there are certain compilers that do not translate to machine code, but other programming languages; they're sometimes called transpilers.
+
+In the end, it's the same idea - you take source code and output something that a computer can understand. It does this by first parsing the input; it most of the times constructs an internal tree, a syntax tree, and it then has several passes or phases where it takes this tree and tries to look at it in detail and find out if there are some parts of the tree it can move, throw away, or if there are some parts of the tree it can fold together, or if there are duplicates, if there are errors, if there are parsing errors in there. Then it takes this tree and it kind of - I'm simplifying, right? - walks down the tree and it outputs machine code that lets the computer execute what this tree is supposed to mean. It gives the tree meaning, it gives the source code which you input meaning. Does that make sense?
+
+**Erik St. Martin:** Yeah, it does.
+
+**Carlisia Thompson:** Yeah, it makes sense.
+
+**Erik St. Martin:** One of the coolest tricks I've ever seen with people understanding how a compiler works is actually from a security perspective.
+
+**Thorsten Ball:** Right.
+
+**Erik St. Martin:** I forget who this was that posted an article about this, but you could rewrite the source code of the compiler, compile the compiler with it, and then compile the compiler with it again, and then it would be in the compiler, but not in the source code. So now anything that you compiled with this tainted compiler would have your backdoor in it.
+
+**Thorsten Ball:** Reflections on Trusting Trust is the name of the paper, by Ken Thomson.
+
+**Erik St. Martin:** Yes!
+
+**Thorsten Ball:** It's super interesting and mind-blowing actually if you read it. It's like a science fiction short story on four pages.
+
+**Erik St. Martin:** So let me ask this... Why an interpreter instead of a compiler? And a good question for some of the listeners may actually be "What's the difference between an interpreter and a compiler?"
+
+**Thorsten Ball:** \[27:46\] Alright. First of all, the difference is an interpreter takes source code as input and executes it, and it doesn't leave anything behind except what the source code tells the interpreter to do. A compiler takes source code as input and produces something that can then be executed. For example, Ruby the programming language is an interpreted programming language, and if you want to run Ruby source code, you take Ruby source code and pass it to the Ruby interpreter, and it executes the source code. And a compiler, like the Go compiler, it takes Go code and produces and leaves behind an artifact, an executable binary file you can then run on your computer and your operating system, and your CPU can now understand this. That's the big distinction. But again... It's turtles all the way down. The lines get fuzzy real fast if you start to dig in, because there are certain interpreters - for example those highly optimized JavaScript engines - that kind of cross the line, because they're compiling while they are executing. This is called "just in time" compilation (JIT).
+
+So the question is, "Is this a compiler, or is this an interpreter?" because it takes source code, it then compiles it to get machine code, and it then executes this machine code directly, just in time. The question is, "Is this a compiler or an interpreter?" I don't know what the answer is... They're called JIT interpreters or JIT compilers, and they're really fascinating.
+
+The reason why I chose to explain how an interpreter works is because I think compilers are much more, let's say -- I won't say 'complex', but you have to do a lot more to get it working. I wanted to keep the scope of the book small, so I only chose to show how an interpreter works as a starting point. Because if you follow the book and you do everything in the book, you get away and you know how its parser works or how it's built, and how you can build your own, and you know how to walk the abstract syntax tree. Those are all parts you can use, again, in a compiler.
+
+The other thing is I'm not a compiler wizard, or anything. I'm not a compiler expert, and it's a topic that's still kind of intimidating to me because I don't know everything about it and I don't really know how those big compilers (like GCC) work. I'm starting to dig in... I tried to build a compiler for the Monkey language, or I'm currently building it, I'm playing around with it, and I think if I chose to do that, to explain how a compiler works, the book would have been like 200 pages longer. It was just a question of scope, and it was a question of how easy is it to get started and how easy is it to finish the book.
+
+I think in the end it's not one or the other, because if you learn how to write an interpreter, you're perfectly well equipped to write a compiler afterwards. In my opinion, it's the first stepping stone to understand compilers better.
+
+**Erik St. Martin:** I guess you would have to introduce some form of assembly language, whether that's your own made-up assembly language or an actual assembler. You would have to somewhat understand that in order to implement the compiler.
+
+**Thorsten Ball:** Yeah, that's the thing. I love to talk about virtual machines, but I try not to get into them. You could build a compiler that outputs bytecode, right? And bytecode is something like made-up machine code; it's machine code for a machine that doesn't exist, and it's not as hairy as assembly language or machine code, and it's easier to understand. But if I were to explain in a book how to compile to bytecode, I'd have to explain what a virtual machine is. And if I have to explain what a virtual machine is, I'm also gonna have to explain what a machine is.
+
+\[32:09\] That's what you said, you have to understand assembly language and you have to understand what an assembler is, and what instructions are, and then you have to explain how the machine works. I don't know... The scope blows up.
+
+**Erik St. Martin:** I was actually gonna recommend a book that I read a few years ago and I'm probably due to read again, that I highly recommend to people. It's very short, and I don't know whether you've come across this... It's called The Elements of Computing Systems.
+
+**Thorsten Ball:** Yes.
+
+**Erik St. Martin:** Yeah, they call it From NAND to Tetris. If you're interested in it, it's NAND as in NAND gate... Nand2tetris.com It's only about 300 pages, and this is kind of the shortfall of the book - because there are so many topics to introduce, it moves very quickly through boolean logic and arithmetic and gates, and how the arithmetic logic unit is composed of these gates, and then it moves up into an assembly language and then a compiler, and then I think ultimately a virtual machine and a mini operating system that runs in your fake language on top of all of this. So the shortfall of it is it moves very quickly, and I feel like you need... It's enough for you to understand how each of these pieces work from an outside glance perspective, but not enough to implement them from scratch. But the cool thing about each of these areas for self-exploration is they did a really good job at having tests. When you're on the chapter about learning about assembly language, they give you a program that can analyze the output of your assembler and tell you that it's wrong. They give you some sample inputs that you can run for this program and see... And each stage is like that, so they're kind of self-contained in that sense, but really when it comes down to like, "Okay, I wanna sit down and I wanna build the virtual machine", you feel like you could cobble something together, but you don't feel confident enough in what you learned in that quick chapter to just sit down and write one.
+
+So now that your book has come along in a language that I'm super interested in, I kind of feel like I wanna reapproach that book and now read your book for a better implementation of that. It'd be kind of cool to start seeing some of the other areas implemented, too... You're talking about virtual machines and things like that, almost like reference implementations.
+
+**Thorsten Ball:** Yeah, so this book is amazing. It's actually - and I'm not joking - what holds up the microphone on which I'm recording this. \[laughter\] The microphone is sitting on top of the book, right? I read this two years ago, and I have the exact same feeling like you just described. It's an amazing book and they have a really good software suite you can download and execute, and example code and so on, but I was still getting frustrated, like you've just described, because... I don't know. Like you said, you walk away from the book and you think, "I kind of get this, but not really." You can invest a lot of time in it, and I don't know if then you would get a proper understanding. But then there's the question, "Could there be an easier way?" I think the book is written by two computer science professors - correct me if I'm wrong, but I think so - and they actually teach the content of this book, and they have courses on this, and they have lectures on this.
+
+If you have this in combination with the book - a teacher that guides you along the way and gives you additional information and hints and tips and tricks and so on, this would be an amazing course to take.
+
+\[35:53\] The thing is, there are few other books like this. If you look at compiler books, most of them have at least 600 pages, and everybody always recommends Dragon Book, and I think it has 900 pages. Those are books - their target audience is not you or me sitting at home on a Saturday evening, like "I'm going to program something today." Their target audience is probably students sitting in college or university and trying to really study compilers. Their target audience is also other professors or computer science experts. That makes it really hard to digest, and that actually kind of kicked off the idea that I should write a book... Because, to be honest, I love handholding, I love if someone walks me through, like "Go from this to this, in these steps." I love this, and there can't be too much handholding and explanation. That's what I try to do - fill the gap between let's say an every man's interpreter book.
+
+**Erik St. Martin:** I think for most of us that don't have large academic background, it's really that "source code or it didn't happen" type feeling.
+
+**Thorsten Ball:** That's right.
+
+**Erik St. Martin:** If I see a whitepaper on something, it's like, this is really interesting, but I don't feel like I have the academic background to look at the mathematical proofs and be like, "Yeah, I totally get this." It doesn't matter if it's just cobbled together code that isn't meant for production use, but just seeing the code itself, the referenced implementation can at least trigger your thought process and you can see how you could do it differently or more efficiently. But learning about these kinds of abstract ideas, especially at like a quick glance -- you've got the book in front you, mine's on my bookshelf... But each of these chapters can't be more than 15 pages.
+
+**Thorsten Ball:** Right.
+
+**Erik St. Martin:** ...how does assembly language work in 15 pages..? I think my assembler book is like 900 pages, you know? So you kind of need a little bit of handholding, or at least some reference code that you can break and fix again and get a better understanding for how each of the pieces work.
+
+**Thorsten Ball:** Exactly. So the point is, in my book -- I wrote this on the landing page... The center of the book is the code. It has 200 pages and I guess half of it is probably code snippets. In other books... I have a few other compiler books sitting right here on the desk too, and the code is at the end of the book, in the appendix. And the code is... Let's say it's not the cleanest code, or the most modern code.
+
+**Erik St. Martin:** Or it'll be pseudo-code...
+
+**Thorsten Ball:** \[laughs\] Yeah...
+
+**Erik St. Martin:** Like, you can't even compile it.
+
+**Thorsten Ball:** Yeah, you can't compile it. You're probably not gonna find the compiler that could compile this 15 years ago. That makes it really frustrating, because if you have code on your computer that's in the book, and you can actually copy and paste it or type it, that changes the ergonomics of the book, because you can actually play around with it, you can experiment, you can make modifications and so on. That gives you, I think, a much better understanding how something works.
+
+In the introduction of the book I recommend that if you want to get the most out of the book, read it and try to type off the code or follow along by writing out the code, or copy and paste it, but try to follow the steps by actually building the interpreter. I think that's how I learn the best.
+
+**Carlisia Thompson:** \[39:50\] Carlisia, you mentioned I think on a prior show that there's a Coursera course for it... Is she still here? Did we lose her?
+
+**Brian Ketelsen:** Uh-oh...
+
+**Carlisia Thompson:** I'm sorry, I was muted. I was muted, I'm sorry! \[laughter\] I just found the link for the course, and I pasted it on Slack. The next session is going to start on 19th December. I should do it...
+
+**Thorsten Ball:** Do it. Do it, definitely.
+
+**Carlisia Thompson:** Yeah... I'm definitely doing it, I'm just questioning if I should do this one.
+
+**Thorsten Ball:** No, it's really good.
+
+**Brian Ketelsen:** It's all about time.
+
+**Carlisia Thompson:** If somebody wants to do it with me, ping me... You're motivating me.
+
+**Erik St. Martin:** If I delay our barbecue project any longer, Brian will probably come over here and kill me.
+
+**Brian Ketelsen:** That's not true.
+
+**Erik St. Martin:** ...so if you wanna wait until I finish that one or get further along on it, I'll do it with you. So I think we're at a good spot here to take a second sponsor break. When we get back -- I know that impostor syndrome is another thing that's kind of near and dear to you as well, Thorsten, and especially when you're talking about compilers, interpreters and things like that, I know that that can kind of make people feel the impostor syndrome even more.
+
+**Thorsten Ball:** Yeah.
+
+**Erik St. Martin:** So let's take a quick sponsor break.
+
+**Break:** \[41:06\]
+
+**Erik St. Martin:** And we are back, talking to Thorsten Ball about his Go interpreter book and all things compilers, interpreters and learning low-level development. Before the break we kind of brought up impostor syndrome. Why don't you talk to us a little bit about that? The whole idea about learning hardware or compilers and interpreters and garbage collection, and all these things -- I know especially for people who don't have academic backgrounds can kind of make a lot of people, myself included, feel inadequate to do the jobs that they're hired for.
+
+**Thorsten Ball:** Yeah, okay. I'm a self-taught developer; I didn't go to college or study computer science and that's always in the back of my head, thinking "Oh, I'm missing something here." I think impostor syndrome is something that everybody experiences - developers, in general, even if they studied computer science, and I think it's a perfectly natural feeling you have. In certain areas - like compilers, for example - this is a hugely intimidating topic, because compiler authors are hailed as some kind of wizards, or heroes, or they're doing some kind of black magic... You probably wouldn't understand it, right? And the textbooks have all this academic field to them, and they have mathematical notation in them, and they talk about a lot of formal things, and so on... And it's really intimidating.
+
+What I experienced in the last years is every topic that at first feels super intimidating loses this appeal once you dig into it, and you start to realize "Wait a second, it's not really magic. Actually, it's pretty to understand here, and here" and then you grow up your understanding and you understand more. In the end, you lose all your fear and this feeling of "I'm not worthy enough to understand this", because you suddenly realize "Oh well, it's actually just this and this. It's not this huge thing I made it out to be."
+
+\[44:15\] The big part of it is trying to get over yourself and trying to tackle this and trying to get an understanding of it.
+
+One of the big things with impostor syndrome is that you always assume that, "Oh the other people - they know much more than I do. I don't know how compiler's work, but it seems like everybody else does. I don't know how interpreter languages work, but everybody else does", and so on. I think that's a fallacy. Probably everybody knows that it's a fallacy and you still get the same feeling anyway. The thing is, if you get to know these other people that are super experts in these super specialized topics, you start to realize that they don't know certain things you know. You can probably find 20 compiler writers which you or I made out to be these super mystical computer wizards - you can find 20 of them that don't know how to use HTML and CSS. If you realize this, this is a super comforting feeling... Once you realize that from the outside it looks like everybody else has it all figured out, but then you realize if you peek behind the curtain, no, it's not like that. You know other things they don't know.
+
+**Erik St. Martin:** I guess it's "Perception is reality", right? There's a couple things... I posted kind of a famous image for impostor syndrome, that kind of shows a big circle and a small dot. The big circle is "What I think other people know, and I'm just a tiny dot", and then it shows the reality, which is you're the circle in the middle and there's this bunch of circles around you with some small overlap. That's really the reality of it; you hit it on the head. Take somebody who works for NASA and does computer vision for Rovers, or whatever, and be like "Make me a web page", and they're quickly gonna stumble, too. It's not that they're incapable of learning it, but you're going to be an expert at whatever you spend eight hours a day doing. You may know nothing about writing video games today, but if somebody hired you in a year from now, eight hours a day, working on video games, you're gonna know a lot about writing video games.
+
+**Thorsten Ball:** Exactly.
+
+**Erik St. Martin:** Brian and I have talked to people who worked on the Go compiler, and even they don't give themselves the credit that they should, because we admire their work, but to them, they feel like it's micro-improvements on things they've been doing their whole lives, right? They're compiler writers, that's just what they do.
+
+**Brian Ketelsen:** I was just gonna give an analogy... I sat next to someone I won't name - for obvious reasons - at one of our speaker dinners at GopherCon and we were having a discussion... This is a person I admire greatly, from either internal or external part of the Go team, and the conversation we had made it very clear to me that this person didn't understand two thirds of the things that we do writing APIs for the web, at all. No clue about how HTTP works, or any of that. And I thought, "This is impostor syndrome. This is really it. This is me knowing some things, and this other person knowing a whole lot of different things but in a very specialized way", and that brought the whole thing to light for me.
+
+**Erik St. Martin:** Yeah, there's no one greater than the other, it's just different.
+
+**Carlisia Thompson:** \[47:51\] Yeah, I started trying to minimize my impostor syndrome by interacting more with people that I think are amazing, and I don't want to minimize the feeling, because it's real, I feel, and I think everybody feels it to whatever extent... It's funny, because you have these people you admire, we always have people we admire, and sometimes we have a chance to see them face to face, and we might get shy about talking to them, because they're so amazing and you think, "Oh my gosh, I'm not at that level at all. Not even close", and we don't realize that they are amazing at what they do because they've been doing it for a long time, but they're not amazing at everything. Sometimes you are amazing in ways that they don't even know... Like Brian was saying about the API aspect of development.
+
+You can totally interact with people like that and even collaborate if you open yourself up for them to help you, for example, and keeping in mind that maybe you can help them as well. It's brilliant. Then you start seeing, "I too have things to contribute." I think it helps a lot.
+
+**Thorsten Ball:** Yeah.
+
+**Erik St. Martin:** You know, Bryan Liles was on episode \#17 of the show, and one of the things that I loved that he said during that episode is "Stop comparing yourself to other people. Compare yourself to yourself." An analogy is "Today I'm one Brian..." The goal is to improve yourself, not to compare yourself to others. I think that's a good takeaway. You should be proud of your own growth at the end of the year, and not be so concerned about the way you perceive others. And especially I think conferences can do that to people, too... Because you see people get up on stage and talk about these wickedly complex things, and things that you think are just completely over your head... This goes back to the whole "Perception is reality" thing. We see that and we perceive that they are the foremost expert on that topic, and what we don't see is they may have spent four to six hours a day for nine months leading up to that, or a year before, just researching that specific topic, and they laid out everything that they know in those slides, and that's really the depth of it.
+
+Then there may be people who just quickly glance on topics to try to simplify them for the audience, and they know far more about the topic than it leads on in their talk, but that's not what we see, that's not how we perceive it, and that's just kind of like the fallacy of it all.
+
+**Thorsten Ball:** Yeah. I think talks at conferences is a really good example, because you watch those talks and you're kind of in awe because you think, "Oh my god, they know so much", right? And you kind of have the assumption in your head that they wrote down these slides really fast, and you can probably wake this person up at night and he would tell me the exact things. But the reality is that this person up there on stage, like you said, spent a lot of time putting this together, and - here's the point - researching those topics. It's not said that this person knew everything he's saying on stage before he started working on the talk.
+
+Personally, my philosophy - I think Martin Fowler said this... He writes books to better understand what the book would be about. He starts and doesn't know everything about a certain topic, and he writes the book to better understand it. Then out comes the book and everybody assumes, "Oh, this guy, he has it all figured out. Look, he writes a book."
+
+The same thing is kind of happening... I get really shy -- people say to me, "Oh, you wrote a book... That's so impressive!" I know how the sausage is made now, and I'm always like "No, no, no... It's not that impressive." It took me a year to write it, and it's just markdown files, and... Oh my gosh, there's so many spelling mistakes and errors...
+
+**Erik St. Martin:** ...As it was written in XML. \[laughter\] Picture that, anybody... Write a book in XML. \[laughter\]
+
+**Thorsten Ball:** Yeah, that's the point. Like you said, that's the fallacy of it. If you see how the sausage is made, suddenly you realize, "Yeah, everybody else is doing the same thing I'm doing here", and that helps a lot.
+
+**Erik St. Martin:** That was actually something I was gonna bring up too with your book - you start to learn that in actually trying to write it, you've learned far more, because you wanna make sure that you're not going to say something incorrectly. So even if you think you know, you research and research and research to make sure that you are pretty certain or at least have enough evidence to back up what you're saying.
+
+**Thorsten Ball:** Right.
+
+**Erik St. Martin:** But I think people think that you just sat down and you're like, "Hm, I think tonight I'll write a book about interpreters." \[laughter\]
+
+**Thorsten Ball:** Yeah... "Let me put down really fast how much I know." It's not like that. Like you said, there were points while I was writing, and I was just gonna write the abstract syntax tree, right? And then you think, "Wait, is that correct? Is that an abstract syntax tree, or is that a syntax tree?" And then I researched what's the difference between an abstract syntax tree and a syntax tree, and as it turns out - correct me if I'm wrong - it's largely a matter of naming things, and some people choose one name and some people choose the other name. The same thing... You write, "We're gonna build a lexer", and then you realize "Is it a lexer or is it a scanner? Or is it a tokenizer?" and then you research again and you learn all this stuff just by trying to understand it, and the end result looks like I actually know what I'm doing, right? \[laughter\]
+
+**Erik St. Martin:** On all of that I would have to defer to you, because in this case I'm fairly certain you know more than I do about this stuff...
+
+**Brian Ketelsen:** Definitely more than me.
+
+**Erik St. Martin:** I've never written one...
+
+**Thorsten Ball:** I don't know...
+
+**Erik St. Martin:** So, do you guys wanna move on to any interesting news and projects going on in the community? I know we've got a few more minutes left of the show.
+
+**Thorsten Ball:** Sure.
+
+**Brian Ketelsen:** There's some cool stuff happening out there.
+
+**Carlisia Thompson:** As always.
+
+**Brian Ketelsen:** Really cool stuff. I think we have to start with the Gopher Academy Advent Series blog posts... If you haven't been following along with that, blog.gopheracademy.com. We've had some amazing blog posts this year. One new post every day, and I have to give a huge, huge shout out to Damian Gryski for stepping in this year and helping to herd all the cats for all of the different blog posts coming up. With Erik and I both traveling this month, it was almost impossible for us to do it, so great, big, giant gopher hugs to Damian for helping to get all of that moving. Really good posts this year.
+
+**Erik St. Martin:** Without him I'd don't think there'd be a series this year.
+
+**Brian Ketelsen:** It was not gonna happen, no.
+
+**Erik St. Martin:** Massive shout out. Also on the news of Damian, I recently saw that he was promoted to moderator of the Go Subreddit, which is awesome.
+
+**Brian Ketelsen:** Head moderator.
+
+**Carlisia Thompson:** Head moderator.
+
+**Erik St. Martin:** Head moderator. I couldn't think of anybody better.
+
+**Brian Ketelsen:** Chief Gopher on campus. \[laughter\] That's Damian. He is the Head gopher.
+
+**Erik St. Martin:** Speaking of people who can make you feel like you have impostor syndrome, not only does he understand whitepapers, but he's got like all of them memorized. \[laughter\]
+
+**Brian Ketelsen:** And he implements them. Have you seen his GitHub repository? He implements them for fun.
+
+**Erik St. Martin:** He's this encyclopedia of whitepapers.
+
+**Brian Ketelsen:** Yeah, that's pretty awesome.
+
+**Thorsten Ball:** His repository is super interesting. There's so much work in there, and it's super interesting.
+
+**Erik St. Martin:** \[56:10\] The other thing too is the Go Blog has a survey on there, which is blog.golang.org/survey2016, and they are kind of reaching out to the community to get an idea for use cases, in particular company use cases and the reasons why people are or aren't adopting, and whether they're continuing to grow within the organization, and things like that. So if you use Go inside your company, definitely participate in that because I have the feeling, as with all of their reach outs to the community, that that will highly impact future Go for all of us.
+
+**Brian Ketelsen:** There's a reason behind that, yes.
+
+**Erik St. Martin:** It's to capture your email.
+
+**Brian Ketelsen:** Yeah. \[laughs\]
+
+**Erik St. Martin:** It's all a trap.
+
+**Brian Ketelsen:** So there's a couple interesting news bits and some projects we should shout out. The first thing, this morning I woke up after -- first of all, eight hours of sleep, which is the first time I've had eight hours of sleep in like two weeks (Oh my god, it felt so good!)... So I woke up and there is a new IDE from JetBrains for Go, and it's called Gogland; something that has "gland" in the name, kind of weird. But I downloaded it and it's kind of awesome; I ran it on Windows and Linux, the experience was amazing. It detected my GOPATH, it detected my GOROOT... When I went out to open a project for the first time, it dropped me right in the source directory of my already configured GOPATH and asked me which one I wanted to open. It's a very nice looking IDE.
+
+**Erik St. Martin:** I haven't installed it yet, but I saw some cool stuff with documentation popups, and there was a couple features where it pointed out in the gutter recursive calls, and all the exit points of a function. There were some kind of interesting things that I haven't seen in any plugins for other editors.
+
+**Brian Ketelsen:** Oh, nice.
+
+**Erik St. Martin:** Yeah, it looked really cool. And I know it had some refactoring stuff, and it was kind of expected from the IntelliJ suite. Yeah, it looks really cool. I'm too much of a Vim guy, so I can't guarantee I will convert to it, but I might at least download it and play with it.
+
+**Brian Ketelsen:** All of my students ask me, "What should I use for an IDE?" and many of them want a real IDE, so I kind of feel obligated to test them all out and play, and so far this looks pretty nice.
+
+**Erik St. Martin:** Lauren just pointed out in the GoTime Slack that they have a Vim mode plugin, so I guess now I really have to install it.
+
+**Brian Ketelsen:** Oh, you have no excuse now.
+
+**Thorsten Ball:** And it's actually pretty good, I've tried it. It's one of the better Vim mode plugins for other editors. It's really good.
+
+**Carlisia Thompson:** Interesting. I'll try it, too.
+
+**Erik St. Martin:** You just recently converted too, right Carlisia?
+
+**Carlisia Thompson:** Well, \[unintelligible 00:59:06.04\] but I've been going back to Atom a few times... I mean, I've been using Vim for a while, but recently with the Go plugin from Fatih, I went full-time. But sometimes I go back to Atom, if I'm doing a lot of copying and pasting and stuff.
+
+**Brian Ketelsen:** Is that like a comfort food thing? I used to keep Sublime Text around when I first started Vim. It was probably a whole year where I had Sublime opened just for when I needed to copy and paste things. And then Erik sat me down -- literally, Erik sat me down at lunch and he's like, "Dude, I'm gonna teach you how to cut and paste stuff in Vim, and then we can move on here. \[laughter\]
+
+**Erik St. Martin:** I ended up like pair-programming almost with him in his office for a little while... I think the reason why is because I was there; I'd tell him, "Just do what you need to do, let's cover the things that annoy you the most, and then anytime you think that something is taking too many steps to do, ask me, and then you'll learn a little at a time."
+
+\[01:00:09.21\] That's kind of the way to do it - you just kind of have to accept that it's a little slow at first learning... Then once you have your foundation of commands, there are quicker ways to do stuff, but you're like "Who cares...? Do I really care whether it's four keystrokes or two? No, probably no." \[laughter\]
+
+**Brian Ketelsen:** So that was me last week, teaching a class on Kubernetes -- actually, it wasn't last week, it was this week... Teaching a class on Kubernetes to system administrators, and I'm on the big projector using Vim... Every two minutes it's "Oh, why didn't you use this movement? Why didn't you do this?" I was like, "Alright, you know what? Next time I'm using Atom. \[laughter\] At least I won't get criticized every five minutes."
+
+**Erik St. Martin:** You gotta be \[unintelligible 01:00:51.29\] and use Notepad, remember?
+
+**Brian Ketelsen:** Right.
+
+**Erik St. Martin:** That was the thing, I remember, in the web development world, where everybody would argue over IDEs... Like, "No, I use Notepad", or whatever Windows text editor is, and it's like, "That doesn't make you \[unintelligible 01:01:05.13\] Do you code professionally?" I couldn't imagine working eight hours/day with no line numbers... I can do without syntax highlighting and shortcuts and all that stuff, but there's some basic stuff like line numbering that just needs to be there.
+
+**Thorsten Ball:** Can you actually work without syntax highlighting? I probably see this only in the Go community that people willfully turn off syntax highlighting.
+
+**Carlisia Thompson:** Brian is doing it.
+
+**Brian Ketelsen:** Yeah, I turned off syntax highlighting maybe six or nine months ago, and I don't miss it at all. It took me three or four days, and now I agree with the other people - I think Andrew Gerrand was probably number one - who said it's much easier to read it without all of that colorization in your way. Now you can read the code, rather than be distracted by colors.
+
+**Thorsten Ball:** Really?
+
+**Carlisia Thompson:** I'm with you, Thorsten. I can't even try it. I can't even think of trying.
+
+**Erik St. Martin:** I still have it on. To be honest, I'll SSH into a machine that doesn't have syntax highlighting, and I'll work just fine for a little while. It won't bother me enough to try to set it up on that machine. So I feel like I could probably do it, but I think I might want somewhere in between, or at least maybe functions are highlighted, so that I could quickly scan and jump from function to function, or something.
+
+**Carlisia Thompson:** See, I'm glad you mentioned that, because when I SSH into a machine I'll bring up Vim and I wanna kill myself because "Where is my highlights, shortcuts and everything?" \[laughter\]
+
+**Thorsten Ball:** But the thing is, if you forget to close a string with quotes, syntax highlighting is gonna tell you immediately, right? Because it highlights the rest of the line like a string. At least Vim does it, I don't know how other inferior editors... \[laughter\]
+
+**Erik St. Martin:** We're gonna start a war now.
+
+**Thorsten Ball:** No, no, I'm not gonna go there.
+
+**Erik St. Martin:** Just to play devil's advocate here though, that stuff does -- one of the beautiful things about Vim is the performance of it. But when you have large files, and especially if they have long lines and you have syntax highlighting, that can cause painful issues in lag. It's almost nice thinking that that would never be a problem with no syntax highlighting, right? I don't know whether I could make that jump.
+
+I use different tools like the tag bar or whatever, in Vim, so that I have a layout of the functions to be able to jump - something like that would probably make it more easily swallowed, but I don't know... Maybe I'll try it one day, like give it a whole day and see how I feel.
+
+**Thorsten Ball:** \[01:03:56.10\] The thing is that the topics of syntax highlighting long lines in Vim - this is right at the top of my "This needs to get fixed, I can't deal with this any longer." Because I have a meltdown every five weeks where I realize it's 2016 and my text editor can't colorize a line because it's longer than 300 characters and it has like a few backslashes in it, right? And I'm losing it! \[laughter\]
+
+**Erik St. Martin:** We can put supercomputers in our pocket, but you cannot figure out what I meant in my string!
+
+**Thorsten Ball:** Yeah, and my colleagues in the office are laughing at me. They have Sublime Text open and it's super fast, and I actually can't mention this because they're gonna laugh at me. \[laughter\]
+
+**Erik St. Martin:** You have to just sit quietly in your misery, because it will only get worse if you share it with others.
+
+**Thorsten Ball:** Yeah, I was shaking my fist there and biting my lips... \[laughs\]
+
+**Erik St. Martin:** Like, "What's wrong?" "Nothing... All is well."
+
+**Brian Ketelsen:** Alright, we need to move on. We are running long, and Carlisia and I both have school functions we need to leave for in... Fifteen minutes ago. \[laughter\] So we should move on to \#FreeSoftwareFriday quickly.
+
+**Erik St. Martin:** Go ahead. Do you wanna go first?
+
+**Brian Ketelsen:** Me?
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** I love going first.
+
+**Erik St. Martin:** You brought it up.
+
+**Brian Ketelsen:** You brought it up, it's your world, baby. Alright, so I wanna shout out to Buffalo Web Framework by Mark Bates. The website is at gobuffalo.io and it's not even done yet, so he's probably gonna kill me for bringing it up live, but it brought love back to web development in Go for me. Now, I know a lot of you are thinking, "A web framework in Go? That is sacrilege-ish. You should just use the standard library", and I used to agree with you until I found Buffalo. If you came from Ruby on Rails like I did, you will find Buffalo about the closest experience as you can come to Rails in Go, and it's awesome. We're using it for the next version of GopherCon's website, which is at github.com/gopheracademy/Gcon. I think you should go take a look at it because it's really awesome. Just don't get me in trouble for shouting it out before he publically announced it, because the website isn't done yet. Sorry, Mark.
+
+**Erik St. Martin:** We'll just claim that we sent everybody there to look at the really awesome logo.
+
+**Brian Ketelsen:** \[laughs\] Yeah, shout out to Ashley McNamara for making killer Gopher logos.
+
+**Erik St. Martin:** Yeah, I've been looking at a lot of her work lately... Awesome. How about you, Carlisia?
+
+**Carlisia Thompson:** I don't have one, but I am laughing at the logo, it's amazingly cute. I don't have a project today.
+
+**Erik St. Martin:** And I don't know whether we prepped you on this in the email, Thorsten, but typically every show we kind of just do a shout out to a project that's making our lives easier. So if you have one, awesome; if you don't...
+
+**Thorsten Ball:** I have a shout out, and I promise you, I thought of this before this show. My shout out goes to the Vim Go plugin by Fatih Arslan. It's amazing, it kind of turns Vim into a lightweight IDE, because there's so much functionality in it. Five versions ago I thought, "This is it, it's done. Feature complete", and he keeps putting new and super practical and interesting stuff in it, and the development is really amazing to watch, and it's a great piece of software.
+
+**Erik St. Martin:** Yeah, it's funny... I agree with you. It was a few versions ago where I'm like, "Sweet, this has everything I need." Then he adds new stuff and you're like, "I didn't even think about that."
+
+**Thorsten Ball:** Right.
+
+**Erik St. Martin:** \[01:07:51.09\] So I actually have a cool project that I came across that I've only really tinkered with, but it's called gitQL; we've been talking about Git... It's like a query language to query against your Git history, which is actually pretty awesome. You can do a "select author" and whatever from commits, and then you can do like "date is between whatever". That's pretty awesome for when you're trying to search around your Git history for stuff. I thought it was pretty decent with doing Git grep and things like that on the command line. This is actually really cool.
+
+**Carlisia Thompson:** And it's written in Go.
+
+**Brian Ketelsen:** Yeah, it is. I just made an alias in Bash, so when I type git blame, it just runs ID -u-n.
+
+**Erik St. Martin:** \[laughs\]
+
+**Brian Ketelsen:** That was a bad Linux joke, sorry. \[laughter\]
+
+**Erik St. Martin:** We have to explain that that returns back...
+
+**Brian Ketelsen:** That just gives me my username back.
+
+**Erik St. Martin:** It would be less confusing if you just replaced that with whoami. \[laughter\]
+
+**Brian Ketelsen:** Yeah.
+
+**Erik St. Martin:** You're the blame for everything... Even if it wasn't directly, it's indirectly.
+
+**Brian Ketelsen:** Yup.
+
+**Carlisia Thompson:** But this tool is really cool.
+
+**Brian Ketelsen:** Yeah, gitQL is pretty awesome.
+
+**Erik St. Martin:** Alright, so I think we are about 10 or 12 minutes over, and I know everybody kind of has some functions to get to, so we are gonna go ahead and wrap up the show. Everybody, happy holidays! For two weeks we're gonna not have episodes, just to kind of close down for the holidays while everybody spends some time with their family and travels and all that good stuff, but we will see everybody back after the new year. January 5th I think is the next recording day.
+
+I wanna thank everybody on the show, definitely thank you, Thorsten, for coming on the show and talking about interpreters and compilers and all that good stuff...
+
+**Thorsten Ball:** Thank you for inviting me, it was a pleasure. This was really fun.
+
+**Brian Ketelsen:** That's a great show.
+
+**Erik St. Martin:** Huge shout out to all our listeners, especially the ones that are hanging out with us in the GoTimeFM channel on Slack; huge shout out to our sponsors, Backtrace and StackImpact - without them, we would not have a show. So everybody go check out their sites and products; we only work with awesome people, so definitely check out Backtrace and StackImpact.
+
+Follow us on Twitter @GoTimeFM, github.com/GoTimeFM/ping if you wanna be on the show or have questions for our guests. With that, goodbye everybody and happy holidays!
+
+**Brian Ketelsen:** Happy Gophermas! Happy holiday!
+
+**Carlisia Thompson:** \[laughs\] Happy holidays, bye!
+
+**Thorsten Ball:** Bye!
+
+**Brian Ketelsen:** Bye!

Early Go Adoption_transcript.txt

@@ -0,0 +1,595 @@
+**Erik St. Martin:** It's Go Time! This is a weekly podcast featuring special guests where we will discuss interesting topics around the Go programming language, to community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+Okay, so episode number three. Today we have Brian on the call, why don't you just tell everybody hello, Brian?
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And we also have Carlisia here as usual.
+
+**Carlisia Thompson:** Hello everybody.
+
+**Erik St. Martin:** And we have a special guest today, long time Go community member - and I mean _long_ time Go community member - he's got a great beard, and he's also the CTO and co-founder of Iron.io. We have Travis Reeder here, tell everybody hello, Travis.
+
+**Travis Reeder:** Hello.
+
+**Erik St. Martin:** Typically we start the show off by just talking about any news and articles that we've come across. Brian, Carlisia, do you have anything?
+
+**Brian Ketelsen:** Oh, I've got something big. We all follow compiler times on TIP these days, because they can either...
+
+**Erik St. Martin:** No way, nobody does that.
+
+**Brian Ketelsen:** Yeah... The compiler slowed down a little bit in Go 1.6, and I saw a tweet from Dave Cheney recently that showed that one of the most recent commits cut compile times - I'm looking at his [juju](https://github.com/juju/juju) graph, it looks to me like it cut about 40%, so we're getting much closer back to Go 1.4 compile times, which we knew would happen and I'm very excited to see. Hopefully when 1.7 ships, the compile pain won't be as bad as it was before. That's a really big event for all of us, so thank you for everybody on the compiler team - Rob Griesemer, you rock, thanks for doing that for us, we appreciate it.
+
+**Erik St. Martin:** Yeah, I think that that was kind of a public thing, when they converted the compiler to Go, because a lot of it was kind of done through code generation that we all knew that that would happen. But it's great to see the performance come back. Is that part of 1.7? Is that locked into that release, or is this just a commit that's kind of hanging?
+
+**Brian Ketelsen:** There's not a feature freeze for 1.7 yet, so I'm assuming that anything that's in TIP now is a candidate for 1.7 and there's no reason it wouldn't be included, unless it breaks everything.
+
+**Erik St. Martin:** I'm super excited about that. Compile times what - doubled? It was something along those lines.
+
+**Brian Ketelsen:** At least doubled, yeah. They were harsh.
+
+**Erik St. Martin:** It's still nothing compared to C or C++, but we have to have a reason to hate, right?
+
+**Brian Ketelsen:** When you have lightning fast compile times and they go down to just fast compile times, everybody whines.
+
+**Erik St. Martin:** \[laughs\] The fast isn't fast enough.
+
+**Brian Ketelsen:** The nice news about these last couple releases is that although compile times went up a bit, performance has improved quite a bit, so with the ssa changes, I think Go is speeding up in general, and if we can get those compile times back down to where they were, we win on both sides - both sides of the compiler.
+
+**Erik St. Martin:** Yeah, great.
+
+**Brian Ketelsen:** So I have another news item that I thought was interesting, but I am completely unqualified to talk about. There was a CloudFlare blog post about building the simplest Go static analysis tool possible, and it made me think that maybe ssa is something within my reach, and it was a very interesting read, so I hope to be able to dig into that when I have some spare time, and play with that. But it's definitely a good read. That blog post will be in our show notes. Have any of you guys played with any static analysis tools?
+
+**Erik St. Martin:** I've played with some of the static analysis tools that have already been created, but I haven't created any of my own. I did see that CloudFlare post though, and yes, that does make things look approachable. I'm not sure that I have anything in particular I want to write yet, but it does sound fun.
+
+**Carlisia Thompson:** New Relic has a static analysis tool, correct? But I don't think it has support for Go yet.
+
+**Erik St. Martin:** To be honest I haven't look at New Relic in a while. In my Ruby days there was a lot of New Relic, but I don't think I've used it with Go, so I'm not sure what support they have.
+
+**Carlisia Thompson:** Is it a general thing that people who are using Go are not using New Relic, I wonder?
+
+**Brian Ketelsen:** I think they just recently added some Go support, I don't know how much though.
+
+**Travis Reeder:** Well, it was certainly popular in the Ruby days, that's for sure.
+
+**Brian Ketelsen:** It was, everybody had New Relic.
+
+**Carlisia Thompson:** Yes, exactly.
+
+**Erik St. Martin:** So we were actually talking about that a little bit this morning, because we know that Iron.io was a Ruby shot prior. How much Ruby is still left?
+
+**Travis Reeder:** There are still some bits and pieces that are in Ruby, typically the things that don't need to perform really well, and I just kind of haven't parted with them yet. To be honest, I'm still a Ruby fan. If I'm writing something that doesn't need to perform and won't be used by a lot of people, I'll still reach for Ruby sometimes.
+
+**Erik St. Martin:** I tell people that too, Ruby I think still has a special place in my heart. I love the way it reads, and stuff like that. For throwing together quick CRUD apps, you can't beat it. I can take Rails and I can throw together an admin area in a weekend, you know? And especially for prototyping. And although these days React and just the JSON API has come pretty close to the productivity that I used to feel with Rails throwing together CRUD apps.
+
+**Travis Reeder:** Right.
+
+**Carlisia Thompson:** Yes, I think when you write in Ruby and Ruby on Rails - I do it still, and it starts becoming a little bit problematic when it just grows and then you don't know what to do with it, so you start to think about Micro services, and maybe moving parts of your app that need to be more performant into other technologies can be a worthwhile endeavor.
+
+**Erik St. Martin:** My thought on Ruby these days is pretty similar to my thought on Java. It's not that I don't like the languages, I don't like the way people write the language. Ruby and Rails have been great, but these huge monolithic coupled together things because people just throw it together because they can, and then it becomes hard to support.
+
+**Carlisia Thompson:** Yeah. And this question that you asked, Erik, reminded me of the question we were throwing around last week about whether we optimize for performance, and I think Travis should be the expert here - I am wondering, Travis, how do you plan for performance loads that you update in the future? How much pre-planning goes into identifying the spaces need to be performant in the future? Because I think a lot of times we go about saying, "Well, I don't need this more efficient technology because my app is never going to need that much performance", and on the other hand... Sometimes you know beforehand, but sometimes you don't know and you need to figure it out. So how does that go?
+
+**Travis Reeder:** It's impossible to predict, right? We didn't know what we would need upfront, that's why we went from Ruby and had to switch to Go. But nowadays we do have a better idea of what we need, and we just always try to push the limit. There is a recent blog post on our blog.iron.io about getting a million messages per second on IronMQ. So we're pushing it; we have no customers that are doing that kind of speed, but we try to push and hit milestones like that, so that if a customer needs that... We're always ahead of what our customers would need.
+
+**Erik St. Martin:** Plus it's just cool
+
+**Travis Reeder:** It's cool, yeah. It's cool when you get those commas.
+
+**Brian Ketelsen:** Nothing makes us happier than good benchmarks.
+
+**Travis Reeder:** Yes, exactly. But that wasn't just Go. A lot of that is due to the database we chose, and the underlying technologies. We're actually using RocksDB under the hood.
+
+**Erik St. Martin:** Rocks is a really interesting project.
+
+**Brian Ketelsen:** Yeah, Rocks is awesome.
+
+**Erik St. Martin:** And CockroachDB is written on top of RocksDB, too. It basically is implementing some of Google Spanners paper, mixed with some other stuff, but that's all in Go, and then their file system layer is done with RocksDB.
+
+**Travis Reeder:** Yeah, I like that Cockroach project, I don't know where it's at now; it was pretty early last time I checked, but we basically did the same thing for IronMQ - we took Rocks as the persistence layer, which is super fast. It's nice for a queue too, because all the data is sorted; it kind of worked out really nice. And then we had to build a networking and replication, and failover, and scaling on top of Rocks, basically.
+
+**Erik St. Martin:** Did you end up using Raft for your consensus protocol?
+
+**Travis Reeder:** Well, I wasn't really on the IronMQ team in this kind of upgrade, but we were using something and I believe it is Raft.
+
+**Erik St. Martin:** And nobody wants to implement the other ones. \[laughter\]
+
+**Travis Reeder:** Yeah, yeah.
+
+**Erik St. Martin:** I remember the first time I saw the Raft paper; I was like, "Ten papers, that's it? No, this can't be right for a distributed consensus protocol?
+
+**Brian Ketelsen:** This is actually the paper consensus for mortals.
+
+**Erik St. Martin:** Yeah, that's right. The title was something like that, wasn't it? Alright, so let's talk about some interesting Go projects. Brian has this whole thing where he goes to sleep and he downloads all the interesting GitHub projects for Go, and then he just spews them out to me in the morning.
+
+**Brian Ketelsen:** It's how I get myself to sleep tonight: browsing the latest commits to Go projects.
+
+**Erik St. Martin:** And I hope that he curates it first, because I don't have that kind of time.
+
+**Brian Ketelsen:** I do, I only share the interesting ones. The first one today I saw a couple months ago and it was just in its beginnings, but it looks like it's getting pretty nice - there is an Oauth2 server, written by Richard Knop. It's called go-oauth2-server, and it looks like it's getting pretty solid in terms of its capabilities. It's a standalone server, it's backed by [etcd](https://coreos.com/etcd/) for configuration and I think postgres for data storage. It gives you the full Oauth2 flows for your apps, and it generates keys, the whole work, so it looks like something that's well worth checking out. Links to that of course will be in the show notes.
+
+**Carlisia Thompson:** It has wonderful documentation.
+
+**Brian Ketelsen:** It does, some of the best I've ever seen for an Oauth server.
+
+**Carlisia Thompson:** Amazing.
+
+**Brian Ketelsen:** I agree.
+
+**Erik St. Martin:** For an Oauth2? \[laughter\]
+
+**Carlisia Thompson:** There are so many...
+
+**Erik St. Martin:** Speaking of Cockroach again, that is probably one of the best-documented projects I've ever seen, too.
+
+**Brian Ketelsen:** Oh, agreed.
+
+**Erik St. Martin:** That's just beautiful, so well documented. And the C++ code was pretty good, too. I don't think I've ever seen C++ look like that.
+
+**Brian Ketelsen:** Readable?
+
+**Erik St. Martin:** What is this weird language? Oh wait, this is C++.
+
+**Brian Ketelsen:** It's really C++? Alright, the second project I stumbled across a couple of weeks ago, and again, it's maturing to the point where it's starting to look really interesting, and that's Rqlite, which is the distributed SQLite.
+
+**Erik St. Martin:** Yeah, I've seen that, too.
+
+**Brian Ketelsen:** Adam's gonna tell us at some point that that's not how you pronounce SQLite.
+
+**Carlisia Thompson:** You're not pronouncing it right, it's SQLite.
+
+**Brian Ketelsen:** Well whatever it is, Rqlite is the Raft-enabled version of SQLite, and it allows you to have a distributed SQLite database, and that's all built in Go, it's distributed... Pretty slick stuff. It looks like it would be really high performance, so I'm kind of itching to test that one out. I might have to build a little cluster and see what I can do.
+
+**Erik St. Martin:** What's the interface for that? They turned it into HTTP rather than interacting with like an actual SQLite adapter?
+
+**Brian Ketelsen:** Oauth, actually. You can query directly against the SQLiteDB on disk, and I think you're required to do all your data changes over the HTTP API, which actually just sends DDL. So the API is a really tiny JSON wrapper for DDL.
+
+**Erik St. Martin:** So the downside is just that you can't just use a normal SQLite adapter, you kind of have to develop a HTTP client to start your data, but still... It's really interesting though, because things like Raft, and etcd, and console has really enabled people to build their own distributed systems much more easily. And to Travis' point too, they build on top of RocksDB for the persistence layer and leveraged graph, and they're doing their own distributed census internally, so you can kind of make up your own databases - not that you'd suggest everybody do that, but...
+
+**Brian Ketelsen:** Facebook did it with MongoDB. They took Mongo and stuffed Rocks underneath it, and have an extremely fast and fault-tolerant and high-performant database system. I think -- is it Charity Majors that heads that up? I can't remember, but anyway... Everybody's doing it, and it's cool.
+
+**Travis Reeder:** Anyone tried that Rocks backend from Mongo?
+
+**Brian Ketelsen:** I have not.
+
+**Erik St. Martin:** No... It was on my list, and...
+
+**Brian Ketelsen:** ...it's still there.
+
+**Travis Reeder:** I wonder if it's dead though, now that Parse is dead.
+
+**Brian Ketelsen:** That's a good question.
+
+**Erik St. Martin:** What was the other one that I got hooked on, Brian? The Cassandra one that was rewritten in C++? What's the name of that?
+
+**Brian Ketelsen:** I can't remember now.
+
+**Erik St. Martin:** I'll think of it right after we end this show. But anyway Travis, if you haven't seen it, it's basically wire-compatible with Cassandra, but written in C++ instead of Java.
+
+**Travis Reeder:** Oh, wow.
+
+**Erik St. Martin:** Yeah, that was very cool.
+
+**Brian Ketelsen:** Databases are Erik's crack. He can't put it down.
+
+**Erik St. Martin:** It's code generation for Brian, and databases for Erik. \[laughter\] You should see the list of databases Brian and I have looked at over the years. Different time series databases, databases that are written on the GPU... Just all kinds of stuff.
+
+**Brian Ketelsen:** I still wanna see one of those work. There's so many hyped databases right now for GPU, but I haven't seen anybody release one that actually does anything.
+
+**Erik St. Martin:** What was the one... GPUdb?
+
+**Brian Ketelsen:** GPUdb.
+
+**Erik St. Martin:** And there was another one...
+
+**Brian Ketelsen:** There's another one... But at least from what I can tell, they both seem to be pretty close to vaporware.
+
+**Erik St. Martin:** Until somebody hears this episode and does something really cool with it.
+
+**Brian Ketelsen:** Yeah, I'm waiting.
+
+**Erik St. Martin:** Please do...
+
+**Brian Ketelsen:** My email address is bketelsen@gmail.com Send me an email and prove to me that somebody is doing something with GPU databases. I don't believe it until I see it.
+
+**Erik St. Martin:** Alright... So what else do we have?
+
+**Brian Ketelsen:** So the last interesting Go project is an old one, but one that I've just started using recently, and found it to be about as awesome as a utility can be, and that's Syncthing. Their website is syncthing.net, and if you're familiar with any one of the peer-to-peer syncing tools like BitTorrent sync, it's the same sort of thing but it's an open protocol that's written in Go. From a utility perspective, it's great to just sync your documents folder between your Mac and your Linux machine, or your laptop and your desktop. I tried it -- I guess it's been two weeks now. I've been syncing my GOPATH source directory between my Mac and my Linux Box, and I have it set to like a 20-second sync repeat. So if I save a file on my Mac while I'm sitting downstairs, and give it 20 seconds, close the lid, I can come back upstairs onto the Linux Box and keep editing that same file with the changes just by opening Vim up. It's been liberating, it's pretty amazing. I didn't realize that a) the synchronization was quick enough to be able to enable that, and it had just never occurred to me before that I could synchronize my GOPATH - at least the source directory of it - and not have any repercussions; it hasn't bitten me in any way. It's been really cool. You git clone something into my GOPATH and next time I'm on my Linux machine it's just there. It's really cool.
+
+**Carlisia Thompson:** That sounds amazing.
+
+**Erik St. Martin:** You're using this in place of, say Dropbox?
+
+**Brian Ketelsen:** It's not centralized storage, it's peer-to-peer storage, so each computer runs its own daemon, and they communicate with a centralized, distributed hash table sort of thing that helps each of the computers locate each other. But you have to have a client authorization, so nobody could just log in and grab my source directory. You have to enable each of the different clients to talk to each other. So there's a good amount of security involved in it, and there is no central storage like Dropbox. It's not quite the same as Dropbox, although you could easily use it for the same capabilities if you had two machines.
+
+**Erik St. Martin:** And it works over the WAN?
+
+**Brian Ketelsen:** It does, it works anywhere. I don't know what technologies they're using, but I haven't run into any NAT-piercing problems or anything like that. It just works.
+
+**Carlisia Thompson:** I'm trying to think of the alternative way to do this as far as writing code, because I want to put a repo on Dropbox or something like that, but the alternative to this, the way you're doing this, would be to push to the central repo all the time, and then pull it on your other machine. And this is super handy.
+
+**Brian Ketelsen:** It really is, it's slick. It cut down the number of crazy branches I've had to push to drastically, because if I'm not ready to commit something to a repository, as long as it's saved on my disk, it syncs to another computer and I'm good. I'm really enjoying the workflow; I'm probably doing something I shouldn't be doing, but I don't care because it hasn't bitten me yet, and it's awesome. Syncthing.net
+
+**Erik St. Martin:** Alright. So let's move on and we'll rope Travis in here a little bit. He's on the show, we should probably talk to him a little bit, huh?
+
+**Brian Ketelsen:** Well Travis, did you have any interesting projects that you've seen recently that kind of piqued your interest, whether they're Go related or utilities?
+
+**Travis Reeder:** Yeah, one that I've been looking at pretty closely is Caddy. It's like a web server/reverse proxy, with Let's Encrypt built in, and things like that. It seems pretty cool, I haven't had a chance to really use it, but I'm very interested in it because we have a want or a need to have some kind of proxy layer, so we're looking at that for sure.
+
+**Brian Ketelsen:** I can tell you that all of the Gopher Academy and the Gopher Academy Blog and GopherCon websites are all served behind Caddy, and have been since something like April of last year when it was in its earliest possible releases, and we absolutely love it. It couldn't be easier to use Caddy.
+
+**Travis Reeder:** Yeah.
+
+**Erik St. Martin:** Brian went all super beta on it, just like you guys did with Go. He's like "It compiles, I'm deploying it." \[laughter\]
+
+**Travis Reeder:** Yeah, it's nice. The only thing I was kind of hoping would be more programmatic, I was trying to sort of be able to pull in all of the internals, and use it in a nice interface, \[cross-talk 00:21:05.28\] It's more web-server-driven at this point, where you need the config file and what not. I was hoping to be able to add a whole bunch of stuff and take away things dynamically.
+
+**Erik St. Martin:** It should be embeddable now. I know Matt has been working a lot on making it embeddable. I think it is now. I know they've been abstracting out some of the components, because Miek Gieben, he's working on CoreDNS, which is like a DNS server that's taking a lot of concepts from Caddy that he really liked. So there's been some abstractions made to reuse some of that logic. If you haven't looked at it recently, you might want to take a look at it again. Check it out, because I'm pretty positive it's embeddable now.
+
+**Travis Reeder:** Yeah, I was actually talking to Matt Holt, and the pieces that I was looking for - proxy and backend and stuff like that - wasn't programmed yet; you had to basically generate a config file and then restart it.
+
+**Brian Ketelsen:** Oh...
+
+**Erik St. Martin:** Oh...
+
+**Travis Reeder:** But I imagine we'll get there.
+
+**Brian Ketelsen:** All you have to do is whisper in Matt's ear and in a day or two it's gonna show up in Caddy, so...
+
+**Travis Reeder:** Well hopefully it does; that was a couple weeks ago, I think. Maybe you guys can whisper it too, and it will happen faster. \[laughter\] Another one that is not too exciting but I've been really liking is Viper. It's basically like command line tools, and pulling in environment variable and config files...
+
+**Erik St. Martin:** And you can override one with the other so that it defaults back to something the same.
+
+**Travis Reeder:** Yeah. We've been using that all over the place now, it's kind of become a default.
+
+**Brian Ketelsen:** That's really cool. Have you tried the remote configuration for Viper yet?
+
+**Travis Reeder:** I have not, no.
+
+**Brian Ketelsen:** I added that I think last year. I love Viper. I think it's really awesome. We used the remote config as the baseline configuration. So things that every machine, every app needs to know comes from etcd and then you can just layer on extra stuff on top of that, and it worked out really nicely.
+
+**Travis Reeder:** That's cool, yeah.
+
+**Carlisia Thompson:** I wanted to mention that I had never written any command line tool before I found out about Go and started learning Go, and I think it's just amazing, having Cobra and Viper. People, if you haven't tried it, you're gonna get addicted to it.
+
+**Erik St. Martin:** And I think all of those came out of Steve's bigger project, which is Hugo.
+
+**Brian Ketelsen:** Yes.
+
+**Erik St. Martin:** I think he abstracted those out of that, because people had kind of similar needs. I love some of that stuff, like Viper with being able to do the subcommands, and things like that. Soo much easier when you have some command line utility that just has a crap ton of functionality, you have to hide away. It's nice to just be able to do the subcommands and Viper allows you to really organize it nicely.
+
+**Brian Ketelsen:** Yeah, those repos are at github.com/spf13/cobra, /viper, /hugo, /pflag... I know them all really well.
+
+**Carlisia Thompson:** I don't think there is anybody as prolific as Steve out there.
+
+**Brian Ketelsen:** Nope. That's good stuff too, and it's funny because I've talked to several projects that were writing command line apps, and they've started with no command line-enabling libraries and then they moved to something else, and everybody ends up on Cobra, because it's just the nicest interface for writing command line apps. So if you're gonna write a Go command line app, skip all the craziness and just go straight to Cobra, because that's what everybody else does.
+
+**Carlisia Thompson:** Yup.
+
+**Brian Ketelsen:** You get all these free opinions on this podcast. It's crazy. \[laughter\]
+
+**Travis Reeder:** I gotta throw in one more project that I think is pretty good. It's the Gin Web Framework, or API framework. It seems to me it's the best one for Go so far that I've found. It gets rid of so much code, and makes everything so much easier.
+
+**Brian Ketelsen:** Yeah, and keeps it readable. That's the trick. You can't lose readability when you're writing those big web apps, and Gin does a good job, I agree.
+
+**Erik St. Martin:** Yeah, I think I've been through almost all of them at one point or another, and I can't decide. There's things I love about each, and there's things I hate about each. I feel like I'm going to hate web frameworks forever.
+
+**Brian Ketelsen:** Well you know, my code generation fetish means that I have to be a goa fan. So it's goa for me and nothing else in terms of web apps. I had to get that plug in there.
+
+**Erik St. Martin:** And I have to be fair as much as Brian tries to beat it into me, I have yet to play with goa.
+
+**Brian Ketelsen:** \[laughs\] One day...
+
+**Erik St. Martin:** Hey, I said the same thing - how long does it take me to convert you to Vim?
+
+**Brian Ketelsen:** Years. But now I haven't looked back, so I think you need to trust me on goa, too.
+
+**Erik St. Martin:** One of these days, when I have a ton of free time, right?
+
+**Brian Ketelsen:** Exactly.
+
+**Carlisia Thompson:** There you go, Travis, you need to try goa, and then you'll let us know.
+
+**Travis Reeder:** Okay, I'll check it out.
+
+**Brian Ketelsen:** You can be the objective 3rd party. Come back and tell us what you think about code generation when it comes to API development. We'll put you on the show and you can tell us what you think.
+
+**Erik St. Martin:** Yeah. For Travis and for everybody listening who's not already familiar with goa, basically it's... Brian could probably describe this better, but it's a DSL for kind of describing your API, and then it generates the actual implementation.
+
+**Brian Ketelsen:** Yeah. Which from my perspective, just describing your API - the idea behind goa was that you had to spend, you had to invest that time describing your API well, and then it generated an API for you, which I thought was good. I really liked the whole idea of code generation, and single source of truth, but the code that it generated was so beautifully idiomatic Go code... I was more impressed by that than anything else. Usually when you end up with a code-generated app, it looks like a code-generated app.
+
+**Carlisia Thompson:** That's what I was going to say... When you've been programming for a while and you used those old code generation tools, you kind of get burned and never try them again. I have a hard time trusting... I trust you, but just like you said about something else earlier - I have to see it to believe it. But the website is amazing, and I wanted to ask, does it also generate documentation?
+
+**Brian Ketelsen:** Thank you, by the way, I did the website. The code generation will create a Swagger JSON file for you so that you can use any of the Swagger tools to provide API docs, which I think is really awesome. So you get both the Swagger schema and the JSON schema, that you can use as the documentation for your API. It also generates a JavaScript client for your API, and a CLI command line app for your API, so you can call your API from a command line, too.
+
+**Carlisia Thompson:** Get out!
+
+**Brian Ketelsen:** Lots of code generation there.
+
+**Travis Reeder:** Get out... \[laughs\]
+
+**Brian Ketelsen:** My motto for 2016 is 'Generate all the things'.
+
+**Carlisia Thompson:** Wow.
+
+**Erik St. Martin:** Alright, I think I'm gonna have to play with that this weekend. \[laughter\]
+
+**Travis Reeder:** So you actually define the... It looks like you define the API in Go code?
+
+**Brian Ketelsen:** It's Go code, but if you're familiar with - what's that testing framework that is...
+
+**Erik St. Martin:** Ginkgo?
+
+**Brian Ketelsen:** Is it Ginkgo? Yeah, so there's a testing framework, and I think that was the inspiration for the Go DSL. It looks like a DSL, it really truly is Go code, but it uses a lot of anonymous functions to make it look like a DSL. So that's what you write, you write this DSL that describes your API, you describe your endpoints, you describe the messages that are going back and forth, and once you've done that, you run your code generator and it whips out a giant application for you. It's really nice.
+
+**Carlisia Thompson:** How about tests? Does it generate tests as well?
+
+**Brian Ketelsen:** I haven't seen it yet, but I think just yesterday or the day before somebody merged in something that generates tests as well.
+
+**Erik St. Martin:** It's interesting, because you kind of pointed out the number of anonymous functions that it uses to do this DSL, but if you look at any other language that's for DSL that's basically what they do too. So people commonly do DSLs in Ruby, but what do they use for that? They use blocks, right?
+
+**Brian Ketelsen:** Yeah, it's all the same. And people get hung up, especially when they see goa for the first time; when they look at that DSL, there's... We use dot imports to make the DSL look prettier. Dot imports are the end of the world in Go, but it's the DSL; the code that's generated doesn't use dot imports, it's very idiomatic and good-looking Go, so don't let that DSL look hang you up too much. It's just the DSL.
+
+**Erik St. Martin:** Yeah, and that's just to generate your code, right? The code that gets generates is idiomatic, so...
+
+**Brian Ketelsen:** Correct.
+
+**Erik St. Martin:** Now, you've been working on an extension to this for generating ORM communication.
+
+**Brian Ketelsen:** That's right. One of the first things I did after I saw goa was say "Well, if we can build an API, why can't we build the database layer, too?" So I played around with a couple different Go database access layers and finally settled on GORM, for being the one that's the least evil in terms of ORMs. So I made a...
+
+**Erik St. Martin:** How's that measured anyway?
+
+**Brian Ketelsen:** It's measured in how much crazy stuff it does behind the scenes that you don't expect. As far as GORM goes, it's almost no crazy stuff. I think we've all - on this show at least - done active record in the past and been shocked by the 38 queries that happen when you make one select statement. GORM doesn't do any of that, so it's not too evil. That's good. So I created this plugin for goa called GORMA, which allows you to use that same sort of declarative API DSL to declare your models too, and then define the relationships between the models using active record style, 'has many', 'belongs to' sort of things, and then declare the relationships between the API endpoints and your models, so it will generate your entire API and the data layer with just a couple hours of thought into what it should look like.
+
+**Erik St. Martin:** That's awesome. I'm definitely gonna have to play with it.
+
+**Brian Ketelsen:** There's a YouTube video on my YouTube channel - that's either bketelsen or brianketelsen, I can't remember which, but there's a YouTube video of me talking at the Tamp Go meetup, that's about an hour and a half long, and I do a end-to-end demo of goa and GORMA, and then I load-test it at the end just to prove how awesome it is. So it's pretty slick.
+
+**Erik St. Martin:** If I watch that video, does it count as playing with it?
+
+**Brian Ketelsen:** Yes.
+
+**Erik St. Martin:** Alright, alright. I'll give you that much. I'll at least watch the video this weekend.
+
+**Brian Ketelsen:** There you go.
+
+**Erik St. Martin:** Alright, so before we run out of show time here, let's chat with Travis here a bit. So Travis, you guys were one of the first - at least that I remember - to publicly state that you were using Go. Definitely long before many of the big guys started waving their hands with the "We are, too!" I think it was pre-1.0. It might have even been before the Go Tool. You guys might have been launching with make files. \[laughter\] I'd really love to talk battle scars and kind of what made you love the language so much to adopt it that early on.
+
+**Travis Reeder:** Sure. The Go Tool did exist, I believe, when we launched, but it was pre-1.0. Our decision process was... Well, basically we were hitting a wall on Ruby, and we needed to change. I was a long-time Java programmer, so it was kind of that I really wanted to go back to Java to get more performance, or use something new, or one of these Java derivatives, like Scala...
+
+**Erik St. Martin:** Because you really liked tweaking the JVM, and you wanted to do it again.
+
+**Travis Reeder:** I love it, yeah. So we looked at these things, Scala was kind of popular at the time too, and Clojure was kind of hip, too. But this Go thing was there, and we saw that Google was back and there were some really smart people behind it. We tried it, and I think the simplicity of the language, with almost same performance as Java - not quite, but close... We liked that, we prototyped really quickly, a queue implementation basically, and tried to see what kind of performance we could push through it, and it worked really well.
+
+We had some convincing to do, our team and our investors, because you never want to pick the wrong technology, and we just moved forward with it. It turns out it was a really good decision, luckily.
+
+**Erik St. Martin:** It's crazy, because I love the language and Brian and I bought into it pretty early on too, but I don't know whether we made any major production releases pre-1.0. Do you think, Brian?
+
+**Brian Ketelsen:** I put R60 or R61 in production. That was definitely make-file days.
+
+**Erik St. Martin:** But it wasn't the core of the application
+
+**Brian Ketelsen:** No, it was one of the pieces of the constellation, out on the peripheral.
+
+**Erik St. Martin:** Yeah. I mean, building an entire company betting on that this was going to explode is really crazy to think about. I'm glad all of us stuck with it; look at where Go is today. But you don't look at the growth pattern... Now you can kind of look at the growth pattern and see the adoption happening, and you can pitch that to the investor and be like "Look at this, this is only going to continue to get better", but then you had nothing. You were like, "There's some really smart people working on it", but there's also a lot of projects a lot of smart people are working on that don't really take off, especially languages. I don't even know how you predict which language is gonna take off. There are other languages that I've looked at that are just as interesting in different ways to me, and they don't have the growth that Go does. It's just astonishing.
+
+**Travis Reeder:** I always ponder this, I always wonder... There are these early adopters like us and you guys - I'm not saying we did this, but I think us doing that and kind of saying how well it worked in production, and how it totally dominated our previous version that was written in Ruby... I think those kinds of things pique people's interest even more. You have this great team building the language, and then you have some companies that are actually using it in production, so it's kind of a self-fulfilling thing.
+
+**Brian Ketelsen:** I almost disagree just because in the early days for every Iron.io blog post about how you guys moved from slow things on lots of servers to really fast things on fewer servers, there were just as many "We tried Go, it ate our lunch and destroyed the entire company" blog posts. It seemed, especially in the first couple years of Go that there was far more negative press about people trying Go than there was positive press. Maybe that was just my perception of things.
+
+**Erik St. Martin:** I think collectively, the passion that existed in community as it stood was so great though that if you dipped your toes in, you kind of got swallowed, you just got pulled into it. And I think that was some of the stuff -- we've talked about this before too, that I think the reason that we loved it so much is the language itself was so simple. You could reason about the code and then of course concurrency and performance and things like that, so that was enough to pique your interest. And then you kind of got into the golang nuts and you started interacting with all these people who just were so passionate and so eager to help anybody who also shared this interest in the language they loved, and I think it kind of pulled all of us in. I think that's why all of us... All of us here are kind of trying to do things back for the community that pulled us in. You guys are running one of the largest Go meetups.
+
+**Travis Reeder:** Yeah. Rob Pike spoke at one of our early meetups at Heroku's product three or four years ago, and he said surprisingly that most of the people that were using Go were from Ruby and Python and JavaScript. They were expecting people to switch from C and C++ to make their lives easier, but it turns out there's a lot of these scripting languages where people wanted more performance. But they had this compiled systems language that wrote sort of like those scripting languages.
+
+**Erik St. Martin:** Yeah, I don't think they predicted that at all. It definitely pulled a lot of people in. People who wanted to do systems programming that felt like maybe it was unapproachable because they've seen C, they've seen C++, they've seen maybe some assembly and it just seemed beyond their reach. Then there were people who used these scripting languages because it felt more productive and they didn't wanna do things in C and C++, and now they had something that they could get the performance without the productivity losses of doing things in C and C++. That may be unfair to say for the productivity losses; I'm sure there's people who were plenty productive with those languages.
+
+**Brian Ketelsen:** I think there's a cognitive load, a cognitive overhead when you're working in something as deep as C++. When you've got templates and all of that code, it's difficult to be really productive. On the other hand, if you're doing the same thing over and over, you reuse a lot of your code, so sure you can be very productive that way.
+
+**Carlisia Thompson:** I feel that with Go as well the syntax is so concise and small. I feel like I'm using the same thing over and over again, which at some point I'm just thinking about the problem ahead of me, as opposed to "How do I do this?" or "How do I do that?" It's completely different.
+
+**Brian Ketelsen:** Yeah, Go is a small language. How many keywords - 67 keywords, something like that?
+
+**Carlisia Thompson:** Isn't it 25?
+
+**Brian Ketelsen:** And two of them are crazy keywords, like 'whereas' that we put in just for fun.
+
+**Carlisia Thompson:** \[laughs\]
+
+**Erik St. Martin:** Just for fun...
+
+**Travis Reeder:** \[laughs\] I really like that you don't need code generation. Coming from Java, you had to use a big IDE that could do a bunch of refactoring and generate all your getters and setters and all this code, whereas with Go you don't really need any of that stuff.
+
+**Brian Ketelsen:** Yeah, a simple text editor. It makes your life easy in Go, I agree. You can keep that whole code model in your head.
+
+**Erik St. Martin:** It's crazy, because Vim - I live by Vim, and Java is the only language I will not try to do... \[laughter\] That's the only one... I'm like, "Alright, alright... I'll just install the IDE", because it feels that painful.
+
+**Brian Ketelsen:** So Travis, what kind of pain points did you hit early on with Go? Did you run into big garbage collection pauses, did you see anything crazy like that, that you ended up having to diagnose early? Or was it relatively painless for you?
+
+**Travis Reeder:** This was a while back, but I think the benefits we gained were so significant that we probably overlooked a lot of the drawbacks. I think probably it was mostly the amount of libraries that were available at that time, which weren't that many. And there weren't that many that were well-tested and things like that, with database drivers and stuff like that.
+
+**Erik St. Martin:** It was maybe a week or so ago Brian and I were reminiscing on that, too. Not in a good way, but thinking back and comparing to today, how much easier people have it. Because you had to write libraries for everything back then.
+
+**Brian Ketelsen:** When I was a kid... \[laughter\] We didn't have DB SQL. The first Go app we put into production, DB SQL didn't exist.
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** Crazy.
+
+**Erik St. Martin:** Yeah, and some of this stuff too... We constantly see stuff now - one of the ones I saw earlier today was OCR written in Go. You can find projects for everything now.
+
+**Travis Reeder:** That's nice. And really high quality. The libraries that come out of the Go community, a lot of them are really exceptional.
+
+**Brian Ketelsen:** Yeah, they're strong, I agree. Go seems to attract really bright people that have solid engineering minds, and then me.
+
+**Carlisia Thompson:** I think Go also benefits from the wave of test-driven development that the Ruby developers went through - that's what I'm familiar with. Before I found Ruby, I wasn't doing that, I didn't even really understand how to do it. And now these developers are working with Go and they bring all those good practices into the community and into their development. So it's very nice... As they say, Go is a modern language, and it's benefitting from past experiences in a big way.
+
+**Travis Reeder:** Yeah, that's a good point. I'd add to that too that it seems like most Go libraries people are testing for performance, too.
+
+**Erik St. Martin:** Yeah, and if they aren't, somebody else is. There's somebody who just crawls... Brian downloads the cool projects, somebody else goes and finds the cool projects and submits PRs to reduce allocations.
+
+**Travis Reeder:** Yeah, it's amazing. Which in Ruby you never saw. They'd be well-tested, but the performance, I don't think it was even looked at.
+
+**Brian Ketelsen:** Nobody cared.
+
+**Travis Reeder:** Yeah.
+
+**Erik St. Martin:** Maybe it was just like the "Why bother?" mentality, or I don't know. I'm a little disconnected from that world now, but it seems like a lot of Ruby itself and a lot of the Rails libraries, people have been going on these crazy endeavors to reduce allocations and things like that there, too. So maybe it's a trend that's happening everywhere, I don't know. It definitely seems more prevalent in Go.
+
+**Travis Reeder:** Yeah.
+
+**Brian Ketelsen:** I think it's part of the Go mindset.
+
+**Travis Reeder:** Yeah. I was just gonna say that. I think people choose Go because -- well, a lot of it is because of performance, so I think the libraries have to kind of follow suit.
+
+**Erik St. Martin:** Yeah, that's true, too. If you're going to choose it for performance, you might wanna actually pay attention to the fact of whether or not you're doing it in a performant manner.
+
+**Travis Reeder:** Yeah.
+
+**Brian Ketelsen:** That reminds me of my first attempt to make an addition to the Go language, to fix a bug in Go proper. I think it was in encoding somewhere, like maybe base64 encoding. I solved the problem, fixed the bug, wrote a test, all of that, and I submitted the CL, and I got back a comment immediately, "This absolutely solves the problem. I need you to refactor it to get rid of the three allocations you added." And I stared at my email for a good five or ten minutes, wondering what I did to add allocations and how in the world I was gonna get rid of them, because I didn't know. I came from Ruby, I didn't care about allocations. I still honestly don't care about allocations generally, but I didn't know what to do. I grabbed Erik, "Erik, what do I do?" \[laughter\]
+
+**Erik St. Martin:** It's funny though, because I look at code and I see some of the allocations that are obvious, but other people, they just totally outshine you. They look at something really quick and they're like, "There's five allocations there." You're like, "What?" How did you know that just by looking at it for a second? I have to go through and count: "Yup, that would be an allocation, and that one would be one..."
+
+**Travis Reeder:** I think on the core team it's almost like a game inside the team... I remember Blake Mizerany - I don't think he's on the core team, but he's very close with Brad Fitzpatrick and those guys... I think they almost have competitions; I think he wrote a log parser, to parse log font, and his whole goal was to have zero allocations, or something like that. They did it, so now there's this log parser that doesn't allocate anything while it's parsing logs.
+
+**Erik St. Martin:** That's awesome.
+
+**Carlisia Thompson:** I'm gonna have to end this call and go look up how allocations are done in Go, how to recognize them and how to solve them. I still don't know what you guys are talking about...
+
+**Erik St. Martin:** So actually there was a talk by Björn Rabenstein recently from the Prometheus team. He did a talk we'll link in the show notes, and I believe some of that he walks through the allocations, and you can actually see the change... So that might be a good look at it.
+
+**Carlisia Thompson:** Awesome.
+
+**Erik St. Martin:** And I think there's another one too, I'll look it up for you and we'll put it in the show notes when I find it. I think there was another one that I'd seen a while back too, where somebody was walking through looking at code and determining whether something was gonna be stack allocated or allocated, and things like that. We'll find that and link to it.
+
+**Brian Ketelsen:** We talked a little bit earlier about the static analysis tools, maybe there's an opportunity for a really simple static analysis tool that helps you understand the allocations that are being made. I know you can use the benchmark tools that are built in to show you allocations, but a nice SSA tool that's Brian-friendly would be pretty awesome, to show what allocations are being made and maybe suggest changes to reduce those.
+
+**Erik St. Martin:** Well some of them get hard too, because if they could suggest the change, you could make the change. There's two tools that are really good for it. One is just using the standard benchmark and test stuff where you can do the pprof, and you can look at it in the pprof tool, or you can visualize it. Those are great tools for looking for allocations. But the other thing is there's Go command line flags, or the Go compiler itself, where you can pass it in and it will tell you every time that a pointer escapes, and it needs to be allocated on the heap, too. That's also an interesting thing to run on your code during the compilation so that you can see whether or not maybe something that you thought didn't... And it's interesting just because of the way... But it's hard to talk about over a call, because I can't give you code examples. But I'll find some videos and we can link them in the show notes and I can send them out. It's not as complex as you'd think. There are a couple of areas where they are obvious, and the harder part is determining libraries that you call that end up allocating for you, and then accidently passing a pointer that ends up escaping and then having to be allocated on the heap, and you may not have noticed it.
+
+**Carlisia Thompson:** Yeah, I can see that.
+
+**Erik St. Martin:** Like you said, most of the time for most people it doesn't matter. When you're trying to hit the scale... How many requests a second did you say you guys were shooting for, Travis?
+
+**Travis Reeder:** A million.
+
+**Erik St. Martin:** Yeah. See, when you wanna hit scales like that, then allocations matter, because a garbage collector comes into play, taking up time, allocations take up time... So when you wanna hit scale like that, or Prometheus... I think they were just talking about half a million requests a second. When you wanna try and hit scale like that, allocations become really crucial. But I don't think it's something for people to get caught up in really early on, especially if you're new to the language, because sitting there trying to trace down your allocations just kind of hinders the fun of developing it and being productive in this language, and seeing how fast it runs on its own without you having to give much thought to it. I think that if you're starting out you should not be concerned with that. Save that for later. I think that it'd just become too daunting, and it'd be harder to fall for the language, because at that point you might as well be trying to learn C, right?
+
+Speaking of taking on things new, two questions I wanted to ask: one is hiring - for you, Travis, how has that been? We haven't really had to do too much hiring for Go people, so I don't know how big the pool is. Do you guys struggle to find talent? Do you train talent?
+
+**Travis Reeder:** Yeah, that's a good question. It's easy to find people that want to work in Go, it's harder to find people that have actually worked in it, though. So mostly people we bring on have played with it, but they have good systems engineering backgrounds or things like that. The knowledge you have transfers over pretty nicely. But we do get a lot of people that just are sick of whatever they're working on, and they're really excited about working on Go, and if you're working for us, it's pretty much all you're working on.
+
+**Erik St. Martin:** Or you're referencing a Ruby app that you're rewriting in Go? \[laughter\]
+
+**Travis Reeder:** Those days are pretty much over, but yeah. It's mostly news stuff now.
+
+**Brian Ketelsen:** Have you had any new hires that came in and picked up Go and just walked aways saying, "Go isn't for me. This isn't the language that I love, I'm gonna go back to that other thing (whatever it is)"?
+
+**Travis Reeder:** No, that's never happened, actually. Never happened.
+
+**Brian Ketelsen:** There you go. That's anecdotal proof right there, that Go is awesome.
+
+**Erik St. Martin:** It's very good, statistical evident. A sample size of one.
+
+**Carlisia Thompson:** Yeah... You're gonna get a lot of that here.
+
+**Erik St. Martin:** The other thing that you guys adopted early on too is containers. You kind of spoke to Solomon announcing Docker at the Go SF meetup.
+
+**Travis Reeder:** Yeah.
+
+**Erik St. Martin:** How soon after he announced Docker did you guys start kind of playing with it and releasing it?
+
+**Travis Reeder:** I forget the actual timeline, but I don't think it was much more than a year probably, after he first launched it. It was pretty funny when he launched it that the day he launched it, he pushed it to GitHub that day, showed it to the people at Go SF... It was just kind of a sad open source project, right? It's amazing, it's three years in now and it's just taking over the world. So we started adopting it... We were already using LXC containers behind the scenes. You'd upload your code to us for our Iron Worker product - I guess I'll explain what that is real quick. It's job processing as a service, so upload your code - you used to just upload it in a tar or a zip, and then after it's uploaded you can queue up jobs, whether it's one job or a million jobs. We were dealing with all the queuing and infrastructure behind the scenes that run those jobs. Today we call it Serverless. In fact, we used to write articles about Serverless before Serverless was a cool thing. We took care of all the infrastructure and all the hard parts for you, and then we ran all that code in LXC containers to keep it isolated, to maximize the memory in CPU, or to limit the memory in CPU. When Docker came out, it was just like... All the stuff we were doing, it was kind of hard and not many people were doing it, there wasn't much documentation, so Docker came out and made everything really easy.
+
+**Erik St. Martin:** Yeah, it's a beautiful abstraction over the top of doing LXC.
+
+**Travis Reeder:** Yeah, and it allowed our customers to run and test their code on the exact same environment that it would be running after they uploaded it. That was our initial thing into Docker; we said, "Okay, well now you have Docker, you can test your code before, to fully test it. You could test it locally and hope that it worked the same way after you uploaded it, but to really test it you had to upload it, queue up a job and see the results of that job and make sure it worked okay, which is slow and cumbersome.
+
+And then all of a sudden, okay, now they can run in the exact same environment that they're gonna be running on after it's uploaded. But you'd still upload your code. Then more recently we've just said we'll just run any image, so you can create your own image from the ground up, whereas before we had a bunch of different language images that we said you could use as a base. Now you can use whatever you want, we'll just run any image. So it's kind of in a progression.
+
+**Brian Ketelsen:** So how do you support the any-image plan? Are you piping in and out of standard-in/standard-out? What's the stick behind that one?
+
+**Travis Reeder:** Yeah, I mean... Even before, we'd just execute your code inside a container, and yeah we'd pull out the logs, store your logs, store the exit status and stuff, but inside, your code does whatever it wants. It can connect to databases and APIs, do some processing and then push the data back into your database, or wherever you want it to go. So it's always been able to kind of do whatever it wanted, and we'd collect all the logs and stats and things around that. So it's not much different, other than that you now have full control over that image, which makes it pretty nice. You're not stuck to our environment, and whatever we installed on that operating system is the only thing you can use; now you can go and install your version of ImageMagicK or anything that you need into it.
+
+**Brian Ketelsen:** That's nice.
+
+**Erik St. Martin:** You said you didn't have any real battle wounds from Go adoption early, how about containers?
+
+**Travis Reeder:** \[laughs\] That's a different story, we had a lot of problems with Docker. When Docker first came out there were a lot of bugs. The Docker daemon would lock up, for instance, and basically... In fact it didn't just lock up, it would lock up the entire machine; you couldn't even SSH into it. So there were some pretty bad ones... But it didn't happen all the time; these things would happen randomly. Our solution to some of these things in the early days was just restart servers, or kill and launch new servers every day, basically... Like always flush out these servers.
+
+**Erik St. Martin:** In the late '90s that was my approaching to administering SQL Server - reboot it.
+
+**Travis Reeder:** Well, it works, you know? It clears out all the crap that's been building up. But it also had memory leaks and things like that, but that also fixed the problem because as long as you restarted the server before the memory ran out... So there were some issues; it's a lot better nowadays, though.
+
+**Brian Ketelsen:** It really is. Running Docker in production is one of the nicest things about 2016, I can tell you that. Especially with tools like Kubernetes and Rancher and Deis... All of these really nice orchestration tools that make it so easy to manage Docker.
+
+**Travis Reeder:** I think Docker and these containers are gonna take over the computing world, for sure. I'm pretty bullish on it.
+
+**Brian Ketelsen:** I agree, too.
+
+**Erik St. Martin:** So what's your prediction there? You like to make a lot of predictions for Go. What's your prediction for Docker and containerization?
+
+**Travis Reeder:** Like where it's gonna go?
+
+**Erik St. Martin:** Yeah. Do you think we'll ever truly get rid of VMs and it will be all containers, all the time? Or they'll just have the primary market share.
+
+**Travis Reeder:** I think it should be all containers, all the time. I love Rancher, and CoreOS's philosophies - just everything in a container. The beauty of it is you fire up a new server, and all you need to do is have Docker on it, right?
+
+**Erik St. Martin:** Yeah. I mean, I love CoreOS's approach to the kind of like, you should write crashable software, right? You shouldn't have to plan the server restart, right? At first, that seemed really odd to me, you know? Like, "Oh man, at any point it could update and restart?" That seems crazy. I guess there are some cases where you never want that to happen, but for most people's use cases your system should be able to tolerate that. If one node going down can affect your entire production system, then you've got much bigger issues.
+
+**Travis Reeder:** Yeah. We even use it in development a lot now, too. You clone a repo, and without any tooling or anything like that, you can sort of start using it right away, and get into it.
+
+**Brian Ketelsen:** Yeah, it has made the development workflow... You know, we talked about CockroachDB earlier; CockroachDB had - I don't know if they still do, but last year when we were playing with our fork of it, it had some pretty serious dependencies that had to be installed in order to build it. Making that whole thing Dockerized, `docker pull cockroach` and run it, and you're done - the development pain has gone down drastically. I haven't had a database installed on any of my development workstations ever since Docker existed. Once Docker came out, that was the last time I installed Postgres or MySQL... Forget it. There's just no need to have those sorts of peripheral utility applications running on a development workstation any more. They're all Docker containers now. `docker compose up`.
+
+**Travis Reeder:** Pretty amazing. On the op side too, it's pretty amazing. We've kind of adopted Docker for all of our deployment and what not, not just for running people's code. Everything's so much easier if you base everything around that one thing. You don't have to say "Okay, well these servers need this stuff installed... These servers are running Go, these servers are running Ruby, these servers are running Java..." You know, all the servers need is Docker, and you can do all your ops and all your deployment through that one unit.
+
+**Erik St. Martin:** Alright, it looks like we're about out of time. I think we actually went over a little bit, but before we go, we have a history of doing kind of like a \#FreeSoftwareFriday shoutout, where all of us will kind of just give thanks and praise to some open source project that is currently or has in the past made our life easier. So we'll quickly go around the room - the virtual room - and everybody can kind of mention a project. Brian, do you wanna kick things off?
+
+**Brian Ketelsen:** Sure. Last week I've mentioned that I've decided my new year's resolution this year - it's a couple months late. My new year's resolution was to start learning frontend development; I've been doing backend forever and completely left behind by the frontend scene. So I started learning GopherJS, which I think is just amazing, the ability to run Go that's transpiled down to JavaScript on the frontend, and recently I found polymer bindings for GopherJS written by Luna Duclos. That's at github.com/palmstonegames/polymer. If you want to write in a pretty material design frontend using GopherJS, then the Go polymer bindings are the way to do it. It makes it easy enough for even me to be moderately successful.
+
+**Erik St. Martin:** Carlisia?
+
+**Carlisia Thompson:** I like to every once in a while acquire new tools to look at my code. I like to know what's going on under the hood, things that I wouldn't necessarily catch just looking at it, and I found this tool called gocyclo. It measures the cyclomatic complexity of your code. There's a simple command line tool, you just run on it. This guys has a few flags and he will let you know how many cyclomatic complexities a specific block of your code has, and it points you to the line number and the file name. I thought that was really cool.
+
+**Erik St. Martin:** Yeah, that's actually really interesting. I have not seen anything like that in Go yet, and cyclomatic complexity measurement is actually really common in the Java world. Almost all CI environments I've ever worked in in Java used it, so that's really cool, I wanna check that out. I don't know whether I've ever seen any Go code that's high branch rates, and stuff. It'd be really interesting to run it on some big Go project and see...
+
+**Brian Ketelsen:** We have it built into the CI routine in goa, so we will fail if our cyclomatic complexity is higher than 20 on any function.
+
+**Carlisia Thompson:** Wow, very cool.
+
+**Erik St. Martin:** That's awesome. And Travis, we're kind of blind siding you here, but do you have a project you'd like to give a shout out to?
+
+**Travis Reeder:** Probably the ones I mentioned earlier?
+
+**Erik St. Martin:** That's true, we did give shout outs a lot in this episode.
+
+**Brian Ketelsen:** It's good, though.
+
+**Travis Reeder:** And I can't forget Docker, I suppose, after talking about containers.
+
+**Erik St. Martin:** Docker's an easy one.
+
+**Travis Reeder:** Yeah.
+
+**Erik St. Martin:** For me, I guess recently just the fsnotify, which Nathan Youngman has kind of taken over that and adapted the API to this spec the Go team kind of suggested. Anybody who's unfamiliar with it, it's basically for monitoring file system changes on files. With that being said, all of these projects and all of the ones we mentioned earlier, we will link to in the show notes, and give everybody new stuff to play with. I want to thank everybody for coming on the call, I think we've had some fun conversations. Definitely thank you Travis for coming on the call with us.
+
+**Travis Reeder:** No problem, it was good to be here.
+
+**Erik St. Martin:** There's rumor that you guys are doing some kind of major announcement in the near future, and maybe we can get you to come back on and talk about that.
+
+**Travis Reeder:** I'd love to, yeah.
+
+**Erik St. Martin:** If you're not already subscribed, go to GoTime.fm and you can subscribe to the podcast and the newsletter. We are also @GoTimeFM on Twitter. What else am I missing here...? GitHub - if you wanna make suggestions for people to come on the show or topics, github.com/gotimefm/ping. With that said, let's call it an episode. I'll catch two of the three of you next week.
+
+**Brian Ketelsen:** Hey Travis, on behalf of everybody, thanks so much for all you do in the Go community, we truly appreciate all that you and Iron.io do to facilitate Go, in San Francisco especially, it's really awesome.
+
+**Travis Reeder:** Good to hear, thank you guys.
+
+**Carlisia Thompson:** Absolutely, I'll second that. Thank you.
+
+**Erik St. Martin:** Alright everybody.
+
+**Carlisia Thompson:** Goodbye.
+
+**Brian Ketelsen:** Goodbye.
+
+**Travis Reeder:** Bye guys, that was fun!

Francesc Campoy on GopherCon and understanding nil_transcript.txt

@@ -0,0 +1,591 @@
+**Erik St. Martin:** We are back with for another episode of Go Time. This is episode number 13. Before we kick off this show I wanna give a quick shout out to our sponsors for this episode. Linode, Changelog's cloud server of choice, and Equinox.io, the best way to package and distribute your Go apps.
+
+Today on the show we have myself, Erik St. Martin, Brian Ketelsen is also on the line...
+
+**Brian Ketelsen:** A Brian Ketelsen without much sleep, apparently.
+
+**Erik St. Martin:** So half of Brian Ketelsen is on the line, and then we also have Carlisia Campos...
+
+**Carlisia Thompson:** Alive and kicking after GopherCon.
+
+**Erik St. Martin:** And our special guest for today's show is Francesc Campoy from the Go Team. Say hello, Francesc.
+
+**Francesc Campoy:** Hey, how are you doing?
+
+**Erik St. Martin:** Good, good. So let's talk about GopherCon, being that I think all of us were there, at least partially. Brian-half-sleep at GopherCon...
+
+**Brian Ketelsen:** Yeah, apparently. So this is our first show after GopherCon. GopherCon officially ended last Wednesday, it's now Thursday... I still haven't even read all my email or done my laundry.
+
+**Francesc Campoy:** I just got to my inbox zero yesterday and I was so proud. I'm done for the rest of the week.
+
+**Erik St. Martin:** I spent airline time doing the inbox zero thing.
+
+**Carlisia Thompson:** I haven't been at inbox zero for a long, long time.
+
+**Brian Ketelsen:** So I didn't have to do laundry because I got so many shirts at GopherCon, I'm just wearing them one at the time. At some point I'll run out... Then I'll have to maybe do laundry this weekend. But it's pretty nice getting a lot of shirts.
+
+**Erik St. Martin:** How do people even manage collecting all of that swag? You need to bring a second suitcase just to bring home swag.
+
+**Carlisia Thompson:** Or you do it like me... Because I was there the year before, I went prepared. My suitcase was small and pretty much empty, because I knew, like I basically only need one T-shirt, because I'm gonna get T-shirts for the rest of the days.
+
+**Erik St. Martin:** I can't keep mine, my wife likes to steal all of them. I think we need to have people make less comfortable shirts and then they won't get stolen. \[laughter\] So Francesc, do you wanna talk to us a little bit about your talk at GopherCon? It was actually really interesting to put that much attention on Nil, which I think from most people's perspective, when you talk about it, it's for bad reasons and not for good uses, and why nil should be embraced.
+
+**Francesc Campoy:** Yeah, I agree. So the talk basically came up when I started talking with someone about how there was nil receivers that could work. If you define a function on a pointer receiver, if that pointer is nil, that doesn't mean that the method will fail. And after talking about that, we started talking about all of the things where nil was useful, and I saw that there was kind of a theme where basically nil and Go is not something that should be avoided in general. I mean, you need to be careful, obviously, but it's something that can be really useful, so I thought it could be an interesting talk. But when I proposed the talk I was in a bar in Belgium, right after FOSDEM and basically I just sent the abstract, and I was very excited about it, but when it got accepted, I was like "Oh wait, now I have to talk about nil for thirty minutes? That's gonna be fun."
+
+**Brian Ketelsen:** \[04:02\] I think you tweeted a picture of that, didn't you? I wanna say you tweeted a picture of you holding up a beer, saying you were working on your proposal.
+
+**Francesc Campoy:** Yeah, that was actually in FOSDEM, so in Brussels. I think it was in February probably, I don't remember. But yeah, I was surrounded by other Gophers. We had finished the Go devroom at FOSDEM, so lots of people surrounding us. Basically we did a proposal party where we just sent all our talk proposals at the same time pretty much, right before it was too late. So yeah, we were part of the people - do you know that peak that you get at the end, the last hours before you get to the deadline?
+
+**Erik St. Martin:** The last 48 hours, where we get like 70%?
+
+**Brian Ketelsen:** The procrastinators' party.
+
+**Francesc Campoy:** Procrastinator - absolutely. Yes, that was me.
+
+**Brian Ketelsen:** So how did you feel about going on first this year?
+
+**Francesc Campoy:** I was pretty nervous... My talk changed a lot since I was notified that I was the opening keynote speaker. I was like, "Oh wait, what?" So I made it more of trying to get a mission of embracing nil, rather than just giving a bunch of technical facts, and I think it made the talk much better.
+
+To be honest, I was nervous also about being the first person on stage, but then I saw Kelsey Hightower was right before me and he did an amazing job, that it was actually... It was very easy to get on stage after him, and also incredibly hard to try to compete against what he did.
+
+**Erik St. Martin:** Yeah, the remix of that poem was awesome. We sent him home with a framed copy of it.
+
+**Francesc Campoy:** Yeah, when I got on stage I said that he almost made me cry, and people laughed about it like it was a joke. It was not. I was almost crying. I was like, it's gonna be hard to say that nil is a good thing while crying, so let's keep it calm. \[laughter\]
+
+**Brian Ketelsen:** It was very moving.
+
+**Erik St. Martin:** You were telling yourself on the inside, "Put yourself together now."
+
+**Francesc Campoy:** Yeah, basically.
+
+**Erik St. Martin:** So the nil talk was one of the ones I actually got to see a good portion of, and I really enjoyed it. Because there are a lot of use cases, and I was glad you pointed out one of my favorites, which is setting a channel to nil in a select, so that you can continue to select on the other channels.
+
+**Francesc Campoy:** Yeah, it's something that is so simple... Once you understand it it's so obvious, but many people when they write concurrent programs don't take that into account, and it will very often happen that they either have a busy loop, or they will leak memory, leak goroutines, and things like that. So there are these little things that I'm trying to get people to keep in mind for whenever they actually need them.
+
+**Erik St. Martin:** Yeah, speaking of leaking goroutines, Ivan's talk with visualizing the concurrency, I've never seen leaking goroutines look so awesome. \[laughter\]
+
+**Francesc Campoy:** That was amazing, yeah.
+
+**Erik St. Martin:** It's like, "How can this be so terrible but yet so beautiful at the same time?"
+
+**Brian Ketelsen:** That's an interesting segue into one of the Go projects that I was keeping my eye on this week. He released that particular package GoTrace I wanna say yesterday or the day before. It's at github.com/divan/gotrace. Really awesome tool.
+
+**Francesc Campoy:** Yeah, I was checking it this morning and the animations are just so beautiful that I wanna run it with everything. Basically the problem right now is that the browsers are not able to catch up with all the goroutines that we start in Go. Maybe we should make goroutines heavier, or browsers faster. But there's a problem here. \[laughs\]
+
+**Erik St. Martin:** Filing a bug for the browser, saying that it needs to increase performance so that we can show all of our goroutines.
+
+**Francesc Campoy:** Yeah.
+
+**Erik St. Martin:** \[08:02\] It's a motivating factor.
+
+**Francesc Campoy:** They look really cool. My favorite graph from everything he showed was the Eratosthenes Prime Sieve. I've seen that program many times before, and it's kind of hard to explain how it works. And after seeing that, I feel like anyone could just be like, "Oh, okay. I get it. I understand what all the goroutines are doing, the data, how it's going through all the filters and everything." It's just beautifully simple.
+
+**Erik St. Martin:** Visualizations are hard, too. That's something I've always struggled with, it's like how do you take some complex thing going on behind the scenes and visualize it so that you can easily understand it, and I think he did a really good job at being able to see the data going between goroutines and things like that, the transfer of execution. It's a really cool project, I'm waiting for the video to come out. I missed parts of it. That's the sad part that Brian and I have to struggle through. We don't always get to see all of the talks.
+
+**Francesc Campoy:** Actually, since you've mentioned videos, I've had this question many times - when are the videos coming out?
+
+**Erik St. Martin:** They take about a month, because there's some post-production time. We have 25 videos that have to be produced, and then lightning talks. They're so massive they have to mail a hard drive.
+
+**Francesc Campoy:** Oh, nice.
+
+**Erik St. Martin:** Yeah, so it takes a couple weeks, up to a month. I would say by time it's hit one month out, the videos should be out. I think last year 18 days or something along those lines is what it took us to get them live.
+
+**Carlisia Thompson:** Did they all come out at once?
+
+**Erik St. Martin:** Yeah, they send a hard drive of all of them, and then I set my computer loose on uploading to YouTube.
+
+**Brian Ketelsen:** This year was a little different because we streamed live on YouTube...
+
+**Erik St. Martin:** On Twitch.
+
+**Brian Ketelsen:** Twitch, sorry. Thank you. Did I mention I need some sleep? So we did the live streaming this year and I think we had a maximum of almost 2,000 people at any given time watching, which was amazing. And a total of almost 9,800, almost 10,000 people. Or was it 8,800, almost 9,000? One of those two.
+
+**Erik St. Martin:** I think it was 9,000.
+
+**Brian Ketelsen:** Yeah, a lot of people around the world watched at various points during GopherCon, and that just made my day. It was really neat to be able to share the conference, that was a very local and specific thing, with the whole world.
+
+**Francesc Campoy:** Yeah, one of the people that were there on Twitch was my mom, watching my talk.
+
+**Erik St. Martin:** Oh, really? That's awesome.
+
+**Francesc Campoy:** Yeah. Fun fact - she doesn't speak English... She loved the talk; she doesn't know what I said, but she loved the talk.
+
+**Carlisia Thompson:** As Scott mentioned on GoTime FM gophers channel - the conference is local, but the content is pretty relevant to everybody, and it has a pretty wide range of talks, and of course people all over the world can benefit.
+
+I wanna mention this because it was so awesome... Yesterday the Remote Meetup streamed the GoSF meetup, and it was amazing. This business of streaming is awesome, we need to keep doing it.
+
+**Erik St. Martin:** Yeah, the only struggle with streaming is if it starts taking away from physical attendance. Because one's free, and one pays for everything. But I think people get a lot more out of attending. There's a lot that you can get out of just being there and being able to network. I guess videos would have taken away attendance if that was ever gonna be a thing.
+
+But I share some concerns though... We had some discussions with Kelsey and somebody else, I think it might have been Dave Cheney, where this whole nature of streaming and recording and stuff like that also starts kind of burning out speakers, because they constantly have to have new content and they can't continuously deliver and improve on a talk, because once they've given it and it's been recorded, then it's kind of done; nobody wants to pay to go to a conference and see a talk that they already saw on YouTube.
+
+**Francesc Campoy:** \[12:18\] On the other hand, conferences being slow at releasing the videos actually help us. \[laughter\]
+
+**Erik St. Martin:** Yeah, exactly, because more people get to see your content, and things like that. For us, the videos going out was really just trying to help the community grow. The more content, the more people can be exposed to the language and the more growth we see in the community, which was kind of our motivating factor for releasing the videos.
+
+**Brian Ketelsen:** Yeah, and my general theory has always been that whether we're releasing the videos or whether we're doing a live stream, most people come to conferences and the talks are almost secondary to all of the rest - the networking, getting together with your friends, the community. A lot of people I talked to skipped out on talks at various times of the day and went off and did things with people that they don't get to see often. So there are benefits to going to the conference that aren't directly related to those talks, and you know that it's gonna be on YouTube later, so there's no need to attend all of them.
+
+**Erik St. Martin:** And Hack Day. Holy cow, people stayed for that. There was probably 800 people there.
+
+**Brian Ketelsen:** That was a big surprise. I think we planned for half of that.
+
+**Francesc Campoy:** Yeah, it was pretty amazing to see so many people working on random things. We had the Go project room, and before going there I was working on something else... I was actually releasing my podcast, because it was Wednesday, and I had totally forgot about it. But it was really funny, because people would keep on coming to me... It was like, "Oh, so what are you hacking on? Can we work together?" It was this very collaborative spirit of everyone trying to help each other, I loved it.
+
+**Erik St. Martin:** You can help me release my podcast episode. \[laughter\]
+
+**Francesc Campoy:** Yeah.
+
+**Brian Ketelsen:** So tell us a little more about what went on in the Go project room.
+
+**Francesc Campoy:** It was pretty funny, because we did not really have that much time to prepare it. So rather than trying to have a very strict schedule, what we decided was we had one of the meetings that we hold for every release meeting. This year was Go 1.7 release meeting, and we did that from 10 to 10:30, just half an hour, so people could see how a new version is released for Go. That was very powerful, because people sometimes think that it's something dark and magic... But no, it's just a bunch of people talking about what they - they wanna make sure that everything is out, and there's no more bugs and things like that, so it was pretty good.
+
+My favorite part was right after we had the dependency discussion. The dependency discussion is pretty interesting, because it's talking about one of the hot topics in the Go community - vendoring. And not only vendoring; talking about "Is vendoring a good solution? How should we do it? What are the tools?"
+
+I know that Chris Broadfoot was there and he took a bunch of notes, and I'm looking forward to the document that will explain basically about all the things that were discussed. But it was a very, very active discussion, that's for sure.
+
+**Erik St. Martin:** That room was packed the entire time, and no riots. It was crazy.
+
+**Brian Ketelsen:** That's what I was gonna ask - nobody got stabbed, or anything? I mean, vendoring - this is a hot topic. This can be contentious.
+
+**Francesc Campoy:** Yeah. I know that some people were very passionate about it, but not to that point, unfortunately.
+
+**Erik St. Martin:** \[15:52\] I really liked how that room turned out though. It kind of grew organically, and I think that it's something that we should continue to grow on its own; make more space and put some A/V in there and maybe live stream that, because there were a lot of valuable discussions that were going on, and it seemed a lot of people wanted to be involved in that, too. I think continuing to grow that each year will be nice as well.
+
+**Francesc Campoy:** Yeah, I'm looking forward to next year, trying to do something even bigger.
+
+**Erik St. Martin:** Speaking of bigger, we wanted to get... Because this year's mascot was a parade balloon - you know, like Macy's day parade... We wanted to get like a big one to float, and we never got around to that.
+
+**Francesc Campoy:** That would have been amazing.
+
+**Brian Ketelsen:** We probably would have had to have some special dispensation from the damn fire marshal, though. Don't get me started on that fire marshal.
+
+**Carlisia Thompson:** We should have a Gopher parade to open GopherCon.
+
+**Erik St. Martin:** We need a Gopher fire marshal.
+
+**Francesc Campoy:** A balloon gopher, just as a plushy, I would love that. So if you're thinking about presents to get me, now you know. \[laughter\]
+
+**Erik St. Martin:** For anybody listening...
+
+**Francesc Campoy:** For anybody listening... Yeah.
+
+**Erik St. Martin:** A parade balloon gopher.
+
+**Francesc Campoy:** Yeah.
+
+**Erik St. Martin:** The little toys were fun that we did for 2015, too. I thought about getting more of those done. We'll have to keep toying with that idea. So did you have any favorite talks that you came out of that you liked, Francesc?
+
+**Francesc Campoy:** There were many talks that were very interesting. I really loved Ivan's talk on the visualization of concurrency, because I think it's something that I struggle with. I teach many people about Go, and it's very hard to visualize what a program is doing, and I feel like with this it is so much easier. My favorite talk though probably was Katrina's.
+
+**Erik St. Martin:** Without a doubt. I haven't seen all the talks, but all the ones that I did see, that one... I think she put into really good terms something that we all struggle with. She just kicked it off really well, with all the ingredients of a Twinkie. It's like, "I have a degree in molecular biology, I know what all of these things are, but I still can't turn it into a delicious pastry."
+
+**Brian Ketelsen:** It was a great talk, very inspiring.
+
+**Francesc Campoy:** My favorite part of the talk was... I mean, the presentation was amazing and the slides were really fun. One of the slides was the metro in Barcelona, which I always appreciate... But my favorite part was the fact that she talked about how you can be fluent without being proficient. That is something I had never thought about, the fact that for instance if you're learning how to speak English, you could be totally fluent at asking beer when you're at a bar, but that doesn't mean that you know how to read Shakespeare, and that's totally fine. I think that applying that to teaching Go can be very interesting. Don't try to learn all the concurrency patterns, don't try to use generic - not generic, sorry. Whoops! \[laughter\] Unsafe. Don't try to use reflection. Just really understand the basics, be fluent in those basics and then move on from there. I thought that was very powerful, and she explained it in such a beautiful way. I loved the talk, really.
+
+**Erik St. Martin:** Yeah, and the comparison to graphs I think really set some of that stuff home. For any of us that look at a language and are like "That makes total sense", we forget that we have all of this nodes of information and we're just drawing connections between them; it makes it easy for us to do stuff.
+
+Even behavior... Like, I know in the Slack channel I've been quick to answer a question, and I'll link to a section of the language spec, and it makes it look like that's just knowledge I have in my head. Like, "Oh yeah, right here, in the language spec." And it's like no, often times I vaguely remember there being some rule about that, I look it up real quick and then link somebody to it. But the outside perspective is that there's a bunch of us running around and we just memorize this stuff, and it's just not true.
+
+**Carlisia Thompson:** \[20:11\] And I think she also did a really great job, like you were saying Francesc, in articulating what we were thinking... I couldn't even point towards what she said before I heard her say it, and now I can, which is there is no clear path for a person who is a newcomer to Go to being proficient, or a person who's a beginner to programming and being proficient in Go; and we know Go is a very simple language to learn. So there should not be this barrier, and a lot of people were having this conversation at the conference and even after the conference.
+
+For example Matt Aimonetti did a beautiful [blog post](https://medium.com/@mattetti/go-is-for-everyone-b4f84be04c43) about Go being for everyone, and I think it is going to be very healthy for us to identify what we need to do and why we need to do these things, because I think a lot of us want people to join the community, and not just because we want everybody to do Go, but if you do want to do Go or try it out, there should be an easy path for you. You should be not only welcome in the community as a person, which I think we're doing a great job at that, and we can talk more about that too, but also as far as learning the language.
+
+**Erik St. Martin:** And similar to that talk was Michael Matloob's talk on contributing to Go, and even open source. I think that was valuable, because a lot of people feel like they're not at the skill level they need to be in order to contribute, and there are so many ways to contribute. One thing that I've advocated to people is that sometimes a solution to a problem is better than no solution. It's easy for somebody to come through and be like, "Oh, you could make this faster if you remove these couple allocations" or "It would look cleaner if you made these couple of abstractions", but we're looking at it after the fact, right? Seeing somebody's solution and thinking about how to tweak it to make it better is much easier than solving the initial problem, so I think that there's value in people contributing test cases or testing bugs to get steps to reproduce vague bugs people put and there's so many ways that people can contribute, but I think a lot of people are like "Well, I'm not at that standard. There's nothing I can do to help, and I shouldn't have any business being in the repo trying to submit patches."
+
+**Francesc Campoy:** Yeah, that actually takes very well with something else that we discussed in the Go project room during hack day, which is we have these... We had actually two different talks with two different sessions where we ended up discussing the same things, which is the user feedback and the diversity discussion. Surprisingly, we ended up talking about pretty much the same things, which were we need more people in the community; to do that, we need to teach more people, and to teach more people we need better ways to basically welcome people that have never programmed in any other language.
+
+We have things like the Go Tour, which I think is a great tool for people that have already programmed in other languages, but if you come from no programming experience at all, when we say "Oh yeah, the for loop is like C++, just without the parenthesis", it's not incredibly helpful.
+
+So we're talking more about okay, so how do we get this started, what kind of resources we want them to get together? Katrina was talking a lot about what kind of resources are available in the Ruby community, and I think that that is something that hopefully during this year and coming up to next GopherCon we'll have new things and new projects about how to basically get more Gophers involved.
+
+**Erik St. Martin:** \[24:11\] I think some of the tour too can be misleading. I was helping somebody who was walking through the tour and there was one particular exercise where I think all it wanted you to do was a loop through a multidimensional array - it was a slices section - and basically allocate the slices for this multidimensional slice. But the example really explained it as like outputting a grayscale image; and really what the value was wasn't important. It gave some examples, but even just in the phrasing of the question, it made it sound like it was this advanced thing, like they wanted you do draw an image with a multidimensional array, and it kind of locked this person up and like, "Wait, wait... I've never drawn images, and stuff like that." So I think having a feedback loop on some of those things where things might seem more advanced that they really are and just changing the wording of it can help a lot, too. And anybody who can submit advice or things that they run into that seem harder than they feel it should have been.
+
+**Francesc Campoy:** You know, we definitely welcome pull requests.
+
+**Erik St. Martin:** That's right, the tour is part of the repo, for pull requests, isn't it?
+
+**Francesc Campoy:** Yeah. I actually maintain it partly, so if you send pull requests, or even better, if you don't know how to improve it but you know that it is not clear, just send bugs. From the tour there is a little bug button on the right corner on the top. From there you go to the GitHub repo, which is github.com/golang/store, and then you can just send your issues or your bugs in there, and hopefully I will take care of them.
+
+I agree that in general the exercises tend to be a little bit too complex, and it's not always related to Go. One of the examples is the first exercise ever. It is a for loop to compute a square root of a number using Newton's method. That by itself just sounds scary, and it turns out it's just a for loop. So it can be a little bit confusing at the beginning.
+
+**Erik St. Martin:** Yeah, and I think for anybody who has more of a formal background some of these things seem clearer than people who are more autodidact, they've taught themselves to program and maybe don't have the formal...
+
+**Carlisia Thompson:** While on subject, there was a lightning talk by this guy, and I keep forgetting his name... I'm looking on the GopherCon repo for the 2016 talks and I can't identify him in there, maybe he hasn't added it yet. In any case, he has this proposal about doing an open source collaborative effort in putting together a book, and he has some specific ideas I thought were brilliant. I'm hoping he was going to go forward with that. I'd love to get people connected to get that... Landon Jones, yes. He's a firecracker. I hope this takes off.
+
+**Francesc Campoy:** What talk was this you said?
+
+**Carlisia Thompson:** It was a lightning talk on the first day.
+
+**Erik St. Martin:** Yeah, he was talking about building a book for high-school students, or something along those lines. I didn't see the talk, but I remember people referring to it.
+
+**Brian Ketelsen:** He cornered me in the hallway. His idea for the book is called The Little Gopher. It sounds really interesting. He's even trying to line up Renee to help with some illustrations.
+
+**Francesc Campoy:** Cool. I'll check it out whenever the talks are out.
+
+**Carlisia Thompson:** If Renee cannot help him, I know a designer who can take Renee's graphics and really do something amazing.
+
+**Francesc Campoy:** \[28:03\] Now that you mentioned Renee, I gotta say that if Katrina's was my favorite talk, Renee's was probably the second one, or maybe the first one. It is hard to choose, because they're very different, but Renee's talk was amazing, and I'm just so happy you had such a non-technical talk at such a conference. It was great.
+
+**Erik St. Martin:** Yeah, I mean, the Gopher is a staple of our community, so when she submitted a proposal we were like, "Alright, we have to do this.
+
+**Brian Ketelsen:** Yeah, this has to happen. And it was kind of interesting that she wanted to do the talk with all of the stage lights dimmed and only the screen; that caused the whole Convention Center staff to go into a full panic. "We can't possibly do that. What if there's a fire and people get up and trip over each other because the house lights are down?" So we had to ask Kelsey specifically to mention, "Stay in your seats, don't move. We're gonna dim the lights. Keep calm, don't panic."
+
+**Erik St. Martin:** Yeah, that talk was just phenomenal. I'm really happy she came out and got to give everybody a little insight into the Gopher. It was kind of fun, and I think it was a welcomed mind-break for a lot of people, too. Because you're kind of overwhelmed with all this new content, so being able to sit back and relax and have some fun with the Go Gopher...
+
+And I loved that she credited a lot of artists who have been doing our work surrounding the Gopher recently, too. It's kind of fun to see her take on that.
+
+**Carlisia Thompson:** I want to encourage people to watch it, if they didn't watch it at the conference. It's not just an amazing talk about the Gopher... She really went deep into the design process, her process, how she approached it, and you will never look at the Gophie the same again.
+
+**Brian Ketelsen:** My favorite part was that she stayed after the talk and gave out those cute little Gopher sheets with custom-drawn Gophers on the back of them that she autographed. I don't know how many people were able to take advantage of that, but I saw dozens and dozens of people walking around with them. I thought that was adorable.
+
+**Francesc Campoy:** It was pretty funny, because there was a really long line, and then a bunch of people from the Go team waiting for her to finish to go get lunch. And when the line was over, the people from the Go Team started lining up, because we also wanted them. They were amazing. My new desktop background is the Gopher she drew for me. It's just amazing.
+
+**Erik St. Martin:** It's like "I can eat, or I can have a custom-drawn Gopher."
+
+**Brian Ketelsen:** That's not a choice. When she made one for me, the first thing she asked me was "What are your girl's names again, Brian?" So I told her my daughters' names, because last year after GopherCon both of my daughters painted pictures of a gopher and we mailed them to Renee. And she said, as she was drawing the picture for my girls, she said "I've got those hanging in my living room", and I was just like "Oh my god, oh my heart..." \[laughs\] I was so impressed.
+
+So this is a good time for us to stop and take a break and thank our sponsor Linode. Linode is Changelog's cloud server of choice. It's what Adam and Jerod are using to build their new CMS and the future of Changelog is riding on Linode. You can get a Linode server up and running in seconds. The easiest way to get started is by going to linode.com/gotime. You can choose your flavor of Linux, the resources you want and the location of your node. They've got eight data centers spread across the world and plans start at ten dollars a month. The nice thing about Linode is that you get full root access. You can run VMs or containers, your private Git server, you can run Hugo and have your own blog. You get native SSD storage, fast 40 gbs networking and nice Intel i5 processors. You have a fancy control panel where you can reboot things and resize things and clone your VMs, as well as a CLI tool that you can use to manage, and an API, so that you can call it remotely. You can use the code 'gotime20' to get two free months, which is $20 credit. You should tell your friends about that, so everybody can go off and get their own servers. Again, go to linode.com/gotime so you can get started.
+
+**Erik St. Martin:** \[32:15\] And to keep us on the air.
+
+**Brian Ketelsen:** Yay!
+
+**Erik St. Martin:** So are there any other talks anybody was able to see that were interesting? I know Donnie Berkholz's talk was really well received as well, Mining the Go Developer Community. I didn't get to see that one. Was that something you got to see, Francesc?
+
+**Francesc Campoy:** Yeah, I got to watch it and it was very interesting. Basically, he kind of did my job, because I tried to make the community better and "Yeah, that is actually very interesting data." There were a lot of interesting things, like how people are using vendoring, what kind of tooling they're using, if people are using debuggers or not... I think it's a very good place to start to basically try to have a campaign on... If you want everybody to use go fmt - I mean, go fmt is the one that everybody uses... But things like error check - how many people are using that, that is a very interesting conversation. And try to get more people to use the tools that everybody agrees increase the quality of the code. So yeah, I loved the talk.
+
+**Brian Ketelsen:** Here's something that's just blowing my mind. We've got one of our very remote people on Slack right now, saying that his favorite talk was the Inside The Map Implementation from Keith Randall. The reason this blows my mind is because I know he wasn't at GopherCon and he watched it over the live stream. I'm just having a little bit of a joyous moment right here.
+
+**Francesc Campoy:** Yeah, I gotta say that Keith's talk was so technical but so funny at the same time that I loved it. My favorite part was when basically in a very fine example of trolling he said, "Oh, Go doesn't have generics, but you can fix it with unsafe." I was like, "Oh my god! You didn't go there." \[laughter\]
+
+**Brian Ketelsen:** Yeah, what was that... A map of function pointers?
+
+**Francesc Campoy:** Yeah, it was pretty amazing. I mean, the whole thing - how it was done and everything, it inspired me to try to implement Go Maps by myself too, but at the same time I feel like for some people it might be a little bit too... Like, I don't want people to be so attracted to unsafe that they're gonna just be using it everywhere. Maps are already there; have fun, enjoy them, don't reinvent the wheel, and especially, don't reinvent unsafe wheels, if possible.
+
+**Erik St. Martin:** The thing I love about the unsafe package is basically it makes you... It's like you wanna delete a GitHub repo you have to type the repo's name to be sure; so everytime you go to use unsafe you have to say 'unsafe'. It just keeps beating it into you, "I should not be doing this."
+
+**Francesc Campoy:** Yeah. I had an idea, I don't know if you saw it... I [tweeted about how you can give an alias](https://twitter.com/francesc/status/920740297713291265) when you're doing imports. So you could do `import totessafe "unsafe"`, so instead of `unsafe.Pointer` you have `totessafe.Pointer`. That fixes the problem.
+
+**Erik St. Martin:** Totally safe dot... \[laughter\]
+
+**Francesc Campoy:** Totally safe dot pointer. Yeah, and it works.
+
+**Carlisia Thompson:** That sounds like a website we should have.
+
+**Brian Ketelsen:** I think we need to make a new top-level domain, .pointer.
+
+**Francesc Campoy:** .totessafe.io, yeah... \[laughter\]
+
+**Brian Ketelsen:** Actually, that would be a good vanity package for any Go package. You could use the vanity URL totessafe, .totessafe
+
+**Erik St. Martin:** \[36:00\] With the tagline "You can trust us."
+
+**Brian Ketelsen:** We promise.
+
+**Erik St. Martin:** Yeah, there were so many good talks. So back to the Go Project room, I wanna make sure we touch on that too, because I know it's definitely something Carlisia was interested in speaking with you while you were on the show... The Diversity discussions. I wasn't in on that, how did that go?
+
+**Francesc Campoy:** It went really well, it was full all the way. That was very interesting, seeing so many people interested in talking about Diversity, and not only people that are members of minorities represented at GopherCon, black people and women, and LGBTQ etc., but there were also a lot of allies that were there to represent and basically to give support. That was very interesting.
+
+We talked about many things. One of the things that I tried to propose and I hope is gonna happen - the same way there was this talk about mining the Go community, and that understands how Gophers do technical things, I was wondering if we could do something similar about who are those Gophers, where are they? Do they live somewhere in the States, in cities where they have meetups, or are they far apart? Do they have kids? Is it easy for them to attend conferences like GopherCon, or do they prefer things like the remote meetups organized by GoBridge? Is that useful for them? That was pretty interesting.
+
+Then we moved into talking about how to make the Go community more approachable. There was a lot of discussion on basically improving the newcomers' documents that we have right now. I could say they're not bad, but we could definitely do much better. There were a lot of people talking about how to make those better, how to learn a little bit from the Ruby community. The Ruby community has a lot of funny examples; it is not only about technology, it is also about having fun while learning and things like that, and trying to apply that to the Go community. I think it's very interesting.
+
+There was also - I don't wanna say his name wrong, Johnny Boursiquot. He pointed out that it is good to have those materials, but once we have them we need to go out to other communities and teach. He was talking how he's going to schools that don't have any technological plan, they don't have a technical curriculum. And he goes there and volunteers to teach kids that otherwise cannot have access to programming classes, and he teaches that in Go. I think that is amazing, I'd like to see more of that.
+
+I think that both things - having better materials for newcomers and then the Go community ourselves going out to reach into these communities that otherwise don't have access to it could make our community much better, much more diverse and also much larger and welcoming.
+
+**Brian Ketelsen:** I think Erik and I had a conversation not too long ago, sometime in the last year, about how Go needed the Go equivalent of Ruby's Why The Lucky Stiff. Those absolutely crazy articles with cartoons that actually taught programming while you weren't busy thinking about it, because you were having so much fun learning.
+
+**Francesc Campoy:** \[39:53\] Yeah. I don't know if you've seen this thing - I love it, and I'm gonna try to copy it somehow. It is Swift Playgrounds.
+
+**Brian Ketelsen:** Oh, the ones on iPad or iPhone?
+
+**Francesc Campoy:** Yes. So basically you learn to program by calling functions, and there's these little... I'm not really sure how to describe, it's like the weirdest animal ever. It just goes around collecting gems and jumping into places, and all of those are functions that you call. But then on top of that you can write for loops and things like that. I think that something like that could be very useful for Go.
+
+I've been working on something similar to that; I'm still in a very, very early stage, but that is one of the projects that basically came out from that discussion in the Go Project room.
+
+**Brian Ketelsen:** Were there other discussions about specific projects or specific things that could be done to increase the diversity of the community in general?
+
+**Francesc Campoy:** We discussed the impact of what Women Who Go has been doing and what GoBrige has been doing, and I think that it is very powerful. All the impact that they've had so far is very positive, so that is something that we should keep on doing.
+
+There is also another idea that I think came from Katrina. Katrina works at GitHub, and they sponsored this thing called First Robotics. We were wondering, could robotics be a good place for Go to be taught? So if we're able to make Gobot work easily on the robots, then it could be a fun thing for kids to learn how to program those bots and go around just by writing Go.
+
+**Carlisia Thompson:** Were you at the San Francisco meetup yesterday, Francesc?
+
+**Francesc Campoy:** Yes, I was there, but I had to leave, so I missed Burcu's [Jaana Burcu Dogan] [talk](https://youtu.be/xteEImopTic?t=2469). I know it was recorded, so I'm looking forward to watching it, too.
+
+**Carlisia Thompson:** Yeah, that's exactly what I was gonna mention. She is gonna put out a proposal to have an abstraction of a lot of the interface that will be required for Go to work with the hardware, including robotics and Gobots. Whenever that comes out, people should try to contribute. To make that happen, we will need to have a better interface.
+
+**Erik St. Martin:** And Ron Evans from the Hybrid Group, who does our Gobot room every year for Hack Day, he loves kids. I don't think there's anything he loves more than teaching kids about robotics and programming.
+
+**Brian Ketelsen:** Yeah, we had a call with him a couple months before GopherCon, and it's probably important that everybody knows that he donates all of his time and he gets sponsors for all of that equipment. He does this because he loves it. He told us in an off-hand sort of way that the whole programming thing is kind of a sideline that he does to fund playing with kids and robots. The guy really loves what he's doing, and we sure appreciate how much time he spends with us at the GopherCon.
+
+**Erik St. Martin:** Did you get to hack on any robots, anybody?
+
+**Carlisia Thompson:** I actually had to leave early, which was a huge mistake. That was actually a totally different day, it was totally relaxed, everybody had done their talks, everybody had watched their talks, and I felt such a relaxed atmosphere. The next year I'm not gonna make this mistake again, because I did the same mistake last year. So next year I'm going to stay for the whole day.
+
+**Erik St. Martin:** \[43:48\] Yeah, so Hack Day was really like a happy accident. The first year we were talking about everybody was probably gonna be flying home, flying for different states, different countries, so they would fly out at random parts of the day... Like, let's just reserve this space for longer - we get a better rate anyway - and then people can just kind of hang out and collaborate until they have to leave for their flight. Then it turned out half the people stayed; they wanted to stay, so we kind of turned it into this thing.
+
+I think we had - Brian, Dave Cheney and I had a discussion about it, and I think the Hack Day thing is misleading. The name was kind of borrowed from elsewhere and it doesn't have the same meaning for us, so I think next year we're gonna name it Community Day, to focus more on what the day is about, just kind of hanging out with community members and having those discussions with the Go Team or collaborating with people on open source projects. And we'll probably do a better job at outlining all the things that will take place on the day, so it doesn't feel so much when you're booking your flight, like "Do I need to stay for this?"
+
+**Brian Ketelsen:** It's hard, because we want it to be not organized, but you have to provide at least the shell of organization so people have an idea of how they can use that time and why it would be worthwhile for them to do it. Then there's the concept of how do people find each other. We put out little tablets at the end of the tables and put numbers on all the tables so people could meet each other at table 32 if they wanted to work on a particular project. That worked out really well, but that's really as deep as I wanna go into organization on Hack Day. I want it to be a day where you can just hang out with your buddies and work on stuff.
+
+I saw a lot of really remote teams that were doing team meetings, face-to-face meetings for the first time all year, in teams that had worked together. That was kind of fun, to see companies having face-to-face meetings at GopherCon on Hack Day. That was cool.
+
+**Erik St. Martin:** Francesc, were you about to say something?
+
+**Francesc Campoy:** Yeah, I was gonna say, something that I really appreciated from the Gobot Room was there were actually a bunch of people just playing around with drones, flying around. It looked really fun, and it made me think about, you know, there's conferences that I've been to, like Devoxx, that have these side conferences called Devoxx For Kids, where they have introductory courses for kids that want to learn to program, and I think that that could be an amazing thing to try. I know that you had this Family Track, which by the way, that was an amazing idea, and thank you for doing that... Having a little bit more of a technical side of the family track, where kids can just go and play with robots, that'd be pretty fun.
+
+**Erik St. Martin:** Yeah, so that was actually something that we tried to do. I think we were too late in the planning of it, because it started to turn into... We were planning a second conference, and it was like "Now we gotta market this, we have to find sponsors for this..." But I think it's something we definitely wanna continue to pursue; we just gotta figure out how to slide that into the planning, and if anybody who's listening works for a company who wants to sponsor something like that, that takes a huge load off of us. That's something that we would ideally like to give to kids for free, and not charge for children to attend that.
+
+**Francesc Campoy:** Yeah, that would be pretty amazing.
+
+**Brian Ketelsen:** So now's a good time for us to talk about our other sponsor of the show, Equinox. Equinox does packaging and distribution and updating for Go applications. They have amazing command line tooling that allows you to package up your Go application and it cross-compiles it for all of the different environments that Go supports, and then uploads it to Equinox's servers, and your customers or your end users can download Debian packages, RPMs, Microsoft Windows installers, Mac packages or use Homebrew to install your applications.
+
+\[48:09\] So they've got hosted downloads and a download page, and it's kind of the neatest thing that I've used in terms of the distribution of an app. You can use their library, their Go package to create your command line tools to autoupdate it. You can make a flag, say "Update" and it will go off to the Equinox servers, download just the diff of the next binary and update your package. Or if your users like Homebrew or the Linux package managers, they can just run an update that way. So it's a great way to keep your applications up to date, and it significantly reduces the support burden that you have as an open source maintainer or even as a company that has applications that are distributed out across lots of desktops.
+
+Equinox is free for community and personal projects, and they have very affordable plans for businesses. You should go to equinox.io/gotime to learn more about it. I strongly endorse it.
+
+**Erik St. Martin:** And Alan Shreve, ngrok.
+
+**Brian Ketelsen:** And everything Alan does, exactly. I use ngrok almost every day, and they don't even sponsor the show. \[laughter\] We love ngrok.
+
+**Francesc Campoy:** Is Equinox also funded by Alan Shreve?
+
+**Erik St. Martin:** Yes.
+
+**Francesc Campoy:** I didn't know that. He's cool.
+
+**Erik St. Martin:** Yeah, we all love Alan. He was walking around GopherCon, too. It was awesome that we got to see him again.
+
+**Brian Ketelsen:** Yes, he was one of our first speakers at GopherCon 2014. Awesome stuff.
+
+**Erik St. Martin:** I think Adam pointed out that he was featured in our recap video, which was awesome. Did you get to see the recap video that we played on day two?
+
+**Francesc Campoy:** Yeah, I got to see it, that was really cool.
+
+**Erik St. Martin:** The Changelog guys, they turned that thing around in a hotel room overnight.
+
+**Brian Ketelsen:** Yeah, talk about some rapid production... It's funny, because I saw Peter Hellberg walking into the auditorium before the show, and I said "Hey Peter, you need to get your cell phone out and record the show when it starts." He's like, "Why?" I said, "Just trust me, Peter." \[laughter\] So he got to see himself on the big screen. That was cool.
+
+**Erik St. Martin:** Yeah, I'm glad I wasn't in there.
+
+**Brian Ketelsen:** Why is that, Erik? Let's talk about that.
+
+**Erik St. Martin:** Let's not talk about that.
+
+**Brian Ketelsen:** I have to get recorded and go on the big video thing, why is Erik St. Martin not on the big video thing?
+
+**Erik St. Martin:** Because - and I almost refer to myself in the third person there... Because I don't know, I don't really like cameras. \[laughter\] I was gonna say "Because Erik doesn't like cameras."
+
+**Francesc Campoy:** You should try to get your brother on the video. Nobody will know.
+
+**Erik St. Martin:** Yeah, he probably would have done it, too. He probably could have got up there and just spoke for me.
+
+**Carlisia Thompson:** Yeah, we talked about that.
+
+**Erik St. Martin:** My stand-in.
+
+**Carlisia Thompson:** You're gonna be at the Kubernetes conference, right Erik?
+
+**Erik St. Martin:** I'm gonna submit a proposal.
+
+**Brian Ketelsen:** Excellent. Then you have to get on camera.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Yeah, that's true.
+
+**Carlisia Thompson:** Maybe he didn't know that, Brian.
+
+**Erik St. Martin:** Right, now you're ruining it. You're supposed to tell me after I submit the proposal.
+
+**Brian Ketelsen:** They told me that it was not gonna be recorded or streamed, so you're fine, Erik. It will be okay.
+
+**Erik St. Martin:** Then I end up in Francesc's place, where it's like "Wait... What? They accepted it?" \[laughter\]
+
+**Brian Ketelsen:** Now what?
+
+**Francesc Campoy:** Yeah.
+
+**Erik St. Martin:** So I think we're almost out of time. Do we wanna move on to any projects that we found in the community or any other news? I know most of us have been hiding away at GopherCon for the past week, so...
+
+**Brian Ketelsen:** \[51:43\] I do have one good GopherCon story that I have to share before we move on. Ivan Daniluk from the Visualizing Concurrency talk - the day GopherCon ended, we ended up in an elevator at the same time, and he came me kind of a stern look and he said, "We're going to have the next GopherCon in Barcelona, correct?" \[laughter\]
+
+**Francesc Campoy:** Oh, yes!
+
+**Brian Ketelsen:** And I kind of didn't know what to say. I said, "You know, Barcelona would be a beautiful place to have a GopherCon. I've never thought of having one there, but I've been to Barcelona and it's beautiful. That's a great idea." And he continues to stare and "Look, I think it's a great idea." It was very Russian-mafia looking, I felt a little threatened.
+
+**Carlisia Thompson:** I'd be very glad to see that. Also, that reminds me, GopherCon Brasil is happening. It's going to be in November 11 and 12, with possibly a workshop on the 13th, but we'll see about that one. The date is set, so start booking the tickets. The hotel is already settled as well. The website should be up maybe tonight.
+
+**Brian Ketelsen:** Wow.
+
+**Carlisia Thompson:** Yeah, it's happening.
+
+**Erik St. Martin:** You move fast.
+
+**Carlisia Thompson:** Uh-huh.
+
+**Erik St. Martin:** Oh, and speaking of Renee, too... The logo that she turned around, that was awesome.
+
+**Carlisia Thompson:** Yeah. To clarify, Renee did a sketch for our logo and it was so cute. It's a little gopher with a belly and sitting on the beach, drinking something.
+
+**Francesc Campoy:** I really wanna see that logo now.
+
+**Carlisia Thompson:** I'll paste it on the channel for you right now.
+
+**Brian Ketelsen:** You can't upload it on a podcast. \[laughter\]
+
+**Carlisia Thompson:** But we have a Gophers channel. So the CFP - people are asking - is going to be up next week. The registration should be up tomorrow, the website should be up tomorrow, the CFP should be up next week, and we're also going to have the prospectus to send to potential sponsors next week as well. So talk to me... There are six organizers, I'm one of them. Talk to me if you're interested in sponsoring. I'm sorry, that's it. I'll stop now.
+
+**Erik St. Martin:** No, it's a good thing. Back to hackling... Somebody totally registered github.com/totesafe.
+
+**Brian Ketelsen:** No way.
+
+**Carlisia Thompson:** That must have been Scott.
+
+**Erik St. Martin:** I think it was Florin who did it.
+
+**Brian Ketelsen:** \[laughs\] That is so wrong.
+
+**Erik St. Martin:** I'm interested to see what shows up there. Is that like the staging area for the unsafe package?
+
+**Brian Ketelsen:** \[laughs\] We need totesafe.io now.
+
+**Francesc Campoy:** I think he got it, too.
+
+**Erik St. Martin:** He registered that, too. \[laughter\]
+
+**Francesc Campoy:** That is the problem when you give bad ideas in public - people will do them.
+
+**Brian Ketelsen:** That's true.
+
+**Erik St. Martin:** I don't know how much time we have to talk about community stuff, but one project I did see was Buntdb. They took a lot of concepts from Boltdb, and added geospatial indexing to it, which I thought was really cool.
+
+**Brian Ketelsen:** Yeah, I looked at Buntdb this morning when you posted it into the show notes section and it looks pretty interesting. The more interesting part for me was that they built it specifically to be a storage backend for Raft, so it meets the Raft storage interface or Hashicorp's Raft implementation. So you can use Buntdb as a Raft store, which is kind of slick.
+
+**Erik St. Martin:** I hadn't even caught that part of it.
+
+**Brian Ketelsen:** Well, you gotta read it, Erik. Gotta open it up.
+
+**Erik St. Martin:** I read the cool part, geospatial indexing.
+
+**Brian Ketelsen:** Well, that wasn't the cool part for me. My cool part was the Raft part.
+
+**Erik St. Martin:** Well, now Raft can store its stuff geospatially. \[laughter\]
+
+**Brian Ketelsen:** That kind of makes sense, since Raft is so distributed.
+
+**Erik St. Martin:** Something tells me that geospatial indexes aren't exposed to that interface.
+
+**Brian Ketelsen:** Yeah, I'm guessing they're not. You're probably right there.
+
+**Erik St. Martin:** I think we are we about out of time. Do we wanna move into \#FreeSoftwareFriday?
+
+**Brian Ketelsen:** Yes, let's.
+
+**Carlisia Thompson:** Can I mention one quick thing?
+
+**Erik St. Martin:** You sure can.
+
+**Carlisia Thompson:** Because it's very much in the spirit of GoperCon. I wanna mention that there is now a CleverGopher channel on Gopher Slack for you to post and see pictures of our gophies in clever places and poses.
+
+**Erik St. Martin:** \[56:10\] There's been a lot of interesting photos that have come through there. And I also find it interesting that every episode there's a new channel that's announced, or discovered, or created on the show. \[laughter\] Every single episode.
+
+**Brian Ketelsen:** It's true. I think the best one was Florin's picture of the gopher in the cockpit of an airplane. It looked like a 737 to me, I'm not sure. It might be an Airbus, but there's a gopher in the cockpit of an airplane.
+
+**Carlisia Thompson:** I didn't think that was allowed, and I was thinking "How did he manage that? Did he arm-wrestle the pilots? Did he get arrested afterwards?"
+
+**Erik St. Martin:** I'm hoping TSA wasn't involved. Although what was this swag... Was it year one that there was some piece of swag that was triggering something in TSA and everybody was getting their bags checked?
+
+**Brian Ketelsen:** Oh, what was that?
+
+**Erik St. Martin:** I can't remember what it was now, but there was some piece of swag that had some sort of powder or something on it, that was triggering...
+
+**Brian Ketelsen:** ...a lot of trouble on the way home. I remember that now.
+
+**Erik St. Martin:** Sorry...
+
+**Brian Ketelsen:** Oops... No pocket knives, right? Oh, and Scott Mansfield said the same thing in the Slack - "No pocket knives as GopherCon swag." Good call.
+
+**Erik St. Martin:** Well, you could put it in your checked luggage.
+
+**Brian Ketelsen:** You could.
+
+**Erik St. Martin:** I also liked Dave Cheney's top tip: traveling with circuit boards and loose wires, they go in your checked baggage. A lot of us were traveling with hardware for Hack Day.
+
+**Francesc Campoy:** Yeah, what could go wrong with that? \[laughter\]
+
+**Erik St. Martin:** I was really worried none of it was gonna show up. Like, I'd get the bag and it'd be mostly empty. Because almost the entire bag that I had checked had tons of logic analyzers and bus pirates and raspberry pies and loose wires and sensors and stuff. I was like, "This is not gonna end well."
+
+**Brian Ketelsen:** Yeah, you got the big flag for extra screening.
+
+**Erik St. Martin:** Yeah, that's why I put Brian's name on that luggage.
+
+**Brian Ketelsen:** \[luggage\] Checked bag for Brian Ketelsen, right here. Alright, let's do \#FreeSoftwareFriday, we're running out of time.
+
+**Erik St. Martin:** Cool. You wanna go first, Brian?
+
+**Brian Ketelsen:** You bet. So I'll briefly explain again, \#FreeSoftwareFriday is just our place to give a shout out to open source projects and/or their maintainers for things that we use frequently and that we love. Today I'd like to give a shout out to - this is kind of a cheat, but I used it a lot this week... So Docker is one of my favorite free software tools, and sure makes life easier sometimes. Thank you, Docker.
+
+**Erik St. Martin:** How about you, Carlisia?
+
+**Carlisia Thompson:** On the topic of Brasil, there's this open source project called Tsuru. It's a Platform as a Service, open source of course. It was put out by Globo.com. Globo is this huge media company in Brasil. It's a project that came out of Brasil, and most of the maintainers if not all are Brazilian developers. I'm not an infra person, I usually don't deal with infra, only the minimum, but it's been described to me as like an alternative to Heroku. It's a huge project, I was surprized when I saw it. It's been used by big companies, so check it out. It could be useful to you.
+
+**Erik St. Martin:** And apparently all written in Go.
+
+**Brian Ketelsen:** It is, yeah.
+
+**Carlisia Thompson:** Yeah, of course.
+
+**Brian Ketelsen:** It's been around for two years, too. It's been out for a long time. It's very stable now.
+
+**Carlisia Thompson:** I actually met Andrews Medina and other developers at GopherCon.
+
+**Brian Ketelsen:** That's awesome.
+
+**Erik St. Martin:** Francesc, do you have a project that you wanna give a shout out to? Feel free to say no, we're blindsiding you here.
+
+**Francesc Campoy:** Does it need to be written in Go?
+
+**Erik St. Martin:** It does not need to be written in Go.
+
+**Francesc Campoy:** \[01:00:00.27\] Then I think I'm gonna go with something that is actually for real but we use regularly for the Google Cloud Platform Podcast, Audacity.
+
+**Erik St. Martin:** Yeah, that is a good one.
+
+**Brian Ketelsen:** Nice.
+
+**Francesc Campoy:** Open source digital audio editor, and it is great. It works so well. It makes our podcast sound way better, without knowing really what we're doing.
+
+**Brian Ketelsen:** Good call.
+
+**Erik St. Martin:** I don't know whether Adam and the Changelog crew is still using that behind the scenes, but I know they used to use Audacity a lot, so we don't even have to give them a link to put on Twitter; I'm pretty sure he knows that one.
+
+**Brian Ketelsen:** Do we have the best deal or what? We just get to talk and somebody else does all of the post production work, and the website... I love this plan.
+
+**Erik St. Martin:** Right? So mine - actually, I recently started using it again, and I used to be a big proponent of it - is Direnv, direnv.net. It's written in Go, and it's a cool little program you run in your shell so that basically when you cd into a directory it looks for a .envrc file and then you can basically load up environment variables or execute shell commands and all kinds of stuff. That's ridiculously nice for when you have to mangle your path or environment variables based on the project that you're working on. It's just seamless, you just kind of create that .envrc file and done, you don't have to think about it again.
+
+**Brian Ketelsen:** Yeah, Direnv is especially nice if you want to have a custom Go path per project; you just drop that .envrc file in there that changes your Go path. It's kind of custom-built for that, purpose-built. Very nice.
+
+**Erik St. Martin:** And I think that is it. I wanna thank everybody for coming on the show, I wanna thank all the listeners who are listening live right now and hackling us from the Slack channel, everybody who will be listening... Definitely refer any Go programmers or people who are interested in the Go language to the podcast. Thanks everybody on the panel, especially thank you to Francesc for coming on the show.
+
+**Brian Ketelsen:** Thank you, Francesc!
+
+**Francesc Campoy:** Thank you for having me!
+
+**Carlisia Thompson:** Thank you!
+
+**Erik St. Martin:** If you're not subscribed, we are on iTunes and Play Store. You can subscribe at GoTime.fm. Big shout out to our sponsors for the show today, Linode and Equinox.io.
+
+If you have something you would like to discuss or suggestions for guests to come on the show, github.com/GoTimFM/ping. I think that's it. It's a lot to cover, but I think I got it all.
+
+**Brian Ketelsen:** You did well, Erik. Good job!
+
+**Carlisia Thompson:** This was great, thanks! Bye!
+
+**Brian Ketelsen:** Bye-bye. Thank you.
+
+**Francesc Campoy:** Bye.
+
+**Erik St. Martin:** Bye.

Go Community Discussions_transcript.txt

@@ -0,0 +1,383 @@
+**Erik St. Martin:** It's Go Time! A weekly podcast where we discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+This is episode two, and with us on the show today we have Brian - say hello, Brian.
+
+**Brian Ketelsen:** Hello Brian.
+
+**Erik St. Martin:** \[laughs\] We also have Carlisia on the call.
+
+**Carlisia Thompson:** Hello everybody.
+
+**Erik St. Martin:** And we have a special guest today, Cory LaNou, who is a developer for InfluxDB, and also highly active in the open source community, and runs I don't know how many open source meetups any more. Cory, why don't you tell everybody hello.
+
+**Cory LaNou:** Hey, how's it going?
+
+**Erik St. Martin:** So you want to give everybody maybe a short high-level background on yourself and then we'll kick this show off?
+
+**Cory LaNou:** Sure. I work at Influx Data, working on the core team for InfluxDB, so that's what I do during the day. I spend a lot of time with the community, as many of you know. As far as the amount of meetups I run, I'm slowly removing myself from the Denver meetup, which is great, but I have a Chicago meetup that I am helping out with, and a Minneapolis meetup that I'm helping out with. Then obviously we do some stuff for GopherCon with the kickoff party, some training, and those kinds of things. I'm also doing a lot of Go training with Bill Kennedy for the Ultimate Go series as well. Between all those, that keeps me pretty busy.
+
+**Erik St. Martin:** Yeah, that's beyond busy.
+
+**Brian Ketelsen:** That's all? What do you do on the weekends?
+
+**Cory LaNou:** Well no, I live on a 320-acre estate up here with my family, and my wife has horses, so that means any free time whatsoever that I have, I'm out fixing a fence or chasing horses, and all that kind of good stuff.
+
+**Erik St. Martin:** So where's the time for the fireworks?
+
+**Cory LaNou:** Luckily that's seasonal, and that pretty much just dictates every single waking moment of my day once that season starts.
+
+**Erik St. Martin:** Seasonal? There's always time for fireworks.
+
+**Cory LaNou:** \[laughs\] I wish everybody believed that.
+
+**Erik St. Martin:** Have you written anything to launch your fireworks in Go yet?
+
+**Cory LaNou:** No, I would really like to. I think all the firings systems out there are really expensive and don't work so great, and I don't think it'd be that hard to use a arm device to go ahead and start doing that kind of stuff, so I might have to look into that.
+
+**Erik St. Martin:** I'm in, I'll help.
+
+**Brian Ketelsen:** An Arduino and a little bit of power, I think you're good.
+
+**Cory LaNou:** As long as it can ignite the match we're good.
+
+**Brian Ketelsen:** Yeah.
+
+**Erik St. Martin:** Alright, so typically the way we do this show is we'll start out with some news. We'll kind of roundtable it and see what everybody has that might be interesting to talk about, we'll chat about that, and then we'll move into Brian's fun projects that he discovers on GitHub because he downloads all Go projects every night into his brain, and then we'll move into talking to you a bit more, Cory, about your community efforts, open source contributions and any advice you have for people aspiring to get into either of those things. With that said, Brian, do you have any interesting news for us?
+
+**Brian Ketelsen:** I think the biggest news recently is the Go 1.6.2 update, although it's a tiny little update from what I can tell. The only thing that really caught my eye in there is the net/http client getting http2 by default. That's big, and I know a lot of people were looking forward to that. The rest of the fixes in there seem to be mostly little compiler bugs sort of things.
+
+**Erik St. Martin:** Yeah, It seemed that way to me too, that the main thing that people would be interested in is the fact that http2 is defaulted now, which I believe was a mistake. It was meant to be default first.
+
+**Brian Ketelsen:** I think that's correct, I think this fixes that.
+
+**Erik St. Martin:** One thing that I'm particularly interested in chatting about is GopherChina just completed - was it two days ago, a day ago?
+
+**Brian Ketelsen:** Yeah, I think so.
+
+**Erik St. Martin:** So the GopherChina stuff, there seemed like there were some interesting talks there, but one particularly caught my eye, which was Dave Cheney's talk on performance, and I happened to see the slides for that - the videos obviously aren't released yet, but the slides look good. There is a lot of stuff that I really agree with. I think he has a lot of advice for how to profile and benchmark apps, but also how to approach benchmarking, and I just kinda wanted to chat about that for a second to get everybody's opinion. When you develop code, what's your approach for performance? Do you think about performance from the beginning, do you never think about performance? Do you think about performance when specific bottlenecks come up?
+
+**Carlisia Thompson:** For me, I never think about it from the beginning. It's usually when the bottleneck happens, then yeah, let's take a look and see what we can do here. I think it is not the ideal, I think a middle ground should be reached there. I think you should think about it a little bit as you develop things, so you don't find yourself against the wall someplace down the line.
+
+**Erik St. Martin:** It's rough, I think we wanna beat ourselves up when we don't have time to benchmark, but at the end of the day we're also expected to deliver products, right? So if performance isn't an issue for the product at the moment, can we justify the time to do it? So as much as we would like to make everything as performant as humanly possible, if a particular application - say it's an internal application that's not gonna be used by anybody, what's the value in making it twice as fast?
+
+**Cory LaNou:** Yeah. For me, I find that, I don't optimize right away or think about performance when I write the code for two reasons. One, because I don't typically have the time, and two because I'm almost certainly wrong every single time when I do get the time to actually profile it.
+
+**Brian Ketelsen:** Yeah, isn't that really what Dave said in his slides? If you performance is good, stop, don't optimize it. Only optimize when there's a problem. For me, coming from languages that have been much slower than Go, I almost never profile anything unless I find a specific problem. I'm already 30 times faster than I was in Ruby or Python or whatever. How much faster do you need? I'm just not a greedy person.
+
+**Erik St. Martin:** I think I tend to look at my code, just kind of quick-eyeing it. If I can remove an allocation or things along that line that are really obvious at the time, I know that a slice is gonna grow beyond some amount, I'll set it from the beginning; at least a base level to prevent the copying every time. It needs to grow. But aside from that, I'll do some baseline benchmarks just so that I have something to compare to later, to make sure that given algorithms aren't getting slower, and things of that nature, but usually it's some performance problem after the fact, end-to-end testing, things like that that start narrowing down hotspot areas that need to be addressed.
+
+**Carlisia Thompson:** My recollection too is that anytime, or most of the time that I did have performance issues, they were related to database queries. I don't even think of a time when I had to go back and rewrite some logic because of performance issues. But database queries definitely, that's usually where I find problems.
+
+**Erik St. Martin:** Yes, queries, and interestingly I think some of the issues that I've found too are bugs with goroutines kind of growing unbounded, where they don't properly close out and memory continues to grow because of it. We've had a few of those over the years.
+
+**Cory LaNou:** We've definitely seen that several times on the Influx Core. We've gotten bug reports, and it's almost always been one of those things where we get a bug report and we look, and "Oh, there's a goroutine that was just unbounded." We never thought about actually shutting it down, and it should have been. One of them, interestingly enough, that was just caught was an http handler would launch a goroutine and we would close the goroutine if somebody cancelled the actual request, but not if the request finished, so that was kind of crazy.
+
+**Erik St. Martin:** Oh, no...
+
+**Brian Ketelsen:** The penalty for success!
+
+**Cory LaNou:** Absolutely.
+
+**Brian Ketelsen:** So in your years of experience in Go, have you ever found a problem with http routers? I'm curious as to why there is such a preponderance of evidence on http router benchmarks in Go? Why do people care how many nanoseconds it takes to compute that path?
+
+**Cory LaNou:** I've gotta put it down to bragging rights, that's the only thing I can think of.
+
+**Brian Ketelsen:** I think it's insanity.
+
+**Erik St. Martin:** That nanosecond talents, man! \[laughter\]
+
+**Carlisia Thompson:** I think developers are by default an optimistic bunch. We always like to think, "Well, we're going to get so many hits on this endpoint, I just need to prepare for that. I know it's gonna happen."
+
+**Erik St. Martin:** But I don't think it's just developers, I think it's humans, right? It's that guy in traffic who has to pass you so he's one car length closer to wherever he's going. \[laughter\] It's the same micro-optimization. You look at it and you're like "Oh, it's one car length." Alright, so... Interesting Go projects. Brian, you kind of do your nightly download of Go projects. I have no clue how you have time for that, but... Every day he's sending me I don't even know how many - I can't even come up with a curated list that he's sent me, so how he curates it is beyond me. Do you have any interesting projects to talk about?
+
+**Brian Ketelsen:** Let's see, interesting projects this week... I think one of the most interesting that's been surfacing quite a bit for me is the Go Micro Framework, micro.mu on the web. I really like the direction that's going. I like the idea that the whole framework is built with the idea that Micro services aren't built in a vacuum, and all of the important tools are built into the platform and then pluggable for your specific choices. So it's got opinions on service discovery and the options to plug into different service discovery providers, for example. I think that's a platform that's going somewhere quickly.
+
+**Erik St. Martin:** How does that contrast to Go kit?
+
+**Brian Ketelsen:** The way I see Go kit is Go kit being a lot of packages that are useful on their own, and useful together for the Micro services world. I think Micro is probably less useful as individual packages and more powerful as a group of packages. I could be wrong about that, but that's kind of the way I see it. I don't see using many of the components of Micro on their own standalone, whereas with Go kit it's really easy to just pick out one or two pieces of Go kit that are strong and that you might need in a particular project and use them standalone.
+
+**Erik St. Martin:** Yeah, I have briefly looked at Micro but I haven't had a chance to play with it yet. So kind of along those lines, Micro services in general - Cory, are you guys using Micro services at Influx, or you typically keep more monolithic applications?
+
+**Cory LaNou:** Yeah, that's a good question. We try to keep monolithic repos, I guess that's one way to say it, and then we do definitely do the Micro services and we have a lot of different services that handle the meta side of the data, the TSM engines. So everything does run pretty much from a Micro service standpoint; it makes it really easy for testing, as you can imagine. We bind everything, loosely couple the interfaces, so testing everything is a dream.
+
+**Erik St. Martin:** What do you use for communication between those services? Are you using RPC, or is this just standard HTTP in JSON, or...?
+
+**Cory LaNou:** We use a combination of things. Protobuf has actually been kind of our go-to lately, and that's been working really well. It's a little bit extra work from coding standpoints, kind of a little extra dance that you'll have to do every time to add the types to the Protobuf definitions, and then compile it to go via 'go generate'. But it's really fast, and it's all basically native Go code at the end of the day when you're done working with it. JSON is just... I mean, it might as well be xml at that point with the speed that we have to work at, so we just don't use JSON for anything unless it's really tiny.
+
+**Erik St. Martin:** Are you using gRPC or are you using Protobuf separately?
+
+**Cory LaNou:** I actually don't know, I'd have to look. I didn't implement the Protobuf stuff, I just get to use it all day long, so I don't know what they added up on that side of the world. I could look though, and find out.
+
+**Erik St. Martin:** There tends to be the argument that Micro services has become like a buzzword too, where everybody wants to jump on it, and there's been kind of some debate there, so it's always interesting to hear how many people are taking the Micro services approach and what's the delineation, where do you divide services and things like that. I always like to hear people's opinions on how they've split things up.
+
+**Cory LaNou:** I think the important part is to understand that you're gonna get it wrong the first time and probably the second time, and maybe even the third time. But eventually you'll get there, right? It's not as simple. People say, "Oh, Micro services" and this is just gonna solve all your problems, but it's still quite a complicated ecosystem when it comes down to it, and it takes a while to sort it out how everything's gonna come together.
+
+**Erik St. Martin:** Yeah, there's a lot of cognitive load there, right? Which services get touched, and you get into distributed tracing, because now how do you follow a given request and find errors that happened with it? If it reaches out to 15 services, the responses from each of those services have meaning in the debugging of that request, and it's always a tradeoff; it's kind of like performance - most of the time if you're optimizing the code for performance, you're taking away readability. It's always hard to decide where to make those decisions, and I think you get a lot of arguments about it too, based on who you ask.
+
+**Carlisia Thompson:** And going back to the Go kits in the Micro services framework in general, isn't a Go kit and maybe a Micro framework might also have a middleware that has handling across services? Isn't that correct?
+
+**Brian Ketelsen:** Yeah, Go kit has a Dapper/Zipkin-like layer that allows you to trace your calls, requests across the different layers of your services.
+
+**Carlisia Thompson:** Oh, that stuff is very important. I hear people saying "Well, if you have a convoluted logic in a monolithic, you breaking that up into services is not going to help your logic be better." But I challenge that, I think it will force you to think about how you would divide things up, and you might not even get it right the first time, but it will force you in that direction, because you have to. But it's super important, like you guys were saying, to have the tools that will allow you to manage your error handling, and all of the glue that needs to come together with Micro services.
+
+**Erik St. Martin:** Well, I think that splitting up into Micro services also is a form of premature optimization, right? There's penalties, there's network latency between things, there's more places where things can fail between the communication of things, and the network is weird. I can't tell you how many times we've debugged RPC-type issues where just the data that came through - you get packets in reverse order and things like that, and you have to fix something that gets locked up because of it. So there's a lot of tools that you can use nowadays that are a lot more solidified for doing these types of things, but there's still risk in everything like that, and kind of having things bundled together, if you don't really have a need to pull it out.
+
+**Brian Ketelsen:** I think there's a lot of validity to the idea that Micro services are just as much of a social and structural concept as they are a coding concept, and structuring your Micro services around the teams might be more important than structuring them around specific code barriers that might be artificial.
+
+**Carlisia Thompson:** Definitely.
+
+**Erik St. Martin:** Alright, I think we chatted about Micro services quite a bit here. Do we have any other interesting projects? I think Carlisia you were talking about a new doc tool that you were excited about, right?
+
+**Carlisia Thompson:** Yeah, this is reminiscent of my editor hacking that happened a couple weeks ago. I found out about this due to - I think it's new; it only works with Go 1.6, it's called GetDoc. It's a CLI tool, which is not super exciting; I don't wanna be reading tons of documentation, it's just out of context for me if I'm working on my editor. But the neat things about it is that it's integrated into Atom and Vim Go, and I think they also integrated it into Emacs, for people who use that. Basically it allows you to just hop over to a word and press a combination of keys that you can control over your keybinding, and the documentation will pop up for things like package in the import list, constants, it will give you the value of a constant, method calls and struct fields. So the documentation just pops up right there, and you press Escape and it goes away. I thought that was super cool.
+
+**Erik St. Martin:** Oh, that is cool. Alright, do we have any other interesting projects we want to talk about before we move on to discussing all things open source in the community with Cory here?
+
+**Brian Ketelsen:** I could give you 30 more, but I think we covered it all in Go Micro, so why don't we move on?
+
+**Erik St. Martin:** Alright then. Cory, you get a chance to talk here. I hope you like talking.
+
+**Cory LaNou:** I've been known to talk.
+
+**Erik St. Martin:** So I think all of us have happened to see your talk from GopherCon India in February...
+
+**Carlisia Thompson:** It was an amazing talk. It was so passionate, I loved it.
+
+**Erik St. Martin:** Yes, and there's a couple of things I want to talk to you about there, but first I have to ask you about the camels. Seriously, I'm jealous, you got to ride camels.
+
+**Cory LaNou:** It was great. Mark Bates, who one of my coworkers, he happened to be going to GopherCon India and actually he joined the team, we didn't even know we were both going, so that was pretty cool. We were kind of running around the whole time out there, and the camels are literally in the middle of the desert, they take you about 30 minutes out into the desert. You basically get on and you do about a 20-foot circle and then you get back off. But you get your picture, so that's important.
+
+**Erik St. Martin:** So that's kind of like the Central Park tour in the carriage. You pay your 50 bucks and they take you around the block...
+
+**Cory LaNou:** Yeah... But what's interesting, if you've never ridden a camel, getting up and getting down is pretty crazy. They get up pretty easy and you have to hang on, but when they get down, they basically just drop completely down to their knees. And when they drop, they drop hard, so if you're not hanging on, you're going to literally fly over the camel. \[laughter\]
+
+**Carlisia Thompson:** I've ridden a dromedary before, but not a camel, and there is a difference - one has two humps, and the other one has one. The dromedaries are more common than camels. I don't think you'll find a lot of camels outside of the Middle East or Saharan Deserts.
+
+**Brian Ketelsen:** We learn something every day on Go Time.
+
+**Erik St. Martin:** I'm definitely not an animal expert. So in your talk, one of the things that actually caught my attention was that you had said that you had been developing for 17 years, and it had only been four years that you've really done open source work.
+
+**Cory LaNou:** That's correct.
+
+**Erik St. Martin:** I kind of want your take on that, because I think that's a big step for a lot of people. There's always that fear of putting your code in the open. I've been doing open source development for I don't even know how many years now, and I still struggle with putting my code out in the open.
+
+**Cory LaNou:** Yeah, it's pretty scary at first, and I even wrote a blog post on it that we can link at some point, but basically open source code is really scary when you put it out there, and my first experience was I had a bug that I couldn't figure out what was going on. Of course, I look it up and it's an issue with the Go language, and it was closed, of course, it was closed by Dave Cheney. So me knowing Dave Cheney, I reached out and I said "Hey Dave, I understand you closed this bug, I'm running into it; I really don't know what the solution is. Can you help me out?" He said "Well, can you give me some context?" So of course I gave him the link to the pull request that I got on InfluxDB. Now, I had only been at Influx DB for maybe two or three weeks at this point, and it's my first experience in open source. And of course, in good open source fashion, Dave just begins to review the entire PR, not the issue that I'm actually looking at. So it's kind of like a rockstar asking you to sing their biggest song in front of them; it was very nerve wrecking, I was very scared. But it was great, it was a real learning experience, and then you find out really quickly that nobody really cares if you're a rockstar programmer or not. Everybody's just trying to get their code out there. You're going to do really dumb things, and people are going to call you really dumb things sometimes, because it's open source, but you just learn from it. Take a positive note from everything you learn in open source, when everybody gives you feedback.
+
+**Erik St. Martin:** It's interesting you make that analogy, because you think about it like karaoke too, right? Just get out there and sing, it's fun no matter what, right?
+
+**Cory LaNou:** Exactly, exactly. Have a good time. It's okay, you're gonna screw up, and believe me, you're gonna do some really dumb things, and you're gonna get a bugs log and you're gonna look, and you're like "Wow, that was really stupid, I cannot believe I did that!" Break the cluster and release it, and nobody knows that you actually don't have consensus anymore. I mean, I've never done that...
+
+\[laughter\]
+
+**Brian Ketelsen:** Neither have I.
+
+**Erik St. Martin:** Right, right. I've NEVER committed a stupid bug that brought down any systems because of something dumb. Never. \[cross-talk 00:22:46.00\]
+
+**Brian Ketelsen:** There's a giant rollback button on my desk. Everybody else has the easy button, I've got the rollback button.
+
+**Carlisia Thompson:** I think GitHub now has a feature for you to roll back easily, I don't think they had it before. You had to roll back things manually, which is what I would do anyway, but...
+
+**Erik St. Martin:** With Git there is the Git Revert, which allows you to create a commit that basically inverts whatever commit that you're trying to revert.
+
+**Carlisia Thompson:** But I think GitHub put a button there that does that automagically, if I'm not mistaken.
+
+**Erik St. Martin:** I'm more of a command line junkie, but yeah, I can see how just being able to go to the website and click the button becomes super useful.
+
+**Carlisia Thompson:** As far as Git goes, I don't trust any UI tool. I wanna see it on the command line. If it didn't happen there, I don't know if it happened, so I wanna see it.
+
+**Cory LaNou:** Git for me is a Swiss army knife that has all these buttons on it, and when you press it, I stab myself every single time.
+
+**Erik St. Martin:** The thing I tell people all the time is if you learn to use the reference log, you'll feel much safer with Git. Because you're like, "Oh, it doesn't matter. If I committed it, I can totally fix it."
+
+**Carlisia Thompson:** But you said the magic words, "If you committed it." If you don't, it doesn't really matter. But it is amazing how many people don't even know that that exists, and it's a life changing thing.
+
+**Erik St. Martin:** Yeah, if you have not played with the ref log, you should.
+
+**Brian Ketelsen:** Git's really simple for me - you just delete the directory and clone again. \[laughter\]
+
+**Erik St. Martin:** No, don't do that.
+
+**Brian Ketelsen:** That's all you need to do: rm -rf <my repo> git clone <my repo> Fixed!
+
+**Carlisia Thompson:** We'll edit that out.
+
+\[laughter\]
+
+**Erik St. Martin:** Yeah, yeah. Do not take Brian's advice there.
+
+**Carlisia Thompson:** Not this one, people.
+
+**Erik St. Martin:** So back to the open source contributions too, I wanted to point out another fact. I think that people not only should contribute, but go in and dig around the code, because I think people will find that their vision of the code for any big name project is far from the reality. They're gonna start digging around and they're gonna find their own words. Regardless of their skill level, they're going to find code that they even think is bad. And I think at the end of the day, as we talked about earlier in the episode, sometimes it comes down to delivering. You have to fix a bug, and you may not have time to implement the best solution. And especially to your point, Cory, there's a limited number of people working on the project sometimes too, right? In your talk you kind of advocate that, help wherever you can. Maybe you don't have the best solution for a problem, but it's a problem that's getting solved that maybe won't get solved because the core members of the team just don't have time to work on it.
+
+**Cory LaNou:** Yeah, I'm a big fan of Help Wanted. I just started a repo the other day on Go open source projects that have the actual issues labeled with Help Wanted. You can go on and find these issues very quickly, and figure out where they need help.
+
+The more important thing for me on that one wasn't because I wanted to help all these open source projects - that actually wasn't my intention - it was because people were always asking me "How can I get started in Go?" and I'm like "Well, there's all these projects out there that need Help Wanted." We just need to get a list of them going. So I think that that's a really cool thing to see out there now, and I'm hoping that people will start spreading the word on that and getting that out. I think that's great.
+
+**Carlisia Thompson:** Yeah, I saw you started putting together a repo? Was that it? I forgot.
+
+**Cory LaNou:** Yes, it was a repo.
+
+**Carlisia Thompson:** We will include a link to that on the show notes for sure, so tell us more about that.
+
+**Cory LaNou:** Yeah, basically it spawned off of a meetup that I was doing in Chicago, and I couldn't make it down there, and the host - we missed a month and we had to get back on track, and we didn't have time to really get speakers lined up. So it was like a week before we were gonna have it, and he was kind of a little nervous, and he was like "Hey, we don't have any speakers", and I'm like "Well okay, we should have a hack night." But just having a general hack night doesn't really give you much direction, so I thought "Well, there's a lot of projects out there that need Help Wanted, and there's gonna be a lot of Go people there, and there's gonna be some people new to Go - let's just get a list of things to pick and choose from", and that's kind of where this idea came from. It really goes hand-in-hand with a lot of the community stuff at Go where I'm doing the intro to Go and stuff like that, and people really want to know "How can I contribute?" The Hello World programs, taking the tour - these are all fine and dandy, but I'm not learning anything, I don't know how to solve a real world problem, I don't know what a codebase is really gonna look like and how I should do it. And contributing to these open source projects, even on the really small Help Wanted, really start to give you a sense as a beginner in Go like "Oh, this is how a bigger project is gonna be organized, this is how a bigger project is gonna expect me to contribute", and you should learn things beyond even just Go at that point. You'll learn the process of doing the pull requests, and doing a review process and that kind of stuff. It's just a great experience.
+
+**Erik St. Martin:** I think it's actually a really good idea, because when you're forced to solve a problem you have to dig around and you have to learn the codebase, which means you have to understand more Go, too. Then on top of that when you submit your pull request, you have other people reviewing your new Go code, so you can have people help shape you. One of the things that I find with Go is picking up the language is the easy part, learning to write idiomatic Go is a totally different story. So if you're submitting pull requests, then you have people automatically looking at those things.
+
+I think that it should be said too that skill level doesn't matter. Just getting in there, and even if your patch doesn't get accepted, you're going to learn a lot along the way.
+
+**Carlisia Thompson:** Let me throw something at you guys, because you've all been doing Go forever, and I'm a newcomer totally. So I would go to InfluxDB source code, download it to my computer, and actually kudos to all of you because I was able to install and get it running on my machine just reading the documentation; for such a big project, I thought that was amazing, I was very impressed. But anyway, so I would go around and read the code and not understand it. I've been programming for a while, and it would just kill me that "Okay, I don't know what this is doing." Then I'd be like "Okay, let me go to a simpler codebase." So I'd go to a simpler codebase and still not really get it - maybe I'm just dumb, but after a while I did get it, after I actually started coding. My point is - a lot of times you say "Just read the code and you'll understand it", and I was reading the code and I was not understanding, and I was looking up issues that had the label "beginner" and I was not understanding it. I was like "Oh my gosh, maybe this is hard. Why am I not just immediately getting it?" Because when you say "Read the code and you're gonna get it", my impression is I need to get it immediately. If not, either I'm dumb, or this code is hard, it's not as easy as people are saying.
+
+**Erik St. Martin:** I think that some people will be more natural at figuring it out, and I think it's just more a matter of domain knowledge. So you have understanding something from a technical perspective, and you also have the understanding of domain knowledge. If you know very little about, say InfluxDB, it's gonna be a lot harder to follow the code because you're trying to pick up the code and the organization of it, the language, as well as the domain knowledge of the system as a whole, all at one time. I think it's not worth beating yourself up over that it's not quick to discover. I think I've attacked some beginner Go tasks that didn't turn out to be so beginner, and I abandoned as well.
+
+**Cory LaNou:** I don't think there's ever been a time that I've gone into source code, like the Go raft library - that's a pretty sophisticated piece of code that HashiCorp wrote. The first time I went in there I'm like "Oh, it's written in Go, I should be able to understand this", and I pretty much got in there and I'm like "Wow, maybe I don't know anything about Go at all." It's just a common thing. I think we definitely should caveat... When we tell people "Hey, go read the source code. It's out there, and you'll understand it", it's definitely both the domain knowledge. It just takes a little while. Sure, I understand all the syntax, that makes sense to me, but I don't understand what it does. That's just a matter of spending time in there, and what I typically try to do is I stopped going to the source code first, I started going to the Go docs first. Because that gives me the overview of the API that that library's gonna have, and that starts to give me a sense of how it's gonna be stitched together, and then from there once I read the code it tends to make more sense. But again, that's getting that domain knowledge, but you get it really fast from the Go docs, and you don't get that very fast when you're reading the code.
+
+**Erik St. Martin:** Become buddies with a project member, too. Get him all excited, buy him a beer. Say, "Talk to me!".
+
+**Brian Ketelsen:** Definitely.
+
+**Carlisia Thompson:** ...ping them on Slack all day long.
+
+**Cory LaNou:** I get a ton of people that reach out to me on Slack for Influx randomly; I have no idea who these people are, and they're like "Hey, I'm working on this bug for you. Can you help me?" Like, "Sure, what do you need?"
+
+**Carlisia Thompson:** Speaking of which, there is a reviews channel on GopherSlack which I just discovered recently. I don't know if all of you are aware. There is a lot of action in there, I wonder if people make good use...
+
+**Erik St. Martin:** I actually didn't know that.
+
+**Brian Ketelsen:** It's a very busy channel.
+
+**Carlisia Thompson:** Yeah. I wonder if people make good use of it. If people get good feedback... I started keeping track of it.
+
+**Erik St. Martin:** So this is just a channel somebody opened up for people to post pull requests and just get anybody who has some spare cycles to review for them?
+
+**Carlisia Thompson:** Yeah, not even necessarily pull requests, just any code, just "Review this code."
+
+**Erik St. Martin:** That's awesome. I didn't even see that yet.
+
+**Carlisia Thompson:** Yeah, GopherSlack, full of surprises.
+
+**Erik St. Martin:** So Cory, you said you have a whole bunch of free time still, right?
+
+**Cory LaNou:** Yes, absolutely.
+
+**Erik St. Martin:** Review all the things. \[laughter\]
+
+**Cory LaNou:** I'll start doing that at midnight every night.
+
+**Brian Ketelsen:** We'll expect to see you in the reviews channel shortly...
+
+**Cory LaNou:** I just joined. \[laughter\]
+
+**Brian Ketelsen:** ...fixing all the code. No, actually it's a great channel, and I've spent quite a bit of time in there, because I always want to make sure I'm doing things the right way, so it's a good place to be.
+
+**Erik St. Martin:** And for anybody who's not aware, we're referring to the Gopher's Slack, which is gophers.slack.com. There's a Heroku app for doing the invite we'll link to in the show notes. So that's what we're referring to. I think we assume because there's 6,000 people in there that everybody knows about the Slack channel, but that's probably a flawed assumption.
+
+**Cory LaNou:*** It's interesting you make the comment about assuming, it's something I've been doing in most of the cities I'm in, as I maintain a document specific to the city, which provides all of the online resources like Slack and Go forums and all that kind of stuff, and it also provides information on everything local - all your local meetups, all your local jobs that are being posted for Go, and basically anything local to that demographic. Because I find all the time, even at the meetup, I'll be at a Chicago meetup and it'd be like "Oh, there's a Slack for Chicago Go?" and I'm like "Yeah, there is a big Slack, and there's a big Chicago technology Slack, and all these things." So I don't assume any more that anybody knows everything that exists. So I found that keeping that document for the meetups helps a lot.
+
+**Erik St. Martin:** Brian and I, it was a month after GopherCon 2015, it was basically a big name company emailed us about the conference and wanting to sponsor, and we were like "It's over." They didn't even know... We had made the assumption that everybody kind of in the Go world knew about the conference. We feel connected, but the world is much bigger than we see.
+
+**Brian Ketelsen:** Yeah, how could you not know about the conference? It's all we talked about on Twitter. Come on! \[laughter\]
+
+**Erik St. Martin:** All you had to do was follow one of us on Twitter.
+
+**Brian Ketelsen:** Right. Everybody who doesn't do that...
+
+**Erik St. Martin:** ...and happen to be online when we tweet.
+
+**Brian Ketelsen:** Exactly.
+
+**Erik St. Martin:** So kind of speaking of the community efforts in your talk, Cory, that was the primary focus of your talk - community and getting people engaged, and advocating that people help where they can, and that they don't need to be an expert. We'd love to chat with you a bit about that as well.
+
+**Brian Ketelsen:** Can I interrupt, Erik? I'd like to point out that Cory walks the walk when it comes to helping out where you can. And when we decided that we were gonna do GopherCon, he didn't ask to contribute pull requests, he asked if he could host things for us. He asked if it would be okay if we shipped all of our Gophers there early. A lot of community building isn't just software, even if it's a software community. It's about organizing those meetups, getting pizza, finding a place to hold the meetup, it's about helping the conference organizers do the things, organizing the pre-party, getting together a group of people that helps stuff the bags before the show... I mean, there's so much that you can do as a person to volunteer for an event or help a project, that isn't really writing code. You can write documentation, you can help spread the word about an interesting project. And Cory, in my mind, you gotta be one of the top guys on the whole internet in terms of walking the walk, and helping out projects and communities like that.
+
+**Cory LaNou:** I'm not even sure what to say to that. For me it was a privilege, that's all it was for me. I look at all that kind of stuff, any time you can help out I think that's a privilege, so it was my honor to do it, and it was super exciting to see an event like that come off. It takes a ton of effort, so being part of that was magical and it was, again, definitely a privilege.
+
+**Erik St. Martin:** So how would you recommend people get involved?
+
+**Cory LaNou:** What I always tell people - and again, I covered this I hope really heavily in my presentation in India and Dubai - is what a lot of people think of when they want to get involved in a local community, the big problem is there's not a local community for a lot of areas yet. Go is still kind of an up-and-coming language, and in one of the charts I show we're about an eighth of the size of like the Java or the Rails community in terms of meetups worldwide. So what we really need is we need more meetups. Everybody always immediately thinks, "Oh, we need an organizer", and that's great - don't get me wrong, we need the organizer, but really as importantly as the organizers is we need that host, we need that sponsor, right? So it's really important to get those people to step up, because typically if you can find somebody to host it, then you can find somebody to sponsor it, then you can find somebody to organize it. And it's all these pieces that come together, and I want to stress one really important thing here: you don't have to be responsible when you form a meetup for all of those. That's not your job. Your job is to find people to help you. It's a community, right? So make sure you enlist all the help you can as soon as you can. Get help. People wanna help you. And if they just think they're doing one piece, they do it. But if you put all that onus on one person, if they think that they've gotta be the organizer, find the sponsor, find the host, it's very daunting. I think that's why a lot of people don't get involved right away.
+
+**Erik St. Martin:** It's interesting that you point that out... Just kind of as an example, we started Go Tampa, because we didn't have a local meetup group, and we put together - it was either one or two, and then we got slammed because, just like you, Cory, we love to put more on our plate than we can handle. So we hadn't really been doing meetups anymore, but by that time there was some interest locally, so Aaron Greenlee, who is here locally in the market kind of just took that on, and he's the reason there's a Go Tampa now, because he organizes all the meetups, he finds the locations and so on. Sometimes just being the person to start the action, it kind of grows on its own.
+
+**Carlisia Thompson:** Reaching out for help is very important, and I put out a challenge to everybody if you are interested or have this thought - just reach out and ask for help, if that's what's keeping you. Cory for sure, he has a ton of time, he will help you. \[laughter\] And I'll help...
+
+**Cory LaNou:** I will definitely help.
+
+**Carlisia Thompson:** ...with what I can. And I wanted to cite an example: I started the Gopher San Diego meetup in the North County of San Diego, and there was one in downtown. And what happened just organically was that we came together as a group. My company is supportive, so I get that support, so we came together as a group and we help each other out. They were doing it every month, and when I came in and started doing mine - I had a couple - they were like "Hey, what do you think of you host it one month and we host it the next month?" That took a lot of the pressure, because I think they were feeling, "Okay, this is being too much for us." So that's how we're doing it right now, because it's best for the group.
+
+We are basically one group, we spread the word, we spread the meetups over two months, so I only have to host one every two months. So people come together and figure things out, but if you don't get started, you are not going to find out what kind of help you're gonna get.
+
+**Erik St. Martin:** So we've covered meetups, but we also have your battle cry from your talk, which was more blog posts, and I think that we have two more that we can add to that: more podcasts and more conferences. I think that that's somewhere too... When Brian and I spoke on the Changelog, which - shameful plug here, they actually produced this show, so kudos to them for letting us get on the mic... So when we spoke on there, we were advocating too for more conferences. We still haven't seen a lot of regionals pop up. We've seen some internationals pop up, and we have a couple of regionals: we've got the GothamGo and then we have the Gopherfest in San Francisco. But aside from that, we haven't seen a lot of regionals pop up, and I'd love to see more regionals come.
+
+**Cory LaNou:** I for one would love to do a Midwest conference. I would love to do something either in Chicago or Minneapolis. I've actually gotten pretty involved in Minneapolis recently, and Chicago is a great city, it's huge, so obviously it would be easy to host, but I gotta say, Minneapolis has an amazing tech scene up there, and I'm very impressed with what's going on up there. I would love to put together a GopherCon in Minneapolis. Anybody who wants that to happen, let me know and we'll see what we can do.
+
+**Erik St. Martin:** And Brian and I are happy to offer advice that we've learned along the way too for anybody who wants to start a conference. There's a little bit more risk involved there just because there tends to be some financial obligations and some big contracts and stuff, but hopefully we can share some knowledge to lessen that burden on people who are interested in getting those things started as well.
+
+**Brian Ketelsen:** Yeah, absolutely. We've probably done four or five calls with people across the world about starting a conference in their area. Don't be afraid to reach out and ask for help. There is nothing we love better than to spread the Go love and get more conferences going. So do ask, absolutely.
+
+**Carlisia Thompson:** I just looked up to see if there was a conference channel in the Gopher Slack - there is none.
+
+**Erik St. Martin:** There is now... \[laughter\] So is there anything else that you would like to advocate, Cory, before we wrap this thing?
+
+**Cory LaNou:** The only thing that I haven't solved yet for getting communities going more is they're hard to setup, it takes time to get traction. But I would love to see more of the who's who in the Go community get out beyond their demographic, and even if it's an hour away or two hours away, go ahead and volunteer to go to that meetup that is a little bit further out than your demographic, and do a talk and really help them to get started. I think if we can see more of that in the community, reaching out two to four hours away from you - not even a flight, just a drive - I think that would really help a lot. I think a lot of us are in the situation where we are two to four hours away from another Go meetup that's trying to take place, and that can really help out and really start to get more of that momentum going.
+
+**Brian Ketelsen:** Isn't that what they call 'the ground game' in politics? Knocking on doors?
+
+**Cory LaNou:** \[laughs\] It might be, but this year I'm trying to stay out of politics.
+
+**Carlisia Thompson:** And even if it's just for the beginning, just be the training wheels for people just for a little while, until they get going, and then you go be the training wheels somewhere else if you can. But even if you can do it once or twice, it's great.
+
+**Erik St. Martin:** Bill Kennedy has driven from Miami over to Tampa I think twice now, and that's like a four-hour drive, so if he can do a four-hour drive twice, you can do a two-hour drive.
+
+**Cory LaNou:** Exactly. I mean, I drive to Chicago, that's five and a half hours. I do it gladly.
+
+**Brian Ketelsen:** That's awesome. That's commitment right there, folks.
+
+**Erik St. Martin:** So typically the way we close out the show, we like to kind of go through... Brian kind of triggered off this \#FreeSoftwareFriday on Twitter a while back, and I think we all kind of fell in love with the idea of that. It's not always financial for people, just hearing 'thank you' from people who benefit from their projects is nice. With that said, Brian, do you wanna kick one off?
+
+**Brian Ketelsen:** I absolutely have a big one this week. GopherJS. If anybody follows me on Twitter, you know I have this hate/hate relationship with frontend development, and GopherJS has been eye-opening for me over this last week or two. I didn't realize that it didn't have to be JavaScript on the frontend, it could actually be something that is Go, and transpiles down to JavaScript, and it's just really changed everything. I'm really excited about GopherJS. It's helped me get over my big, ugly fear of frontend code. You guys rock, thank you GopherJS team. Thank you, thank you, thank you.
+
+**Erik St. Martin:** Carlisia, how about you?
+
+**Carlisia Thompson:** I came across this neat little tool called Haxor News. It's a command line tool that you can use to access Hacker News. I think it's really cool because first of all I don't ever go to Hacker News - not because I don't like it, but because every time I go I just get lost, because I go from one thing to another, to another, and then find myself somewhere else. So with this tool, I just type 'hn' top for example, and I get the top news. I'm not so inclined to go chase that out, I really just wanna see the headlines. And I'm loving typing 'hn' onion if I need a chuckle I type that on the command line, and then boom! Never fails. It's awesome. \[laughter\] Do it, try it. Trust me!
+
+**Brian Ketelsen:** I'm downloading it now.
+
+**Carlisia Thompson:** Yeah, it's so awesome. And it's got a lot of colors, color-coded, and you can press a number and go and see that particular item more in depth. It's so awesome...
+
+**Erik St. Martin:** I tend to stay out of the browser so that I can be productive, and you're bringing this unproductive thing to my command line now. \[laughs\]
+
+**Carlisia Thompson:** I submit that the content is not the problem, it's the browser. The browser that leads you down the rabbit hole, but this is just pure content. No buttons to click, not links to follow, just the content.
+
+**Erik St. Martin:** Does it ignore the comments?
+
+**Carlisia Thompson:** Yes, exactly. I haven't gotten to see comments, I don't even know if they have comments. I suppose so, but...
+
+**Erik St. Martin:** I know we're kind of blind siding you with it Cory, but are there any projects or people that you would like to thank in the open source community?
+
+**Cory LaNou:** For me it's the one I use every single day, and it's Vim Go. I could not live without it. Vim Go is just... If you use Vim and you do Go, you have to use it, it's amazing. Some of the stuff that he's put in there lately has just been unbelievable. I can't tell you how happy I am with the amount of work that goes into that project.
+
+**Erik St. Martin:** Yeah, I wanna send Fatih a case of beer.
+
+**Cory LaNou:** Oh, like a semi load.
+
+**Brian Ketelsen:** He's a huge coffee drinker, so send him coffee. And they just had a baby, so he probably needs more.
+
+**Carlisia Thompson:** Exactly, I was gonna say that. Congrats!
+
+**Erik St. Martin:** Can we get some donations and we'll just buy him a brewery? \[laughter\] I think that's the level he's at right now.
+
+**Brian Ketelsen:** Yeah, don't forget, all you Vim Go users out there: he has a Patreon at patreon.com/fatih, and it's a great way to thank him for his Vim Go development.
+
+**Carlisia Thompson:** We'll include it in the show notes, for sure.
+
+**Brian Ketelsen:** Yeah, it's pretty awesome.
+
+**Erik St. Martin:** And for me it's Kubernetes. I'm in love with Kubernetes. That's what I've been playing with more recently. Anybody who has not played with Kubernetes for container orchestration should. Just way too much fun.
+
+**Brian Ketelsen:** It's a gamechanger, absolutely. That's a good one.
+
+**Erik St. Martin:** And with that being said, I think that we are ready to close the doors on this episode, unfortunately. I wish we could talk all day, but we cannot. With that, I'd like to thank everybody for coming on the show. I want to thank everybody who is listening to the show, and everybody who will listen to the show because all of you are going to refer friends to go to GoTime.fm and register. We will also have a weekly email there that you subscribe to. If you are not already, follow us on Twitter, @GoTimeFM. If you have ideas for things you'd like for us to discuss, or questions for upcoming guests - and we'll start publishing a schedule for that - you can find us on github.com/gotimefm/ping. We will link to all of this in our show notes. With that said, goodbye everybody.
+
+**Carlisia Thompson:** Goodbye.
+
+**Cory LaNou:** Goodbye.
+
+**Brian Ketelsen:** Bye!

Go Kit, Dependency Management, Microservices_transcript.txt

@@ -0,0 +1,622 @@
+**Erik St. Martin:** We are back, it is episode \#25 of GoTime. Today's sponsors are Minio and Backtrace. On the panel today we have myself, Erik St. Martin, we also have Carlisia Campos - say hello, Carlisia.
+
+**Carlisia Thompson:** Hi, everybody!
+
+**Erik St. Martin:** And Brian is off doing some training and stuff, so Scott Mansfield from Netflix has joined us today as part of the panel. Say hello, Scott.
+
+**Scott Mansfield:** Hello Scott. \[laughter\]
+
+**Erik St. Martin:** You actually took that literally. That works. And our special guest today joining us on the panel is Peter Bourgon. Say hello, Peter.
+
+**Peter Bourgon:** Hello, and I am not special in any way.
+
+**Erik St. Martin:** You are special! Peter is like a staple in the Go community. You've been giving people advice on running Go in production longer than most people have known about Go. You spoke in 2014 on advice for running Go in production...?
+
+**Peter Bourgon:** Was that the first GopherCon, 2014?
+
+**Erik St. Martin:** Yeah, that was the first GopherCon.
+
+**Peter Bourgon:** Yeah, that was us back then... Soundcloud days.
+
+**Erik St. Martin:** So you wanna give everybody a little background and backstory for anybody who's not familiar with you and the stuff you work on?
+
+**Peter Bourgon:** Sure. I came to Go after a relatively long career doing C++ actually, so I was one of the few people that actually tracked how Rob and the original crew thought people might come to Go. I was writing mostly network servers, I guess. I was working at the time in kind of a distributed search space, and when Go was released, I happened to be on sort of a sabbatical, so I got to spend a lot of time with it in the early days, and it really piqued my interest, and I had a lot of fun doing some introductory projects. I think my first thing that I ever did was probably something that a lot of people start with.
+
+I tried to think of an algorithm that would really benefit from concurrency, so I thought "I know, I'll implement naive Quicksort, and I think I gave each partition task its own goroutine, and I got really annoyed that it was actually slower than doing it all in a single goroutine. Has anyone on the panel ever tried something like that before? Like, first attempts, and being quite disappointed with how it turned out?
+
+**Erik St. Martin:** I'm trying to think of some of the original ones... See, this is where I start to fall under your same memory problem - I vaguely remember some stuff, but what was it? I know there's some things with my own misunderstanding of the language that kind of fell flat, but I don't know whether implementing a specific algorithm... I can't think of an exact...
+
+**Peter Bourgon:** I struggled with the concurrency stuff for a little while; my pet project at the time was this synthesizer thing which never really got anywhere, but I started off by sending individual float32s down the channel. That doesn't work. You need to buffer those up.
+
+Anyway, so I dug in and managed to introduce it at my next job in a small capacity, and became even more interested and started building a lot of typical things out, like a proxy... I think my first project that stuck around was this key/value store. I guess everyone either does that, or a web router; one of the two things.
+
+\[03:57\] And then I joined Soundcloud, where I was able to do it full-time, and there were a couple of people already working in Go at Soundcloud, actually. They formed the original Berlin Go users group back in late 2011, which was - if my memory serves, and it doesn't - pre-1.0, so that was back in the R59 days... Does anyone remember those?
+
+**Erik St. Martin:** I remember those... I remember makefiles.
+
+**Peter Bourgon:** Oh yeah.
+
+**Erik St. Martin:** No Go tool, makefiles.
+
+**Peter Bourgon:** No Go tool. GC, 6G, 6L... Yeah, sure.
+
+**Erik St. Martin:** Yeah.
+
+**Peter Bourgon:** Yeah, so at Soundcloud we sort of built out sort of an internal platform that was all in Go. I was on a team that did some -- again, it happened to be the search/discovery team; all of our internal infrastructure and applications were written in Go, and there were a couple other teams scattered throughout the company that really liked Go at that early stage. I think some of them were in the internet-facing teams, or some of the transcoding teams... Yeah, so Go services were kind of scattered throughout.
+
+So we built up a relatively good background of early Go tips and tricks, and we made a lot of mistakes, and corrected for them, and all of that information... I conducted some interviews and scribbled some ideas together from different teams throughout the company. I probably interviewed about six or eight different teams back then. Those interviews and those learnings became the basis of that first talk at the first GopherCon.
+
+**Erik St. Martin:** It's interesting... You've kind of spoken about the horror stories, like being disappointed, or things that we've done incorrectly. I'd actually like to circle back to some of those... Does everybody have an example of one that they remember that went horribly wrong? Something you viewed about the language incorrectly and used incorrectly and it kind of fell flat? I know personally I abused channels like no tomorrow in the early Go days. I see code that I wrote back then and I'm just very disappointed in myself. Like, why did I think that that was a good idea?
+
+**Peter Bourgon:** Super common, I think.
+
+**Carlisia Thompson:** Yeah, I think so too. I don't know, when I came into Go things were already rolling, and a lot of people to give advice... So when I started to write channels the first time, I quickly got advice to just "use a mutex here, you don't need it." So I was like, "Oh, that's a thing..." and I looked into it and I'm like, "Okay, you can't use channels all the time."
+
+**Erik St. Martin:** Yeah, I would use them for state.
+
+**Scott Mansfield:** I'm lucky that most of my beginning code is in the same project that I'm still working on, so it's all been kind of rewritten. That just erases that bad memory...
+
+**Erik St. Martin:** \[laughs\] You don't have to look at it anymore...
+
+**Scott Mansfield:** Exactly.
+
+**Erik St. Martin:** Yeah, well that's the hard part, too - if you put stuff out in the open source world, it kind of lives on forever, even past the point where you look at it and you're like, "Yeah, nobody should be using this."
+
+**Peter Bourgon:** I don't know if I remember any specific horror story, but I definitely remember it took me a long time to really grok the subtleties of interfaces.
+
+**Erik St. Martin:** Yeah, I'd agree, too. I always forget what the exact error is, but one of the confusing parts for me was in the early days with interfaces when you'd pass something as a value or a pointer, and it needed a pointer receiver. If it expected a pointer receiver on the method it would work, but if you passed a value it wouldn't work, and you'd get an error and there was always confusion about why that didn't work until I looked into actually how interfaces are built. When you look at them, there's actually a value inside of it, as well as a pointer to the type, so it's like "Well, it can make a pointer to the value, but it can't make a value from the pointer, or vice versa." That used to mess with me all the time, because I'd be like, "Why does it work one way but not the other?"
+
+**Carlisia Thompson:** \[08:07\] Somebody gave a talk about that one at the Go Language team members, I've forgot who, and there was a good explanation. But yeah, it's not easy; you don't find this information right away when you start learning. Even now...
+
+**Erik St. Martin:** Well, I guess it exists in the form of the language spec, right? That's actually a really good place, in the Memory Model. I remember reading the Memory Model, and that started solidifying a lot of concepts to me, about ordering, how the compiler can actually reorder your statements, so you can't actually guarantee when this is run concurrently that these things are gonna happen before each other just because you put them in the code that way, and that really started helping with my knowledge. But I think you have to have some experience. You kind of have to find your way around first, and develop some battle scars and then read it, because then you have something to relate it to.
+
+**Carlisia Thompson:** Yeah.
+
+**Peter Bourgon:** Totally.
+
+**Erik St. Martin:** If you just read the language spec and the Memory Model you're like, "Okay", and then you're gonna still make the same mistakes.
+
+**Carlisia Thompson:** Yeah, I agree.
+
+**Peter Bourgon:** This is a trap I find myself falling into whenever I'm trying to teach newcomers, or give advice sometimes. Everything I learned was a function of my doing it the wrong way once, and then kind of realizing it's the wrong way. It's a very didactic process, and I think most people probably work in a similar way, so it's actually not very helpful to just tell them, "This is the right way, you're doing it wrong." You have to kind of show them what the problems are, and let them feel the pain, so to speak.
+
+**Scott Mansfield:** Yeah. I know that I never actually learned any new language or any new concept without going and implementing something in that language, or just trying to implement that concept. It just doesn't stick.
+
+**Erik St. Martin:** Yeah, there's that balance... Like, how do you get enough knowledge to not be totally falling on your face, but be developing enough battle scars from doing it where you can kind of start to understand what's going on.
+
+**Carlisia Thompson:** And talking about learning and teaching, Peter, I see that you are now giving workshops. Do you plan to continue? How's that going?
+
+**Peter Bourgon:** Yeah, I guess there's a couple of topics that are sort of in my wheelhouse and it depends on the audience. I've given basically Go training from zero, and kind of a tour of the language, and it gets the class up to reasonably sophisticated Go programming. In that course, I just walk through all the language features and do some tour exercises, and step through docs like the Memory Model and Effective Go, and explain how all the orthogonal pieces interact.
+
+So I've done that a couple of times in different setting and different lengths... And that's okay, that's kind of rewarding. The main thing for me is just to get more people into the ecosystem, and maybe this is hubris, but kind of point them down the right paths, rather than encouraging them to build yet another HTTP request muxer, or whatever the thing may be. There's maybe more interesting projects to get your feet wet with. And then lately I've been doing quite a lot of stuff around the topic of microservices, and Go Kit comes into play there absolutely, but I think that there's also another way to look at teaching the language, a very service-oriented or server-oriented way of approaching and introduction to the language that seems to me to get a bit more traction in the sense that people more quickly understand the strengths and the values of Go, and they kind of say, "Oh, this actually compares very favorably to how I have to currently do things in Python, or in Spring Boot", or whatever the framework of the day is.
+
+These are quite popular workshops, especially at typical conferences like GoTo or QCon, or some that I've done lately.
+
+**Carlisia Thompson:** \[12:10\] I love that idea. I wish you would maybe write about it. Is there a book in the works maybe? \[laughter\]
+
+**Peter Bourgon:** A book, good lord...
+
+**Erik St. Martin:** You're putting work on his plate for him. You're committed now.
+
+**Carlisia Thompson:** I'm delegating. \[laughter\]
+
+**Peter Bourgon:** Goodness...
+
+**Carlisia Thompson:** No, it really is to me I think very useful to have an approach to teaching the language that highlights its best features. There are many ways of teaching things, and I think people make use of different ways in this way of teaching that -- I don't remember exactly how you said it, but presenting the language in a way that it's a... How did you say it, in a service-oriented way?
+
+**Peter Bourgon:** Through the lens of servers, yeah.
+
+**Carlisia Thompson:** Right, because it's so much of what we do, and especially what we do with Go, so it's super useful.
+
+**Peter Bourgon:** Yeah, I totally agree.
+
+**Erik St. Martin:** So the microservices thing is kind of like another explosion in recent years too, and we see a lot of frameworks in many different languages, and orchestration platforms, and service discovery and things like that. Let's talk a little bit about that and your passion for that, because you've kind of been in that world for almost as long as you've been Go. Kind of learning and building your view of the world and how it should work, and advocating to people how to do this successfully.
+
+**Peter Bourgon:** Yeah, I guess there's two angles on this. There's the why is it interesting to me at sort of a high level, and then there's the why do I think Go is a great match at a technical level.
+
+I'll start with the first, I guess. I was really doing microservicey type stuff for quite a long time; of course, it didn't have that name until very recently. I really only dove into what we commonly know as microservice workloads today, when I was at Soundcloud, and we kind of made an executive decision - or at least an engineering department decision - that this was probably gonna be the future and we should probably invest some resources into building out an architecture that worked in this manner. At the beginning I think I was the first team that was using our internal platform and kind of the prototype customer, but I was really excited to try it out, because it got at something that I couldn't quite put the word at the time, but which I really have thought a lot about, and I think I can describe it properly, now that I'm a few years removed. And that is this experience I had in previous companies where it would be my first day or my first week on the job, and I would join a team, and there would be this existing codebase that to my eyes was just massive, and full of dark corners and unexpected interactions, and a lot of legacy... Not necessarily croft, but just legacy knowledge baked into it. And the only way to become comfortable in that environment was to put in a whole lot of grunt work that you couldn't really rush and you couldn't really optimize.
+
+You had to read the code, but that was never enough; you had to go and ask people why things were the way that they were, and sort of probe them with intelligent questions about, "Well, did you consider this alternative? Oh, okay, you did and didn't work out for these reasons... What implications does that have on this other part of the system?" So for me it was always a multi-month process to get my head around a new system, and what I sort of discovered with microservices was that this cost was dramatically reduced when the size of an individual codebase with well-defined boundaries was much smaller. In my workshops I say one good definition of a microservice is "Code that you can keep in your head", and I think that's a really great way to delineate a boundary for this sort of thing. \[16:03\] It's code that you can totally keep in your layer two cache, in your brain, or whatever, and that implies that you can pretty well describe it with a single sheet of paper and 15 minutes to a co-worker. And maybe there are a couple of edge cases and dark corners in there, but it's not the sort of stuff you need to dedicate half a year to figuring out. And if this is true, if this is how your organization's built, like a loose constellation of these sorts of codebases, then it's much easier to move between them, to understand them, to understand the interaction points - at least for me, at least for the way I model software. And in turn, it gives you a lot more confidence - when you join a new team or you start a new project or you take over an existing project - to refactor it perhaps, if the requirements change, or to make changes and maintain it, and have confidence that you're doing that in the right way.
+
+That's sort of the soft side, it's why I love microservices. They make me confident again, and they give me a certain amount of happiness that I lost when I was working on gigantic years-old legacy monoliths or huge projects like that. That was a lot of talk, I'm sorry for taking the floor.
+
+**Erik St. Martin:** It's your floor to take.
+
+**Carlisia Thompson:** That was a great explanation, and I love this idea of the ideal size of a codebase being whatever amount that you can hold that in your head as a mental model. This has been coming up over and over again when we talk about microservices.
+
+**Erik St. Martin:** I think it applies to a lot of things though, too. Recently I was talking to some people at KubeCon last week or the week before, and I used almost the same premise for whether or not you should use something like Kubernetes like an orchestration platform, and my example was if you can't name me all of your hostnames, and you can't say like ChicagoWeb01-30, that doesn't count... But if you can't reasonably name off all of your host, you probably shouldn't be managing them individually. You should be doing something to orchestrate those and provision them and manage them at a higher level of abstraction. I think that that's the reasonable thing...
+
+And in management too, right? From your perspective, when you have an organization with a big monolithic project, it takes a lot more coordination between teams, that are seemingly unrelated, but because now they're in the same codebase, the projects are more tightly coupled together than they need to be.
+
+**Peter Bourgon:** Yeah, and as ever, it's this balance. There's a spectrum between -- I like this word, "balkanization", where everything is its own separate service; you can take that to an extreme, of course, and you just have to look at the architecture diagrams from Uber, or whatever... It's like a thousand microservices, many of which are duplicated because teams just don't know about existing functionality necessarily. So you can definitely take it too far.
+
+Now I guess we're getting a bit to the technical side, and this is a point that I'm very clear to make - whenever you move away from a monolith or you start down this path of giving each developer a set of their own independent microservices to manage, you're actually creating way more technical problems for yourself, in so many dimensions, than you're solving. And what microservices enable is organizational harmony, and they improve shipping velocity, and they improve communication overhead, and exactly as you said, coordination in a single codebase - when that becomes too hard, then microservices can help.
+
+**Scott Mansfield:** \[19:48\] Let me give you a counterpoint to this kind of argument. You can do the same thing in a big monolith - you have very well-defined interfaces, for example, between each packages, and then you don't have to worry about the vagaries of going over the network every time you want something. What do you say to that?
+
+**Peter Bourgon:** Absolutely. I think the term that gets batted around for that architecture is the "elegant monolith" style, where everything is pretty well delineated internally. There's not a lot of shared code, very well-defined API boundaries... It's just that the deployment artifact is all hosted in a single process, which carries a huge number of advantages; atomic refactors, and the deployment story is significantly easier, the testing story is way easier... Yeah, so this is a great thing to do, especially if you're just getting started.
+
+When I give my little workshops, I say "If you're five engineers or fewer, there's no reason that you should be running a microservice architecture." You're just not having any of the problems that microservices solve. This architecture you describe is a great alternative, and one that you can kind of adapt to microservices as you grow and become more successful.
+
+**Carlisia Thompson:** Yeah, I saw Peter's talk at Golang UK and he was very discouraging of using microservices. \[laughter\] And I really liked it because he went through all the pain points, some obvious, some not so obvious - obviously, he has a ton of experience - and he went through many pain points that you can go through by having a microservice if you are not really properly set up for it, like he was saying. If you are super small, you don't need to divide your codebase in many microservices.
+
+But at the same time, Scott's remark is to the point I think, because as I have been learning more about packaging in Go in the recent months, Go makes it so easy to really contain your code through the use of packages. I wonder if for Go the heuristics would be different as far as a feasible size for a codebase.
+
+**Peter Bourgon:** Do you think it would be bigger or smaller, Carlisia?
+
+**Carlisia Thompson:** I'm wondering if it could not be bigger and still be very functional, if you use the features of the packaging; now there's that internal feature which allows you to hide even more things. And there are companies using monolithical apps, like Digital Ocean, and there's another one that I forgot now.
+
+**Peter Bourgon:** Yeah, I think it's completely viable. I guess I don't have the stamina to give my workshop again here, but there's so many problems that come when you're splitting your business domain along process boundaries. If you can avoid doing that, if you can split it on package boundaries and then wire things up internally with some interprocess or intraprocess communication layer rather than JSON or HTTP or whatever... And package boundaries make a good proxy for that sort of thing. Although then you start entering this still quite confusing for me domain of how do you structure your repo? How do you decide where to cut up your packages?
+
+Ben Johnson has an opinion about this, but I've tried to use it and it often fails for me. Maybe I'm holding it wrong. There's lots of opinions about this sort of thing; I'd love to hold a panel about that as well.
+
+**Carlisia Thompson:** I would, too. I'm super interested in that. By the way, the other company I was thinking about was Google. Google has a single repo. But yeah, Ben Johnson was talking about that, Bill Kennedy promised that he's going to start writing about that as well... I'm working on a talk and a blog post about packaging, although mine's going to be more like entry-level than one of you guys. But personally, I can't even imagine working with a monorepo. Just the whole "deploy everything everytime, run every single test everytime or at least once in a while..." I can't imagine.
+
+**Erik St. Martin:** \[24:19\] It depends on how coupled your repos are. If you have multiple repos that are highly coupled to each other, then the testing story and deployment story gets more complicated with that, too.
+
+I think it's interesting, because a monorepo can still be broken up, right? If you look at the Kubernetes codebase, or the Docker codebase, there's a command directory which kind of has the main packages in it, and then there's like a package directory that has code implementations of those things. So there's still areas of the repo that are kind of siloed off for these particular things, but you can guarantee that when you make changes to the Kube control binary, which is the command line interface for interacting with Kubernetes, you can ensure that it doesn't break against new versions of stuff when it's all tested together.
+
+It's really hard though, because anybody who's worked for companies large and small, you start "Well, it's good for these scenarios but bad for these others" and you can join the other team depending on kind of what the exact use case is. I love monorepos for many reasons, and then I love splitting it up for others. I feel like there's no easy win either way. And I feel the same way about breaking up packages, like where the package boundaries are defined. As long as I've been doing this, I still can't find a way that I like. I feel like "This worked for this one time, but it's terrible for another project", and it sounds like that's a struggle everybody's having.
+
+I haven't seen Ben Johnson's post on what he's recommending there... At least I don't remember it. It might be my seven-day window thing. I need to look at that. Is that on his Medium blog?
+
+**Carlisia Thompson:** Yeah, he has a blog post and he has a repo with an example. And actually, if you look through the pull request, there's quite an instructional conversation between Peter and Ben going over the tradeoffs, it's very interesting. One thing's for sure - a monorepo would make it easy for dependencies, so maybe we should talk about that.
+
+**Erik St. Martin:** Yeah, so I wanna get into dependencies and I wanna get into Go Kit a bit. But before we do that, it is time for our first sponsor break.
+
+**Break:** \[\\00:26:46.05\]
+
+**Erik St. Martin:** Okay, moving on. Carlisia, you wanted to talk about...
+
+**Carlisia Thompson:** Dependency management.
+
+**Erik St. Martin:** Dependency management!
+
+**Carlisia Thompson:** That little thing... \[laughter\]
+
+**Erik St. Martin:** That tiny little problem nobody has, right?
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Peter, I know you have a lot of views on this, and some of the tooling and how things have evolved, and you've kind of followed this all the way through its course, which has been "As long as it's solved..."
+
+**Peter Bourgon:** Quite on the contrary... I actually have almost no strong opinions about it. What I do have a strong opinion about is that it gets solved, yeah. Precisely.
+
+So how did this all begin? Back in the early days, in the pre-1.0 days, we all decided we should go get our dependencies, and because goget identifies projects in sort of a spacial dimension, they identify them by name, but provide no way to identify them in sort of a time dimension, there's no way to identify version... The consequence was that we kind of all just had to trust that all of our dependencies were going to remain stable, or the changes they make weren't going to be breaking, or if they did make breaking changes, that we would catch it somehow magically, as soon as it happened, and then make changes to fix it somehow, magically.
+
+This hope-driven development worked surprisingly well for a number of years, in the sense that Go gained popularity and people were still shipping productive production software with it. But in the open source ecosystem it has sufficient differences to the Google monorepo and to the Google way of doing things, so as we all are pretty much aware I'm guessing by now, it has started to fall over in the broader ecosystem for me that the hardest thing to deal with was actually when I started programming against Kubernetes' APIs. Has anyone tried to do that?
+
+**Erik St. Martin:** Yes.
+
+**Peter Bourgon:** Goodness...
+
+**Erik St. Martin:** And ouch! Very much ouch! I'm building stuff against their APIs too, and there's two problems. One, before they did the client Go library, which is just the client libraries, you had to import the entire Kubernetes package, which was terrible. Then the second problem is nested vendoring.
+
+Following this course, in the early days I almost agreed with Google. Like yeah, you don't really, but you forget that in the early days there wasn't a lot of libraries, so you ended up writing a lot of your own stuff, so it just really wasn't a problem.
+
+**Peter Bourgon:** And the libraries that did exist were relatively small, so you didn't have this huge vendor tree problem, you didn't have this "dependencies of dependencies of dependencies" problem.
+
+**Erik St. Martin:** Exactly. They were relatively small, served a very distinct problem, and you could either copy the one part of code you needed, or... It was very small, but you didn't have this tree of vendor directories, where it's like "Great, now I have Kubernetes vendored in, but how do I get it to recognize their vendors, and what happens when they have vendored the same libraries that I have vendored, because I'm using them for different purposes.
+
+**Peter Bourgon:** Exactly. So a lot of people saw this coming, and a lot of really smart people started developing tools to manage the vendor directory as what we kind of all settled on as the place to store your dependencies. That's fine - you can check it in, you can not check it in... It kind of doesn't matter. And this approach, the blooming of a thousand flowers by all the contributors was kind of blessed by the core Go people. They wanted to have "the community" solve this problem, and then when a solution emerged, I guess they didn't say this explicitly, but I guess they would have blessed it somehow, and then that's what people would all choose to use.
+
+\[32:00\] Unfortunately, that was I think in retrospect quite naive, because what ended up happening was we have 13 standards of ways to manage dependencies, and that means different file types, different file locations, different file formats, different behaviors in all the tools. Broadly, you can say that they do very similar things in very similar ways, but there's subtleties in the differences.
+
+In the end, it means that when you publish a package and you have dependencies and you want to - I guess it's a pretty sane thing to want to do - bind your code with specific versions of its dependencies, then you're necessarily kind of opting into one of these tool ecosystems, but there's so many that in order to consume different packages, you end up having to support all of them. And since none of them are part of the standard Go tooling, then you're kind of like telling your consumers they need to opt in to not only the Go tool, but these other third-party things which have their own project lifecycles and bugs and all these things.
+
+So it's a total mess. And while you can always find a path through the storm and solve something for your specific use case or for your specific project, there's no single coherent, teachable, simple way to solve this problem generally. So that was the state of the world.
+
+**Erik St. Martin:** Even if we all as a panel said you should use this one, it's not gonna matter because of that whole nested dependency problem, right? I use one, but I import a package that uses another one...
+
+**Peter Bourgon:** I think it was super naive in retrospect to say "The community is gonna figure it out", because what happened was you have these camps, and they kind of ossified and for good reasons - everybody has reasonably good reasons for choosing one style or another, but now we have all these competing standards. So in my mind, the only way out of this is to - and I guess this is where we're getting - form a committee with representation from the core team, and pick a standard. Maybe that takes the form of blessing one of the existing tools officially, or maybe it takes the form of producing a hybrid tool, or a common tool, or something like that.
+
+This is the committee that I was driving as of a couple months ago, and that's what we're in the process of doing right now, to kind of eliminate this heterogeneity in this space, and hopefully help a lot of people.
+
+**Carlisia Thompson:** So just to get things clear, you're not the head of the committee anymore?
+
+**Peter Bourgon:** Right, so I was never on the committee... Basically, what happened was I had a number of weeks at my day job where I was working with people trying to get a handle on the dependency management story, and was being confronted with all these tools and workflows, and they were broken for our use cases in subtle ways, and we filed bugs... People were just getting pissed off, frankly, and many of them were - and I saw this also in the broader community - kind of saying, "You know what? I'm not interested in programming Go anymore if this is the way it's gonna be." And this was really super sad for me.
+
+So I just kind of said, "Forget it... I think I have enough political capital in the Go community that I can kind of anoint myself the person who's gonna figure this out, but I don't have enough political or technical know-how to actually do it myself." So I said, "I'm gonna be sort of the communications director, or the PR person, and I'm gonna organize a committee of people whom everyone trusts, hopefully, and they're gonna figure it out. I'm just gonna be the organizational person." I'm gonna run interference and try to be a firewall and help them achieve that goal. So yeah, I'm not on the committee, I'm just figuring out all the logistics, I guess.
+
+**Carlisia Thompson:** \[36:08\] Alright, so you're still heading it, though.
+
+**Peter Bourgon:** Yeah, I guess.
+
+**Carlisia Thompson:** You're heading the initiative.
+
+**Peter Bourgon:** Yeah, you could say that.
+
+**Carlisia Thompson:** And what is the state of the prototype that's being built? Has it been made open?
+
+**Peter Bourgon:** Not yet. The workflow was we first in a Google Doc describe what I want the process to be, we took some feedback on that (it was great), then we picked the committee, and it actually ended up being a core committee of Andrew Gerrand, Jessie Frazelle, Ed Miller and Sam Boyer, whom you know from the extremely lengthy "So You Wanna Build A Package Manager" Medium article; I think the estimated reading time was like 45 minutes, or something like this. Super, super, excellent article.
+
+So they're the core committee, and then we have this sort of trusted advisory group of the authors and maintainers of the top four tools at the moment, which are Matt Farina of Glide, Daniel Theophanes (I'm sure I'm butchering that name, I'm sorry Daniel), he's the Govendor chap, Dave Cheney of gb, which is kind of the odd duck in the group, and then Steve Francia, who is kind of like a Go liaison now at Google, and he's been doing a lot of work in this space, as well. So it's these people that are sort of driving it, and to answer your question - the implementation is currently under way. We went through a long period of building a spec for the thing, got some feedback on that and the implementation's now basically being implemented... A prototype implementation by this core committee. That's not open yet, because we wanna have something at least minimally usable before we make the repo public.
+
+**Carlisia Thompson:** Gotcha.
+
+**Erik St. Martin:** And to clarify - this is going to be kind of a new approach based on the knowledge of people who have already developed tools, and not some way of interacting with these specs that already exist.
+
+**Peter Bourgon:** Right. What we did was an extensive, comprehensive survey of the states of the ecosystem, both in Go and in other languages. We consulted with all of the authors about the pain points that they experienced and if they wanted to represent their user's experience, and what things they found to be super important, the most important top K features, or whatever. And then we took feedback from the community based on user stories, based on design points... There's a whole bunch of questions. "Should the tool in this scenario do this or that? How should it interact with the GOPATH? How should it manage version ranges?" and so on and so forth.
+
+Each of these questions has a wide variety of possible answers, so we enumerated all those as best we could. Then, with this "survey" of possible use cases and design space points and user stories and all these things, we winnowed it down to what we considered to be the bare minimum usable, covering 90% of the use case tool, and it ended up being quite a small surface area, so not too many subcommands. Then we made that spec, the spec of such a tool public, and we took feedback on that. So yeah, it's sort of like lessons learned, and hopefully a common ground between what everybody's doing.
+
+**Carlisia Thompson:** From where you stand now Peter, what do you see as a possible timeline for this coming together as a production-ready tool for vendoring? If it goes on the path that it's going now; of course, if people say it needs to change, then who knows...? But if it goes on the path that's going now and there is agreement - there will never be consensus, but if it proves itself useful the way it's coming along, what do you see as far as timeline?
+
+**Peter Bourgon:** \[40:05\] That's a great question. My hope at this point is that we're gonna have a usable prototype by the end of the year timeframe, and luckily it's going to be a tool that you can kind of go get independently of anything else, and you can kind of try it out. We're gonna have a period of use, I guess, refinement, iteration...
+At this point I hope interested members of the community are going to be filing issues and potentially even PRs on it, and then the goal, at least as I understand it now - and this is all subject to change, of course - would be that this dependency management tool would become packaged into the Go tool, so a separate Go space dep, let's say (subcommand) in the 1.9 timeframe. So that's the hope at the moment. Who's to say if it's gonna get there, but even if it doesn't get in the Go tool, it will be usable separately.
+
+**Erik St. Martin:** I think the nice thing about it being in the Go tool is that it becomes the canonical thing people use. Because that's the hardest part, right? Once this thing it's released, it's just another one in the sea, and then we're still gonna have the issues of "I'm using that tool, but I'm vendoring things that use another tool." I think as soon as it's kind of adopted by the Go tool, it becomes kind of the standard, and people start porting to use it, and the ecosystem becomes friendlier for everybody.
+
+**Peter Bourgon:** Exactly... Scott has just pasted in the Slack channel... \[laughs\] The problem here is exactly the number of competing standards. The usability problems introduced by having all these tools is exactly what needs to get fixed, and in a lot of ways that's really hard, because you don't want to -- we've only learned the lessons we have from all these incredibly smart people putting in the hours and the dedication to making their tools as good as they are. But at the end of the day, if you wanna have a reasonable, coherent ecosystem, you can't have arbitrary installation instructions for every arbitrary package that you come across.
+
+You really do need the single standard, and we're gonna do our best to make that transition period as easy as possible. There's a couple of options for that. We can read the most popular existing file formats and kind of do the transition automatically, or we can have a transition tool that's packaged beside the dep management tool. We haven't quite figured out what that's gonna look like, but we're committed to making the transition UX about as good as it can be.
+
+**Erik St. Martin:** Even if there's a secondary process that I have to download to fix my vendor directory... I don't care that you use this, because I can fix that, and just kind of run something that reads their vendor file and flattens it out onto yours, or however that works.
+
+**Peter Bourgon:** ...for example, yeah.
+
+**Erik St. Martin:** The hard part too here is I think we're critical on the Go team, too. I think it was naive, but I also kind of understand where they were coming from, where it's not really a language thing, it's an ecosystem thing. But I also argue that there's many things in the language that were brought in that were ecosystem things, which has actually helped adoption. The Go tool - everybody uses that now. I think that that made the language so much more approachable when everything kind of got bundled into the Go tool.
+
+**Peter Bourgon:** \[43:46\] Arguably the great lesson of the Go experiment is that you can't really treat the language and its tooling ecosystem in isolation. They are really part of a package that developers buy into as a whole, and I think that that understanding has really helped Go, and the commitment to gorename, gofix, go fmt, govet, golint - all these things packed together in a way that makes a compelling developer experience.
+
+**Erik St. Martin:** Are you familiar with the Rails world?
+
+**Peter Bourgon:** Only peripherally.
+
+**Erik St. Martin:** I wonder how much of what everybody loves about Go is a similar thing that people loved Rails for, which is that convention over configuration thing. There's just this canonical way of doing things, and that makes it much more approachable. You're not looking at 50 ways of doing this, and the paradox of choice, where you can't figure out which decision is the best for you and you just don't make a decision. The Go tooling has kind of taken that away, like "How do I format my code? What are the proper idioms?" and things like that. It's kind of well defined.
+
+**Peter Bourgon:** It's certainly what attracted me to the language early on. And what kept me away from Ruby - less so Rail, more so Ruby - is that in Go (and not Ruby) there's only one way to do something. Those limits, paradoxically, give me the freedom to worry about the problem domain and not about my method of expressing it.
+
+**Carlisia Thompson:** Yeah, I love that.
+
+**Erik St. Martin:** Scott, you're firing shots on the GoTime FM channel... Aliases! \[laughs\] Hand grenade!
+
+**Scott Mansfield:** Yeah... There was one point that I wanted to bring up that I thought was very good in the document that is out there now for comment. The idea of keeping this very restrictive, but also just simply dropping some of the more complex requirements I think is going to work out the best, because keeping that area small, that purview small to begin with is going to let you actually observe in the real world what the problems are. And I think too many people earlier, part of the churn, especially in the vendor channel on the Slack, was around all these complex use cases that people could just come up with all day. But having something out there and operating in the real world is going to get you the proper tooling.
+
+**Peter Bourgon:** I totally agree. It's very easy to come up with a convoluted workflow that breaks any tool you can imagine, and all you have to do is stamp a "Required" on that workflow, and suddenly you're back to square zero. What do you do?
+
+**Erik St. Martin:** And I think some of it comes from -- you know, all of us come from different languages that already had package managers that worked a particular way, so you're influenced by the idioms that you used programming in the language. I think that's where we see some of these patterns from all of these different tools - the influence from the package managers they came from.
+
+I think the perceived use cases come from that, too. The language itself is the same way. You're like, "Oh, well I need this language feature because I need to be able to do this", but really there's another way it can be done if you view it from the language perspective. So it's kind of the same way here. We have to think about it from Go's world. No language actually has import paths, like actual URLs as their import path, so we're already kind of in a whole new world.
+
+Scott, did you wanna talk about aliases, or you're just throwing jokes here? \[laughter\]
+
+**Scott Mansfield:** No, that's purely me trolling... I really don't wanna talk about aliases.
+
+**Carlisia Thompson:** Nobody wants to talk about alias. \[laughter\]
+
+**Peter Bourgon:** Have you talked about it yet on the program?
+
+**Erik St. Martin:** There was an episode I think we vaguely talked about it... Brian is very adamant that he does not want them.
+
+**Peter Bourgon:** Good.
+
+**Erik St. Martin:** Scott, you're supposed to be playing the part of Brian today, so you should be like, "NO ALIASES!"
+
+**Scott Mansfield:** Okay... NO ALIASES! They're horrible. I really don't understand why, but I've been told so, so...
+
+**Carlisia Thompson:** \[48:05\] That ship has sailed, you guys.
+
+**Erik St. Martin:** Yeah, I think it's just because people think it creates kind of like a footgun. It's not that it's inherently bad, it's just... The language has done a very good job at shielding people from creating monstrosities, you know?
+
+**Scott Mansfield:** You give me a day and a laptop and I can create the worst Go code you've ever seen, so I don't really need aliases to do that.
+
+**Erik St. Martin:** Challenge accepted! \[laughs\] I wanna see that, too. I actually wanna see everybody's worst Go code, like what is the worst thing you can come up with. The most racey, ugly-looking, Perl one-liner... \[laughs\] That's something I don't miss. Did anybody work in Perl in previous lives?
+
+**Carlisia Thompson:** No, not me.
+
+**Erik St. Martin:** Peter, you wouldn't remember, right? \[laughter\]
+
+**Peter Bourgon:** I remember one of the first programming books I got was like "CGI Perl" or something like this... I think that was an O'Reilly book, and I think I got about 15 pages in until I gave up pretty quickly.
+
+**Erik St. Martin:** I don't miss the days where there was competition with like, "Look, I wrote an IRC client in one line of Perl!" You're like, "But why?!"
+
+I worked with a guy and he used to joke it was a write-only language; you didn't modify Perl, you just wrote a new one.
+
+**Peter Bourgon:** Exactly. You know who's using Perl all the time? Damian at booking.com, they're still a Perl shop.
+
+**Erik St. Martin:** Yeah, they're doing I think OOP Perl, though. I'm pretty sure that people have probably learned their lessons by now, that you don't write applications in one line; that's just not reasonable.
+
+So a big project of yours is Go Kit, and I wanna get into that. But first, I think we have our second sponsor break, so everybody get a drink. Well, not everybody listening, but the people on the show.
+
+**Break:** \[\\00:50:02.02\]
+
+**Erik St. Martin:** Okay, so Go Kit... We've started out with microservices, now we're gonna circle back. So along the lines of your microservices love, the past couple of years now you've been working on a project called Go Kit, which has seemed to really be taking off, and I wanted to talk a bit about that.
+
+**Peter Bourgon:** Sure... So let me give a quick background, I suppose. Go Kit was born when I was at Soundcloud. We had been doing a lot... We were very heterogeneous in terms of languages, very polyglot, and Go had great representation at the beginning. When we were growing, we realized in order to achieve economies of scale we needed to settle down a bit, we needed to not be deploying Haskell code to production, because then we had about two engineers that could support that. So we started to circle around certain officially supported ecosystems, and one that everyone seemed to enjoy was Scala; there was a lot of great support in the Scala ecosystem. It was a very expressive language, lots of people interested in it. Scala had this thing called Finagle (from Twitter) which solved a lot of problems that were very common to microservice architectures.
+
+\[52:01\] Another language was Go, and a lot of people really wanted to use Go, and I was kind of chief among them. But when we started deploying a lot of services, we realized that there wasn't a Finagle equivalent; we would have had to write our own circuit breakers and rate limiters and safety stuff, and load balancers, and integration with our service discovery system. This was all work that needed to happen, and that the Scala people kind of got for free. So in the end, while Go was still being used for SRE-type tasks, infrastructural tasks, it fell out of favor in the application domain in terms of like the business logic services that drive the product. That was super sad to me, and I didn't want that to ever happen again. I didn't want Go to get squeezed out because it didn't have support for this kind of architecture, so that's what birthed Go Kit and that's what's been driving it so far.
+
+**Erik St. Martin:** Do you have a lot of users in production with it now? Do you know?
+
+**Peter Bourgon:** Yeah, definitely some... Although this is sort of the thing with open source projects; I haven't tried to do an official survey or asked people to reach out to me yet, but it's really difficult for me to get a sense of who's actually using it, because I guess if I do my job right and my documentation is good and it doesn't crash, then I kind of never know. Because all the repos that would be importing it -- otherwise they might show up on GoDoc, as an importer, but all the repos that would be importing it are probably private. So I'm definitely aware of a couple of big uses... I'm not sure how much I can say.
+
+I guess one frequent contributor is this fellow by the name of Bass van Beek, and he's using it extensively in his game startup. He's helped me a lot with distributed tracing and the gRPC transport side of things, and a couple of other things besides... And there's definitely -- I'm aware of probably about a half dozen companies... People from companies that have reached out to me and said they're using it extensively; probably another dozen or so that say they're using parts of it... Beyond that, it's hard to say. I can say it has a lot of stars - that's pretty much meaningless, isn't it? \[laughs\]
+
+**Erik St. Martin:** That's the difficulty, right? And that's kind of like why we do our \#FreeSoftwareFriday thing. You usually only hear from people when they're having a problem. If it's saving the world, they're like, "Yeah, you know..."
+
+**Peter Bourgon:** Yeah, exactly.
+
+**Carlisia Thompson:** I don't think the stars are so meaningful. I think it shows interest... I was actually just looking at Go Kit's channel Gopher Slack and it's got over a thousand people.
+
+**Erik St. Martin:** Wow.
+
+**Peter Bourgon:** Yeah, that's super surprising to me, and I guess... Actually, if you go to the Gopher Slack list of channels by members, I think it's top five, or something.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Well, that's crazy though... Because when you think about it in context, that's 10% of all the people in the Gopher Slack, total. For one project. That's good.
+
+**Peter Bourgon:** I'm into it.
+
+**Carlisia Thompson:** Yeah, and if you're taking into account that a lot of people are not even active, that might be more like... It's a much higher percentage of the active members.
+
+**Erik St. Martin:** Right, and a lot of people don't hang out in all of the channels. Not being in there doesn't mean lack of participation in it too, so...
+
+That's always hard, like how do you measure involvement in a community (in any community)? How many Go programmers are there? It's hard to even guess. You could be off by an order of magnitude. You try to look at projects, or conference attendees and things like that, and make an educated guess, but we'll probably all be very wrong. There's usually more people using a technology that aren't active in the communities than there are people involved in the communities.
+
+**Peter Bourgon:** \[55:52\] Right... The great, dark mass of unspeaking programmers. I hear it's like, 80% is probably a good initial estimate. You only get interaction with about 20% of your users.
+
+**Erik St. Martin:** Wow. I knew it was a big gap, but that's huge. So we're saying 80% of people who use any given technology typically aren't visible in public communities...?
+
+**Peter Bourgon:** I've heard that statistic bandied about, but I can't put a source to it right now. But intuitively, that kind of makes sense to me.
+
+**Erik St. Martin:** That's crazy. So I know that we have talked about Go Micro on this show too, and I'd love to get your opinion on some of the other microservices frameworks and how they related to each other and what you see as benefits and drawbacks. Do you feel that you address the problem differently, that you solve a different problem? Because sometimes we perceive problems as the same.
+
+**Peter Bourgon:** Yeah, I would say so. I would say my approach is pretty fundamentally different to the Go Micro approach. I know him by reputation, if not super well in person; we've had a lot of conversation in this space, obviously... His Go Micro project is, from where I sit, it's a lot more of a batteries-included ecosystem, I would say. And I'm sure this isn't so strictly true anymore, but the Go Micro approach is the way to write a microservice is by opting into all of these dimensions of the problem space, and the Micro universe has point solutions for each of those dimensions.
+
+I guess it's a lot more opinionated in the sense that to boot up a service you're going to implement a particular interface with lifecycle management methods on it, and you're going to absolutely hook it up to a service discovery system and it's going to interact with a service discovery system, and you're absolutely going to have this control plane that exists and allows you to query the health of services, and that's gonna be backed by this particular open source component, which you can swap out if you want... But you need something in that place, you need something doing that work. So it's more opinionated, and as I see it, it's kind of this universe of things.
+
+Go Kit, in contrast, is coming from the angle of "You already have in your organization an infrastructure, and you've already chosen what you're gonna use for service discovery." Or maybe you're not using anything for service discovery; maybe you're doing it completely manually. Similarly with your transport layer - maybe you're not using gRPC, maybe you've already standardized on Thrift, and that's not a decision that you can change lightly. And Go Kit is going to basically allow you to bring Go into this heterogeneous infrastructure and allow you to write Go microservices that interact with these components that already exist. So it's a much more conciliatory approach, it's much more like playing nicely with others approach, and it's much more focused on the software architecture of the service itself. It has much looser opinions about how it interacts with the environment. I think covering a lot of the same grounds, but just with different approaches. Does that make sense at all?
+
+**Erik St. Martin:** I think it does perfectly. That's kind of where my view has always been with... You know, Micro is kind of the "Here's your whole layout, here's how you do everything", and Go Kit is more of a framework that allows you to make decisions, but "Here's some paradigms and ways that are known to work well together", and you can kind of pick and choose.
+
+**Peter Bourgon:** \[59:56\] Exactly. And here's integrations with these common components, common service discovery systems, common instrumentation systems. Whenever I give talks about Go Kit I say, "Fundamentally, it's about leveling up software engineering, and leveling up the way you build microservices, like code cleanliness, separation of concerns, exclusion principles, inward-facing dependencies, clean architecture...", it's about all these software engineering principles applied and writ large. It's a lot less about enforcing opinions in the architecture or infrastructural sense.
+
+**Scott Mansfield:** That's quite a tall order.
+
+**Peter Bourgon:** How do you mean?
+
+**Scott Mansfield:** It takes plenty of time for an organization to adopt all those things. I guess being somewhat modular would allow them to do that, but having all of that all in one go is quite a lot to learn for people who don't have that deeply ingrained.
+
+**Peter Bourgon:** "Having all of that" meaning all of these software engineering principles, or all these components?
+
+**Scott Mansfield:** All the software engineering principles that you just named; that's quite a lot for people to absorb if they're not already doing a lot of those things.
+
+**Peter Bourgon:** Oh, for sure. And for that reason, I view Go Kit as more than anything else a sort of educational enterprise where hopefully you can kind of start easy, start simple... There's one big hurdle at the beginning, but then you can see okay, once you get over that, where all the other pieces line up.
+
+**Erik St. Martin:** I think that's kind of the fun part too, that it's almost like a recipe book. You come in here and you're like, "Okay, I think the first thing we need to do is solve service discovery", and then there's a list of things that are known to work well together. It's like, "Okay, let's take on the service discovery aspect. Now, okay, we have all these services and they're communicating with each other, but how do we do distributed tracing? Okay, let's adopt that now. Well, what about distributed logging?" and you can kind of pick these things as projects. Adopting all of it at once is gonna be a no-go for any large organization; that's too much risk at one time, so being able to pick these things out one at a time has its benefit... Whereas your newer grassroots efforts - those types of projects that are popping up have a lot more freedom and flexibility to kind of just adopt as much as they want in one go, because it's a whole new effort.
+
+**Peter Bourgon:** Yeah, totally. And if you're a two or three-man shop and you're starting fresh on brand new infrastructure, maybe Go Kit is a bit too much of an initial hurdle. Maybe there's too much there, and maybe you get a lot more productivity by starting with something like Go Micro where a lot of the decisions are already kind of laid out for you. I think that's totally viable.
+
+**Erik St. Martin:** The other thing I wanna point out just looking through the list of all the things that are available in Go Kit (the list of components) is four years ago we were writing almost all of our Go code from scratch, and now nobody's implementing new service discovery mechanisms really, right? Those things already exist.
+
+**Peter Bourgon:** I hope not.
+
+**Erik St. Martin:** It's just crazy to think that stuff - that things that four years ago everybody had to build for themselves, we just don't even worry about it anymore. When you see somebody build it for themselves, you're like "But why?!"
+
+**Carlisia Thompson:** Peter, give us some insights here as far as interoperation between Go Kit and other things, or self-written code. Can you use Go Kit logging together with Micro, or together with my own code, or just metrics? Is it possible?
+
+**Peter Bourgon:** \[01:03:46.09\] Yeah, totally. In Go Kit there's a bunch of packages, and I would broadly say there's two types of packages - there's ones that you can use completely independent of anything else, that you can drop into your existing codebase with no other changes and just reap the benefits of that particular package. So logging is a great example. Chris Hines who was an early contributor and who basically should take all the credit for everything good in logging - we worked together and he drove the creation of this unified logging interface, which I think is really wonderful to use; it's structured logging. We are strongly opinionated that structured logging is the way you should do logging in this sort of environment. And a bunch of supporting infrastructure around it. So you can use that package completely independently. I'm biased, but you should. You should definitely look into using that.
+
+Same thing with metrics, for example. The instrumentation package defines a set of common interfaces that are broadly applicable, and implementations that connect it to (I think the latest count was) 8 or 9 common metric and instrumentation systems, Prometheus being chief among them, in my view. So this type of stuff you can use right away.
+
+There's other packages that sort of rely on your microservice being structured in a particular way, using the endpoint abstraction and the transport abstraction. This requires a bit more buy-in, that's kind of the hurdle I was talking about. But if you jump over that hurdle, if you buy into these abstractions that I've laid out, then you get to leverage things like distributed tracing, with integrations with Zipkin, and Appdash, and the LightStep ecosystem, and OpenTracing and all this stuff. You get to leverage circuit breakers and rate limitors and a number of other packages in there, service discovery as well. So that's the split as I describe it.
+
+**Carlisia Thompson:** Yeah, I was trying to figure that out, where the boundaries were for each of the things.
+
+**Peter Bourgon:** Yeah, and I could probably do a much better job of giving introductory, on-ramp style documentation on the website. Right now I've been so focused on the advanced use cases I've kind of let that atrophy a little bit... So I'll put that in my queue.
+
+**Carlisia Thompson:** Cool.
+
+**Erik St. Martin:** I think that we are basically out of time, but did anybody wanna talk about JBD's new tool before we roll this thing out? Because that's freaking cool, the gops tool. I wonder how it's supposed to be pronounced...
+
+**Carlisia Thompson:** Yeah, I was wondering...
+
+**Erik St. Martin:** I think it's gops.
+
+**Carlisia Thompson:** I would say gops.
+
+**Erik St. Martin:** It's this really cool debug tool for Go processes on your machine. You can run gops stack and pass it the PID of a Go process and you can actually see the current stack and you can get GC information and memory statistics from a running Go process.
+
+**Peter Bourgon:** Yeah, it's something I haven't been able to use in anger yet, but I'm super excited about the potential here. Because we all know Go processes are really introspectable in theory, but I can't be the only one when looking at something in a staging environment, for example, and having to remember how to piece together the call graph from whatever endpoints happen to be exposed. The idea of a single, unified introspection tool or interface to an arbitrary process is really exciting to me, and I'm really keen to take it to a limit at some point.
+
+**Erik St. Martin:** Yeah, that's kind of the fun thing about having a runtime, is that all this stuff exists in there, you just kind of have to poke at it. I've only used this from poking and prodding things that are running just out of sheer curiosity and playing, but again, I look forward to trying that where I actually have a use case for it, or in the middle of debugging. I don't wanna have to take down the process, I just wanna prod it.
+I think Scott disappeared on us. Where have you been at, Scott?
+
+**Scott Mansfield:** \[01:07:54.23\] No, I'm still here. I was actually looking at the code while you were talking; it looks like you have to install an agent in the processes that you wanna introspect, so that it will open this UNIX socket in the temp directory, so that the gops program can actually go inspect things by talking over that socket. So it doesn't seem like it's built in quite as much...
+
+**Peter Bourgon:** Oh, interesting.
+
+**Erik St. Martin:** Yeah, we should definitely clarify that. It's not that you can take any running Go process and do that. It works similar to the way you can expose the runtime stats over HTTP, there is kind of a library for it... But this adds more functionality than just exporting the -- how's that package pronounced? expvar, Yeah, you look at these things and you're like... So when somebody named this, how did they pronounce it?
+
+**Scott Mansfield:** Pronunciation just wasn't important at the time.
+
+**Erik St. Martin:** It's like, I have two words, how do I make it one word? Here we go, expvar, I love hearing people's pronunciations of stuff. Peter, you use Kubernetes, do you call it KubeCuttle (Kubectl)?
+
+**Peter Bourgon:** KubeCuttle, yeah, sure.
+
+**Erik St. Martin:** Yeah, I don't do that. It's KubeControl or Kubectl. I've never called it KubeCuttle, but people call it that all the time.
+
+**Peter Bourgon:** I like Kubectl, too. But I like KubeCuttle because it's like a Cthulhu angle to it, which is generally how I feel when I'm programming.
+
+**Erik St. Martin:** So does that work for systemd too, it's systemcuttle, and EtcdCuttle?
+
+**Peter Bourgon:** Yeah, exactly.
+
+**Erik St. Martin:** Does it make you feel better that you're trying to diagnose something, "I'm just gonna cuttle it?" \[laughs\]
+
+**Peter Bourgon:** Well, like maps, it feels coherent to me. When I cuttle, I think like the squid, like Cthulhu coming to devour the world. And typically, when I'm debugging something, I feel like my mind is being devoured by all the bad decisions I've made that lead me up to that point. So it lines up, it's what I'm saying.
+
+**Erik St. Martin:** \[laughs\] Oh... Did anybody have any other interesting projects or news they wanted to go over before we wrap the show up?
+
+**Carlisia Thompson:** Do we have time?
+
+**Erik St. Martin:** Yeah, I mean... I don't have anywhere to be.
+
+**Carlisia Thompson:** I wanna give a shout out to GothamGo and everybody that's in New York City this weekend. I hope everybody has a great time.
+
+**Erik St. Martin:** Yes... I wish I could be there. I'm traveling too much, though. Are you going, Scott or Peter?
+
+**Scott Mansfield:** No. I've been to way too many conferences recently. I need to actually get some work done.
+
+**Peter Bourgon:** Same.
+
+**Carlisia Thompson:** Same here.
+
+**Erik St. Martin:** That's basically where I'm at. I just got back from a conference.
+
+**Carlisia Thompson:** Apparently, I have a few things to go through, but somebody cut me off and there is no time. There is the Go Font - the Go Team came up with this new font that's meant for Go code. It's on the blog, there's a blog post about it, and it shows how the font looks like. It seems okay to me.
+
+**Erik St. Martin:** Oh, interesting.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Yeah, I hadn't seen this.
+
+**Carlisia Thompson:** It seems a bit... When I look at it, it feels to me antiquated, but...
+
+**Erik St. Martin:** It's hard though, because I've never been a font zealot. There's people who are really big into fonts, and they can look at this font and be like, "Oh, that's this style", when I've just never... It's either easy on the eyes or it's not. That's as far as my font knowledge goes.
+
+**Carlisia Thompson:** What did you think, Peter and Scott? I'm curious.
+
+**Peter Bourgon:** Scott, do you wanna go first?
+
+**Scott Mansfield:** Sure. I didn't really spend a whole lot of time looking at it. I mean, it's like trying to get somebody to change their religion, practically; if you want me to change the font on my editor, you'd better have a good reason. Or we can go to war. But it's the same idea for me; I don't have any reason even to try and adopt it. I think that the font that I use right now is fine. I've been using it for years and I don't feel like that font is actually more readable for me, so... That's where I am.
+
+**Carlisia Thompson:** \[01:12:07.23\] How about you, Peter?
+
+**Peter Bourgon:** I guess I would classify myself as an amateur font person. I know about serifs and kerning and x-heights and all that stuff, and I actually ran the font by one of my semi-professional typeface nerds, and unfortunately there's a lot wrong with it. The kerning is pretty bad, the differentiation in the weights is pretty bad... I mean, I don't wanna dump on somebody's work or anything, but it's not a good font. It's not great.
+
+**Erik St. Martin:** I'd love to see somebody explain that, because that's the hard thing... Visually to me it's either appealing or it's not, and I'd love to see why, and actually get a breakdown. Our nerd brains work that way - "Okay, this is bad, but why?"
+
+**Peter Bourgon:** Yeah, maybe offline we can look into that.
+
+**Carlisia Thompson:** Yeah, and maybe it's good for some people and bad for others. It's a matter of taste. Somebody had the taste to come up with it, and I saw a lot of people resonating with it and liking it. I'm a font illiterate, I don't know type, so when I look at it I might get reactions that don't do much for me, but I like the idea.
+
+**Erik St. Martin:** It's hard for me, because if I change my font to anything else, I feel like I might as well just writing in a different language... Like, "What are these weird characters?" \[laughs\] It's hard to get your eyes to adjust when you stare at code so much if it's even slightly different.
+
+**Carlisia Thompson:** Yeah, it has a great impact when you change anything. That's why it's so horrible when you interview and you have to code on somebody else's computer, or a no-line editor... I totally get lost. It's like I don't even know what's happening. It's not my editor, I can't function.
+
+**Erik St. Martin:** And it doesn't have to be very far off too, to feel that out of your element; one hotkey you're expecting doesn't work and you're like, "I'm ruined. I can't code." \[laughter\]
+
+**Carlisia Thompson:** We're very fragile creatures. \[laughter\]
+
+**Erik St. Martin:** For all the adoption of new technology that we like, we're still very stuck in our ways.
+
+**Carlisia Thompson:** But I think that has a lot to do with it. There's so much change around us; we need to have a core that's fixed.
+
+**Erik St. Martin:** That's our safety blanket.
+
+**Carlisia Thompson:** Change everything, but don't change my environment, don't change my editor.
+
+**Erik St. Martin:** Yeah, that's true. I mean, I'm using the same editor I've been using for (I don't even know) 10-15 years, something like that.
+
+**Carlisia Thompson:** Wow.
+
+**Erik St. Martin:** I just can't... I can't cut the cord. I see new editors and I'm like, "Well, that looks cool", and I just can't cut the cord. I feel like, "I gotta get work done, I can't afford to try to learn a new editor."
+
+So do we have anything else, or we wanna move into \#FreeSoftwareFriday?
+
+**Carlisia Thompson:** Peter, do you have any interesting projects or news to mention?
+
+**Peter Bourgon:** I don't have any projects, but I kind of wanna exploit your audience for this thing that's been bouncing around in my head a little bit lately. Can I do that, or is that totally not appropriate?
+
+**Erik St. Martin:** Yeah!
+
+**Carlisia Thompson:** Please.
+
+**Peter Bourgon:** We all know Prometheus, right?
+
+**Carlisia Thompson:** Oh yeah!
+
+**Erik St. Martin:** Yes!
+
+**Peter Bourgon:** ...this instrumentation and monitoring service. Among its many benefits, I think one of the greatest things for me is that it's so operationally simple. You just run the binary, it's great for jobs, there's no cluster, there's no distributed file system... It just kind of does what it says on the tin. When I give the microservice workshop I say, "You should definitely be using Prometheus, because it's so great", but then people ask me, "What should I be using for logs?", and as far as I know, there is a really good answer for this. I mean, most people say it it's ELK Stack - the Elasticsearch, Logstash, Kibana Stack (or I guess it's called the Elastic Stack now).
+
+\[01:15:52.09\] But if you ever tried to operate an Elasticsearch cluster, you know it's not easy. In fact, it's notoriously difficult. So I'm wondering what a Prometheus for logs would look like - architecturally, operationally - and if maybe there's already a product out there that I just don't know about... I mean, I've done a lot of research, maybe there's something that exists. I would love to have people ping me maybe on Twitter with their ideas.
+
+**Carlisia Thompson:** That's interesting. What about Go Kit Log?
+
+**Peter Bourgon:** Go Kit Log is about how you manage logging within your process, within the service itself. What I'm curious about is once the log information leaves the process boundary, like on STDOUT, say, how do you get that into a system that is searchable and usable, operationally simply, and without having to deal with Elasticsearch, effectively?
+
+**Carlisia Thompson:** Okay, so are you talking about what Prometheus is for metrics, you're talking about that for logging?
+
+**Peter Bourgon:** Yeah, something like that, at a very high level.
+
+**Erik St. Martin:** Have you looked at things like Logstash, or...?
+
+**Peter Bourgon:** Yeah, Logstash is like a FluentD thing where it's pushing logs around, but it's not actually doing any storing or querying.
+
+**Erik St. Martin:** Okay, so you wanna address this from the... There's lots of stuff out there for doing metrics and alerting and things like that; you want something that's designed specifically for logs storage. Like, if we had to rethink distributed log transfer and storage and querying today, what would that look like? Not an implementation built on something that exists, but a completely new effort - what would that look like?
+
+**Peter Bourgon:** Exactly. And maybe there's already software that's purpose-built for exactly what I'm thinking and I can just use it. If so, that's great, I'd love to know about it. But I don't.
+
+**Carlisia Thompson:** But you're talking about in Go, right? Or just in general.
+
+**Peter Bourgon:** Well, in general would be fine. The only thing in the space that I'm aware of that serves this need is Elasticsearch and it's too operationally tricky, and some other reasons I won't get into. I'm not a big fan of it for this use case, but yeah... Maybe something in Go, that would be great.
+
+**Erik St. Martin:** Now, Scott has a different opinion on log storage. Netflix doesn't do a lot of the distributed logs. Do you wanna speak to that a little bit, Scott?
+
+**Scott Mansfield:** So I would probably need to clarify that... We do have a massive logging system; we generate a ton of logs, but I don't... So as a company - it's the same old joke: we're a logging system with side effect of streaming video, and there's a massive Kafka cluster that's the ingest for this, and I believe that it has some processing after that and goes into...
+
+**Peter Bourgon:** ...HTFS, I imagine.
+
+**Scott Mansfield:** Yeah, but my view is... I tend to try not to rely on logs, I just keep metrics around. Everything that I could possibly want to introspect.
+
+**Peter Bourgon:** Totally.
+
+**Scott Mansfield:** ...and if there's some specific thing... It's like bucketize all unknown errors, then yeah, we'll start logging something. But at that point there's no performance hit because I'm gonna close the connection anyway. So yeah... That's my little speech.
+
+**Erik St. Martin:** It's difficult when you get at scale; you can't log into the servers and check the logs anymore. You kind of have, like you said, metrics, and then you have the log messages that you wanna be alerted on, so there's these different reasons you want logs. You want to diagnose a distributed -- trace basically a request through the system and see what happened for that. You want kind of generic, aggregate summaries of things that are going on in the health of your system, which metrics solve, and you want alerts, so that when particular things happen you can be notified of them.
+
+I think that solves most of the use cases for at-scale logging, because I think it gets too hard... Can anybody think of any other use cases that a system like this would need to solve?
+
+**Peter Bourgon:** \[01:20:00.27\] I mean, certainly... I cut the logging domain into two parts: one is your typical debug info warn application logging, where you might need this kind of deep introspection in order to debug certain issues. But you don't need a high quality of service; you can drop some of those log messages and it's not gonna be the end of the world. But then there's this other thing, I call audit logging - maybe it has a different name in a different context - where it's like, if you're running Netflix you wanna see... Or let's say you're running a bank - you wanna see every time somebody makes a deposit or a credit. This stuff is critical to your business; you need durable, reliable logs of all of these transactions, and that probably needs to end up somewhere reliably.
+
+Both of these things is sort of what I'm considering, although they are drastically different QoS guarantees.
+
+**Carlisia Thompson:** Well, let's talk about structured versus unstructured logging... Nah, I'm kidding. \[laughter\] That's a whole show right there.
+
+**Erik St. Martin:** The gloves come off... \[laughter\] So we wanna move on to \#FreeSoftwareFriday? In case we didn't tell you, Peter...
+
+**Peter Bourgon:** Uh-oh...
+
+**Erik St. Martin:** To your point early on, that you don't really hear from people when all is going well - we try to (in every episode) kind of just throw out a project and thank them. It does not have to be written in Go. It can be a person, group, or project, and just kind of thank them for providing stuff that makes our lives easier. If you can't think of anything, you don't have to, but we'll put you as last, that way you have time to think of something.
+
+**Peter Bourgon:** Great, thanks.
+
+**Erik St. Martin:** Alright, Carlisia, do you wanna go first?
+
+**Carlisia Thompson:** No, I don't have anything today.
+
+**Erik St. Martin:** How about you, Scott?
+
+**Scott Mansfield:** Sure... Last week I went to QCon in San Francisco, which is a really amazing conference, actually... It was really high-quality. And I went to one talk on Twitter's caching system, which naturally I was interested in, because I work on the Netflix caching system. They have written their own C-based cache called Pelikan, that basically speaks Memcached, but is entirely different on the inside. This talk that they gave was all about all these different things that can go wrong, which inform the design of this new cache. Their Pelikan cache is actually open source. We'll put the link in the show notes, but I can paste it in Slack now.
+
+There's all kinds of things... They use a static size hash table because they used to see these latency spikes at exponentially increasing intervals, which happened to correspond with hash table extension, and a variety of things like that. The talk was really cool... Unfortunately, QCon talks take a while to come out, so it probably won't be around for a while, but the project itself is really cool.
+
+**Erik St. Martin:** Oh, cool. So it was recorded? It will be out eventually?
+
+**Scott Mansfield:** Eventually... I don't know when, unfortunately. I have access to the videos because I attended, but...
+
+**Erik St. Martin:** Oh, brag about it. \[laughter\] So to give you a little more time, Peter, I'll go next. So I have not used this, I'll preface it with this - I have not used this yet, but I was at KubeCon last week and I was talking to the CoreOS guys, and they have a really cool project called Zetcd. It's basically a bridge between ZooKeeper wire compatible and Etcd. If you use things that are backed by ZooKeeper, like Kafka and things like that, you could actually wire this thing up in between and have it talk to Etcd instead. I thought that that was ridiculously cool, because I've never been fond of managing ZooKeeper clusters. I will drop that in the channel too for anybody who's listening live.
+
+Alright, Peter, do you have anything? Feel free to say no.
+
+**Peter Bourgon:** \[01:24:03.21\] No, I've got one. It's a small thing, because sometimes the small things are the best things... I was using grep for most of my life until I stumbled over this program called ack, which was a bit more usable version of grep. And I was using that for a long time until I stumbled over this thing called The Platinum Searcher. It turns out there's a Go implementation of it, which I've been using for the past couple of months with a lot of success. So I'll also drop a link into the Slack for that one...
+
+You can install it, and it installs this pt, and you can use it like a grep, except you don't have to do weird contortions with -r, and grep like you expect it should work. It's super, super fast.
+
+**Carlisia Thompson:** I'm glad you've mentioned that because Dave Cheney mentioned it, and I was like "I'm gonna install it immediately", and I never did. But now I'm gonna install it immediately. \[laughs\]
+
+**Erik St. Martin:** I'm in the same boat. I used the Silver Searcher for many years now, and it still installed, and people keep reminding me of The Platinum Searcher, and I'm like "I'm gonna use that", and then I go along my way and continue to build stuff and I forget all about it. So now it's gonna live in my sea of tabs until either my computer shuts down and I lose the tab, or I actually install it.
+
+Alright, so I think with that we are out of time, and I definitely wanna thank everybody on the panel. Thank you, Scott, for stepping in, and thank you, Peter, for coming on the show. Thanks to everybody who's listening now, and who will be listening to us when the recording is released.
+Huge thank you to our sponsors, Minio and Backtrace. Definitely share the show with your friends, family, colleagues... We are @GoTimeFM on Twitter, GoTime.FM - you can go there to subscribe, and if you want to be on the show or have ideas for the show, or just questions of the hosts or guests, hit us up on github.com/gotimefm/ping. With that, goodbye everybody, we'll see you next week.
+
+**Carlisia Thompson:** This was fun, bye! Thanks, Peter.
+
+**Peter Bourgon:** Bye guys. I had a hacking good time, thanks everyone!
+
+**Erik St. Martin:** Hacking good time... \[laughter\]

Go and Data Science_transcript.txt

@@ -0,0 +1,317 @@
+**Erik St. Martin:** It's Go Time! A weekly podcast where we discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+Welcome back for another episode of Go Time. This is episode number four. Today we'll be talking about Gopher data science and other interesting news and projects we've come across this week. I'm Erik St. Martin and with me is always our other amazing hosts, Brian Ketelsen - say hello, Brian.
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** And also Carlisia Campos. Say hello, Carlisia.
+
+**Carlisia Thompson:** Glad to be here, hi!
+
+**Erik St. Martin:** And for anybody who's already listening, today we're joined by Daniel Whitenack, who is very vested in Gopher data science. He's also going to be speaking at GopherCon this year about it. How are you, Daniel?
+
+**Daniel Whitenack:** Good, good to be here.
+
+**Erik St. Martin:** So let's kick this episode off by talking about anything we've kind of run across this weeks in news and just random articles and things. What's everybody got?
+
+**Brian Ketelsen:** The biggest thing this week is the feature freeze for Go 1.7. It was announced on the Golang-nuts and Golang-dev mailing list. There's a lot of changes in this, with the SSA and compiler changes, so everybody out there needs to download Go 1.7 and compile it, test your programs, because this is a really big change, and there's opportunity for breakage. Of course, our tests cover everything, but it's a big place for us. Compiler speeds are down, down-down-down.
+
+**Carlisia Thompson:** I saw something about binaries. Is it vendoring binaries? I didn't have a chance to investigate, I was super-interested. Does anybody know?
+
+**Daniel Whitenack:** Yeah, I think it was binary-only packages, without providing the source.
+
+**Brian Ketelsen:** Exactly, so you can get a binary on your package now.
+
+**Carlisia Thompson:** So you can do it both ways?
+
+**Brian Ketelsen:** Correct. If you want to release a precompiled package that was only a binary with no source, you could do that by giving somebody a URL to a go get, or to use go get.
+
+**Carlisia Thompson:** Oh, I see what you're saying, gotcha.
+
+**Erik St. Martin:** Yeah, so kind of more along the lines of like the commercial packages and libraries that you can buy, say, for the Windows side of the world.
+
+**Carlisia Thompson:** So then if I'm using your package as a binary, I can pop it in my projects and use it as a binary?
+
+**Brian Ketelsen:** I don't know if it applies to precompiled libraries. I think it was only commands, but it would be interesting to see if it actually applied to the library files, the A files.
+
+**Erik St. Martin:** I have to look more into that. I briefly saw something about that, and I kind of breezed over it, I've been really busy this week. But there's something like 300 closed tickets for that release.
+
+**Daniel Whitenack:** Exciting. I'm excited for the compile times.
+
+**Erik St. Martin:** Yeah, me too. I can wait to get back to 1.4 speeds.
+
+**Brian Ketelsen:** We're getting closer. It's still slower that 1.4, but we've regained a lot of that lost territory, and that makes everybody happy.
+
+**Erik St. Martin:** The other interesting thing that I saw this week too was Brad and Andrew's live coding sessions. Did you guys see that? Where they're putting out a callout for people who want live code reviews.
+
+**Brian Ketelsen:** That's frightening.
+
+**Carlisia Thompson:** I didn't see that, but that sounds great.
+
+**Daniel Whitenack:** I didn't see it either, but I would love to participate in that.
+
+**Carlisia Thompson:** I've seen them doing it in the past, and it's great.
+
+**Brian Ketelsen:** I don't know... If you didn't have impostor syndrome before, imagine Brad and Andrew tearing up your code. They're both great guys, so don't get me wrong, but that is a tough crowd to please.
+
+**Erik St. Martin:** I don't know, I think that it would just make my own thoughts of myself come to light. I'd be like, "I knew it. See?" \[laughter\]
+
+**Brian Ketelsen:** I knew I was a terrible coder. Yeah... GoTimeFM, where we talk about our impostor syndrome for an hour. \[laughter\] There's another big news item this week, and that was Peter Bourgon's article, his update of his Go Best Practices talk from 2014. He updated that to 2016, and there's a lot of really good takeaways in there; I don't think we have time on the show to cover them all, but some really good tips in there about dependency management, about testing, how to structure your library, what to name your packages - you name it, it's covered really nicely in there. Like I said on Twitter, I think this is really a cannon. Every Go developer should read this and try to internalize all of these rules, because they're really good stuff.
+
+**Daniel Whitenack:** Yeah, I think it's gonna take a while for me to unpack, but I think it's one of those things... You know, I have a bookmark that I'm gonna visit every week, and as I'm implementing different things, I think referencing that and just seeing if I'm doing things in a sane way is gonna be great.
+
+**Erik St. Martin:** I think that that talk was a favorite, still to this day, from GopherCon 2014. People really loved that talk, so it's fun to see him go back and kind of reflect on his thoughts and to shoot down the things that he thought were the way. Although I don't know whether he fully dismissed any of the concepts that he presented in 2014. I think he got a little looser on his beliefs on a couple of things, and then a couple of added new ones. I need to read through it again. And like you said, Daniel, it's like that - you read it one time and you're like "What did I just read?" You kind of have to keep going back to it.
+
+**Brian Ketelsen:** Yeah, something this big takes a long time to internalize all of it. I would love to take this article, mix it with Dave Cheney's error-handling article from a week or two ago, and just put it under my pillow and sleep on it every night, hoping that I could absorb all of that at once. That's be great.
+
+**Carlisia Thompson:** I'm holding myself back, as I don't wanna be such a big fan girl, but for people new to the community and to Go, Peter is definitely somebody to absorb. I would say Peter and Dave Cheney are at the top of my list as far as best practices and things I think are best to follow.
+
+**Daniel Whitenack:** Yeah, I would agree, and I think coming into Go not too long ago, of course you search around different Stack Overflow responses and whatever, and you can really get a mixed bag of ideas about - like Erik said - about error handling or what have you. But going to these resources, I found, gives some clarity on that mixed bag that you find across the interweb.
+
+**Erik St. Martin:** I'm interested to see some more best practices too, just to kind of compare and contrast, because I think people have different success stories with different things, and especially when it comes to vendoring, that can be a hot topic. We could probably talk for a full episode about vendoring.
+
+**Brian Ketelsen:** I think we could have an entire GopherCon on vendoring, and still not get any consensus from anybody. \[laughter\]
+
+**Carlisia Thompson:** Who needs consensus?
+
+**Brian Ketelsen:** Nobody needs consensus, good point.
+
+**Erik St. Martin:** Alright, moving on - interesting Go projects. And speaking on sleeping and downloading information, Brian, with your nightly download of cool projects.
+
+**Brian Ketelsen:** Here's one that I saw a couple weeks ago and I wasn't too sure about it, because I didn't see all of the code there. This one's called GAFKA, and it's a suite of Go tools for managing KAFKA clusters. It's at github.com/funkygao/GAFKA and it looks really complete. It looks really complete now. Very interesting if you manage KAFKA, which a lot of people do, and it's got a lot of nice little Go commands and Go tools for working with your cluster, things that will save you from the ugly mounting of Java shell scripts that you have to do generally when you're messing with KAFKA.
+
+**Erik St. Martin:** This is just helpers for administering and kind of... That world for KAFKA? Or for places as Sarama and some of those client libraries?
+
+**Brian Ketelsen:** I didn't see any client libraries in there, this is only a suite of tools for managing the cluster, looking at consumer groups, that sort of thing. I wanna say there are at least a dozen different utilities in there for dealing with your cluster.
+
+**Erik St. Martin:** And Daniel, I imagine you're quite versed in KAFKA, coming from the data science world?
+
+**Daniel Whitenack:** Yeah, we use KAFKA in production and I think with this I might be able to give those Java scholar guys that run for their mommy... I also like the part of it about admitting health info to InfluxDB; that's something I can imagine being super useful on my end.
+
+**Erik St. Martin:** Alright, what else have we got?
+
+**Carlisia Thompson:** Well, I've run into this concept of ChatOps this past week, from two different places. One was the Remote Meetup group, they had somebody come in and do a talk about ChatOps, and they did it using GitHub Hubot. He did a marvelous job. He said what it was, he demonstrated it, he did a demo, he explained how you can use it... It was fantastic. And I've never worked in a place that was using it, I don't even know if this is super new. I know the concept of chat bots is not, but the concept of having chat ops right there where you are doing your communication...
+
+And then I also came across this microlibrary which is a Go library. It's a Micro services kit or a library, and it has capabilities for chat bots. They have a blog post, and we'll have a link to it - they say chat ops bots should be a first-class citizen. I think that's great. I work on the command line a lot and I love it, but I also love the concept of bringing operations into the place where you are communicating with people, and also all the extra capabilities that you can get from these new modern tools. You have to watch the Remote Meetup video to see what I'm talking about. I can't thoroughly describe it; I've worked with this, and it's at the tip of my tongue here to describe. I was just fascinated, and I definitely would love to work using this tool, so there it is.
+
+**Daniel Whitenack:** Yeah, and I think part of what I see that's appealing is kind of moving away from being in Slack and always copy-pasting screenshots of my terminal into the Slack channel, but rather executing the command via the chat bot and kind of having a human understandable version of what I'm doing, and enter right into the conversation so everybody is on the same page and doesn't have to wonder where I executed that and what my environment is and why it looks weird - getting over that hurdle.
+
+**Erik St. Martin:** It's hard though, because I used to love the chat ops stuff, and then I've been kind of pulled more and more away from it because I try not to look in the chat channels nearly as often as I used to, because it gets really distracting. You kind of see your notification, you look in there, and it's like "Oh, it's just somebody deploying something..."
+
+**Carlisia Thompson:** Yeah, exactly. I'm glad you brought that up, because I wanted to mention it and I forgot - what I saw on this video was not at all notifications. Because yeah, we get notifications, we get these hiccups to get there. This was more about having the extra features. For example, querying something and getting the response from different services across your services; it's more like you're in command and you query, and you're asking for information. And maybe somebody else is there as well, and you can share the information, as opposed to being just a passive consumer, just like being dumped information. I thought that was extremely cool.
+
+**Brian Ketelsen:** Yeah, I think from a framework perspective, Micro is probably the most interesting thing in the Go world that's come out in 2016.
+
+**Erik St. Martin:** That's bold.
+
+**Brian Ketelsen:** It is bold, but I called Rails, I called Go, I called Docker - you're gonna have to trust me on this one. Micro is big. And it's big because it offers a much broader view of Micro services. It's not just a set of tools to help you make Micro services, it's a whole ecosystem. And I think that's important, because making Micro services on their own is not as important as deploying and managing, operating, and consuming those Micro services. So having that big framework, that whole ecosystem of tools I think will make Micro services more accessible to everyone, and certainly more manageable. The ChatOps is a great side of it, but it just goes to show the power of Go's interfaces, because it's the same interface that you can use to interact with it by protobuf or by a web page. You can take the same Micro service in the Micro framework and interact with it from the command line, you can interact with it from a web page, you can interact with it from Slack, and it's all using that same interface. I think there's a lot of power behind this, and you need to star it in GitHub, because this one's going places. And he's hiring, I saw a tweet this morning - Asim Aslam is the guy who's running Micro right now, and he's looking for people.
+
+**Erik St. Martin:** Awesome, I'm interested to see what comes out with it.
+
+One thing that I came across this week was a project called UNIK, which is spelled interesting; that wouldn't be the first way I'd think to spell it. One of the things I know that at least Brian and I have discussed before was this whole motivation behind containerization and Micro services and things of that nature, was how long before unikernels started taking off. So one thing I came across was this project called UNIK, which allows you to compile your Go app, and it does Java and C and C++ as well, to compile it into a unikernel. So you got Micro on my mind here.
+
+**Brian Ketelsen:** Sorry. It's my fault.
+
+**Erik St. Martin:** So I'm interested what comes along there, what people do with it and how unikernels evolve.
+
+**Daniel Whitenack:** Do you guys have previous experience with unikernels in general?
+
+**Erik St. Martin:** Only in building some to play with for toy reasons, not so much as far as like production usage.
+
+**Carlisia Thompson:** I don't, at all.
+
+**Erik St. Martin:** Yeah, basically the notion of unikernel is it's just a really trimmed down kernel, a bootable program. When you look at your container, like PID 1 the process that starts up is your application, but you still have an operating system that bootstraps that particular process. And a unikernel is basically your app is the operating system. And I think they have some stuff tied in under the covers, but I'm no unikernel expert either, so I wouldn't take my word for it.
+
+**Daniel Whitenack:** Yeah, it's definitely an interesting concept and something that's been on my radar to play around with, but I haven't quite got there yet.
+
+**Brian Ketelsen:** I think the interesting thing for me is, from the security world, the most secure code is the code that isn't there, and the idea of a unikernel is that you take your app and only the pieces that you need to talk to the hardware and compile that down into something that feels like an operating system to run your app. So the attack surface of your application is significantly smaller because you don't have all of the extraneous stuff that comes in an Ubuntu distribution, for example. So you've only got the one port open because you're only listening on port 80. There's significantly smaller attack surface, and I think that's one of the main benefits of unikernels, at least in my mind.
+
+**Erik St. Martin:** So I think we have roughly 30 minutes left in the show, so let's get chatting with Daniel about data science.
+
+**Brian Ketelsen:** Oh, this is exciting. We've been twitching for weeks to talk about data science. This is big.
+
+**Daniel Whitenack:** Sweet, I'm excited.
+
+**Erik St. Martin:** Brian and I are on the analytics side of things. I mean, we've spent a good 4-5 years in this space working with analytics side and building software to support them.
+
+**Brian Ketelsen:** I'm the fringe. \[laughs\] You could call us data scientists; you could call us the programmers that enable data scientists. \[laughter\]
+
+**Erik St. Martin:** Or the interns
+
+**Brian Ketelsen:** That's right. Maybe you can start - for all of us, can you give us kind of a background? A primer? What is data science? Where does it fit? What are the things that are data science and what are the things that aren't data science?
+
+**Daniel Whitenack:** Yeah, I think that's definitely a good place to start, because depending on who you'll ask, you'll get very different answers. I think one useful differentiator that I like to keep in mind is what is \#datascience and what are people talking about when they say 'data science' on Twitter, and then what are data scientists, those employed as data scientists actually doing in the industry. So I think in the first case what people are talking about a lot are things like AlphaGo beating the Go Grandmaster... If you're not familiar, AlphaGo is a deep neural network trained by Google. They basically train these neural networks such that it could beat the grandmaster Go champion - Go being the boardgame, not the programming language. I think this is really amazing. This is a huge achievement and should be talked about a lot.
+
+On the other side of things, you look at what do most of the data scientists employed in the industry do? There was an interesting article recently in Forbes that actually pulled a bunch of data scientists and found out what they spend their time doing. Actually a lot of it, 90% of it was gathering data sets, collecting data sets, parsing data and extracting patterns from data. So about 90% of what data scientists do doesn't necessarily involve some nifty machine learning, but more of the process of moving data around, transforming it and extracting patterns to make it useful. Then that other last 10% could be various things. So a little sliver of that is doing kind of interesting machine learning techniques; maybe another sliver of that is making dashboards or visualizations, and then various other tasks. So I would say in general for me data science is the process of transforming data - wherever that might be - into insights for your business. Sometimes that might require a neural network, but pretty much always it requires some problem-solving and some ETL, and maybe some arithmetic. I think those are kind of the pillars of data science.
+
+**Brian Ketelsen:** I've got a question for you, and this is a little bit crass, so forgive me in advance. I read an article a couple of years ago, maybe two years ago, about how Target knows when your daughter's pregnant before you do.
+
+**Daniel Whitenack:** Yeah, my wife works for Target, and it's apparently true.
+
+**Brian Ketelsen:** Yeah, it scared the hell out of me, it really did. Because people buying just the things that you buy every day, it never occurred to me that they could take the patterns of things that I buy, compare them to other patterns and realize, "Hey, this guy's getting a divorce. This one's pregnant. These guys are having a baby next month." They can tell by that data what my life is. It's almost the metadata thing from the cell phone world, it's really scary. How much of data science is being pushed because of commerce, and how much of it is being pushed because of advertising? Where does that fit in the grand scheme of things? What's the real driver behind the advances in data science?
+
+**Daniel Whitenack:** Yeah, sure. I think if we look a little bit back over the years, there's been certain industries that have always been involved in data science in some sense. If we look at insurance companies or other companies like that that are interested in assessing risk of a person based on things that have happened to them, and other things like that. So that's been going on for a while, and then there was this time when people learned, "Oh, we can target certain types of people with advertising", so for a while there a lot of the data science job postings were advertising-related. Now I think it would be fair to say that data science - again, I'm calling data science this process of creating data-driven insights - is really permeating pretty much every level of businesses. A lot of data scientists now are working to inform even internal business people, not even necessarily to make a company more money directly; they might be concerned about intelligently monitoring outages in their infrastructure, right?
+
+Then it goes from that kind of lowest level all the way to the directly applicable processes to the money side of things, having to do with marketing, improving your ads and all of that. So I think from the very lowest level in the backend processes, all the way up to marketing yourselves to the outside world, I think you're seeing data science permeate all of that. I think the idea is really that data scientists now, when you're employed and you're coming into a company, the idea is not necessarily to say "I'm gonna come in and I'm gonna optimize ads" or "I'm gonna come in and I'm going to predict risk, predict fraud" or whatever it is. A lot of companies are building data science teams and even embedding data science teams across the organization to, say, "How do we make our processes at each level of our organization data-driven?"
+
+**Brian Ketelsen:** It's interesting that you mentioned the dev-op side of it. I didn't see the whole talk, but I saw the slides on a conference that happened a week or two ago, it escapes me which. I wanna say that company was one of the bigger companies, like Uber or Halo or something like that, and they were talking about how they use data science to reduce the false positives in their monitoring systems. They knew because of the cycles and the patterns of their monitoring, they could reduce the false positives, the pages, 90% of the time, and that cut down their duty calls while they were in the middle of an outage that wasn't really an outage by 90%. There's real cost savings, real benefits behind that.
+
+**Daniel Whitenack:** Yeah, exactly. So in that case you're really optimizing a lot around your business processes and your engineering processes. Yeah, so that's from Uber... That's their system, Argos, which is their alerting system, and actually on the backend of that, the time series database, they wrote internally in Go. I was at that talk and it was super impressive; I was kind of blown away by all the intelligence that they're putting into that learning, and really making some pretty astounding gains in reducing their false positives.
+
+**Brian Ketelsen:** Nice. Was there any open source component to that? Have they released any of that yet?
+
+**Daniel Whitenack:** As far as I know not. I mean, hopefully they will, given the trends we've been seeing lately. Hopefully at some point they're able to release the database or the frontend or whatever. Right now I think - at least the last I saw - most of it was still internal. But they did give a pretty good discussion of their logic around how they're modelling things and how they're hoping to keep improving the system over time. It's definitely an interesting talk to see. I'm not sure if the video is up online, I know the slides are.
+
+**Brian Ketelsen:** Alright, we'll put those in the show notes, for sure.
+
+**Erik St. Martin:** Let's talk for a moment about the tools of the trade - what are the current tools of the trade (languages and frameworks) and what do you see those being replaced with on the Go side? Because I know that's something we've chatted backchannel about that a bit in our excitement on watching some of these things evolve.
+
+**Daniel Whitenack:** Yeah, sure. So I would say even just like a year ago, if I was to go to some data science event, one of the big questions was "Should I learn R or should I learn Python?" These have traditionally been the big players in this space. There's a lot of great tools... I'm not as familiar on the R side, but I worked a lot in Python. On the Python side you've got this whole suite of numerical and data science type tools like Python Pandas and SciPy, NumPy, all of these things. That was kind of how things went for a while.
+
+Then recently, at that same conference where they discussed the Uber alerting stuff, I was seeing definitely much more of an attitude in the community about... Well, a question was posed, "What language should I learn?" and I think they were expecting to hear R or Python, but the answer that the speaker gave - who happened to be Josh Wills from Slack... He basically said, "Learn them all, because every week I use Python, I use JavaScript", and he mentioned Go as well. I think and I hope that the community is kind of opening up to see that each of these languages has unique capabilities and unique use cases, and the hope is that we don't kind of morph all of these languages together as all kind of doing the same thing, but we utilize them where they're particularly useful, and utilize their unique features. Then of course there's a whole suite of tools around "big data technologies", like Apache Spark and Hadoop. These are mostly kind of Java Scala applications. But even then, a year ago or something, there was a lot on that side of things, there was Java Scala, and now you're seeing a kind of broader range. There's things like looking at InfluxDB or the time series database that Uber worked on, or even things like Pachyderm, which is an interesting project - these are big data frameworks that are not Java Scala based, and utilizing technologies like Go and Docker. So I think there is a shift going on right now in the community; I don't know if you guys have seen any of that as well.
+
+**Brian Ketelsen:** I think Pachyderm is probably one of the more interesting things I've seen in a while, because it almost takes that "You can do everything on your laptop" philosophy with awk and sed and moves it into the Docker world. So instead of piping UNIX commands together, you're just piping Docker containers together, and that makes an interesting big data workflow, especially when you add something like Mesos or Kubernetes into the mix, where you've got large orchestrations of big data things happening. It sounds really interesting.
+
+**Erik St. Martin:** Yeah, I've seen a few projects over the years where people have started trying to do text parsing and some probabilistic stuff in Go... But what was that project we ran across...? We were kind of researching the show and it was just astonishing how big that page was.
+
+**Carlisia Thompson:** Oh, yeah...
+
+**Brian Ketelsen:** Oh, I know what you're talking about - the golang data library page. It's at mjhall.org/golang-data-science-libraries. It's a huge page full of data science libraries in Go and we all just kind of stopped and said, "Wow! There's 500 links on this page." I was thinking there were two or three data libraries for Go, but no, there's a lot.
+
+**Daniel Whitenack:** Yeah, and something I've seen is... Even still you talk to a lot of data people and they talk about Python or R, and you hear about people working in those languages, but the newer companies that I've interacted with or contracted with, they are adopting Go and other modern languages more readily, and they're not abandoning that strategy for data science; they're also using those languages for data science. Maybe no one's kind of rallying around a certain small subset of tools like they are in Python. Pretty much the data science community has rallied around Pandas and SciPy and NumPy and these other tools. Maybe that hasn't gone on in Go yet, but there are, like you said - if you look into it, there are a lot of libraries that will allow you to do generally what you want to do, and maybe with a little bit more investigation and a little bit of custom package building on your end, but generally there's nothing preventing you from doing those same things in Go.
+
+**Erik St. Martin:** Are there any specific Go packages or frameworks that you're currently using?
+
+**Daniel Whitenack:** Sure, yeah. I mentioned Pachyderm, I am using that currently, and have had some great experience with that. I also very much like the idea that you can think in terms of these data pipelines and think in terms of piping data from one container to another. This is very useful, because let's say I want to do something very efficiently; concurrently at one stage of my pipeline I can write that very easily in Go and wrap that up in a container. If there was a case where maybe there's a very certain Python library that I'm very interested in, there's nothing preventing me from having that be part of another stage of the pipeline.
+
+Generally a lot of what I'm writing is in Go, but I like that flexibility. I also like the reproducibility of it, which is a pretty huge problem in data science right now. So the fact that you can commit your input data, your output data at every stage of the pipeline is very useful and powerful, I think. Also I've been using a variety of databases. I've recently used BoltDB and looking at some other embedded databases has been useful for me to kind of speed up some operations. Then also using some tools from Gonum as well. Gonum has a variety of packages that are in development or have been developed to some degree, like Matrix manipulation, implementation of Lapack and even plotting functionality. That's been useful, because there's been certain times... I like to do something in Go, maybe the package doesn't exist, but I can take stuff from Gonum and very easily implement the algorithm that I'm wanting.
+
+For example, I recently did a k nearest neighbours sort of thing. In the spirit of the Go proverb, "A little copying is better than a little dependency", I basically just stole some of the Euclidean distance functions and that sort of thing out of Gonum and was able to throw together exactly the k nearest neighbours thing I wanted, pretty quickly. So those are some of the things that I've been using.
+
+**Brian Ketelsen:** We did a project recently, last year, where I needed to do some data processing, and I found it really easy to take Python libraries and port them over to Go for data science type things. I can't remember what I needed to do, it was one of those numeric-type things, but it really was not difficult at all, and very performant.
+
+**Daniel Whitenack:** Yeah, and I think part of the mindset of like... In Go sometimes it's easier... Something I've seen - maybe you guys can comment on this - is doing... In Go sometimes it's just faster to write a for loop than it is to import a certain package to do some relatively simple thing. And I think it applies similarly in the context that you just described. Maybe there's not this very specific thing in Go that you want, but you can steal a little bit by porting over from this Python package that describes what they did, and you can utilize some of the things from Gonum maybe, and you can piece it together really quickly, and out of that you get something that's very performant, and something that you can put into the context of asynchronous communication and all of that that Go handles so well.
+
+**Brian Ketelsen:** Right.
+
+**Erik St. Martin:** Matt Holt is in our backchannel, which is GoTimeFM channel on Slack, the Gophers Chat. He said that he implemented k nearest neighbour in Go for his machine learning class. He said, "Great experience, totally worth it. Just inline it."
+
+**Daniel Whitenack:** Yeah, I totally agree.
+
+**Erik St. Martin:** To your point, I think that that's a good pattern when looking at importing dependencies in general, right? If you need one function - especially if it's small - do you need to import that giant library? All of it has implications too, so I guess it's always something to evaluate whenever you pull in a big dependency.
+
+**Daniel Whitenack:** Yeah. And there are a good number of packages related to data science, including machine learning packages. I recently saw a data frame package called Gota that's in development, which will be definitely very nice for exploratory analysis, I think. I would be sad if doing data science in Go just felt like doing data science in Python. For me, part of the joy of Go is that I can kind of piece things together in this way; I can take a little bit from here, bring over a little bit from Python maybe, and throw it together in a way that is very performant, very efficient, and very easy to deploy, and has those unique characteristics. So yeah, that's kind of my mindset, I guess.
+
+**Brian Ketelsen:** So what kind of advice do you have for somebody who wants to get started with playing in data science in Go? Do you have resources or advice, or places you like to send people?
+
+**Daniel Whitenack:** Sure, sure. First of all, like I said, I think doing data science in Go should be a little bit different, so I think definitely starting out I would say that those same resources that other people starting out in Go find useful, like Peter's resources or Dave Cheney's, and kind of getting into that mindset of "Where does our mindset in programming go? Why do we do things in this way and not that way?" Those are definitely useful in getting started and playing around on the Go playground and all of that.
+
+Then a lot of what I've learned has been trial and error; importing this package and trying that, writing my own custom stuff... Hopefully that's changing. A lot of data scientists come into Python and try things in Jupyter notebooks to try to figure out interactively how does this work. One of the things I've been working on recently is a Jupyter kernel for Go. It's functional right now, it needs some work, but I'm hoping that that along with further development of plotting things and other things like that will kind of ease the burden of people coming from a Python world to the Go world, and be able to do some things interactively and see what happens in that respect.
+
+Then of course there is the list of things that have already been done in Go, like InfluxDB and Pachyderm and most sorts of things. Generally there is Getting Started sections to those projects. In Pachyderm they have a great Getting Started example where they do word count with simple grep and awk commands. That's kind of a fun way to get started in doing data science in that way.
+
+**Carlisia Thompson:** Daniel, we shouldn't be surprised that you're going to talk about Go And Data Science at the upcoming GopherCon, but can you give us a little teaser about the talk? Who should be looking forward to being there and seeing that talk?
+
+**Daniel Whitenack:** Sure, sure. So it's still in the works, but the teaser I'll give is that from start to finish basically I'm gonna do data science, and do it hopefully in a distributed way, all with Go. So starting out saying like "This is a problem we wanna solve. We're gonna explore the data with Go tools, and then once we know what we're gonna do, we're gonna implement something simple in Go that will do that" and then we can think about how will that scale, and we'll use a Go tool, maybe Pachyderm or something like that to scale that up and illustrate how you can go through that whole data science process using nothing but Go.
+
+Then also I'll definitely provide some call-to-action to the audience to start doing some data sciency things with Go and point them to some packages and some projects that they can contribute to.
+
+**Carlisia Thompson:** So is it going to be like a live demo?
+
+**Daniel Whitenack:** Yeah, I mean it will be a combination between some code that I'll show on the screen, and then depending on how things work out, I'm hoping to show some type of live demo.
+
+**Brian Ketelsen:** I say you gotta go Kelsey Hightower or go home.
+
+**Daniel Whitenack:** Exactly. It's a scary proposition, but it could be a lot of fun.
+
+**Brian Ketelsen:** Just live code on the screen.
+
+**Erik St. Martin:** If you have slides, you have to deploy VMs that do this stuff from the slides.
+
+**Daniel Whitenack:** Sure, sure. Actually, I'll point to some Go notebooks and you can do it yourself in the notebook.
+
+**Carlisia Thompson:** Very cool.
+
+**Erik St. Martin:** So speaking of Go notebook, there's the Jupyter, right? And there's now a Go library for that?
+
+**Daniel Whitenack:** Yes, so there's a working kernel for Jupyter, it's called Gopher Notes. I started this back in, I guess it was January. It's functional now, so you can use it to make Go notebooks. There's definitely open issues and things to work on, so this is one of those things that I think hopefully some people find useful right now, but it's also a great place for people to get involved and knock out some of those issues and get plotting enabled in the notebook. I'm hoping, like I said, that this project will kind of help ease people into Gopher data science. Also, I think there is a part of data science that is very interactive - you wanna explore the data, you wanna see what it looks like, you wanna plot a histogram, and a lot of that is interactive, so bringing some of that interactivity to this world would be fun.
+
+**Erik St. Martin:** I think we're running very short on time, but for anybody who's not aware, can you give a brief rundown of what Jupyter is?
+
+**Daniel Whitenack:** Sure, yeah. There's actually a whole ecosystem of Jupyter projects right now. The main project is called Jupyter Notebooks, and what you can do is you can start a Jupyter Notebook server on your computer, and then if you go to the browser, you can start a Python notebook, and there's a lot of other kernels now. You can start a Go notebook or a Scala Notebook. When you open that, it's kind of similar to - I don't know if anybody's used Mathematica before, but there's different cells, and you can put code in those cells and evaluate that interactively. So it's live code in the cells, but you can also interject other things into the notebook; you can put in markdown into the notebook and render that, you can put images in, and then at the end of your notebook you can hand that off to someone else and say "Hey, here's what I did." You can also run it in your browser, or you can export it as a PDF or a slideshow and share it with other people, or turn it into a dashboard even. There's a variety of plugins that allow this functionality.
+
+**Erik St. Martin:** Excellent. We've just about exhausted our time here, but before we kind of transition into closing out the show, is there anything that you wanted a chance to share with everybody that you have not got a chance to?
+
+**Daniel Whitenack:** I think a lot of what we've talked about is definitely what I wanted to talk about. I would encourage people out there - there are a good number of people doing data science in Go out there, even if they're not the most visible in the data science community... So let' s say, all of you Go engineers out there start playing around with some of these data sciency applications and I think you'll find that the experience is really good and you can come out with some great deliverables in Go and things that can actually be deployed, and scale, and all of those good things we like about Go.
+
+**Erik St. Martin:** The way we typically wrap this thing up is we have our \#FreeSoftwareFriday where all of us go around and thank some projects or contributors - or both - that are making our lives easier currently or in the past. With that being said - Brian, who do you wanna thank?
+
+**Brian Ketelsen:** I know our rule is no more than one, but I have two - forgive me in advance.
+
+**Erik St. Martin:** I did three one week, it's cool. \[laughter\]
+
+**Brian Ketelsen:** Okay, good. So the first is ngrok from Alan Shreve. My god, there isn't a day that I don't go by without using ngrok. It's just the best tool on the planet for sharing something that's running on your machine with people that are somewhere else. If you haven't used it, I think it's at ngrok.io, but you can just search for ngrok. What an awesome tool... I use it constantly, I love ngrok. And then, a kind of an extra special shout out to the people in GopherJS room on the Gopher Slack who have had unbelievable patience with my sad, sad JavaScript skills - thank you guys!
+
+**Erik St. Martin:** Carlisia, how about you?
+
+**Carlisia Thompson:** I'm going to mention Jupyter Notebook and the Go kernel. Daniel did a great job describing Jupyter Notebook, but I still wanna mention it because it is not just for data science, and I'm gonna tell you why. I came across this commercial tool that is a notebook, and my mind was blown. This is the tool that I looked for all my life, and it's what I use now to take notes. Just like Jupyter, it has cells. You can have code cells or markdown cells or tech cells - it's been the most amazing thing. And I keep telling my husband - he's a data scientist - "You have to try it, this is the most amazing thing!" Two weeks go by and I'm telling him, "You gotta try it, you gotta try it", he finally comes over and looks at it, and he's like "Huh, I have this. But it's free, open source, and it's called Jupyter." I'm like, "That's what Jupyter is!?" Because I ran across Jupyter when I ran across the Go kernel that Daniel did for Gopher Gala, when I was browsing Gopher Gala submissions. Then I went and looked at Jupyter, and I was like "I don't understand what this is. It's not for me, and I'm not willing to spend the time." So I find this tool and then I'm like, "Oh, that's what it is!" So actually last night spent time setting up Jupyter and hooking up the Go kernel to it, and it is super amazing. It's not just for data science - you can keep your notes, you can run code... I have ideas to put together Go courses, and I would totally use Jupyter for that, because everything is self-contained, it can have different sections, I can run the code right there, you can do a presentation... Just like Daniel was saying, you can export it and when you host it on GitHub you see the whole thing formatted; it's not interactive, but the whole formatting is there and it looks beautiful. It's great.
+
+**Brian Ketelsen:** I'm sold.
+
+**Erik St. Martin:** I kind of wanna look at it just for normal note taking.
+
+**Daniel Whitenack:** Yeah, and thanks to Carlisia for going through the setup and giving me feedback on the different issues as well. I definitely appreciate it and I'm glad people are starting to use it.
+
+**Carlisia Thompson:** Yeah, I did run into just a super minor hiccup, and I opened an issue. Daniel was so quick, he was instantaneously responding to what I was having trouble with. I think he'll do the same for everybody.
+
+**Erik St. Martin:** Uh-oh, she's setting a precedent.
+
+**Brian Ketelsen:** There's pressure... \[laughter\] On next week's show we're gonna talk about open source pressure... \[laughter\]
+
+**Erik St. Martin:** ...and how we can add more to the contributor. \[laughter\]
+
+**Carlisia Thompson:** Setting expectations...
+
+**Erik St. Martin:** We also like to ask our guests too if there's anybody they kind of wanna thank, any projects they'd like to bring highlights to...
+
+**Daniel Whitenack:** Yeah, I wanted to mention Vim Go because I've started using it recently. I know a lot of people use it out there, but I'm kind of a recent convert. I've just found it amazing, and I think it's... Once I kind of got in the process of using it and writing Go with Vim Go, I think it's improved my development process quite a bit, and that's really the one I would like to thank. I think his name is Fatih Arslan. I'm definitely thankful to that; I think it's super powerful and it can improve your workflow. Previously I was using Atom, and now I've pretty much just been using Vim Go recently and I think it's a great project.
+
+**Brian Ketelsen:** Yeah, Fatih is now a new dad, so congratulations to everybody...
+
+**Daniel Whitenack:** Congrats!
+
+**Carlisia Thompson:** Congrats!
+
+**Erik St. Martin:** That's a week ago, two weeks ago now?
+
+**Brian Ketelsen:** I don't think there's been that's gone by that we haven't talked about Vim Go.
+
+**Erik St. Martin:** Yeah, one of us always has Vim Go, and I'm gonna play right along with it, because who I'm gonna thank is Nvim. I've been a Vim user for a long time, and I kind of tinkered with Nvim. I don't even remember why I went back to standard Vim, and then Brian's like "Dude, why are you still using regular Vim?", so I went back to Nvim, and I'm loving it. And then of course, it wouldn't be the same without Vim Go, so I'll thank Vim Go again.
+
+**Carlisia Thompson:** Is it Nvim or Neovim?
+
+**Brian Ketelsen:** Neovim. The command line you type is nvim. Yeah, and those are two great tastes that taste great together, because Neovim does asynchronous processing and Vim Go enables that very nicely, so you can do things like compile while you continue to edit, and that's not possible in regular Vim, and it's really tasty in Neovim.
+
+**Daniel Whitenack:** Oh, cool. You guys are giving me something to do after the talk ends. \[laughter\]
+
+**Erik St. Martin:** We're always learning with Vim. It's doesn't matter how long you've been doing it, you still find new plugins, you find new versions. And I think we are actually over time, but it's been fun.
+
+**Daniel Whitenack:** It's been a lot of fun!
+
+**Erik St. Martin:** Yeah, this has been great, and I'm looking forward to your talk at GopherCon as well. And for anybody who wants to hear more from Daniel, you should attend his talk at GopherCon.
+
+**Daniel Whitenack:** Yeah, and I'll be around and be happy to talk about Go and data science throughout the conference, so hit me up.
+
+**Brian Ketelsen:** Yeah, just on that note real quick, as we're wrapping up, we're gonna have panels with the speakers in the afternoons, so if you wanna get some quality time with the experts in the field, the afternoons of GopherCon on your time, GopherCon.com, buy your tickets now. Did that sound like a soap commercial? \[laughter\] I tried.
+
+**Erik St. Martin:** You gotta do the fast talking thing if you're gonna do the commercial, because you gotta get that in like five seconds.
+
+**Brian Ketelsen:** That's what I was going for... I guess I can't talk fast, sorry.
+
+**Erik St. Martin:** Alright, so I wanna thank everybody who's on the show, the entire panel. I want everybody who is listening and who will be listening, definitely share the show if you guys wanna hear more. We're gonna kind of vary topics between community and what's going on, and talking to people, as well as deep-dive technical content. Go to GoTime.fm if you wanna subscribe. We're @GoTimeFM on Twitter, and then we also have a Slack channel if you wanna catch backchannel action during the shows. That's GoTimeFM on the Gopher Slack. We also will be doing this thing live too, so we'll get a link up so that we can continue to do this; I think it went really well this episode. So with that being said, goodbye everybody.
+
+**Brian Ketelsen:** Goodbye. Thanks, Daniel.
+
+**Daniel Whitenack:** Goodbye.
+
+**Carlisia Thompson:** Goodbye.

Go in 5 Minutes & design patterns_transcript.txt

@@ -0,0 +1,509 @@
+**Erik St. Martin:** We are back for another episode of GoTime. Today's episode is number 18. Today's show is sponsored by Linode and Backtrace, so first we want to give them a huge thank you for sponsoring the show. Today on the show -- I'm gonna switch things up a little bit. First we have myself, Erik St. Martin, also we have Carlisia Campos here. Say hello, Carlisia...
+
+**Carlisia Thompson:** Hello!
+
+**Erik St. Martin:** And Brian Ketelsen...
+
+**Brian Ketelsen:** Howdy!
+
+**Erik St. Martin:** And our special guest today is Aaron Schlesinger, which... I guess you work at open Deis right now?
+
+**Aaron Schlesinger:** I do, yeah.
+
+**Erik St. Martin:** And working on Kubernetes-based stuff. You also have a project that we've seen, which is Go In 5 Minutes. Do you wanna give everybody a little bit of background about yourself?
+
+**Aaron Schlesinger:** Yeah, sure. I've been writing Go for just about three and a half years now, at a variety of different places and on my own. It kind of just started as a hobby project. I was coming from Scala, which was kind of a mess at the time, and I was looking for simpler tools to start out. So I came to Go, kind of fell in love with the community... The first kind of big discovery was how easy concurrency was, and that's what really kind of poked me.
+
+Then I moved to a couple different companies, all writing Go. I finally landed at Deis. I am kind of through that whole process, just participating in the community in different ways... When I first started Go In 5 Minutes, I saw there was a little bit of lack of intermediate and advanced content for Go, so I wanted to combine some intermediate/advanced material with a super simple format, so I focused on these short, 5-minute screencasts to start out. Then it just grew from there.
+
+I started writing a blog alongside of the screencasts, did some longer screencasts... I think the longest one I did was like an hour. So I've just kind of been capturing all my thoughts, all my experiences, all my input that I'd gotten from people and the community... Just kind of trying to give back to the community in any way I can, through this medium of Go In 5 Minutes.
+
+**Brian Ketelsen:** That's awesome.
+
+**Erik St. Martin:** Now, talk to us a little bit about what the content is there. Is there a set structure where you're building on top of previous episodes, or is this more based on user feedback, questions you see around the web, and answering it in the form of video?
+
+**Aaron Schlesinger:** Yeah, it's kind of both. I have my repo on GitHub, basically it's just all the issues or requests for screencasts. There's a couple in there to remind me to fix the site, or something, but almost all of it, the vast majority is people asking about, "Can I get a screencast on how to use the SQL package?" or how to do some specific thing with net/http and what have you. So about half of the screencasts are in response to those, and the other half are just things that I've seen that might be underutilized or new, or something like that, and I just try and distill it down into that 5-minute format.
+
+\[03:49\] I try to make sure that each screencast has no prior dependencies. Some of the screencasts will be like, "If you have seen this screencast, it will help you, but you don't need it." But most of them are just like, you start at minute one and it takes you all the way through to the end. My goal is by the end you at least know the basic building blocks for how to get something done. Then, if you want to go into more detail, I put on the site the equivalent of the show notes - links to good blog posts and good documentation and so forth, for people who wanna dive a little deeper.
+
+**Erik St. Martin:** I think this is really interesting. It's kind of along the same lines of the posts that Ben Johnson has been doing, kind of giving people little stuff to chew on for net/http or things like that, introducing people more to the standard library. I'm seeing that more and more as kind of like a pattern where you're exposing people to these things they might not be familiar with.
+
+I think that's building on kind of where we're at with the language too, because a lot of people are starting to get the syntax down, but now it's kind of idioms and learning their way around the standard library.
+
+**Aaron Schlesinger:** Yeah. The standard library is so vast, and I feel like we're just scratching the surface, even now. And now it's growing, too. We just got context in Go 1.7, and that's crazy useful.
+
+**Erik St. Martin:** I'm so happy about context!
+
+**Aaron Schlesinger:** Yeah, me too.
+
+**Erik St. Martin:** What I tend to do is I tend to be familiar with at least a base package, like "I'm gonna be doing something with bytes." Then, whenever I'm trying to do something new with it, I try to explore around and see what else is there, and be like "What is this?" Or like the io.TeeReader; you start tinkering with it and coming up with use cases.
+
+**Aaron Schlesinger:** Yeah, I think that's the hard part - imagining the use case before you've actually used it. And I feel like even still, there's kind of this chicken and egg, where if the community can't really nail down use cases, then the thing is not gonna be used, so use cases won't get developed out of the thing. So it's kind of like someone or some group has to come in and say, "Hey, this is a way to use TeeReader. Go try it in your code some time and see how it works, and develop it out from there."
+
+**Erik St. Martin:** Yeah, I think I agree. I think learning is like that. You almost have to struggle first, so that when you're exposed to it, you have something to relate it to, where you're like "Oh wow, that would have been really useful when I had done such-and-such." But when you're first just coming across it, you're like "Yeah, I don't need that, I don't need that" and then you long forget about it.
+
+**Aaron Schlesinger:** Yeah, for sure. I can't even count how many times I've written io.copy myself, and it's like an embarrassment now; it's like, "Come on, you should have remembered that." It's like THE function in the io package that you should always know. I just forget and I forget, and then all of a sudden, finally, maybe a month ago, it just clicked. I'm like, "Oh yeah, io.copy, it's there. I should use it in this situation." It's kind of funny how that happens.
+
+**Erik St. Martin:** You need to setup an io.copy jar on your desk, rather than a swear jar.
+
+**Aaron Schlesinger:** \[laughs\] Yeah, I should.
+
+**Erik St. Martin:** So talk to us about what some of the most popular ones are. Do you have ones that get exponentially more viewings and followings that others, or is it pretty scattered?
+
+**Aaron Schlesinger:** \[07:41\] I think the number one by far is how to write a full stack web application, all the way from database access, down to serving up templates and writing JavaScript. That one was how to do it with just the standard library. I think that one had like 5,000 views after the first week. The rest of them, maybe they get to 1,000 views in the first couple weeks. I don't know what the second or third would be, but that one's the top.
+
+**Brian Ketelsen:** Hang on a second... You did that in five minutes?
+
+**Aaron Schlesinger:** Yeah... That one was a huge hand-waving one. There is tons of code that I wrote beforehand, and I glossed over tons and tons of it in the five minutes. The code's all out there in the Go In 5 Minutes repo, so I heavily commented all of it, and wrote a bigger outline in the readme, like "Where should you look to do templates, where should you look to do databases." I kind of did all that in the hopes that my hand waving would basically introduce people to the big building blocks and how they fit together. Then, once the five minutes is up, they can go and drill down as they see fit.
+
+**Erik St. Martin:** So this is more like kind of just starting the journey, getting enough seed planted and showing people where they can go from there.
+
+**Aaron Schlesinger:** Yeah, for sure.
+
+**Erik St. Martin:** How often are you releasing these?
+
+**Aaron Schlesinger:** That's a great question. I started off every week, and then pretty quickly burned out, to be honest. I've been doing every two to three weeks now.
+
+**Carlisia Thompson:** Aaron, I saw that you have an episode on the singleton design pattern, and on your repo you have an issue open for future "explain design patterns" episodes. And by the way, I wanted to mention to people that you have a repo where people can go and make requests if they want to learn about something in specific, or just upvote the issues that are there. Having a repo for that ourselves, that's very useful. There are so many interesting topics listed there, it's pretty cool.
+
+In any case, going back to the design patterns question that I have - how do you go about putting together a video tutorial for design patterns? Is it based on a lot of work that you have done with design patterns in Go? Or do you try to abstract how design patterns are implemented in other languages, and then sort of like how that would be done in Go? How do you go about it?
+
+**Aaron Schlesinger:** Yeah, that's a good question. Actually, I kind of do a mix. There are obviously some I've used in my own work, whether it's open source or at Deis; most of that is open source anyway. But I also look around, I ask around various... There's tons of Slack channels now in the Gopher Slack; so I either ask around or I just look at other people's open source. Then I also take some things from time to time from Scala, since that was the last language I worked in before Go. That angle I think is pretty useful to an extent, because Scala is so different... It's kind of this Frankenstein between a functional and an object-oriented program built on top of the JVM. There's tons of stuff in there, things like the builder pattern... Functional programming is obviously a big thing there. I think there's a ton of stuff that we can bring over to Go and idiomize for Go - make it simpler, make it fast...
+
+I try to take from all three, but I wouldn't say I have a specific strategy or algorithm for figuring out where to take design patterns from and how to present them.
+
+**Erik St. Martin:** \[11:58\] We had Dave Cheney on the show two episodes ago (episode 16) and we were talking a little bit about design patterns and how they came about. How do you see the design patterns as we know them in The Gang Of Four book applying to Go? What's your opinion on how they kind of fall in? Should we be trying to leverage all of these things inside of Go, or do you think that there's certain mechanics about the language that we should try to stick more to Go ways of doing things and not necessarily adopt all of these patterns?
+
+**Aaron Schlesinger:** I'd say technically of course it's possible, I think probably possible to do every single one of the Gang Of Four design patterns. But I think that Go simplicity is actually very powerful. I think Dave did a talk - it was either Dave or Rob Pike... One of those two, or maybe even both - they did a talk on basically saying, "Simplicity is hard and simplicity is powerful." That's my mantra. I watched and read the slides for that talk, and that's kind of what I try to live by with Go.
+
+If you take a builder pattern, design pattern, something like that, and you bring it into Go, my goal is to try and explain why we should use it, instead of why we shouldn't use it. I would say from a cultural or community standpoint, I would rather not take a design pattern and write a little bit more code, rather than bring in a huge design pattern into your codebase, make it a little bit less code but harder to understand.
+
+**Carlisia Thompson:** Yeah, I can see that and I hugely agree with that. I did Java for quite a while and I knew Java fairly well back then when I was doing it. In the Java world - or at least in my Java world - design pattern was the go-to thing. It was pretty much like, there is a pattern, find out what it is and stick to that, because that's going to make your life easier, or it was going to make your code "better." I don't say better without quotes anymore, after Dave Cheney. But in any case, I think that is the trick with software design - trying to abstract things too early, you might end up pinning yourself against the wall. Like you're saying, Aaron, writing more code, and only really abstracting things into an interface or into a design pattern after you know what it is that you need is what I think we should be thinking about, as opposed to "Oh, we have design patterns, let's implement that!"
+
+**Erik St. Martin:** Well, that was kind of Dave's talk too, about the SOLID design, talking about single responsibility, open and closed, and the key points that will make software more maintainable, and then looking at design patterns as how they apply to that, whether they make things more complicated, and just recognizing this stuff. That's the whole thing, right? Design patterns are neither good, nor bad. Well, they're mostly good, but it's not religion. We don't have to look at some problem and then shop for the design pattern to solve that. It's okay to have things that are custom too, if it simplifies your design without creating a lot of coupling or things like that.
+
+**Aaron Schlesinger:** \[15:53\] Yeah. I think since I started writing Go, I kind of started to look at design patterns like just a recipe. If you're a cook, you wanna make an apple pie, you're gonna probably go to a couple different recipes to get the feel for how to make this pie; what's the general stuff that goes into it, how generally do you cook it, and then you're gonna probably make it your own after maybe a couple pies, after you cook for maybe a month or so. That's what I think the Go community is doing and should be doing. We're not just taking -- I keep going back to builders, so I'll continue there... We're not just taking builder from Java or C++. I've seen a couple different implementations of it, some of which are way simpler than the Gang of Four book, or what we see in Java.
+
+I think that there's not just one builder pattern now in Go. I think that there's kind of, your mileage may vary, and some of the patterns work better for situations than others, and I think that's a great thing. That's evolution.
+
+**Erik St. Martin:** Yeah, and I think we can look through the standard library and we could find examples of maybe like the visitor pattern... I think the hash sorting is done in a visitor pattern if I recall. We can find examples of that, but I don't think we necessarily have to bring everything over. I think as they apply we leverage them, and we benefit from features of the language that allow us to do things in a simpler way than some of these patterns were implemented. Because all of these things, especially a lot of the patterns are based off Java, which has its own set of features, things that Go does not have, and then also things that Go has that Java does not.
+
+So I think we look at our own problems differently, and I'm interested to see how we evolve with our own patterns, and we start to see some of these little idioms that people use, little tricks that are continuing to become commonplace in some of the more common libraries. I think if you look at most large projects in Go right now, it varies so much. We haven't converged on patterns in Go, that are specific to some of these larger use cases. Because you look through the Docker codebase or the Kubernetes codebase - things are very different between the two of them.
+
+**Aaron Schlesinger:** Yeah.
+
+**Carlisia Thompson:** I think one downfall of design patterns, especially if you're doing something you don't have a ton of experience with and you set yourself to use a design pattern, is that let's say you're going to use a specific one and you might wanna do something that's a little bit out of that pattern, but then you wouldn't totally conform to the pattern and you make the choice to use the pattern, as opposed to doing the right thing for your code. That's a problem. If you don't have a lot of confidence, you don't have the experience with what you're working with, you might end up making that kind of choice. I think it's problematic when people do that. But if you keep it flexible, I think there's a lot to gain to at least know what design patterns you can use, because it can be very helpful in organizing your code, and also increasing the clarity of what you're doing, and then it's easy to communicate what it is that you're doing to other people.
+
+**Aaron Schlesinger:** Yeah, absolutely. If people can go back to that cookbook and say, "Oh, this looks pretty similar to visitor pattern..." The other thing I was gonna say, on your point, Carlisia, the Go programming language now is starting to give birth to concurrency design patterns that C++ and Java can't really do, because they don't have a first-class channel or a first-class lightweight thread primitive.
+
+\[20:01\] So it's even more important I think for people to be able to pick up things like the barrier pattern using WaitGroups and using Goroutines and then adapt to their needs. Because there's so many ways you can use that pattern, for example.
+
+**Erik St. Martin:** Yeah, and I think we see stuff, you know, fan-in, fan-out, and things like that, that become so much simpler because we have the concept of the channels. It becomes so much easier to do things like that.
+
+**Carlisia Thompson:** There is a talk by Rob Pike, it's called Go Concurrency Patterns. I've watched the whole thing before, and I was just gushing over it because it's beautiful. The patterns are beautiful.
+
+**Aaron Schlesinger:** It really is.
+
+**Carlisia Thompson:** Right? I'm sure you've seen it.
+
+**Aaron Schlesinger:** I love that talk.
+
+**Carlisia Thompson:** So yes, definitely, there are patterns for concurrency, and because at that point I had done concurrent code in Go, and I was just going "Oh my gosh, my code does not look like that at all", but I totally get it. I didn't memorize it, but my head was going "Oh, yeah!" So there are different ways that you can organize code according to what it is that you are doing. So it pays off, I think, for you to know what you can do.
+
+**Aaron Schlesinger:** Yeah.
+
+**Erik St. Martin:** There was a talk at GopherCon 2014 too by John Graham-Cumming too, called A Channel Compendium, that had a lot of stuff like that, with some of the patterns with timeouts and things like that, with channels, which is also a really interesting talk to watch. And I wanna say Derek Collison's from that year had a bunch of stuff too that was related to patterns with concurrency and performance related to them.
+
+So I know we volleyed back and forth a little bit on benefits and drawbacks, and not to be religious about design patterns... Many of us come from backgrounds where we had to heavily use design patterns, especially Java world, but let's kind of bring it in for maybe people who are more new to programming and Go is one of their first languages and they don't really have a lot of knowledge in the design pattern world to kind of apply. Would you recommend that people still study a book like The Gang Of Four book, and learn design patterns for Go? Do you think that it benefits them in Go, or do you think that they should focus more on just trying to learn idioms for Go itself?
+
+**Aaron Schlesinger:** I would go with the latter. I know that might be heresy, but I would absolutely say learn Go, learn idioms, and once you start getting more complex, you have a 5,000-line codebase or 10,000-line codebase, that might be a good time to start looking at design patterns and finding ways to reduce your lines of code using those design patterns. But if you're starting out, I think keeping your code as simple as possible, as understandable as possible using those idioms - that's far more important in my opinion.
+
+**Carlisia Thompson:** Can I just +1 that? \[laughter\]
+
+**Aaron Schlesinger:** Maybe it wasn't heresy...
+
+**Carlisia Thompson:** Yeah, I agree with that, and I'm very much a newcomer to Go. So by just using the straightforward stuff and learning the idioms, you might not have that organization at the end, but you're going to end up with a much bigger tool belt that you can use. Because design patterns, they don't really change, so once you know them and learn them, they're going to be what they're going to be. But you knowing the Go idioms - if you don't take the time to implement them and know what they are, you're going to be doing yourself a disservice, I think.
+
+**Brian Ketelsen:** Alright, it's time for us to take a quick break to talk about our sponsor, Linode.
+
+**Break:** \[\\00:24:22.17\]
+
+**Erik St. Martin:** Excellent! So you mentioned that you worked at Deis. I'd love to talk to you a bit about the work that you guys are doing there; there's some really interesting contributions you guys are making to Kubernetes, Helm and things like that. So I'd love to hear about work that you're doing there, and maybe how Go is advantageous to you guys there. Aside from the fact that Kubernetes is written in Go, so if you wanna contribute, you're kind of forced to... \[laughter\]
+
+**Aaron Schlesinger:** When I first got to Deis, I worked on the PaaS. It's now called Deis Workflow, but at that point it was just Deis. It was basically trying to be a Heroku for Kubernetes - open source, you can go and install it on Kubernetes. Then right before I got there, Helm had kind of become a thing, but it looked super different from what it looks like now. It was just kind of like, "How do we get people to easily install the PaaS?" Because at that time there were seven or eight different components, and you could use most of those components on their own too, if you wanted to.
+
+So it was kind of like this plug-and-play thing where if you wanna use your own logging you can, but we'll also ship you components that can do most of the logging stuff that you'll need. Then there is the router, the routing mesh - you could use that on your own, and it would fit into the PaaS.
+
+Helm popped up because we wanted to give that flexibility to people without writing a thousand page document with specifications for each module, and having sample manifest and all that stuff. So Go came into play big time with the PaaS, because we had to do things like watch the Kubernetes event stream, see when a pod comes up and see the exit status of the pod.
+
+When you're watching an even stream that screams concurrency, once it screams concurrency, then I just pick up Go. It's just the easiest thing for me, by far. Before we picked up Go there was some Python... Actually, there was some Go before I came to Deis, and then there was some shell script. The shell script component was what I first worked on. That was the thing that we had to watch the event stream in. We started with a four-loop in a shell script.
+
+**Erik St. Martin:** I was just gonna say, what is this? Just a four-loop curling out, long-polling?
+
+**Aaron Schlesinger:** \[27:50\] Yeah, it would sleep for two seconds and then poll the Kubernetes API. I made the decision to make the plunge after we started getting bug reports where people were saying, "Oh, it missed the pod!" Because the pod would start up and then die within that two seconds. So that's when we took the plunge, we rewrote all that in Go, and just kind of never looked back. That was the benchmark that made us decide we're gonna move forward and start writing everything in Go.
+
+We still have some old stuff in Python and it's working great. Our API server is actually all Python, and Python is super well suited for that. But the other components - our logging system is all in Go, that deals with consuming and fanning out tons of log data. We have a log storage system, same thing; built on Redis, but the whole multiplexer for all the data just fans into Redis, collates all the data. We've got this plugin system that can push the data all out to... I think we've got like 7 or 8 community-generated plugins, and stuff.
+
+The Go choice there has been super helpful, because just by virtue of its simplicity and its concurrency support. Looking back, I kind of think "Why didn't we move sooner to Go?" because it saved us so much strife.
+
+**Erik St. Martin:** Out of curiosity... All your watchers and stuff like that for the event stream - are you using the Kubernetes client library, or did you just write an HTTP wrapper in Go?
+
+**Aaron Schlesinger:** We are almost exclusively using the client library. I actually just saw today that they split up the client library and they're starting to pull out pieces to a new repo.
+
+**Erik St. Martin:** Yeah, there's the client Go, and I'm actually in the middle of refactoring out some of my own logic to call that...
+
+**Aaron Schlesinger:** Oh man, I'm so excited for that, because right now our dependencies are like a gig of all the Kubernetes code and all the dependencies that we don't need. Once we have that, it's gonna be a couple kilobytes of code; I'm gonna be so happy when we get that...
+
+**Erik St. Martin:** Yeah, I was really happy to get rid of the whole vendored Kubernetes repo.
+
+**Aaron Schlesinger:** Yeah, that's a bit of a mess.
+
+**Erik St. Martin:** So that's awesome. Are you contributing to Kubernetes, or is this mostly kind of tooling built around Kubernetes?
+
+**Aaron Schlesinger:** Most of it is tooling built around... When we find warts in Kubernetes that affect what we're doing, or we find warts that are kind of related to issues that we've seen with Deis, then we usually contribute upstream. But now, Helm is part of the Kubernetes repo. So Helm, technically, since we're contributing to Helm, we're contributing to the Kubernetes project as a whole. We're involved with a bunch of the SIGs too, so we're gonna be starting to contribute more and more to the Kubernetes core, and also some of the projects that spin off of the SIGs as well.
+
+**Erik St. Martin:** Yeah, there's more and more Special Interest Groups now that I've been seeing come out. It's too hard to keep up with all of them.
+
+**Aaron Schlesinger:** Yeah. What I would love to see eventually is some kind of centralized schedule for SIGs, so that we can all do that. We'll just figure out "What is today's SIG? What are they talking about? What's on their agenda?"
+
+**Brian Ketelsen:** I had to unsubscribe from all those SIG lists. It was driving me crazy.
+
+**Aaron Schlesinger:** \[laughs\] Yeah, I feel your pain.
+
+**Erik St. Martin:** Well, and there's so many good groups, large organizations submitting proposals and stuff for expansions to Kubernetes. It's really hard to keep up with all the proposals that are going on. You kind of have to pick your world and hang out there.
+
+**Aaron Schlesinger:** Yeah.
+
+**Brian Ketelsen:** Did we mention that SIG is a Special Interest Group in Kubernetes? We're way out of this typical Go world now, sorry. Too many Kubernetes users here.
+
+**Erik St. Martin:** It's all written in Go, it applies.
+
+**Brian Ketelsen:** It applies, we're just getting deep.
+
+**Aaron Schlesinger:** \[31:57\] Yeah, and you know, to take it back to Go for a second, the Kubernetes codebase is extremely interesting from a, maybe we can say an etymology standpoint; the original codebase was kind of written like Java, and then it open sourced, and then people outside of Google started contributing, and now it's like this crazy mix of Java-like code, idiomatic code, code from other organizations...
+
+**Erik St. Martin:** ...generated code...
+
+**Aaron Schlesinger:** Yeah, generated code, there's some protobufs-generated stuff in there, there is a swagger spec which I think generated some code at one point, and then they didn't generate it again, and started just building on top of the generated code. Looking at this massive codebase, you can jump to definition essentially and see the whole world of Go code styles in one repo. It's really amazing.
+
+**Brian Ketelsen:** Absolutely.
+
+**Erik St. Martin:** Yeah, I'd have to agree. From file to file, things kind of... There's not a whole lot of consistency. In certain areas there's consistency; you can tell certain groups of people work in different areas, but if you're bouncing around the repository, you can definitely see the style changes. I think that will all converge over time, right? And I always mix up these two books - either Bob Martin's Clean Code book, or The Pragmatic Programmer, but they kind of lead to the boy scout rule, which is always leave the campsite a little cleaner than you found it.
+
+As long as people are continuously refactoring a little bit to make more idiomatic Go out of these areas they touch, it's slowly going to evolve into that. But yeah, you can definitely see Java patterns in there.
+
+**Aaron Schlesinger:** Yeah, absolutely.
+
+**Erik St. Martin:** So, does everybody wanna talk about any news and projects that have been going on?
+
+**Brian Ketelsen:** It's a pretty big week for interesting things coming out. The Go newsletter came out today, and they had like an ngrok clone for SSH. That was generally interesting on its own; I can't remember what it was called. But the thing that powers it was much more interesting to me, which is Teleport. github.com/gravitational/teleport is a modern SSH server for clusters and teams written in Go. I had to go touch that and play with it and look at it, and it's really actually kind of awesome. You can install a highly available cluster of SSH bastion servers that will authenticate clients and then proxy them off to the servers in your system. So you can have many clusters of servers, and all of your users just go to your Teleport services and you can SSH to anything on the other side of the cluster. It's really complicated, but cool and easy to use SSH management proxy thing. I'm gonna have to play with it some more, because it looks awesome.
+
+**Erik St. Martin:** That's interesting, I actually didn't see that. I haven't seen the newsletter today. So one thing I saw - it was either today or yesterday - Brad Fitzpatrick mentioned that they are officially getting rid of the legacy backend for the Go compiler, which means from this point on it will be all SSA, which is cool.
+
+**Aaron Schlesinger:** Cool! I didn't see that.
+
+**Brian Ketelsen:** Yeah, SSA or GTFO. \[laughter\]
+
+**Erik St. Martin:** I'm just really interested to see that, because it's going to make things much easier to continue to write rules to make more performant machine code out of it.
+
+**Brian Ketelsen:** But look at the gigantic gains that we got just in 1.7; I can't wait 'till people have some time to actually work on some enhancements to that. I think 1.8, 1.9, 1.10 are gonna be amazingly fast and stable and awesome.
+
+**Erik St. Martin:** \[36:06\] Yeah, especially when more people start getting in and writing the SSA rules. That's far beyond my ability to start looking at assembly language and coming up with these rules.
+
+**Brian Ketelsen:** Well, speaking of 1.9, Vim Go 1.9 was released. We've got a lot of Vim Go lovers. That was a big release.
+
+**Erik St. Martin:** We should ask this every episode to our guest - what is your editor of choice, Aaron?
+
+**Aaron Schlesinger:** Oh, man...
+
+**Brian Ketelsen:** This is like religion. You can't do that, Erik... \[laughter\]
+
+**Aaron Schlesinger:** Yeah... I use Atom almost exclusively actually, with whatever that master Go plugin is that installs all the other go plugins. It's like MetaGo or something.
+
+**Erik St. Martin:** Gometalinter?
+
+**Aaron Schlesinger:** I think that's the one.
+
+**Brian Ketelsen:** Atom has a Go package written by Joe somebody...
+
+**Carlisia Thompson:** It's called Go-plus.
+
+**Brian Ketelsen:** Yeah, Go-plus, there you go. That installs all the other Go things.
+
+**Erik St. Martin:** I gotcha. I thought you were talking about all the static analysis tools and stuff. There's the big gometalinter that runs a series of them.
+
+**Aaron Schlesinger:** I think Go-plus installs metalinter. It may not install it directly, it may just install all the stuff that metalinter does; I can't quite remember. But yeah, I use Atom with Go-plus, and then I have to turn off goimports, which is a bummer, because it crashes my computer almost every day.
+
+**Brian Ketelsen:** Your GOPATH is too big.
+
+**Aaron Schlesinger:** Yeah, looking through all the Kubernetes' depths - not good. \[laughter\]
+
+**Erik St. Martin:** I kid you not that I actually have a script run and kill the Go code binary every couple of minutes while I'm working on Docker or Kubernetes libraries. Because it just gets so bloated... I mean, Vim of all things becomes useless. It's like, press down, wait 30 seconds... So I have to constantly have the Go code binary die while I'm working on Kubernetes.
+
+**Aaron Schlesinger:** We have a similar problem. I just got Docker for Mac; I think it's out of beta, I can't quite remember. Whatever it is, it's the new Docker for Mac that runs on the ex-hive thing, that new ex-hive VM wrapper. I do all my Go development pretty much inside of a container, so I try to run govet. And yesterday I forgot to restrict it just to my code, so I tried to run govet on my whole vendor directory as well, and I actually had to restart my computer, because the ex-hive plugin ate up like 260% CPU, and then... I don't know exactly what happened, but even my mouse, my dock, everything on my Mac was unresponsive, so I had to hard-kill my computer and restart it, because of Kubernetes' dependencies again.
+
+**Erik St. Martin:** See, I love the irony in this, though. Because you can sit back and be like, "Look at all this crazy stuff I build, and I still feel unqualified to operate a computer." \[laughter\]
+
+**Aaron Schlesinger:** Exactly! It's funny...
+
+**Brian Ketelsen:** For me, it just comes back to the whole, "Why do I keep using a Mac?" But this isn't that show, so I'm walking away.
+
+**Aaron Schlesinger:** Fair enough, I'll walk away, too.
+
+**Carlisia Thompson:** I'll go next with the news... Can I?
+
+**Erik St. Martin:** Yeah.
+
+**Carlisia Thompson:** So it was just made public that Steve Francia is joining the Go Language Team at Google. So happy about that! He wrote a blog post talking about what his role will be. It seems pretty awesome.
+
+\[39:53\] The other thing I wanted to mention is there is a repo with patterns in Go, and it looks pretty cool. It has an accompanying website with tables for each type of patterns, and a bunch of patterns inside each table, with the status. The status means if there is a code implementation for that or not, and it seems whoever is in charge of this is putting code forward, that corresponds to each of the patterns.
+
+**Erik St. Martin:** Wow, this is Gang Of Four for Go. Do you see this link, Aaron?
+
+**Aaron Schlesinger:** Yeah, this is pretty awesome.
+
+**Brian Ketelsen:** That's not the word I would've used. \[laughter\]
+
+**Carlisia Thompson:** I might have gotten this link from Aaron's repo. I'm not sure where I got it from.
+
+**Aaron Schlesinger:** Yeah, I don't know if I put an issue in...
+
+**Carlisia Thompson:** There is one, yeah.
+
+**Aaron Schlesinger:** Maybe there is. I saw this a couple of weeks ago, read through it at 3 AM... I actually think this is awesome, because it starts the discussion that essentially we had. They might not all be good patterns, but at least it starts. Everybody is talking about, "Do we need this for Go? Do we not? What should we change?" and so on.
+
+**Erik St. Martin:** Well, I think that there are some things in here that I can definitely see are ridiculously useful, like in building distributed systems, like circuit-breaker pattern. That's something you definitely want, otherwise you're gonna end up overloading systems. You definitely need to prevent doing thundering herd problem and things like that.
+
+**Aaron Schlesinger:** Yeah.
+
+**Brian Ketelsen:** Let's take just a minute and thank our second sponsor, which is Backtrace.
+
+**Break:** \[41:42\]
+
+**Erik St. Martin:** I'm still caught up on these design patterns for Go, like holy cow! \[laughter\]
+
+**Brian Ketelsen:** Walk away!
+
+**Erik St. Martin:** Somebody put some serious time in this.
+
+**Brian Ketelsen:** What I would love to see behind each of these is a conversation about whether these things belong in Go or not. Don't get me wrong, I love design patterns, and I love the concept of thinking about code architecturally, but I just think that there are some things that have absolutely no business in Go, or should be done in such a way -- maybe that's what the link to some of these should be. "There is really no pattern for this in Go, just use a stringer", and that should be it.
+
+**Carlisia Thompson:** I'm glad you mentioned that, Brian, because as we were talking before, I was thinking, wouldn't it be great if somebody could compile these idioms that at least you have been talking about, that Go has, that could be used in place of design patterns? If we could have a compilation of things and talk, like you were saying; this would be a good chance to do that. Here's the design pattern, here's how you would do it by using idioms in Go, without actually having to do a full-blown implementation of the design pattern.
+
+**Erik St. Martin:** \[43:54\] Yeah, more like, you know, you may be used to solving this with this pattern and this language, but this would be the way you would solve the same problem in Go.
+
+**Carlisia Thompson:** Exactly.
+
+**Erik St. Martin:** Hey, we have new episodes of Go In 5 Minutes for you, Aaron.
+
+**Aaron Schlesinger:** Alright. It's kind of like this whole page is... Each category might be an episode, or something. \[laughter\]
+
+**Carlisia Thompson:** Yeah... \[laughs\]
+
+**Erik St. Martin:** Another topic that I wanted to talk about - did anybody see that post with Facebook implementing the DHTTP load balancer in Go?
+
+**Brian Ketelsen:** I did. I read the whole darn thing.
+
+**Erik St. Martin:** That's ridiculously cool. I know that Parse was using Go, and they got acquired by Facebook, but now here's stuff where Facebook's actually adopting Go, and at the rack level, which is awesome.
+
+**Aaron Schlesinger:** Yeah, it's really cool.
+
+**Brian Ketelsen:** It's very complicated. I think of DHTTP and I think, "Yeah, I've got a DHTTP server somewhere", and I've managed networks that had even two DHTTP servers, but not so many that you need gigantic failover redundant systems and craziness... That's just a scale thing that very few of us get to play with.
+
+**Erik St. Martin:** That's always the stuff that interests me, the ridiculous scale that you don't typically have to think about.
+
+**Aaron Schlesinger:** It looks like they use this to bootstrap containers. They have their own internal container system, that this link say is called Tupperware. And it looks like when their containers come up, they use this thing to bootstrap their services, which is kind of crazy to me.
+
+**Erik St. Martin:** And allocate IP addresses, and all that stuff.
+
+**Aaron Schlesinger:** Yeah.
+
+**Erik St. Martin:** I definitely want to dig into it more. I read part of it, and then I got caught up and I didn't finish reading the article, I'll be honest, but it looked really cool.
+
+Alright, so I think we are about out of time... Oh, the other thing - anybody who was not at Golang UK - the videos are out, which is awesome. I've got more videos to watch, even though I haven't yet made the time to watch all the videos from GopherCon... And we're, how many months later? \[laughter\]
+
+**Brian Ketelsen:** It is what it is...
+
+**Erik St. Martin:** Yeah, we're still waiting for more to be released, too... But yeah, we need more time.
+
+**Carlisia Thompson:** Talking about the videos from GopherCon, there is one particular video that everybody is in awe with. It was a talk by Liz Rice. She basically did a container in Go live, in her presentation.
+
+**Brian Ketelsen:** Yeah, that was a really great talk.
+
+**Aaron Schlesinger:** I loved that. That was so cool. If I'm not mistaken, I think Jessie Frazelle started a repo that implemented this proof of concept where Go could build a containerized version of its own binary.
+
+**Brian Ketelsen:** Wow...
+
+**Aaron Schlesinger:** Yeah. It's containers all the way down, man...
+
+**Brian Ketelsen:** Inception!
+
+**Aaron Schlesinger:** Yeah.
+
+**Erik St. Martin:** I still like that -- what's the name of that project, the Unikernel one, where you basically could turn your Go app into a Unikernel?
+
+**Aaron Schlesinger:** Oh, that's cool...
+
+**Erik St. Martin:** I can't remember what that was. It's alright... Adam says we have 12 minutes left of the show, so I can sit here for 12 minutes and think about it. \[laughter\]
+
+**Brian Ketelsen:** Yeah, I don't remember what it is... And I should!
+
+**Erik St. Martin:** I wish I had the opportunity to watch some of the Golang UK videos so that I could make some recommendations, but I just noticed that they were out earlier today or last night.
+
+**Brian Ketelsen:** I watched Liz's because Dave Cheney sent out a tweet that says, "Everybody drop what you're doing and watch this." And when Dave talks, people listen. \[laughter\] So I did.
+
+**Erik St. Martin:** Unfortunately, I didn't see the tweet... Otherwise I would have listened, too.
+
+**Brian Ketelsen:** You see, you should have stopped what you were doing, because Dave said so!
+
+**Erik St. Martin:** Somebody needs to go out and tell the rest of the troops.
+
+**Brian Ketelsen:** \[47:58\] I retweeted it, isn't that enough?
+
+**Carlisia Thompson:** Yeah, Erik, everybody retweeted it. \[laughter\]
+
+**Erik St. Martin:** Apparently, I've been absent from Twitter...
+
+**Carlisia Thompson:** I don't know where you were.
+
+**Brian Ketelsen:** It was one of my most proud Twitter moments too, because I tweeted at Liz and I said, "We're watching for you at GopherCon next year, Liz", and I misspelled GopherCon... And boy, did I catch hell for that!
+
+**Erik St. Martin:** Oh, I remember seeing that!
+
+**Brian Ketelsen:** Of all the people in the world who should be misspelling GopherCon... \[sighs\] That gets the heavy sigh.
+
+**Erik St. Martin:** So being we're gonna run an hour for this episode, we've got a few more minutes. Another cool project that I saw was vuls, which is a vulnerability scanner written in Go. This is actually kind of cool; it seems like the infosec world is adopting Go for more and more things... There is this one, Mozilla wrote one called MIG, for doing forensic investigations across a large cluster, and Yahoo! I remember wrote one - I can't remember the name one... That was a web-based vulnerability scanner that was written in Go, and highly concurrent. I think that they just didn't release the rules that they were using for scanning, but the actual project itself was released, and I'll have to find it. Before this episode is out, I'll make sure that that ends up in the show notes.
+
+Speaking of episodes being out, last week's out is live, for anybody who's listening right now. This one will be out in a week. We are finally caught up on time, so we will record one episode and we will release the week prior, every week from now on, barring any unforeseen circumstances.
+
+Anything else anybody wants to talk about? We can start getting into some \#FreeSoftwareFriday?
+
+**Brian Ketelsen:** Yeah, I think it's \#FreeSoftwareFriday time.
+
+**Erik St. Martin:** Alright.
+
+**Brian Ketelsen:** I'll kick it off, because I love kicking it off. It's my thing. I've been reading Ben Johnson's blog posts, and I don't know if anybody's seen that WTF dial app that he's been doing, but it reminded me that BoltDB is a lot more awesome than people give it credit for. He wrote a nice justification about why sometimes it's okay just to use a key/value store instead of MySQL or Postgres. So I wrote two applications over this last week using BoltDB and find it to be about the most simple and painless way to store data on a disk. So a big shout out to Ben Johnson for BoltDB.
+
+**Erik St. Martin:** Alright, who's up next? Carlisia?
+
+**Carlisia Thompson:** I can go next. I want to give a shout out to Api2Go. It's a project in Go, and it's for the use case where you want to implement a RESTful API, and if you want your responses...
+
+**Brian Ketelsen:** The JSONAPI spec?
+
+**Carlisia Thompson:** Yes. If you want your requests and responses to conform to the JSONAPI spec, this will facilitate your life. It will let you do stuff by hand, if you want to just use the minimum interface that they have. But they have some interfaces that if you implement them, it will automatically map your routes to the methods that you're writing for your REST API, and it's fantastic. I've been using it for a project that I'm working on, and I love it. I haven't had any problem, it's super well documented, it's got a ton of examples.
+
+**Erik St. Martin:** How do you guys keep up with all of these?
+
+**Brian Ketelsen:** We don't...
+
+**Erik St. Martin:** Does anybody have a running count of the number of REST frameworks?
+
+**Brian Ketelsen:** I bet I've tried them all... \[laughs\] I'm willing to put money on that.
+
+**Erik St. Martin:** I have not seen this one yet.
+
+**Carlisia Thompson:** Oh, there are so many.
+
+**Aaron Schlesinger:** \[52:03\] Does anyone know how many are in Awesome-Go?
+
+**Erik St. Martin:** I need to look at Awesome-Go more often... It's been a while. It's probably been a couple of months since I've looked at Awesome-Go to see if anything new is there. But it's so big now, how would you even know? You need to export it and do a diff...
+
+**Brian Ketelsen:** My problem is that Awesome-Go is -- I don't think it's that curated. I think it's more, "Here's a pull request, and we've accepted it." And does their definition of awesome meet my definition of awesome? I don't think it does.
+
+**Erik St. Martin:** But that begs the question, "Does it make sense to have some canonical place to look for these things?" And then you switch to them and decide which ones you like. Although it's hard to tell what the adoption rate of one is versus another.
+
+**Brian Ketelsen:** So you could do something like npm search?
+
+**Aaron Schlesinger:** Oh man, that's a great segue into some \#FreeSoftwareFriday I wanted to mention.
+
+**Brian Ketelsen:** That was my troll for the day, right? \[laughter\]
+
+**Erik St. Martin:** Well, if it's a good segue, go ahead.
+
+**Aaron Schlesinger:** Alright... Well, I wanted to mention a library by Sam Boyer called GPS. It is a library that basically you import into your code; it's about ten lines of code, and you can get the entire dependency tree for any package, in a Go data structure. On top of it, it's being brought into the Glide project, which if you don't know it's a package manager for Go. It's also going to be used, I predict, inside of Peter Burjon's \[53:35\] working group to do better package management in Go. So I predict that this project is going to be used in whatever solution they come out with. Eventually, we're going to have something like npm search for Go, which would be amazing.
+
+**Erik St. Martin:** That kind of reminds me... There was another tool that I saw come out - I can't remember where it was or who mentioned it, but it basically does the whole visualization of your dependency tree for your project. For the life of me, I can't remember what the project name was, but I will link to it in the show notes, because I will find it; my brain won't be able to let it go. It basically drew out a big graph of your dependencies.
+
+**Aaron Schlesinger:** Nice.
+
+**Erik St. Martin:** Wait, somebody in the GoTime FM Slack channel just mentioned it.
+
+**Brian Ketelsen:** Ask, and you shall receive.
+
+**Erik St. Martin:** Right, so it's called goviz. I don't even know how to pronounce the GitHub username.
+
+**Brian Ketelsen:** We'll just put that one in the show notes.
+
+**Erik St. Martin:** And link to it on Twitter. But yeah, that was super cool, too. So for my \#FreeSoftwareFriday, I'm gonna give a shout out to Miek Gieben for CoreDNS.
+
+**Brian Ketelsen:** Whoow!
+
+**Erik St. Martin:** Yeah... That's such a cool project from the Kubernetes world. You're familiar with SkyDNS, right?
+
+**Aaron Schlesinger:** I am... Is that a question for me?
+
+**Erik St. Martin:** Yes, so SkyDNS has been around and connected to Kubernetes for a couple of years now, but Mieke actually completely rewrote it and worked with Matt Holt on refactoring Caddy, so that Caddy could be more pluggable, the way the configuration works, the middlewares and stuff. So CoreDNS basically can replace SkyDNS now, but it's massively cooler with the way the modules, middleware and stuff like that works.
+
+**Aaron Schlesinger:** That whole community around Caddy is just awesome to me. I love those people.
+
+**Brian Ketelsen:** Word! Big time! I use Caddy for everything, for two years now. I don't regret a minute of it.
+
+**Erik St. Martin:** Brian accused Matt when he was on the show of being the nicest person in the Go community... \[laughter\]
+
+**Brian Ketelsen:** I still think it's true.
+
+**Aaron Schlesinger:** He is!
+
+**Brian Ketelsen:** Yeah, he's awesome.
+
+**Aaron Schlesinger:** \[56:08\] He DM-ed me on Slack when he first started Caddy. He said, "Do you think Caddy is an okay name to use?" I said, "Well, what does it do?" He said, "It's a better web server." I said, "I don't care what you name it, build that! \[laughter\] People will use that."
+
+**Brian Ketelsen:** You can call it Bob, we don't care.
+
+**Erik St. Martin:** Yeah, call it Thing!
+
+**Aaron Schlesinger:** Thing, yeah. I love that guy, too. That whole community that he's built around Caddy is one of the best in software.
+
+**Erik St. Martin:** Yeah, just tying in ACME and Let's Encrypt...
+
+**Aaron Schlesinger:** Focusing on this concept of like security by default, with no extra work, no extra configuration, that's what we need. That's perfect.
+
+**Erik St. Martin:** I'm really interested to see how many other people spawn projects similar to CoreDNS using the Caddy libraries as the building blocks to build their own tools on top of.
+
+**Brian Ketelsen:** Yeah, this refactor really made it amazing to do that, so why not? We need a blog post.
+
+**Erik St. Martin:** Somebody needs to come up with a new idea.
+
+**Carlisia Thompson:** We did so many blog posts out of this episode, it's not even funny.
+
+**Brian Ketelsen:** You know what we need - a 5-minute video about it.
+
+**Aaron Schlesinger:** Actually, I'm way ahead of you. I'm not doing it with Caddy, I'm doing the ground-up thing with Lego.
+
+**Brian Ketelsen:** Oh, nice!
+
+**Aaron Schlesinger:** But Caddy might be a good one to follow up with.
+
+**Brian Ketelsen:** I've decided I'm not gonna use Lego for anything. I'm not gonna manage that... I just reverse proxy everything behind Caddy and smile. \[laughter\]
+
+**Aaron Schlesinger:** That's not a bad idea, actually.
+
+**Brian Ketelsen:** I do, I'm not kidding. Just... Why? Why do it?
+
+**Erik St. Martin:** I haven't even set Caddy up as a reverse proxy yet.
+
+**Brian Ketelsen:** Oh, it's so freakin' easy.
+
+**Erik St. Martin:** Most of my stuff is kind of hidden away right now. I'm working on stuff that just interacts with Kubernetes libraries and stuff like that. It's not kind of exposed. So I think now we are actually out of time. Anybody have any closing notes before we call this thing a wrap?
+
+**Brian Ketelsen:** No.
+
+**Carlisia Thompson:** No.
+
+**Erik St. Martin:** Alright then. I wanna thank everybody for being on the show, especially thank you to Aaron for coming on this show. Everybody definitely check out his Go In 5 Minutes videos; I think it's gonna be really interesting to see all the new ones that come out from this show. I think we've had a lot of good discussion. Thank you to the listeners, everybody who's listening live and interacting with us on Slack. Definitely subscribe - you can go to GoTime.FM to subscribe if you haven't already. We are on both iTunes and the Google Play Store. Follow us on Twitter @GoTimeFM and github.com/gotimefm/ping if you want to be on the show or have recommendations. Definitely thanks to our sponsors today too, Linode and Backtrace. With that, goodbye everybody!
+
+**Brian Ketelsen:** Goodbye!
+
+**Carlisia Thompson:** Thank you Aaron, and goodbye everybody!
+
+**Aaron Schlesinger:** Goodbye, everyone!

Go work groups and hardware projects_transcript.txt

@@ -0,0 +1,471 @@
+**Erik St. Martin:** It's episode \#22 of GoTime. Today's episode is sponsored by Linode and Code School. Today on the show we have myself, Erik St. Martin, we have Carlisia Campos - say hello, Carlisia.
+
+**Carlisia Thompson:** Hi, everybody.
+
+**Erik St. Martin:** She's still laughing from everything that happened before the show, I can hear it.
+
+**Carlisia Thompson:** I'm trying to hold it back.
+
+**Erik St. Martin:** Brian Ketelsen was not able to make it, but today standing in for him we have Cory LaNou. Say hello, Cory.
+
+**Cory LaNou:** Hey, everybody!
+
+**Erik St. Martin:** And our special guest today is a core contributor to Go and probably familiar to just about everybody. I'll go ahead and let her give her own introduction. JBD.
+
+**Jaana Dogan:** Hello. I work on Go. I actually have been contributing to the project for the past years, and I've just started to contribute as a part of my full-time job. My role in the team is pretty unique. I wouldn't say that I am contributing code to the project at this point; the team wants me to be a user, a power Go user, so looking at things from the perspective of the user, keeping writing code against Go, rather than contributing more code to Go.
+
+I'm kind of like a typical Gopher, but live in maybe one release cycle in the future, and exposed to tip, development going on on the tip and what is coming up next. My responsibility is particularly giving feedback about the usability API design, where things require more thinking from the user's perspective. I've recently started to do this job, and I was late for 1.8, but will be more involved in the future releases. It also depends on how many user-facing critical changes are coming in. That's what I do.
+
+**Erik St. Martin:** So what types of applications are you developing? Because it seems like you do a lot of stuff in hardware, audio and mobile... Is this kind of tackling each of these areas and just trying to build applications and see what you run up against?
+
+**Jaana Dogan:** Yes. I was originally working for Google Cloud, and somehow bootstrapped all the cloud libraries, some sort of like good API design and idiomatic libraries, and everything around cloud products and how we can actually interact with the ecosystem so much better. I kind of like moved to another role to work on the mobile project. The scope of the mobile project was first making the runtime running both on iOS and Android, and then come up with some libraries that will work on those two platforms and providing some tooling similar to Go tool, that will allow me to build mobile applications rather than just the binary. I was involved in that.
+
+\[03:43\] As a continuation of that work, last year I was working with the Android team. Android is going through some sort of reorganization when it comes to building some tools and some more structure to build custom Android kernels. The team also wanted to expose GPIO and other peripheral communication interfaces from Android, and wanted Android to work on popular Linux development ports, so I was involved in there, trying to figure out how we can make Go as a first-class citizen for Android, targeting on the embedded markets and what they are envisioning for the future.
+
+**Erik St. Martin:** So this is sort of like people who are using ODROID or Xen BeagleBoard Blacks and things like that, that even can get Android on?
+
+**Jaana Dogan:** Yeah. This is just Linux boards. This has been such a historically much requested feature, to be able to extend Android with board-specific hardware abstraction. What was historically requested was a more extendable hardware abstraction layer, so you can contribute more board-specific things and extend the capabilities and deploy Android to other billions of Linux boards around. So the Android team is trying to meet that goal by making it more configurable, so any manufacturer can take Android and make it work on their Linux board.
+
+**Erik St. Martin:** Awesome. Brian's been playing a little bit with writing Go on a Raspberry Pi for his smoker.
+
+**Jaana Dogan:** Oh, nice. That's awesome.
+
+**Erik St. Martin:** That's just too much fun. Smoking dinner with Go.
+
+**Jaana Dogan:** \[laughs\]
+
+**Erik St. Martin:** I just love creativity with that, and we've seen a bunch of that stuff, too. You're constantly showing stuff off on Twitter.
+
+**Jaana Dogan:** Yeah, there are billions of projects. I have billions of projects; I personally like physical buttons a lot, so I just realized that my entire world is surrounded by software and touch screens and things; that's why I was just replacing things with hardwired physical buttons that I feel more comfortable with. There was tons of things to do.
+
+Due to the relationship with the Brillo Project, the Android project is called Brillo Project. Android focusing on the embedded aspects - it's called Brillo. We're getting so much stuff from China every month... We had this huge repository of devices around and sensors and all sorts of displays. It was really fun times.
+
+**Erik St. Martin:** It occurred to me one day, because I was looking at the piles of stuff I have here... Because I have a similar thing - when I'm tinkering with electronics, why am I gonna buy one chip from SparkFun or Adafruit when I can just buy like a hundred of them for a similar price from China? And then all that stuff acquires, and it's sitting there in the drawers, and it occurred to me one day when I saw something you were posting, it's like "I wonder what your stash looks like..."
+
+**Jaana Dogan:** \[laughs\] We created a couple best combination of things, because I was working on a developer-facing product and we were also trying to come up with a set we can propose as a de-facto combination of those little devices, so the users can run the tutorials with them. And yeah, we've been thinking too much about them, thinking about designing custom things, and it's been so much fun.
+
+**Erik St. Martin:** So Cory and Carlisia, do either of you have experience tinkering with the hardware side of things or embedded?
+
+**Carlisia Thompson:** \[07:52\] I did at the Gopher Gala last year. Nathan had a project and I joined to help him a little bit, with also somebody else here from San Diego Ravi. So I got to play with a Raspberry Pi, and we put in code that actually made the Raspberry Pi use a motion sensor, and that was very cool.
+
+I sort of have an irrational aversion to hardware, because my impression is that hardware doesn't work when I touch them. \[laughs\] I don't know, it's completely irrational. So I try to stay away from hardware in general, although it's pretty cool.
+
+**Erik St. Martin:** You give off like a static charge that just messes up all electronics?
+
+**Carlisia Thompson:** Yes, but it's like... It's supposed to have a button and I don't find a button, and these ridiculous things... But at any rate, I thought the Raspberry Pi is small and I could handle it, so I really fell in love with it. But I didn't play much with it after that.
+
+**Erik St. Martin:** One of the things that I think I loved the most was learning how simple serial protocols are. Then what you do is you buy yourself a logic analyzer and then you start finding random pieces of electronics and trying to find the chips and what their serial ports are, and then start geeking in on what it's doing. \[laughter\]
+
+**Jaana Dogan:** Are you doing any serious debugging that way, or is it just how you investigate what is going on...?
+
+**Erik St. Martin:** It's more from just like a reverse-engineering standpoint, like "How does this work?" I've tried a couple of times to send my own commands and stuff on regular boards, but that's usually where it gets not so simple, because ordering comes into play. Reverse engineering any sort of protocol is hard because you have to understand...
+
+**Jaana Dogan:** But a logic analyzer is the printf of working with these protocols, and people were so surprised that I have scopes and all these logic analyzers around. But it's just like a mandatory requirement.
+
+**Erik St. Martin:** Yeah. So you start with something like a Raspberry Pi or Arduino, and you can look at that and you might be able to debug from a website the commands that you're sending, but ultimately you end up on GPIO pins and communicating with other hardware. At that point, you're cut off, and it's really painful to try to get it to blink a light a number of times when it hits somewhere and debug that way; typically you wanna probe in with a logic analyzer and look at the communication.
+
+**Jaana Dogan:** Yeah. And sort of like trying to understand what is going on with the kernel driver... I've been exposed to a couple of bugs - it was impossible to get anything done without actually looking at the final output of the signal.
+
+**Erik St. Martin:** I think it's fun for people to learn at the hardware level, too. I love having oscilloscopes, plugging it on audio wire and looking at what audio actually looks like...
+
+**Jaana Dogan:** When I was a child, my father introduced us into signal processing by just looking at oscilloscope output, and I gathered so much information from there by just... I remember we had a very small set of -- we were just producing some sign wave, and looking at it and changing the frequency, and it just gave me so much... Then he also introduced us to bitwise modulations and things like that; visualization is just perfect. I think as a part of our education we should also encourage more of this way of thinking, by looking at what is going on and reverse engineering it.
+
+**Erik St. Martin:** Yeah, I was teaching my son a while back... Using an oscilloscope we made almost like a theremin, just a 555 timer and a little light sensor. He had a blast with it until we got annoyed with the high-pitched sound that it made. I didn't quite think that went through, that he would love this thing and wanna play with it. \[laughter\]
+
+\[12:08\] So is hardware your true passion, and kind of where it meets software? Or is this just something you do to break away from the software side?
+
+**Jaana Dogan:** Yeah, more of the latter. I have a full-time job which is already boring. I think my entire projects have grown with the necessity of me having to design or prototype a hardware for my music experimentation. I still try to build instruments, rather than working on the... I don't know how to say this, but my entire music is very experimental, and also involves hardware I invent, as well as software. So it's more like a side project, a weekend project where I escape from my daily routine.
+
+**Erik St. Martin:** Yeah, I think that typically is what I do, too. Mine sits for months on end sometimes. I think I like thinking about that I might one day have the time to work on some secret project I have in my head. Then I create new ones without ever finishing the one prior. It's like, "Oh, I wanna help with building the barbecue controller." Then we're playing with RC cars one day and it's like, "Oh, I'm totally building a traction control system for my RC car..."
+
+**Jaana Dogan:** I think that's the beauty of all this maker thinking. We are always in this constantly "work in progress" projects; we invent by looking at what is going on and what is in common... I think we are doing this for the joy, rather than trying to achieve anything. I think that's fair.
+
+**Carlisia Thompson:** I wanted to go back a little bit, and I didn't jump in right away because I was looking for the link. Erik once mentioned the course called NAND To Tetris, and I'm super looking forward to doing it. I think I'm going to be able to do it next year.
+
+It's basically a course that takes you from the very basics, and step by step all the way up to building a modern computer. And the good news for me is that it's all simulation, and I don't have to deal with hardware.
+
+**Jaana Dogan:** Nice.
+
+**Carlisia Thompson:** I personally don't have anything against hardware; as I was saying, they just don't work with me... I don't know, I just have this impression. But in this case it's all simulation, and you don't have to... And it gets expensive too, buying these one-off things. But this is really cool.
+
+I'm saying this because I also think it's very important for us to learn a little bit more about what it is that's below of what we are doing.
+
+**Jaana Dogan:** I totally agree. In order to contribute to the first argument, I think simulation is really important. For Brillo, my co-workers were more passionate about building a graphical interface that allows people to understand what it feels like to work with GPIO, rather than work in anything else. The number one reason is making hardware work, and making sure it's working correctly; getting it to a state where everything is working is really hard, so you just wanna have a feel, how it feels, what the APIs look like, how easy it is without touching any of that stuff. So I think it's just really valuable to have simulation going on.
+
+**Erik St. Martin:** \[15:55\] I think that there's cheap ways people can do electronics too, and I wanna say that to make electronics work is like learning through discovery, or something like that. The number of components that you need is pretty small, and I think it's nice to have that hands on, and for people to learn what happens and what a burnt capacitor smells like. There's something interesting about doing that.
+
+The NAND To Tetris book that Carlisia was talking about - I love that book. The one thing I don't like is that chapters go really fast, so you kind of need supplemental learning material, but it starts at kind of like gates and boolean logic, how to build a NAND gate, and then how those are kind of assembled. Then you can basically build the ALU of a computer using nothing but NAND gates. Then it kind of builds up there where you kind of have your own assembly language, then your own assembler, and then kind of like an object-oriented language and then a virtual machine.
+
+The thing that I love about the book is each stage is kind of on its own, and they have a way of unit testing your stuff. When you try to build your assembly language, it has expected inputs and outputs so it can validate it.
+
+It's a really cool experience for people who are interested in learning from the hardware level up into the code that we write every day.
+
+**Carlisia Thompson:** And they have a course on Coursera, too.
+
+**Erik St. Martin:** Oh, they have it on Coursera now?
+
+**Carlisia Thompson:** Yeah, so they have the book and they have a course on Coursera.
+
+**Erik St. Martin:** Yeah... So Brian isn't on the show because of choppy internet connection where he's at in London, but he's heckling us from Slack. He just reminded me of the person who built the ALU in Minecraft using the same book as his approach, which was really interesting. You set the binary number with torches, and that goes through all these little things and the cows move... \[laughter\] Then you go the other side and you can read the output.
+
+I'll find a link to the video where somebody is messing with it, it's hilarious. You wonder, "Who sits there and thinks of that?" Like, "Oh, I just did this NAND To Tetris thing. You know what I should build an ALU with? Minecraft!" \[laughter\]
+
+**Jaana Dogan:** Very cool. I kind of feel like we were the last generation who has some sort of privilege to understand everything, from end to end. When I was a child, the personal computers were so small... I remember having a Spectrum, and its manual was basically starting with BASIC programming language. The computer architecture kind of like gives you all the main components and how they work and how they interact with each other. The final chapter was an instruction set, and how you can write optimizations and things.
+
+By looking at the current complexity of the things, I think the current generation doesn't have the same privilege to learn and understand everything from end to end. What Raspberry Pi was trying to do was trying to make things more accessible. I think all the Linux boards are doing a better job now, but everything is just too complex at this point; there's just so many layers, and it's so easy to get lost.
+
+When I introduce myself, that I'm supposed to be a power Go user, and giving people, the team, usability API design feedback, maybe initiating libraries and tooling to fill the gaps... If there's any experimentations required, probably I have more time to run experimentations, so it's part of my responsibility. And I'm still in this transitioning period, and while I'm there, I'm just trying to listen to the community and gather some feedback, actionable items.
+
+\[20:02\] One of the things that Brian was mentioning is this feedback around tooling. I wanna understand, rather than specific bugs and complaints, what are the bigger picture problems. If we would like to rethink our tooling, what should we fix and how should we fix it? This involves an understanding of the current workflow of the users and what is missing there, and trying to understand more of a bigger picture, rather than focusing on little things.
+
+I'm kind of surprised by the number of people who actually returned back to me and wrote about how they feel about certain things, things that maybe need to be redesigned or can be supported by experimental tools or extension tools. I'm really excited to hear more, and I do believe as a community or as a language we will never succeed if we cannot create this type of feedback channel and question what we are doing once in a while.
+
+**Carlisia Thompson:** I'm wondering if you are using any guideline or if you are trying to go in a specific direction to avoid having the vocal minority speak for the issues that are not a priority for maybe the majority of the people. Or maybe you're looking into having usability as the guide for what you are doing, or any other guideline that you are using, to make sure that you're achieving your goal no matter who's responding to your request.
+
+**Jaana Dogan:** Absolutely. The goal of this project is not trying to understand what the established users are trying to do... Let me give a little bit of insight of how I see things. I think there are too many reasons why people learn a language or just get involved in a language. The first one is personal development or interest - this is what mainly made the initial Go community. These people have more tolerance, they're more passionate about the challenges for the sake of learning.
+
+The other type of people comes there just because it's a requirement. It's enforced by your employer, school, whatever. I think our community was so dominated by the first group that we couldn't really question too much about how we're treating the newcomers and what is missing. For a person that is not coming from the same background that our community is coming from - what is missing?
+
+I think our language and tooling is totally built on historical conventions, but are we doing anything to communicate them? Are people getting lost just because they cannot make the connections?
+
+I really liked Katrina's talk at GopherCon this year because she was pretty clear about this. When I looked at the spec, I understood everything, but I wasn't able to make the connections and was not able to line up all the different topics around the sentence I was reading. I think it's generally true for everything, not for the language spec - when it comes to APIs, when it comes to what we consider good readability, or tooling...
+
+I think we are coming from a typical background, and everything is so much clearer to us, but not true for the vast majority in tech.
+
+**Carlisia Thompson:** And have you been able to at least have some insights about things that can be done to make that better?
+
+**Jaana Dogan:** \[24:05\] My audience is a little bit restricted. I cannot really go to people who are coming from totally different backgrounds and I cannot enforce them to use Go and give them feedback. The only way I see which might be valuable but it's still not ideal - because it's a small subset of the same culture on itself... I think new graduates, or people who are at Google who really believe that this language is not really a product that is fitting their worldview might be a good place to seek for that type of feedback. That's the only practical, easy and actionable thing I can work on.
+
+I think the main goal of rethinking about these problems is to make newcomers happy, rather than working for the existing users. Because existing users already know what they need to do.
+
+**Cory LaNou:** When you talk about newcomers, I'm curious if you're primarily targeting the traditional newcomers that are just coming off of projects that Go is gonna just work better for or are you actually targeting people coming from the different fields of technology, technology that Go is not already being used in?
+
+**Jaana Dogan:** I'm particularly targeting people who either have experience - or inexperienced - in another language, and just trying to use Go as a replacement.
+
+**Carlisia Thompson:** It sounds to me that one challenge that you have is to help people see the benefits of Go without going through so much hassle. Because people can read a blog post, "Oh, Go is very productive and Go is very fast" are the positives, but they still have to commit to trying it out. And maybe making that gap shorter, from the moment they get exposed to the idea of using Go, to the moment that they actually do something with Go and see the results. I guess what your challenge is in making that gap as short as possible.
+
+**Jaana Dogan:** Yeah, this kind of also relates to the first initial idea I had, how I see people... I still see people who already believe that this language could be valuable for themselves and trying to invest time in this language has a little bit more tolerance. I understand what you're saying, but I don't have a really clear answer to how we should gather feedback from people we don't know and people who are not necessarily talking to us.
+
+Maybe what we need to do is more of like typical user studies where we just put people who absolutely have no background in our material and see how well they're going and how they feel, as a feedback.
+
+**Cory LaNou:** Do you think it's the language features that is the time that we have to spend the investment on for newcomers? I say that because when I came to Go, everything was easy. I mean that from the standpoint of like using other languages, there was a lot of work; there was a big environment to set up; you had to have everything just right, you had to have a special editor, and then once you got it going, the language syntax was very difficult. All those things in Go are really easy, so I'm curious...
+
+It sounds funny, right? We're trying to optimize for these newcomers and give them the onboard faster, and I think that's great, but I also feel like it's phenomenal compared to most other languages already. So I'm curious what aspects do you think that can be improved the most?
+
+**Erik St. Martin:** \[28:01\] I'd like to kind of jump in here too, because there's one area that I think we can improve in. When we look at the walkthrough online, the Go tutorial - it goes through a lot of the language features, but some of this stuff is not necessarily approachable just in domain knowledge.
+
+One instance I know of somebody who's going through the tutorial and got hung up on one of the things, and I think he was just working with slices or arrays or something like that, but the object of that particular chapter was to build bitmaps, or something like that. And it was really confusing just understanding what the domain model was. And then a lot of people are still learning in these bite-sized chunks.
+
+One of our sponsors, Code School... In the Ruby world they had the Rails For Zombies thing, and people could connect with that. They're building this little game and it deals with zombies and things like that, and it makes things a lot more approachable because understanding the domain isn't there anymore. It's not understanding "What do you mean by 'build a bitmap'?", it's just dealing with the task at hand, working with slices.
+
+Actually, on that note, before we continue back into this, I guess it's kind of like a perfect transition because one of our sponsors is actually Code School, and they've just launched a new Electives course, for anyone wanting to get started in Go.
+
+The course is lead by Carlos Souza and has five levels. Level one is completely free; all you have to do is head over to CodeSchool.com/Go, click on the giant Start Course For Free button and create a free account to get started. Level one has two videos and eight challenges, and the cool thing is that all of the coding will be done completely from your browser. You don't have to hassle with installing Go, messing with your Go path, or any of these things. You can just sign up for your account and get started.
+
+After you've made it through the first level, they have four more levels that have around 30-35 challenges that will work your way through variables and type inference. You can learn about all the data types and error handling, collections, and by the time you make it down into the level four and five, you get into some of the unique factors that bring many people to Go, working with values and pointers, receivers, interfaces in composition, how to structure packages, writing concurrent code, which is the primary reason a lot of people are coming to Go.
+
+Make sure you head over to CodeSchool.com/Go, try out the first level. Thanks again to Code School for this awesome course and for sponsoring the show.
+
+So just before the break, Cory was asking you, JBD, what areas you think can be improved to optimize for newcomers?
+
+**Jaana Dogan:** I do not believe that we have an easy onboarding experience. When I started using this programming language, I learned so many things through code reviews and asking people... One of the obvious examples is we still don't have Canonical tutorials for the tooling, and it just took me experience to get there and feel productive, that that certain point where I feel like "Yes, I understand this language, its tools and everything."
+
+I think initially the community was more of exchanging ideas and knowledge; there was a lower barrier to contribute to one of the contributor's codebase, and get your Go code reviewed, and information was so much easier to access. I don't believe that it's true anymore. What do you feel about that?
+
+**Cory LaNou:** I guess I think that makes sense. Maybe part of my comment there might be because I've been doing Go so long it feels pretty natural, but I guess I do remember when I came online the toolchain I definitely struggled with, and I think that's what you're commenting about. The language not so much, right?
+
+**Jaana Dogan:** Yes.
+
+**Cory LaNou:** \[31:56\] But I guess I do remember struggling with "How do I get my tester on? How do I get this to build? How do I install this thing?" That was a lot of searching on Google for me to find that originally, so I can definitely understand that.
+
+**Jaana Dogan:** Yeah, I kind of feel the same, even for the error messages from the toolchain. There are so many cryptic things... Once you learn what the message means, you are productive and understanding the case, but it just requires you to always google things, and I think that's the goal of my project and how I see things, how I prioritize these improvement projects.
+
+**Cory LaNou:** One of the things that I found very helpful in the current toolchain is a little tool that Ben Johnson wrote, it's called GOO. Instead of running Go Test, I run GOO Test all the time; what it does is it detects the very first error in the stack output every time, and copies it to my buffer and it highlights it. It's nice when you do a Go test and "Here's your 15 errors", you really care about the first one, right? It's all you care about. Something that simple is actually incredibly helpful.
+
+**Jaana Dogan:** Yeah. The feedback I'm gathering is tons of small improvements like this. There are so many things that actually will make us reconsider things, but there are tons of things to improve by just changing the order, making something more highlighted and small - things like that.
+
+**Carlisia Thompson:** And thinking about improving things just by changing orders, I think it would be great if we had a website that was easy to use and contained a path, from beginning to the end, from beginner programmer, newcomer to Go, to very advanced software development. It's not that it's supposed to contain everything, but it's one path; then people can veer from that path as they need, but at least they have one path.
+
+For example, I ran into this website called go.java - it has nothing to do with Go, it's just called go.java. And it has that - it has four menus at the top. It's Learn Java Skills, Create and Contribute, Develop Software (obviously, for more experienced developers) and Lead Your Organization - if you're an organization, what do you need? Great. Those are the paths. Those four things I think will lead anybody from where they are to the next step.
+
+This past year I've seen the level of resources increasing dramatically, but it's still hard to find... You have to be sort of keeping tabs or searching, and you're not sure, like "Is this the best one that I should be looking at for me?" We don't have that entry point anywhere. I mean, we do have the blogs, of course, we have the documentation, but I think we can improve immensely on that front.
+
+**Jaana Dogan:** We've been thinking what Rust has done. They have a book, and it's just like more of canonical guidelines to do anything; it doesn't explain the language, but the entire ecosystem. You know, you have binary, but how to... Maybe we can include best practices for production and things like that.
+
+I do think that the blog was sort of like being used to publish white papers, but it's not quite organized and it doesn't give you navigation. I really believe that we need some sort of another medium to write guidelines which may also contain what you've been saying, or the thing that I was mentioning with the toolchain where there's no canonical way to see what I can do with this aspect. So I agree, and I think there are multiple people agreeing on that, and there are some people who are already working on it.
+
+**Carlisia Thompson:** \[36:14\] Awesome.
+
+**Erik St. Martin:** Yeah, I think that tends to be the struggle. I think there's a lot of resources for teaching the semantics of the language, but then people look at it and they're like, "Okay, how do I get from A to B? I understand these different constructs of the language, but I wanna build a web service. Where do I start? What does a typical structure of an application look like? Am I doing it right?" I think people give up there, which is interesting.
+
+**Jaana Dogan:** We are thinking more than just production of building some of the best practices about building systems. I think the next year or two will be more about trying to understand how we can communicate best practices once you have a Go binary. Yeah, you have a Go binary - what is next? What are the best practices for production, or what we can teach people to think about building large systems, what we can do for diagnostics, instrumentation, profiling, tracing and debugging?
+
+Some of these items require actually some community-wide solutions. The next one or two years will be more like investigating what to do now. The entire ecosystem should be more focused on playing with the binary, rather than achieving the binary.
+
+**Erik St. Martin:** That's interesting. I guess this is probably just part of the growth of a language, right? I mean, we're still very, very early on, so those types of things are maybe the natural progression in a language. How would you contrast that to other languages?
+
+**Jaana Dogan:** I would say that it's the typical... I mean, the only language I was involved with from the very beginning to the end was Java. I think it's just natural that you expect people to focus on readability idioms, learning the language and mastering it. Then, taking it to the next level is actually about building really good production stuff with it, and supporting the production teams.
+
+I do believe it's natural in every language that the focus will be shifted more to the other aspects, because there will be more knowledge on the idioms in the language. I think it's very natural that we are shifting towards that way.
+
+**Erik St. Martin:** You said you had some other points you really wanted to discuss, for the wider community to be in on, right?
+
+**Jaana Dogan:** Yeah, I think understanding what we are going to be working on in the next two years is the biggest challenge we have, because the scale is really big and there are too few people on this project, working full-time. The community is growing, but I do believe that our communication is pretty broken. The main reason - let's put it this way... I think all the random topics we've talked about are always being talked in random conversations. We need more structure, probably, and better communication to achieve anything that will expand our impact region.
+
+\[40:00\] What I really see missing in our community is there's no point of talking about transmission feedback; in the beginning we had more central points, and our community is getting really big, so it's really healthy that we have distributed communities. But as we are getting more distributed, it's so much harder to gather feedback, and only a very small portion of the communities are actually contributing to the development of the language. This is pretty expected, but I see really obvious cases where people are complaining on Twitter, but then I see that there's no issue filed, and I'm just trying to understand what is the missing thing that makes that person not feeling encouraged to file it as an issue.
+
+**Erik St. Martin:** That's interesting. Have you seen the way the Kubernetes processes developed? This is actually gonna be what I'll mention in the \#FreeSoftwareFriday section, but I think it kind of fits in here. They run special interest groups. There's kind of like split up...
+
+**Jaana Dogan:** That was basically what I was trying to achieve, I was about to explain. I do believe the only way to get there is creating focus groups and work groups probably. We pretty much have an understanding of which areas we should invest in, and there are already so many people from the community who are working on their small, personal projects or their company-sponsored projects, but there's no discussion around those topics in a collective and systematic way.
+
+**Carlisia Thompson:** There seems to be a recognition from you; is this recognition shared by the other Go Team members, and do you find that there is resistance...? Is everybody trying to figure out if this really applies, or are you already moving in the direction of trying to find solutions for that?
+
+**Jaana Dogan:** In the Go Team there is a subgroup called Cloud-Related Projects we have at Google and beyond. This team is mainly responsible for just making sure that everybody is committed to good APIs and trying to understand how they can support the community...
+
+For example, this particular subteam was pretty supportive of the workgroups, because their work... As I said, the biggest challenge is the scale is so big, and they would like their work to be impactful. Listening to the community and trying to react according to the necessity of the community requirements is the top priority for the Go Team.
+
+We're trying to establish this workgroup and see if it's going to work, because if our communication is not efficient or if people are not participating, or if we are not really making the communication accessible, this model is not going to work either. So we would like to try with at least one workgroup to see how it goes. From that point on, there's been other people who suggested other work groups, other responsibilities, and I think this will naturally happen.
+
+Without this structure, or some sort of giving ownership, or more collective feedback from the users or the contributors, it's just impossible to scale the language.
+
+**Cory LaNou:** \[44:08\] Yeah, I think the micro groups is definitely a way to go there. I think some of it is when you're on a micro level and say, "We just expect the entire world to weigh their opinion in." It's hard, it's not approachable. For me, personally... The Go community is fantastic and I find the people that are in the Go community to be really approachable. This is just my perception, but I've never felt like the Go Team has been approachable. And I'm not saying it's their fault, I just feel like there's no conduit that I have that's "Hey, I wanna express my opinion" other than if I tweet something out and hopefully I don't get any backlash from that. So the approachability there might be part of the problem, as well.
+
+**Jaana Dogan:** I think the main problem is we don't have a channel to brainstorm ideas. Currently, you have the issue tracker. You have the proposal process, which you definitely need to come up with something really mature and working in order to propose and get it reviewed. There's nothing in between. It's so hard to understand, and just like work on existing, random ideas or brainstorm about what could be done, just because of the lack of that lightweight... I don't know, I do believe it's the lack of medium, rather than people not trying to listen.
+
+Ranting on Twitter, or... I think each team member has some capacity, and we need to provide data to them in a more aggregate way, so they can consume and effectively solve issues.
+
+**Cory LaNou:** I think also just letting the community know that you're looking for direction and you're looking for input too, that will be a big deal. I think most of us just kind of go along our merry way, and we figure "Hey, this is Google. They've got this under control, they know where they're headed", right?
+
+**Jaana Dogan:** That's not true... I mean, Google actually hired me to work on this project to give feedback to the team. People think that Google has a really big control on this language. Google didn't really care about this language for a very long time; it's becoming more popular very recently, but I think the perception is wrong. It's more about having no channel; without having a good channel, it's just impossible to have a healthy communication, and it may sound more isolating or ignoring the actual facts just because you don't have an efficient way to gather this feedback and execute on that.
+
+**Cory LaNou:** Right. I think my point is - and again, in no way I'm trying to insult Google or Go or the team, I wanna be really clear... I think it's the fact that, you know, I'm pretty involved in the community, so if I've got that perception, and I don't think I'm probably alone there, right? So I think it's one of those things where it's really good that you're talking about this and you're really letting people know that "No, we want to go in this direction and we're looking for this participation."
+
+**Jaana Dogan:** Yeah, I agree. I think this is not really communicated well, but I don't really believe that anybody is against this.
+
+**Carlisia Thompson:** The people that will form these committees, can they come from outside of Google?
+
+**Jaana Dogan:** Yeah, absolutely. I don't really believe that having more googlers on this project is going to help, because it really shaped around Google, and it's blocking itself or blocking its reach because it's so totally dependent on the Google culture. I think everything should be outside of Google, ideally.
+
+**Carlisia Thompson:** And for the Google Cloud platform working group - at least that's what I understand - it's already in motion...
+
+**Jaana Dogan:** \[47:54\] Oh, that's not the Google Cloud. We don't care about a specific provider.
+
+**Carlisia Thompson:** I'm sorry, what working group did you say you were going to start with?
+
+**Jaana Dogan:** We were thinking about a cloud workgroup more than any provider. We were just trying to understand more production-related stories and beyond - support, APIs, and what we can contribute to the community to make it easier. We're trying to achieve things that are provider-agnostic.
+
+**Carlisia Thompson:** And do you have already any guideline for people to raise their hand and say "I want to participate in this working group"? Do you have criteria for selection for people to join in?
+
+**Jaana Dogan:** This is still a proposal internally, and I'm working to finalize it. I wrote the proposal myself. The initial idea was to initiate some sort of feedback from different people and understand the requirement for a workgroup, and if people agree, I think what we'll do is just continue. I don't have specific people in mind, but as long as I announced this thing, I think I will just try to gather feedback from people. I think naturally people who are giving feedback will be a part of the workgroup in the future.
+
+**Erik St. Martin:** And it's published, too. For the Kubernetes groups, the way they operate the special interest groups is there's a published list of them. If you're interested in the way networking works, or scheduling, you have all the contact details there, who the primaries are, they have weekly meetings where they do demos, and you can comment on that stuff. There's a lot of that stuff that I think could be played with to get everybody interested in specific areas, collaborating better.
+
+Like you said, you're just throwing it out into the sea when you're complaining on Twitter and you hope that somebody who has the means to solve that problem for you sees it.
+
+**Jaana Dogan:** I think we can also solve this like... The core team doesn't have bandwidth to think about these issues by just sharing the responsibility with other groups, and naturally just because there will be a group that is assigned to think about these problems, I do believe that the feedback loop will be more efficient.
+
+**Erik St. Martin:** I think another thing that you wanted to talk about was why languages succeed and fail, but before we do that, let's talk about next sponsor, Linode. If you head over to Linode.com/gotime, you can get your very own Linode up and running in seconds.
+
+Choose your flavor of Linux, the amount of resources you need, and choose from any of their eight data centers spread across the world. You get full root access, you can run VMs and containers; if you haven't had the chance to play with Kubernetes, now's a great time to go there and spin up a couple of Linodes. Three nodes will cost you $30/month; even if you wanted to play with it for the weekend, they've got hourly billing.
+
+They also have a great CLI app, so that you don't even need to log into their website if you wanna deploy or tear down some of your Linodes, and a great HTTP API. Even though there's not a Go SDK now, but we'd love to invite you to create one and open source it. If you do, please come talk to us, we'd love to hear from you.
+
+If you head over to Linode.com/GoTime, you can use the code "GoTime20" to get two months free, which is a $20 credit with unlimited uses. Make sure to tell your friends and head over to Linode.com/GoTime.
+
+So you were talking about language succeeding and failure mostly due to communication?
+
+**Jaana Dogan:** Before we get in there, I've seen something on the Slack channel... Aaron is saying "Working code speaks louder than workgroups to start serious conversation." I partially agree with this, but I partially disagree. I think experimentation or community-driven projects have a really small scope. You cannot achieve community-wide APIs by starting experimental projects, or personal projects because you're by design excluding so many aspects, as you're restricting yourself to your own goals.
+
+\[52:15\] I think the idea behind workgroups is to see what else is there. Otherwise, it's just easy to execute working code and solve a small aspect, but I don't really believe that working groups -- the main goal behind working groups is solving specific problems in its own small scope.
+
+**Carlisia Thompson:** One thing to keep in mind when you bring up these concerns is that you're looking at it from the perspective of scaling the use of Go. We are relatively new, maybe not so new anymore - I don't even know if we should say we're so new - and we are trending upwards in terms of adoption, and your concerns that we don't have such a great communication, we don't have such great channels for feedback, feedbacks are being given out there without it being incorporated into the people who are working with the language and documentation that goes with it, and you're thinking "Well, if this way now, how is it going to be when the community is double?" A lot of people think this community is going to grow a lot, so I think you're right to be thinking this way.
+
+From what you said, I think having working groups or special interest groups is a great idea. It will not hurt to have feedback, and I think it can only be used for improvements.
+
+**Jaana Dogan:** In the past months I've received so much feedback about how we should communicate more of a roadmap, internals and things... From a programmer's perspective, he would like to understand what is going on and what the future will be like, because he designs things in a particular way so that the design is efficient on top of that underlying black box, which is the language runtime and language itself in this case.
+
+I do believe that having workgroups will increase this communication with the core team and the community members a lot, because given that they will be involved maybe in design and what is coming up next, they will be able to receive more canonical information and they can share it from there, rather than reverse engineering, debugging, trying to understand it by experience.
+
+**Carlisia Thompson:** I think the biggest benefit that I see from this idea is having a group of people that is a buffer between the language team and the community. Obviously, the language is only going to be so big, and to me, obviously, they should be participating in important decisions as far as the language and the ecosystem, because they have a ton of knowledge, especially the philosophy of the language, which counts a lot. They are the experts.
+
+But having people one off proposals and talking to different people here and there, and people change, and rotate, and they don't really know where people are coming from with suggestions, I can only imagine how hard that must be for the language team to participate in this constantly revolving set of people who are approaching them. So having a group that is, of course, not a forever group, but a group that is going to stay for a while and focus on one aspect of the language and the ecosystem, that group having the trust of the language team and the trust of the community, it can only make it better.
+
+**Jaana Dogan:** \[56:30\] Yeah, I think it's impossible to scale if you are an engineer working on the core team, to engage as much as you write code. They are already really productive, and you cannot really ask them to expose themselves to all these channels to gather feedback and understand what is going on. I would never expect anybody to waste their time on that, because I think their time is really valuable and it needs to be canalized to the right things. With this buffer group, as you said, we will give them some knowledge and summary of what is going on, and that's what they need.
+
+**Cory LaNou:** I also think the special interest groups are really cool because a lot of times I think when people are working at their projects and they're looking at Go and saying, "Oh, if it could do this, or if I could have this from it, that would help my project", but they maybe don't think that it applies to the wider group, so they don't really engage, and if they knew there was a special interest group that was surrounding the topics they're already concerned with, I think that would really help draw more of the community in as well.
+
+**Jaana Dogan:** I totally agree. I think for really high-level things or brainstorming, people see it like it's just like absurd to talk to the team, or explain a little bit of their ideas, because nothing is finalized. People are just seeking for some sort of community to build on their initial ideas, and the workgroups will be the perfect solution to iterate on ideas, regardless of its obvious or not; we need some sort of, as I said, middle channel to feel encouraged to talk.
+
+**Erik St. Martin:** I think it triggers ideas too, though. The special interest groups for Kubernetes will do weekly meetings and will do demos; when you take part in these, you'll see something demo-ed, and it will trigger your own ideas where you can contribute feedback then. I know there's been scenarios where I've seen stuff coming down the pipeline where it was a real problem I had that I thought I had to develop something else, and it just wasn't in my thought process that it could be solved in another way. These things kind of trigger more thoughts.
+
+And not everybody's accustomed to reading the draft proposal form of things, so they just don't participate. There's very few people who go in and read those drafts and then comment on them; most people wanna see working code, they wanna see a demo, they wanna have verbal discussions about it.
+
+**Jaana Dogan:** Yeah, I totally agree. I think a demo is the only way to communicate just a little prototype, but nobody is going read your proposal written in a very formal way, with no visualizations. So I do agree that meetings are awesome.
+
+**Erik St. Martin:** We'll call this one the first one.
+
+**Jaana Dogan:** Yeah, I guess so. This is the workgroups that actually thinks about the workgroups and comes up with a strategy on how they should work.
+
+**Erik St. Martin:** And now we're getting meta... We've got a workgroup for a workgroup. \[laughter\]
+
+**Cory LaNou:** Now, if you had your pick, I'm curious what would be the top one or two workgroups you would like to see?
+
+**Carlisia Thompson:** That's a great question.
+
+**Jaana Dogan:** \[59:55\] I don't wanna really reveal my ideas, but I think that there are things that are really obvious to me, such as... Well, this is not entirely engineering related - the first one is a docs group. Our current blocker is documentation, and explaining conventions and things. I do not really believe that all the other teams are really caring about documentation; I think they are seeing things within their perspective, and I do believe that a community group can totally tell them what is more obviously missing. So that's one of the... Maybe docs and outreach together, because the community is already doing so much work in a very structured way, at every conference, or on blogs, or everywhere else. I would love to see some sort of central group so people can share knowledge with each other and create material for each other, so writing and talking and documenting things become easier.
+
+**Cory LaNou:** Yeah, a big +1 to that. I'm a huge fan of a docs group.
+
+**Erik St. Martin:** See, every time somebody says "docs" I think "dox", like publishing private information about people. \[laughter\] We just get together and dox people... \[laughs\]
+
+**Jaana Dogan:** Is it my accent?
+
+**Erik St. Martin:** No, even when Cory said it. Both ways, it's pronounced the same.
+
+**Carlisia Thompson:** You're saying it has the same... What's it called...?
+
+**Cory LaNou:** Phonetically...
+
+**Erik St. Martin:** Yeah... So I think we're actually running a little over time. Did you guys want to talk about any projects or news that are out? One of the biggest ones I saw was Netflix released their new Chaos Monkey, which was really cool, and that's all written in Go now. Do you do chaos testing at all, any of you?
+
+**Cory LaNou:** No, I think I'm just gonna wake up one day and go to our cloud team and tell them I enabled it, and see what happens. \[laughter\] I'm sure they'll appreciate it.
+
+**Erik St. Martin:** Just let them be surprised. I think it's a really fun way of testing, the first time I saw that. It's really creative; you should assume that everything dies.
+
+**Jaana Dogan:** Yeah. At Google we have this sort of thing once in a while, and everything is just like literally off. I'm not participating anymore, so I'm so happy... But if you have something in production, good luck.
+
+**Carlisia Thompson:** Yeah, I do chaos testing - it's called release to production. \[laughter\]
+
+**Erik St. Martin:** I don't often test my code, but when I do, I do it in production...?
+
+**Cory LaNou:** Always.
+
+**Carlisia Thompson:** Always.
+
+**Erik St. Martin:** The chaos is actually happening in the office, not in production.
+
+Yeah, I mean, most people don't really test that way, so it was an interesting paradigm a number of years ago when it was released. I just found it really interesting that they completely rewrote the Chaos Monkey in Go. I think Scott Mansfield had mentioned that when he was on the show, that they were working on it, so that's finally open sourced.
+
+A related project that I actually ran into over the week was Pumba. It's chaos testing for Docker, which was interesting. It has a lot of like the "kill your container and restart it", "send random signals at the process" and things like that. Another interesting aspect of it was that it allows you to emulate network conditions where you experience packet loss coming into your container, packets being reordered, corruption and stuff like that. I have not played with it yet, so I can't give it an awesome stamp of approval, but it definitely looks interesting and I wanna start playing with it.
+
+**Cory LaNou:** Does it come with a preconfig for AWS network situations, so you can basically replicate what AWS is for you right away? \[laughter\]
+
+**Erik St. Martin:** \[01:04:04.12\] There's just a "AWS = true" flag. I'll drop the link in the channel for anybody who's listening live. I ran across it late last week, and I haven't had a chance to play with it yet, but it looked really cool. And we know 1.7.3 came out, and I think there was just a few bug fixes there. I don't know whether there was anything major there, but it's a point release, so that's to be expected.
+
+Anybody else ran across any interesting projects this week?
+
+**Carlisia Thompson:** I don't have anything this week.
+
+**Cory LaNou:** I don't have any projects, but I did wanna shout out to some community people. About a year ago I moved back to the Midwest as most of you know, and I started some meetups in Chicago and Minneapolis, because the Go community wasn't on track there. It's been a little bit over a year and the people that have stepped in to help me do that have really stepped up and they've basically taken over. Again, this is all about community for me and it's just great to have Varun in Chicago, and Eric, Jack, Nick and Calvin in Minneapolis. It's just fantastic to see how they've really gotten these Go groups back online, and to see these communities rebooted.
+
+**Carlisia Thompson:** We have a Meetup channel on Slack, don't we?
+
+**Cory LaNou:** Yes, we do. Meetup Organizers, I think.
+
+**Carlisia Thompson:** Yeah, so that's where everybody that Cory's just mentioned is, including Cory.
+
+**Erik St. Martin:** We have to applaud anybody who helps grow the community, whether that's through code or writing tutorials and blog posts, or doing conferences, or anything that continues to further the growth of the community. As JBD has been talking about today, kind of collectively molding the language together. Rather than just throwing stuff over the fence and hoping for the best, we start trying to find ways to collaborate and work on it together.
+
+We typically close out the show with our \#FreeSoftwareFriday where we give shout outs to open source projects for people that are kind of saving the day for us. I think Cory and I both have actually already spilled the beans on ours. Who I was going to thank is the Kubernetes special interest groups; to the point that we've been talking about, I think that there's a lot of value in that and it helps everybody collectively mold the project into what they want it to be in demos, in vocal discussions about concerns related to specific areas that matter to you. I think that's extremely valuable.
+
+And Cory, you just said yours.
+
+**Cory LaNou:** Yes, I did.
+
+**Erik St. Martin:** Do you wanna say it again?
+
+**Cory LaNou:** Yeah, just a shout out, like you say, to all the organizers of local Meetups. It's just such a big deal, and especially in my mind right now are the organizers of Chicago, which is Varun, and Minneapolis, which is Eric, Jack, Nick and Calvin. They have just done a superb job of taking communities that... Really the Go community just kind of fizzled a little bit from a Meetup standpoint, and they've got them back on track and they are going really well now, and have great attendance. It's great to see those cities back online.
+
+**Erik St. Martin:** How about you, Carlisia?
+
+**Carlisia Thompson:** I want to give a shout out to the most wondrous thing, it's the Gopher Slack bot. Florin Patan works on that, and it's... I don't even know how to describe it. You type "@gopher help" and you get a listing of all the commands you can use, and it's sweet, it will give you a bunch of goodies. So just go ahead and do it. On Gopher Slack, of course.
+
+**Erik St. Martin:** I'm typing it in now. @Gopher help.
+
+**Carlisia Thompson:** Yeah, it's a user, but it's a bot.
+
+**Erik St. Martin:** Okay, here we go. It's messaging me.
+
+**Jaana Dogan:** Do I need to direct message it, or...?
+
+**Erik St. Martin:** \[01:08:01.03\] You just add it in the channel, and it direct messages that.
+
+**Carlisia Thompson:** But JBD has made a good point - you can totally do a direct message, and just type things out there, so you won't be spamming the channel.
+
+**Cory LaNou:** I think we just crashed it. \[laughter\]
+
+**Erik St. Martin:** It is open source, and pull requests are accepted. This is kind of cool, though... Like, just type in newbie resources and recommended channels... That kind of makes it more accessible. The Gopher Slack has grown so much, there are so many different channels in there, and you're trying to find your way around... So this is kind of cool.
+
+**Carlisia Thompson:** Yeah, it's super cool. And of course - I don't know if we did it, but it crashed.
+
+**Erik St. Martin:** Speaking of crashes, I didn't get a chance to mention this. Way earlier in the show before our first sponsor break, I actually crashed, I was gone for a while - I don't think anybody noticed, but the funny part about it was it was after JBD said "I'm supposed to be a power user", and the second she said "power user", Boom! I got black screen of death, like stack trace on a MacBook Pro. \[laughter\] It was scary.
+
+**Jaana Dogan:** Well, that's part of my job, to expose all those screens, so no one else needs to go through the same thing.
+
+**Erik St. Martin:** I died laughing... Like, "Man, I hope this come up quick..." But I have never, in the whole time of owning a Mac, ever had a stack trace on a screen, and you say "power user" and Boom! \[laughter\] Priceless.
+
+So you don't have to throw anything in there, but if you have something, we'd love to hear a project you might wanna give a shout out to, too.
+
+**Jaana Dogan:** Well, I don't know. I don't wanna highlight anything at this point. I have a couple of things to mention, but I don't really think that it's necessary.
+
+**Carlisia Thompson:** No problem.
+
+**Erik St. Martin:** What did you wanna mention?
+
+**Jaana Dogan:** It was just a couple of random ideas... There are some co-op implementations I came across. It's just really nice to see some of the new generation network protocols are implemented for Go, and I'm just playing with a couple of things, building my co-op networks. This protocol is basically useful in IoT space, and it's really interesting to see that people are investing time and trying to issue things that we would like to issue.
+
+**Erik St. Martin:** Yeah, and I think we definitely need to link out to some of your repositories too, because you've got a lot of repositories for hardware interoperability with Go, too.
+
+**Jaana Dogan:** Yeah, I think most of my repositories are private at this point...
+
+**Erik St. Martin:** Oh, you're holding out on us.
+
+**Jaana Dogan:** I have so much stuff in private... I was playing with tons of devices lately to figure out the right APIs for these peripheral IO protocols that I was mentioning for a while. Maybe I can release a couple of them and share them as well, while we are talking about IoT.
+
+**Erik St. Martin:** Okay. If you do that, we'll make sure we link any of them in the show notes when the show actually gets released.
+
+**Jaana Dogan:** Alright.
+
+**Erik St. Martin:** I lost my time, because I got rebooted due to your awesomeness...
+
+**Jaana Dogan:** \[01:11:41.04\] Well, this was a formal meeting for the meta work groups, so... I just wanna conclude by saying that I think people really think, and there's no intention to isolate from the actual problems the community is experiencing, or anything. But trying to find the right channel will take some experimentation. I think the language grew really quickly and the team was really small, so I think this was kind of expected, that it won't be ideal if there's a rapid growth. That unfortunately happened, so we need to consider options and act to make things better.
+
+**Erik St. Martin:** Growth is always painful, and I think we'll get through this as it's just one hurdle in the evolution of the language.
+
+**Jaana Dogan:** Yeah, yeah.
+
+**Erik St. Martin:** So with that... Somebody gave me the time in Slack, we're at like an hour and thirty-three minutes, so we get to have an especially long episode this time, which is awesome. There's so much more I wanna talk about, too... I really wanted to get into music and hardware, but I don't think we wanna have a three-hour episode, which stinks. \[laughter\] We might to have to get you back on just to talk that stuff.
+
+**Jaana Dogan:** We can do just random live streaming; it doesn't have to be particularly GoTime, or anything. It might be interesting to just brainstorm. What I would like to issue with workgroups is something where you show up and talk to people on random things; not music, not my personal music, but anything related to Go. Because talking really helps you, as you said, going through different ideas and seeing different options, and it's just really healthy and enjoyable.
+
+**Erik St. Martin:** Yeah, and I think that's one thing people miss when working remotely too, that kind of interaction and triggering ideas with each other. It humanizes people; when you're talking to somebody you realize the way that they come off in a draft proposal or a GitHub pull request review, or something like that - that you perceive people one way, but when you actually get to interact with them face to face or at least verbally, you get to understand people are human.
+
+**Jaana Dogan:** Yeah.
+
+**Erik St. Martin:** So I think with that we should close out the show.
+
+**Jaana Dogan:** It was really nice to be here.
+
+**Erik St. Martin:** Yeah, definitely thank you for coming on, this has been a lot of fun. I think we should figure out something for having some sort of live streaming or playing with electronics over YouTube, I think that'd be kind of fun.
+
+**Jaana Dogan:** It might be interesting to just record a little bit for the Go Time, just my vocal capabilities...
+
+**Erik St. Martin:** Oh my god, that's so...
+
+**Jaana Dogan:** I know... I'm not promising anything, but maybe. It's a challenge for me; my personal challenge is to record something for you.
+
+**Erik St. Martin:** I challenge you right now. We have some closing notes that I'll make my way through, but I wanna hear a crazy goodbye... \[laughter\] I don't know when we cut in for what's gonna be produced, but for anybody who's listening to this that wasn't live for that, it was absolutely awesome and hilarious to hear some of the voiceovers that JBD was doing when we first got on the call. I'm challenging her now to end the show with a goodbye after I get through the notes. That's just really crazy.
+
+Alright, so thank you everybody on the panel for being here. Thank you to Cory for stepping in for Brian while he's out...
+
+**Cory LaNou:** Thanks for having me. It was an honor to be here.
+
+**Carlisia Thompson:** Thank you. So glad.
+
+**Erik St. Martin:** We definitely thank JBD for coming on the show and talking with us today. A huge thank you to our sponsors, Linode and Code School for sponsoring the episode. Again, like I said, please go check them out, show them some love, keep us on the air.
+
+I definitely wanna encourage everybody to share this show with fellow programmers. You can go to GoTime.fm and subscribe. Even if you are subscribed, if you haven't seen the new website, you should go check it out. Changelog and GoTime did a whole huge rebranding and it's freakin' awesome.
+
+Follow us on Twitter, @GoTimeFM and you can ping us on github.com/gotimefm/ping if you want to be on the show or have questions or have ideas for content. With that, we are ready for the goodbye.
+
+**Jaana Dogan:** Thank you -- sorry, I just really need my really low voice... \[low voice\] Thank you for listening, and goodbye.

It's Go Time!_transcript.txt

@@ -0,0 +1,197 @@
+**Erik St. Martin:** It's Go Time! This is a weekly podcast featuring special guests where we will discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+We've got a great show lined up today. This is our first episode, so we're gonna do some brief introductions and talk a little bit about what the show is about, and then we've got some news items that we'd like to talk about. With that said, I'm Erik St. Martin, I've been programming in Go since about 2011. I'm co-organizer of GopherCon along with Brian Ketelsen, who is also here with us. Brian, say hello.
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** Do you want to tell everybody a little bit about yourself?
+
+**Brian Ketelsen:** Sure. I'm Brian Ketelsen, I've been doing Go since 2010 and, like Erik mentioned, co-founded Gopher Academy and started GopherCon because we wanted a conference to go to and nobody else was doing it, darn it.
+
+**Erik St. Martin:** We need more conferences. We definitely need more conferences.
+
+**Brian Ketelsen:** We do. I'm really glad to see the explosion of Go conferences around the world.
+
+**Erik St. Martin:** And we also have Carlisia Thompson here with us. Carlisia, how are you?
+
+**Carlisia Thompson:** Hi Erik, hi Brian, and hi to the listeners. I work as a backend developer for a net tech startup. I am based in San Diego. My first contact with Go was when I went to GopherCon last year and I fell in love. It was great, it seemed to me like it brought together features of different languages that I liked, and I've been playing with it since.
+
+I'm also a co-founding member of GoBridge, and kind of like the same reason you guys wanted conferences, I wanted to have material to learn Go and also help whoever wanted to learn Go, so I'm glad that GoBridge exists to do that.
+
+**Erik St. Martin:** That's excellent. I think that's kind of a shared love of all of us here on the show, just kind of advocating community and advocating people get into this language and technology we love. Hopefully with our different backgrounds and experiences we can bring some insights to the listeners, and also introduce them into things that they might not already be familiar with.
+
+With that being said, one of the segments that will be a common thread is we'll talk about some news, events and any interesting articles that have come across our emails and social media and everywhere we find the things, along with having some special guests. We've actually got quite a few really interesting guests lined up for the next couple of episodes, so definitely stay tuned for those.
+
+If you haven't already, please subscribe. The easiest way to do that is to go to GoTime.fm, and you can also subscribe to the weekly newsletter there. We also would like to advocate for everybody to hit us up on Twitter @GoTimeFM with any questions you'd like to hear us answer, questions for guests we have coming up, questions in general.
+
+**Brian Ketelsen:** Feedback, comments, praise, kudos...
+
+**Carlisia Thompson:** Suggestions for guests to be interviewed...
+
+**Erik St. Martin:** Yes, definitely. We'd love to hear from everybody, people we should invite on the show. There's so many great people in the community that I think that we can get on here. With that being said, let's open this up to some news. Does anybody have anything interesting that's come across their email and social media this week?
+
+**Brian Ketelsen:** I do. I think the biggest new thing that came out was Go 1.6.1 and 1.5.4 were released. Small security issues on Windows and crypto libraries, but everybody should update. There's really no reason to be using 1.4 anymore, so go update to 1.5.4 or 1.6.1 now. That's a big one.
+
+**Erik St. Martin:** Those releases were actually a couple of CVE security vulnerabilities, right? One was related to DLL injection, and I forget what the other one was.
+
+**Brian Ketelsen:** If I remember right, the Windows one would allow a program to load any DLL dynamically that happened to be in the same library as the executable Go file; that was fixed. Then the other one had something to do with the crypto libraries not checking bounds on numbers that they send into the big integer library. I think it specifically affected HTTPS client certificates and Go SSH clients.
+
+**Erik St. Martin:** That's right, I think I vaguely remember that. It was something pertaining to being able to create denial of service attacks on binaries to leverage that.
+
+**Brian Ketelsen:** Right. The next big news item I have is the explosion in Go editors these days. If you follow me on Twitter you know my undying love for Vim and Vim-go, but really there's a lot of great editors out there right now that have good Go support. I played with Visual Studio Code on all three major platforms this week - I played on Mac, I played on Linux and I played on Windows, and I have to say I'm really impressed of the integration with the environment. The debugging worked everywhere, all of the tools work well. If you're somebody that likes a more formal-looking text editor, Visual Studio Code is awesome.
+
+The Atom editor got a big update this week, I think it's at 1.6 now.
+
+**Carlisia Thompson:** It's 1.7.
+
+**Brian Ketelsen:** 1.7, okay. So it got a big update this week, and the Go tools there look fantastic, too. So there's really a lot of great options for editing code if you like just text editors, and then the IntelliJ big plugin for Go and on the IDEA platform is awesome, it looks really good. If you don't mind having that big IDE, then the IntelliJ with the Go plugin is amazing, too.
+
+**Erik St. Martin:** And Carlisia, you're an Atom user, aren't you?
+
+**Carlisia Thompson:** I am, die-hard fan.
+
+**Erik St. Martin:** I keep wanting to love these things, but I guess I'm too stuck in my ways. How have you been liking the new update?
+
+**Carlisia Thompson:** Well, I since 1.6 had... I actually just today noticed some features that 1.6 introduced, and I can go and talk about this stuff forever, but I hope we will have an episode just to talk about editors and the different Go tools in each editor. I'll talk more about it then.
+
+I wanted to say though that for Visual Studio I got very interested in checking it out, because I see people that I admire in the Go community using Visual Studio with Go packages, and they are loving it. I tried it twice, and I couldn't get my head wrapped around it. I totally geek out on editors, so I was willing to go out there and look for stuff, so I'm hoping somebody is going to do a video walkthrough, showing us all the features. And if somebody has already done that please let us know, because it sounds awesome but I didn't get it.
+
+**Erik St. Martin:** I keep seeing these editors come out, and IDEs and I'm like "I wanna use it", and every time I try, I'm just like "I want Vim back, I want my Vim back!" Speaking of which, news-wise they just announced Vim 8, which I'm pretty excited about, and I'm sure Brian is, too.
+
+**Brian Ketelsen:** Yeah, that's big.
+
+**Erik St. Martin:** And especially with the async functionality, right? That's been one of the biggest pain points with people creating IDE-like functionality, doing builds and tests and things like that in the background, is that there were all these little hacky workarounds for doing asynchronous tasks inside of Vim. I think that that's really gonna change the game for the ability for plugins to be built.
+
+**Brian Ketelsen:** Yeah, I'm curious to see where the Neovim world ends up now that Vim 8 is announced with the asynchronous support. It will be I think detrimental to the community if the async support in Vim 8 is different than the ones in Neovim. I hope that they end up being roughly compatible and it doesn't make all of these plugins have to have different forks for different environments. I've been using Neovim for two years now as my primary editor, and along with Vim-go, once you add the asynchronous capabilities, you just can't go wrong. It's really awesome to be able to just run your Go tests asynchronously and get a popup in your status bar that tells you whether they pass or fail. Same with your Go builds, that async capability is really nice in Vim-go.
+
+**Erik St. Martin:** That's funny, I haven't even considered that when I was looking at that Vim 8 announcement, that "What does this do for Neovim?" I know that Neovim has some additional goals on top of just the async functionality, but the whole reason it was created was this whole fear that Vim was kind of staying mostly the same. I wonder whether they'll merge efforts or whether they'll continue to, like you said, maintain different forks.
+
+**Brian Ketelsen:** Yeah, it will be interesting to see.
+
+**Erik St. Martin:** But with that being said, we're kind of going Vim instead of Go here.
+
+**Carlisia Thompson:** Yeah, but talking about tools, I wanted to mention this article that came up this week. It was somebody from The Washington Post talking about really neat things about Go, and one of the things of course is the tooling. I absolutely love this article, it made me feel just fuzzy and warm inside, because not everything's perfect, everything has flaws etc, but I was reading the article and I was going "Yep. Yep, yep..." It mentioned all of what makes Go super awesome. When I had my first contact with Go I thought "Oh my gosh, I have to type so much. If I wanted to type so much, I would have stayed doing Java. What is this!? But let me check it out. Everybody's saying it's great, so let me just stick with it." And I that continued for a long time, until I found out about the tools. Go-imports, for example, at least in Atom, I cannot live without it. I went forever without knowing about it, and all of these little annoyances - that you usually think might be annoyances - they just go away with using these tools, which is what we are talking about here.
+
+So the article is really well worth a read if you want to get familiar with what Go has to offer. It's called "Embrace Go - A modern programming language". I don't know if you guys read it and have something to say about it.
+
+**Erik St. Martin:** This is the Washington Post article?
+
+**Carlisia Thompson:** Yeah. They are using Go at the Washington Post, and also they are doing this core project which seems to be a platform for communities for the publishing industry. I'm not very familiar with it, but I know for example Bill Kennedy has helped them with a project. He keeps saying "It's great, it's great". I'm not very familiar with it, I would love to have somebody from the Washington Post come and talk about it. Both that project and how they're using Go at the Washington Post.
+
+**Brian Ketelsen:** I read the article, and my big complaint is he tagged it with GopherCon in the tags on the blog post, but doesn't mention GopherCon anywhere. What is going on with the GopherCon tag and no GopherCon content?
+
+**Carlisia Thompson:** He links to it.
+
+**Brian Ketelsen:** Where?
+
+**Carlisia Thompson:** He links to GopherCon and he links to a blog on the Gopher Academy.
+
+**Brian Ketelsen:** Oh, interesting.
+
+**Carlisia Thompson:** The word "momentum" is linked to GopherCon, and he links to a blog post.
+
+**Brian Ketelsen:** Oh, nice. I'll take that SEO.
+
+**Erik St. Martin:** Wow, Carlisia has got memorization of what word is linked...
+
+**Brian Ketelsen:** I'm impressed!
+
+**Carlisia Thompson:** \[laughs\] It's because he highlighted "momentum" and I wanted to see what he was poining to, so I noticed.
+
+**Erik St. Martin:** I actually haven't had the chance to read the article yet, so I think it will be interesting for me to read. Speaking of momentum, when we look at the language and how it's grown over the years, it's just staggering. It blows my mind just how fast it blew up and the number of companies that have kind of jumped on board and have started releasing information about stuff that they're building with Go. It seems like every day there's a new Fortune 100 company being like "Yep, we're using it too."
+
+**Brian Ketelsen:** I think it's a double-edged sword though, because when you read Hacker News or Reddit, you expect to see these gigantic "The world changed because we moved to Go", and it's really more of a soft excitement. People are gradually updating all of their things to Go, and it doesn't feel revolutionary, it feels evolutionary. I think there's a lot of -- I don't know if 'pent-up disappointment' is the right word for it, but I think people were expecting some gigantic Big Bang, and there just isn't one. It's just this groundswell of grassroots Go adoption everywhere, and it doesn't read well in the TIOBE Index. It's strange. Go adoption is going really well, it just doesn't look like it externally.
+
+**Erik St. Martin:** I guess that's true. A lot of people are using it for internal projects and are just probably not as vocal about it. One example of little grassroots-type thing is the Bower news that came out -- was it last week?
+
+**Brian Ketelsen:** Yeah, I think that was last week.
+
+**Erik St. Martin:** Yeah, and they rewrote part of their API for -- I think it was fetching the packages, wasn't it?
+
+**Brian Ketelsen:** Yeah, serving up Bower assets.
+
+**Erik St. Martin:** Yes, that's awesome. It's great that they released that information, too. You wonder how the JavaScript community sees that, that they didn't kind of dogfood right?
+
+**Brian Ketelsen:** Well, I hope they're all as pragmatic and anti-dogma as we are. You use the right tool for the job, and in that case they proved to themselves that Go was the right tool for that job. There are places where I wouldn't want to yet use Go. I can think of a few places that Go is difficult to use, like mobile development. You gotta use the right tool.
+
+**Carlisia Thompson:** I think that has a lot to do with how we are now seeing this huge trends towards moving to Go, because people might say "Oh, I wanna have this feature, I wanna have that feature. Let's implement this feature so I can do X, which I cannot do unless I have this feature, or it would just be so annoying", but that's not what Go is all about. If you dig a little deeper, some of the past releases of Go, they had improvements, but there were no syntax changes, and like Francesc came out and said "That's a feature, the fact that the syntax didn't change. That is a feature in itself", and that says everything about the philosophy of Go. It's not to be used for everything, it's to be used for specific things. But those specific things, it does them really well.
+
+**Erik St. Martin:** I think we covet the things we know though, right? We naturally want to grasp to the things that we're familiar with, and especially when you're in kind of like a high-stakes environment where you're just trying to get stuff done, so you reach for some tool or technique that you've done a million times before and it's not there, it feels painful. I was around watching Brian adopt Vim, and it just seemed like this completely unnatural thing for him. \[Brian laughs\] He wanted to understand; he knows people are productive with this and they love it, but every time it just felt unnatural, and sometimes you just kind of have to put yourself in the frame of mind of somebody in that, and just kind of accept it for what it is, and then you kind of start to see the love that people have for it.
+
+**Brian Ketelsen:** Yeah, I'm sure there's some sort of learning graph for that , where you try to do the things that you're used to, and eventually you give up and then try to understand how to do it the way of the tool that you're using, and for me that was a very painful process coming from Ruby. I kept trying to write Ruby code in Go, and being disappointed in how well it worked. It wasn't until you start to put yourself in the Go mindset and understand what that Go mindset is that things really click nicely.
+
+**Carlisia Thompson:** Yeah, I've said this before: there has to be some stick-to-it-ness with Go, and probably with most things. But definitely, if you stick to it a little bit, you will see it.
+
+**Erik St. Martin:** It's interesting... Brian and I had a couple conversations with Manning publishers with the Go In Action book, and it was funny because they kept pressing this idea of "What's the silver bullet? What's that one-line selling point for Go?" The thing Brian and I kept coming back to - and talking with Bill Kennedy too, we were all kind of collaborating on this effort - was there's not silver bullet. It's all the things that are there, and it's all the things that aren't. It's all the little things collectively that make it such a fun and interesting language, and it's not this huge thing like monads, or whatever. I had to say 'monad', I had to.
+
+**Brian Ketelsen:** Thank you. Thanks for getting that in there. I think if one thing sticks out for Go though - and I've seen especially on Twitter a million times - is people saying Go is optimized for programmers, because reading code is the most important thing that a developer does, and Go is really easy to read. I saw a tweet, I think this morning or yesterday, the same thing: "Once my developers were able to read Go efficiently, we all decided that Go was the place for us to be, because reading Go code is simple, it's easy to understand what's happening." There are other languages that are interesting, and sexy, and exciting. Scala is a great example, but trying to understand what happens in a Scala program, it takes a PhD. I can't do it, I'm not interesting. Nope.
+
+**Carlisia Thompson:** Talking about getting to know Go and sticking to it, there is another tool - well, I should say initiative - that I came across some time ago and recently again. It's called Your First PR. There is a Twitter handle called @YourFirstPR, and there is a website on a GitHub repo. Basically it's an initiative to bring together people who have never contributed to open source, and we are hoping that if you want to do Go and are looking for ideas for projects, just hop on this and find out things that you can do, and practice your Go and practice your open source contribution. It tries to bridge people who are looking for opportunities to contribute to open source, with maintainers who have projects and have issues for people to solve, for people to implement.
+
+The way it works is you, as a maintainer, have to find the issues that will be appropriate for a first-time open source contributor, and you would tweet at them the issue or you would go on the repo and add an issue there. I would imagine that you could also submit a list of filtered issues that maybe you tag with, for example 'help wanted' or 'beginner-friendly'.
+
+There are two articles on that website. One that I had read some time ago and I absolutely loved, it's called "First-timers only", and I highly suggest people who are maintainers read that. I'm sure you're going to get a lot of ideas. And I hope the Go community will grow and more people will be exposed to it and have a chance to learn about it, practice, and maybe you'll stick to it or not, but at least you gave it a shot. This is a great opportunity, and people who are doing open source development, you can use this to get help, so it's a win/win all around.
+
+We always say that coding is about coding more, right? You get better at coding by coding, and also I always say if you're a developer, get together with people, get together with the developer community and open source contribution is great for that. So it's just perfect all around, I think. What do you guys think?
+
+**Erik St. Martin:** Yeah, I've always been an advocate of everybody contributing to open source, and I think that fear of rejection keeps a lot of people from it, too. But yeah, those bite-sized chunks I think are a great way, and I think also accepting that the code that you see people deliver is not their first pass, right? Everybody has this perception of their favorite programmer, that they just spew golden code on pass one. Sometimes any solution is better than no solution, and I've commonly told people that I kind of feel bad during code reviews and having pull requests rejected - and not necessarily rejected, but feedback, right? Like "Oh, it would be more performant if you did X" or "It would be cleaner if you did Y", to understand that solving the problem is the hardest part. It's easy to look at somebody's solution and to think about how to mold that a little better; it's an iteration of something that already exists, versus solving the initial problem.
+
+I think that if you step out of your comfort zone you can learn a lot from other people, and projects, and digging around in source code.
+
+**Brian Ketelsen:** Absolutely. I think making your first contribution to any open source project is a gigantic barrier. There is so much that we as programmers can do locally that becomes much more difficult when you're doing it on a remote or distributed project. The whole concept of Git and pull requests, and branches, and merging - all of that is intimidating if it's the first time you've tried it, so having patience is important. That's one of the things that we try to do in Slack a lot with the Gopher Slack - walk people through the whole process easily, without judgment and with lots of patience, to help them contribute. Because once they have a great success on that first contribution, you know there's gonna be a second and a third. You're preparing the next generation of OSS developers.
+
+**Erik St. Martin:** I think a great point about one of the things that's so great about the Go community is how inviting they are. I remember in the early days when I joined, there was a lot of academic people. I didn't go to college for this stuff; I've been doing it a number of years and I feel I'm good at what I do, but I don't have the academic background that some of these people do, and you feel intimidated coming into it. And everybody's so approachable. It doesn't matter who it is you talk to, everybody sits down and everybody's just excited about the language, and if they can help and teach people, they do it. I think that's one of the things that's kind of kept me around.
+
+**Brian Ketelsen:** Yeah, I couldn't agree with that more. My first Go contributions were brutal, terrible. The first open source thing that I released - I think I announced it on the Go mailing list, the Go Lang Announce List, or whatever it was, and three or four people immediately chimed in with corrections to my awful code, and they did it in a very polite and inviting way, not in a "You're an idiot, we hate you" kind of way, and that set the tone for the whole Go community for me.
+
+**Erik St. Martin:** How about Carlisia? What was your experience coming in and interacting with the existing community?
+
+**Carlisia Thompson:** My first interactions were just getting to know people and being completely absorbed in because I wasn't a Go developer; nobody cared. I was at GopherCon and everybody talked to me. I'm the kind of person who just goes up to everybody - I go up to anyone and say "Hey, what's up? What do you do? Tell me about you." I was doing that throughout all the days and got to know so many people. It was very heartwarming. I got to know the women at Women Who Go, I got to meet many new developers in the Go community. That was my very first contact and I think that counts as community contact as well, not just contributing to open source. I haven't done code contributions, just mostly contributing to material for Go x^Bridge as far as Go goes. Actually, I want to get better at open source contribution, and that's one of the reasons I'm so interested in these things.
+
+**Erik St. Martin:** Yeah, and even small tasks. Maintaining an open source project is a lot of work, a lot of people do this in their spare time, and contributing is kind of like a means of thanking them. People are grateful for any help they can get, even the smallest bite-size task. Speaking of thinking open source projects, Brian, you've recently started this whole \#FreeSoftwareFriday.
+
+**Brian Ketelsen:** Yeah, that's the best segue you've ever made, Erik. I appreciate it. I started this I think in November with a blog post about how good it felt to have someone thank me for a particular open source project that I did, and how much I feel like open source developers in general just enjoy that concept of appreciation. We often scratch our own itches in the open source world; we build the tool that we need because we need it, and we release it because we believe in open source, but it's kind of fun when you get a tweet or even an issue on your GitHub repository that isn't really an issue, it just says "Thanks!" So I started a hashtag on Twitter called Free Software Friday where I actually put a calendar event in my calendar. Every Friday morning at 9 AM I think of the open source projects that I really appreciate, that I might have used over the last week, and I just send a shout out to either the project or the maintainer if I know them. I want to continue that here in the podcast because it's important to let the people know that are working so hard that you appreciate the things that they're giving their time for.
+
+**Erik St. Martin:** I agree, I think that's prime real estate there. I would love to reach out and thank everybody for all the tools that we use on a daily basis that help us be productive and build cool and interesting projects without having to invest so much time. So why don't we quickly go around and thank your favorite project or projects for this week? Brian, do you wanna kick it off?
+
+**Brian Ketelsen:** Sure. I spent a little bit of time using Rancher from Rancher Labs this past week and I was really amazed at how nicely it managed the whole Docker experience in production, so I want to give them a huge shout out for making that open source and available. It's a little bit less intimidating than something like Kubernetes when you're starting off, but it has a lot of really powerful features and a nice interface. It makes it easy to use, so I definitely want to shout out to Rancher.
+
+**Erik St. Martin:** That's great. All these container projects have been so interesting, and Rancher is unfortunately one I have not played with myself, but I think I need to add that to my list for weekend hackery.
+
+**Carlisia Thompson:** Is it just for Linux?
+
+**Brian Ketelsen:** Yes, it is. It's a container orchestration tool, so it only deploys on things that... Well, it deploys on anything that runs Docker, so I guess technically now that Macs and Windows run a form of Docker, it's not just for Linux anymore. So I correct myself, it's not just for Linux - but it is just for Linux. \[laughter\]
+
+**Erik St. Martin:** And Carlisia, who would you like to thank this week?
+
+**Carlisia Thompson:** I totally geeked out on my editor just recently - I do that every once in a while - and I wanted to thank the person who created Vim Mode Plus. He only has a handle, it's @c9md. That was built on top of Vim Mode, and those two are packages for Atom, it's just so you can use Vim. It's hugely helpful for me, because I do like Vim and I want to use it, but get to a point where I get stuck, and that's where I activate the Atom interface. So it's very worth checking out, especially the new features with Vim Mode Plus. One of them that I really liked was the search functionality. You get highlighting, incremental search, search counter, and there are many other new things, so thank you!
+
+**Erik St. Martin:** Speaking of Vim, I would like to thank Vim itself. I guess I have to do kind of a triplet here, because Vim, Arch Linux and i3 window manager - those are the core things; everything else I do builds on top of, so I think without any of them...
+
+**Brian Ketelsen:** Trifecta!
+
+**Erik St. Martin:** Exactly, that's the word I'm looking for. So I guess without any of them I would not be nearly as productive.
+
+**Brian Ketelsen:** Yeah, in my mind Vim, Arch and i3 are almost religion for me at this point.
+
+**Erik St. Martin:** And we'll convert more, we'll convert more.
+
+**Brian Ketelsen:** \[laughs\] The one true way to develop.
+
+**Erik St. Martin:** So for anybody else who wants to reach out to open source maintainers or projects in general, or companies that support people who work on these open source initiatives, definitely follow and reuse the \#FreeSoftwareFriday on Twitter on Fridays. And with that being said, time to close out the show. I want to thank everybody here on the panel for jumping on this call and having some good conversations, I want to thank all the current listeners and all the future ones that the current listeners are going to pull in by sending them to GoTime.fm.
+
+**Brian Ketelsen:** Yeah, don't forget that you can share this show by finding us at GoTime.fm, or tweeting @GoTimeFM.
+
+**Erik St. Martin:** Yes, and definitely as we mentioned earlier in the show, send us questions, send us people you'd like to see on the show, or if you wanna come on the show, definitely reach out to us there. We also have a GitHub set up where issues can be opened for these things, if you prefer that, which is github.com/gotimefm/ping. With that being said, goodbye everybody until next week. Next week we have a special guest coming on the show.
+
+**Carlisia Thompson:** Cory.
+
+**Erik St. Martin:** Yeah, Cory LaNou. I lost my head there...
+
+**Carlisia Thompson:** I gotcha.
+
+**Erik St. Martin:** Yeah, Cory will be coming on to talk a bit about community, and I think that's something we can all relate to. So until next week, bye everybody!
+
+**Brian Ketelsen:** Goodbye.
+
+**Carlisia Thompson:** This was fun, goodbye!

Jessie Frazelle on Maintaining Open Source, Docker, dotfiles_transcript.txt

@@ -0,0 +1,853 @@
+**Erik St. Martin:** We are back for episode number 11 of Go Time. I'm Erik St. Martin. Today we have Brian Ketelsen on the line...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** And Carlisia Campos...
+
+**Carlisia Thompson:** Hi, everybody. Glad to be here.
+
+**Erik St. Martin:** And our special guest today is the queen of containers, Jessie Frazelle. How are you?
+
+**Jessie Frazelle:** Good, how about you?
+
+**Erik St. Martin:** Doing great! So we were out last week and we are back; we've got some good news before we get started. Today we're gonna talk to Jessie about all things containers, working on open source projects and any other fun topics that we come up with along the way. Before we get started we have two exciting pieces of news. First, Carlisia is now officially a full-time Go developer.
+
+**Carlisia Thompson:** Oh my gosh, yeah!
+
+**Erik St. Martin:** Do you wanna tell everybody a little bit about that, Carlisia?
+
+**Carlisia Thompson:** Sure. So I've been open to this possibility for a while now, and I will be joining the fine folks at Fastly next week; next Tuesday will be my first day there, and I'll be in San Francisco for my own boring week, and I'll be working remote from San Diego. I'm super excited... You should definitely check out Fastly, they're awesome.
+
+**Brian Ketelsen:** That's great, this is great news.
+
+**Erik St. Martin:** We're excited for you.
+
+**Carlisia Thompson:** It's such a good team, I love all of them.
+
+**Erik St. Martin:** And no more Ruby.
+
+**Carlisia Thompson:** No more Ruby, just Go. APIs and network stuff.
+
+**Erik St. Martin:** The second piece of news is not only are we not kicked off, but we have sponsors. We actually have two sponsors for this episode. Linode, who will be doing all of our hosting for the Changelog and Go Time CMS' that are being worked on and we've talked about before, and also Equinox. We'll talk a little bit about each of those later in the show, but first let's get started with Jessie.
+
+Jessie, you also have a new job, right?
+
+**Jessie Frazelle:** Yeah, so I started two weeks ago at Google, but I really have only done one week of orientation and then I went to a conference, so it's sort of surreal.
+
+**Brian Ketelsen:** But business as usual for you, right? A week of work, a week of conferences...
+
+**Jessie Frazelle:** Yeah. I mean, I've submitted a few pull requests, so there was that. I think I need to update them... But yeah, business as usual.
+
+**Brian Ketelsen:** That's awesome, congratulations.
+
+**Erik St. Martin:** So you're getting to work on Kubernetes, or...?
+
+**Jessie Frazelle:** Yeah, I'll be working on Kubernetes. I don't know specifically what yet. Before, I had previously made a PR to add seccomp to Kubernetes, and then I made a pull request to also clean up some Docker files and then Go Lint a few things, so hopefully that's good.
+
+**Carlisia Thompson:** I want to put a word in and say congratulations, Jess.
+
+**Jessie Frazelle:** Thanks.
+
+**Erik St. Martin:** That's awesome. Everybody seems to be going to work for Google now. I keep seeing everybody joining Google.
+
+**Jessie Frazelle:** I mean, it's pretty nice.
+
+**Erik St. Martin:** Are you working with Kelsey and everybody, too?
+
+**Jessie Frazelle:** Yeah, Kelsey and them are all there, and Francesc - it's all super-cool people teams, and even in my first week I had multiple people emailing me who I had maybe only seen their names on like a kernel mailing list. I'm like, "Wow, you're really cool." So they just have a ton of really cool people, I guess.
+
+**Erik St. Martin:** A little star struck?
+
+**Jessie Frazelle:** \[04:00\] Yeah. \[laughs\]
+
+**Carlisia Thompson:** Sarah Allen from Bridge Foundry also just joined Google. She's doing some mobile work and also using Go.
+
+**Jessie Frazelle:** Nice!
+
+**Brian Ketelsen:** That's awesome news.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** So first you started out on Docker... You were there for a few years, right? Were you on the founding team? How long were you with Docker?
+
+**Jessie Frazelle:** I had contributed before joining, but I think I was there almost a year and a half, or something. Or a little over a year and a half.
+
+**Erik St. Martin:** Definitely one of the most well-known members of the Docker team.
+
+**Brian Ketelsen:** Yeah, almost the public face of Docker, definitely. We should talk about how hard it is to be the OSS maintainer for such a large project.
+
+**Jessie Frazelle:** Yeah, it's definitely painful, and I actually missed it after leaving, which I never thought would happen. But it is super hard to be the person giving people bad news all the time and then taking people's crap when they're frustrated because stuff's not working - which totally makes sense, and I get in that mood too when stuff's not working, and then go yell at some maintainer somewhere. But I think it's easy to forget that there's another human being on the other side of the issue.
+
+**Carlisia Thompson:** I wonder if you have opinions on how things could be better for maintainers on such a large project. I'm sure you have opinions.
+
+**Jessie Frazelle:** Yeah, I have a lot of crazy opinions. One of the most interesting things I think is if the maintainers from Huawei that helped us, they're located in China, I think, but it almost seems like there's a lost-in-translation type of... The fact that they don't insinuate that we're being mean, or something. Because a lot of other people will just read a response out of context and maybe it's just a little blunt, but it wasn't meant to come off that way. So it's kind of funny that we all realize that the Huawei contributors would respond back so nicely, even when maybe we were being a little bit disgruntled. Keeping that in mind for everyone would be cool.
+
+**Erik St. Martin:** I think a lot of people, whenever you're upset about something, you're naturally going to read the other person's response as an attack, right? I think that's the hardest thing, to take a step back and look at it objectively and not use your own current mood as your means of interpreting what somebody's saying.
+
+**Jessie Frazelle:** Totally.
+
+**Erik St. Martin:** Yeah, so tons of work. I don't envy you.
+
+**Brian Ketelsen:** I can't even imagine. It's like juggling cats that are already juggling chainsaws. \[laughter\] Everything's sharp and everything has claws.
+
+**Erik St. Martin:** I submitted a pull request two weeks ago to Docker, and I think there was like 80 or something pull requests then; now it's well over 100, like 120 pull requests.
+
+**Jessie Frazelle:** Oh gosh, they must be anxious right now. Whenever we got to 100 or over 100, it's like "We need to merge things or close things..." It gets scary.
+
+**Erik St. Martin:** So that was kind of your point... Yeah, I saw that post - I think you posted it on Twitter earlier, where somebody was like "My condolences, you're now an open source maintainer."
+
+**Jessie Frazelle:** Yeah.
+
+**Erik St. Martin:** He was talking about finding that comfortable line where you know you can't close everything... So for Docker it's 100?
+
+**Jessie Frazelle:** Well, usually it stays around 75 or so, but once it hits over 100 it makes almost everybody kind of... That three digits, it's rough. But issues-wise, I think that we honestly gave up. It's not that we don't care about issues, but there's no way that's ever gonna go to some reasonable number.
+
+**Erik St. Martin:** No, and once it gets so big, people can't even keep up with the fact that they're submitting duplicate issues, because you can't find a similar issue.
+
+**Jessie Frazelle:** \[07:57\] Yeah. We were even fortunate to have someone who is so active in the project from the community itself; I swear, we all joked that he's like a human database of Docker issues. I swear, he really just knows them all, and he would be like "This one's a throwback to this other old one that's super old", so eventually Docker ended up hiring him, and I think that was like the greatest move ever. \[laughter\]
+
+**Erik St. Martin:** It's like Damian for Docker issues. \[laughter\]
+
+**Jessie Frazelle:** Yeah... It's crazy.
+
+**Erik St. Martin:** Do you guys keep statistics of how long it takes to turn around issues or pull requests? I'm interested to see whether some have lagged so long you just had to delete them.
+
+**Jessie Frazelle:** Yeah, so issues and stuff - there's definitely stats on this, but I don't actually know the answer. But issues, it's like we don't really care about the oldest there, but with pull requests we'll have weekly maintainer meetings and we'll go through the oldest. Usually, the oldest is something where it was controversial, so it's nice to do those in the maintainer meetings, because we can easily get like two "looks-good-to-me"s from two people in the meeting. Or if people really are objecting to it, they can voice their concerns there without us having to do 85 million different back-and-forths on the actual pull request itself. So usually that's only like a month old probably, tops.
+
+**Brian Ketelsen:** That's not too bad.
+
+**Erik St. Martin:** Yeah, that's not as bad as I was expecting it to be. Because you've gotta figure that it grows faster than it goes down; you're either spending time managing other people's pull requests or writing your own code, and that's gotta be a hard debate, which thing you work on.
+
+**Jessie Frazelle:** Yeah, it's a juggle. Because we used to - I don't know if they still do this, they probably don't... But we would try to have maintainer days, where like on Tuesday one week I was just closing issues that day, and then the rest of the week I got to write code. So almost everybody kind of had a day where they did stuff, but I think it happened more organically than that, in that if I was stuck on the actual feature I was building, I would then go and close things to free my mind. I think that's almost like the best system, when it happens organically.
+
+When you're stuck in a maintainer day and the day before that you were just about to finish your thing, it sucks.
+
+**Carlisia Thompson:** How's your workflow, Jessie, for accepting PRs or evaluating PRs? Do you download the PR and run it locally in run tests? Or is that automated? How does it work?
+
+**Jessie Frazelle:** So normally I would just make sure that it has the first CI passing, which is checking that it's been signed, and all that stupid legal stuff. Then if it's actually green in the CI... Say it's just a small bug fix and they added a test case, I'll go in and check out their change, remove the fix and then make sure that the test fails without it, and then add it back in and make sure that it passes locally too, even though the CI just did it, just for sanity's sake. And then if it's a bigger one, we'll usually have some sort of design review of it first, unless they just popped into the repo and gave us a new feature.
+
+After the design review, we go through and do a full-on code review, but I would say most pull requests that come in, they're like a typo change or some small fix. The feature requests are what take the most time, but when they're done correctly it can be smoother.
+
+**Erik St. Martin:** \[11:49\] Yeah, so I'm actually quite impressed by the pull request process for Docker when I went through that. There's a number of automated CI steps that it goes through. There's a document that it starts out, "Describe what the problem is, describe how you fixed it, give us a one-liner for what's gonna go in the changelog"... There's all this documentation that they expect you to put in there, and it's really clearly defined. It's probably one of the best I've seen, doing pull requests.
+
+**Brian Ketelsen:** Who put all that together, Jessie?
+
+**Jessie Frazelle:** The CI stuff, before I started at Docker, we used Travis and it only ran our unit tests, which considering that you've made a change to Docker, you probably know that most of our tests are integration tests, and they take a really long time. So we were testing the integration test by hand. Two people would have to look good to me on the PR and two people would have to test that PR locally, which is such a waste of time. It was basically like that comic where it's like, "I'm waiting for it to compile", but you are writing tests.
+
+**Erik St. Martin:** I still rock that T-shirt with the swords... "Compiling. Carry on."
+
+**Jessie Frazelle:** \[laughs\] Totally. So we ended up switching to Drone, and Drone had some issues with Docker and Docker, because we need very specific things to test Docker, since we need Docker for Docker... Yeah, it's crazy.
+
+**Erik St. Martin:** Docker inception.
+
+**Jessie Frazelle:** And it also just totally messes with your server after. So we then switched to Jenkins. I kind of just switched it overnight, and at first a few people got mad, just because nobody likes change. And it didn't exactly work right away, but once we got things working, now it's all still Jenkins and there's multiple architecture builds. It's kind of cool, there's like arm-power-z... IBM gave us these power-z nodes and I was like "ooh, mainframe!" and then they ended up being really slow.
+
+**Brian Ketelsen:** Did you hack the Gibson?
+
+**Jessie Frazelle:** It would have been cool. \[laughter\]
+
+**Erik St. Martin:** So talk to us a little bit about what you worked on for Docker, because Docker's a pretty big project. Now it's split up across I don't even know how many repos and subprojects, but what specifically did you enjoy working on?
+
+**Jessie Frazelle:** Yeah, I think most of the engine team itself worked on more the container runtime stuff and design of the CLI. Then there was another whole team that handled all the distribution of tarballs. I liked more of that, and then also I ended up doing that whole thing with the CI, where I was like the CI assist admin for way too long. Then also I redid our entire bash scripts for our apt repo and set up an rpm repo as well; now they're stuck with those terrible bash scripts because of me, but... \[laughs\]
+
+**Erik St. Martin:** I hope I have the name right... I think it was Yehuda Katz that said this, and he said something along the lines of the thing he fears the most about releasing stuff open source is having to maintain it. And it's almost the same thing - you build the CI thing out and it's awesome, but now you're the maintainer.
+
+**Jessie Frazelle:** Yeah, and it became super stressful because the Windows servers that we had for some reason needed to be restarted every other day. So just the first ten minutes of my day were like restarting Windows servers, and I was like "This is such a waste..." And there was an entire team that did CI for the enterprise side of Docker, so finally they took it over and redid it; it made it way better than I ever could, because I really didn't know that much about Jenkins and stuff like that. So I think now it actually runs pretty well, but it was pretty stressful there for a time.
+
+The entire CI once broke because of a stupid kernel bug, and then we ended up upgrading to a kernel with another bug. So I was basically like, "Computers just don't work. We should all give up now." But then we got over it.
+
+**Brian Ketelsen:** I think we've all been there.
+
+**Jessie Frazelle:** Yeah. \[laughs\]
+
+**Erik St. Martin:** ...like, daily.
+
+**Carlisia Thompson:** Daily, I was gonna say.
+
+**Erik St. Martin:** \[16:01\] How can I love tech and hate tech so much at the same time?
+
+**Jessie Frazelle:** It's terrible. \[laughs\]
+
+**Brian Ketelsen:** I have a question for you. It's a little bit of a different topic, but you've been at Docker, you've been at Mesos, and now you're at Google. Many people say that Go is kind of the language of the cloud. You've seen pretty much the whole cloud now - what do you think about that proposition?
+
+**Jessie Frazelle:** At Mesosphere they were writing a lot of C++ - that's what Mesos is written in - and they even had some cool networking stuff in Erlang, but other than that it's all Go, that's what I've seen. And I love Go, so obviously I'm biased, but I even made a couple pull requests to Go and I wanna make more as well, because it's super fun to contribute to that. It's almost more fun than something on GitHub for some reason, because it's different and new. But yeah, I would say that's definitely the language of the cloud.
+
+**Brian Ketelsen:** What is it about Go that makes it better for cloud work?
+
+**Jessie Frazelle:** Probably the fast compile time, because I honestly forgot when I was compiling Mesos how slow things used to be, and just with header files, and everything needs to compile again, and I was just sitting there twiddling my fingers, not knowing what to do with life. So that's definitely helpful, and also being able to compile it into a binary and not have to worry about .so files and stuff like that. It's so nice. Distribution.
+
+**Brian Ketelsen:** Yeah, the static binaries make a huge difference. I would agree with that, sure.
+
+**Erik St. Martin:** Yeah, I think that's a big thing that attracted everybody to the language - being able to do static binaries, but still have a more dynamic feel to the language.
+
+Every time I go back to C or C++ and have to wait... Like, "Oh, come on..." I think everybody should have to compile one just to keep us honest though, right? \[laughter\]
+
+**Jessie Frazelle:** Yeah, because I was complaining about the slowness that came with upgrading from 1.4 to 1.5 Go and I was like, "What?! I'm a terrible person. Such a hypocrite. I should not have done that" \[laughs\] after seeing what C++ was like.
+
+**Erik St. Martin:** Yeah, we've joked about the compile times. But now they're back down... I think they split the difference, I think they're less thanhalf way from where they were between 1.4 and 1.5, so we're getting closer... But if you go back and compile a C or C++ app and then go back to Go, you realize just how fast it is.
+
+**Jessie Frazelle:** It is amazing.
+
+**Erik St. Martin:** I guess we should probably stop and talk about sponsors real quick. I think now is a good time, right everybody?
+
+**Carlisia Thompson:** Yeah, let's do it.
+
+**Jessie Frazelle:** Cool.
+
+**Erik St. Martin:** So Linode is the first one, and we've mentioned that all of our new CMS architecture will be hosted on that. Ours and Changelog's, because we are a part of Changelog. So Adam and Jerod really love Linode, and everything's gonna be hosted there.
+
+I think Brian was saying you have some experience with Linode, right Jessie?
+
+**Jessie Frazelle:** Yeah. Since I set up our CI, we also needed a separate server for testing IPV 6, because it's hard to do in most cloud providers, but they had a really good setup, so we ended up using that, which was nice.
+
+**Brian Ketelsen:** Oh, that's nice. Linode was one of the first VPS's as I stood up many years ago, probably 10 or 11 years ago now, and I really enjoyed using it for a long time.
+
+**Jessie Frazelle:** Nice, yeah.
+
+**Brian Ketelsen:** I understand one of the neatest things about their setup is that you've got a CLI tool that you can use to manage it; just get your API key and go to town managing your nodes directly from your terminal. I'm all about managing stuff from the terminal.
+
+**Jessie Frazelle:** I didn't even know about that, and now I feel like I just did it a terrible way with bash scripts. \[laughter\]
+
+**Brian Ketelsen:** \[20:05\] Now, one thing that is missing - I know they've got SDKs for Python and Perl, PHP, Ruby, Java and Node, but there is no Go SDK. So anybody who's out there looking for an opportunity to make a mark in the Go land, a good place to start might be a Linode SDK for Go.
+
+**Erik St. Martin:** And we have a discount code too, which is 'GoTime20', and you get two months free, which is a $20 credit. The nodes are $10 each per month, and these are all SSD and I think they have eight data centers to choose from.
+
+**Brian Ketelsen:** They do, and they've got really nice Xeon E5 processors, 40 gbps network. You can go to linode.com/gotime to get started, let them know we sent you, because we're awesome and so are they.
+
+**Carlisia Thompson:** People are asking if they can make an SDK for Linode. Not only you can, but you should. You should do a Go SDK for Linode. That's what we're looking for.
+
+**Erik St. Martin:** Right. How long do we have left on this episode? And... Go! \[laughter\]
+
+**Brian Ketelsen:** And... Pull request submitted. That's awesome news. So they have lots of add-ons. They can do backups for you, they can do load balancing, they do some management professional services and DNS as well, so give them a shot. It's one of the original, the OG BPS providers, if you will, and they're pretty cool.
+
+Our other sponsor is Equinox, and we've talked about Alan Shreve a couple times, and his other project, ngrok. Equinox is pretty slick because it allows you to manage updates for the applications that you send out to your customers. At my job at Backplane we use Equinox to deliver the command line application that lets you update your backends. So Equinox is pretty slick; I think I wrote maybe a three-line bash script that allows us to deliver that new command line application up to Equinox's server, and then using Equinox's infrastructure you can either do a brew install or an RPM install, Debian, or just download a tarball or a zip file or a Windows MSI installer. It's amazing that we just do one quick bash script to upload that source code and it gets compiled for all the different platforms, uploaded to Equinox's infrastructure, and then all of our customers, regardless of their platform, can stay updated all the time. They just have to implement a small API in their app, and then the app becomes self-updating, so when we release a new version they just type 'backplane update' and it automatically upgrades their app. Pretty neat.
+
+**Erik St. Martin:** That's the coolest thing, I thought... Rolling all the RPMs and all that stuff for you. Jessie was mentioning that earlier, that becomes a process in itself, just kind of deploying all the packages for stuff. And the self-updating thing, I wanna play with that.
+
+I've seen this... I think you've talked about it maybe a year or so ago, and I kept meaning to go play with the self-updating part and I have not yet, and I feel bad.
+
+**Brian Ketelsen:** It really is. I started at Backplane in mid-April maybe, and it was the first thing I did... Maybe my second day there - the first code I submitted was the Equinox client, and we couldn't be happier with how easy it is to run. Very nice. So go to Equinox.io and sign up for their automated application delivery service with self-updating stuff. You won't be disappointed at all.
+
+**Erik St. Martin:** And remember, when you support our sponsors, you keep us on the air. \[laughter\]
+
+**Brian Ketelsen:** That's right. The network will pick us up for another season, and hopefully that season will be as epic as Game of Thrones is this season.
+
+**Erik St. Martin:** I think that's hard to compare.
+
+**Brian Ketelsen:** \[laughs\] I'm coming in with dragons next week.
+
+**Carlisia Thompson:** \[24:01\] But this is true, though. These companies have other places they can advertise, and they're advertising with us because they're supporters.
+
+**Brian Ketelsen:** Yay, thanks to our sponsors.
+
+**Erik St. Martin:** So Jessie, I saw something on your Twitter profile that got me laughing... Maintainerati. Coming to a bike shed near you. \[laughs\]
+
+**Jessie Frazelle:** Oh, yeah! So I decided after I wrote that blog post about closing pull requests to start a conference that's more like an open space for maintainers, because it seemed like a lot of the maintainers that responded to my blog request had cool ideas about ways to fix things or even just problems they were having, and they were so similar to the ones that we saw that I was like, "Obviously we need a space to talk and combine and conquer."
+
+**Erik St. Martin:** That's awesome. So have you set dates and a location for that?
+
+**Jessie Frazelle:** Yeah, so it's gonna be next to GitHub at their office in San Francisco on February 15th.
+
+**Erik St. Martin:** Awesome. How many people are gonna be there?
+
+**Jessie Frazelle:** So I think we're gonna cap it like 120 for the first one, just so that we can make sure that it's not out of control and certain, and people can talk and discuss things.
+
+**Erik St. Martin:** You don't wanna have problems to maintain the maintainers? \[laughter\]
+
+**Jessie Frazelle:** Yeah...
+
+**Carlisia Thompson:** And where do people sign up for the event?
+
+**Jessie Frazelle:** We have a website, maintainerati.org, and right now it's just a form fill-out with email addresses, and then I think we're gonna send out invites pretty soon, once I get my life together. \[laughs\]
+
+**Carlisia Thompson:** Cool.
+
+**Erik St. Martin:** At everything about that I started laughing. Like, "Coming to a bike shed near you" and WONTFIX Cabal.
+
+**Jessie Frazelle:** Yeah, it's called "The WONTFIX Cabal" and it's basically run by the maintainerati. Because I already own that domain. \[laughter\]
+
+**Erik St. Martin:** So it started with the Containerati, right?
+
+**Jessie Frazelle:** Yeah, I haven't really used that domain for anything cool and I should, but yeah... Somehow I should combine the two into the ultimate Cabal... I don't know.
+
+**Erik St. Martin:** Yeah, what would you call that? It's like The Maintainerati Of The Containerati, or...
+
+**Jessie Frazelle:** Like The Red Wedding Of Containers... \[laughter\]
+
+**Carlisia Thompson:** I have very serious concerns for the day after this conference. How all these maintainers anarchists are gonna come back and just not fix things.
+
+**Brian Ketelsen:** Yeah, they're just gonna start closing issues left and right.
+
+**Jessie Frazelle:** Yeah, so me and Katrina Owen, who recently joined GitHub, she was like "Yeah, they wanna hear about all the features that the maintainers want", and I was like, "It's so ironic that we're gonna be the ones demanding features from GitHub."
+
+**Brian Ketelsen:** There's a really juicy irony in that, isn't there?
+
+**Jessie Frazelle:** Yeah. \[laughter\]
+
+**Erik St. Martin:** So what other things do you have going on lately? Mostly caught up with your new gig with Kubernetes? Are you working on anything personally for projects? You're always seeming to be trying to port new things to run inside containers. We actually were joking that you're probably trying to get Skype in a container.
+
+**Jessie Frazelle:** Okay, so one, I had Skype working in a container \[laughter\] on this computer that I was trying to use.
+
+**Erik St. Martin:** I knew it!
+
+**Jessie Frazelle:** I literally have like three computers in front of me right now, but it just like decided to fail, of course, because computers... So yeah, I guess personally I made that contain.af website, which I should add more questions to; it's like a quiz game to help people learn about figuring out things in their environment as far as what syscalls and capabilities you have. But honestly, I don't have time for that because I'm still trying to figure out my new job, and stuff.
+
+**Brian Ketelsen:** So for anybody who hasn't seen it yet, Jessie's dotfiles are the most amazing thing on the planet. I think that if I could take a month and just go spelunking through those dotfiles, I would be the happiest man on the planet.
+
+**Erik St. Martin:** \[28:02\] You know, I'm not important anymore. Brian used to borrow my dotfiles... \[laughs\]
+
+**Carlisia Thompson:** I went to check out her .vim files because I remember Brian mentioning it. Next week I'm getting a brand new machine, and for the first time in three or four years I've decided that I'm going to have clean slates. So I checked out Jessie's .vim file, and not only the vimrc file... She actually has a makefile there for you to run, and just magically configure out the things.
+
+**Erik St. Martin:** Let's say you're stoked for all of that, that we can have folders for each thing and then when I'm on a machine I can just kind of symlink the things that I want for that machine.
+
+**Jessie Frazelle:** Yeah, I love the symlink thing... It's so nice.
+
+**Brian Ketelsen:** These dotfiles are a thing of beauty. So there's containers for everything, and then a beautiful little bash script that converts the command that you want to run into the container command to actually run the container. It's beautiful. How long does it take to build all those Docker files and actually ship them up to a Docker hub?
+
+**Jessie Frazelle:** I actually have a private registry where I host them, because for some reason - and I think that they're trying to fix it - my automated builds on Docker hub, they just don't build. I just think I have too many. So I have a private registry that has Jenkins hooked up to it, so it runs continuously and just pushes them there. Then I secretly use that, while everybody uses my public ones... Which is crazy. \[laughs\]
+
+**Brian Ketelsen:** You really are the container queen.
+
+**Erik St. Martin:** Docker registry is telling you, "Alright Jessie, this is getting out of hand." \[laughter\]
+
+**Jessie Frazelle:** Well, it used to happen, because I have multiple Docker files in one repo itself; there's like over a hundred in that one repo, and the infrastructure is not built to rebuild all those Docker files the second I push. Because I'll push them multiples times a day, and maybe a forced push right after I'd just pushed, because I messed something up. So I think it just times out after rebuilding ten of them, and it's a random ten every time, or something.
+
+**Erik St. Martin:** Just like a denial of service attack every time you push... \[laughter\]
+
+**Jessie Frazelle:** Yeah, it's really bad. And finally someone noticed, that worked there other than me, because I think they have a very long-standing issue open about this. But then they were like, "Oh, this looks really bad. Your Docker files that a lot of people use are super out of date", and I'm like "Yeah, I just kind of gave up on it working, so..." \[laughs\]
+
+**Erik St. Martin:** I just love every time somebody mentions something, it's almost like you're like, "Challenge accepted."
+
+**Jessie Frazelle:** Yeah... I almost feel like there hasn't been - it's been a while since someone said something that I have not actually containerized yet, so it makes me worry some for the future.
+
+**Erik St. Martin:** I got a big one for you... A window manager.
+
+**Jessie Frazelle:** Oh, nice, nice... I've been meaning to try that. Everyone's like "Why don't you run i3 in a container?" and it just makes me think that at that point I'm making Rancher on the desktop.
+
+**Brian Ketelsen:** Well, that's true.
+
+**Erik St. Martin:** Yeah. \[laughs\]
+
+**Brian Ketelsen:** Is that a bad thing, though?
+
+**Jessie Frazelle:** No, that's something that would be so cool, but I would need help from their end. He had X working at one point, and I don't know if it was correct X. He wouldn't let me use it, and I was like "Okay, please."
+
+**Erik St. Martin:** He was just keeping it a secret to himself.
+
+**Jessie Frazelle:** Yeah, like either it was so bad that he didn't want me to even try it, or it's so cool that they're gonna do some thing with it.
+
+**Brian Ketelsen:** There was about three weeks a year or a year and a half ago where I ran CoreOS on my desktop as my primary developer machine, and it was challenging, I won't lie.
+
+**Jessie Frazelle:** Wow, nice. Everything's in a container then.
+
+**Brian Ketelsen:** Yeah, everything had to be in a container, and it was painful.
+
+**Erik St. Martin:** Yeah, I tried that for a workstation for a little while, and I got a little annoyed. For your own desktop you want it to be pristine, but sometimes you just gotta get stuff done and you shortcut, and you wish you didn't, but yeah...
+
+**Jessie Frazelle:** \[32:07\] Yes, that actually keeps me up at night. I just, I can't... \[laughter\]
+
+**Erik St. Martin:** It would keep me up at night if all sorts of other things weren't already keeping me up at night. \[laughter\] It's like there's no more time left. Alright, so everybody wanna talk about any news and projects?
+
+**Carlisia Thompson:** I actually had a question for Jessie... Is there time for that still?
+
+**Erik St. Martin:** Yeah, there's always time for Jessie.
+
+**Carlisia Thompson:** Alright, so Jessie, question about your prolific speaking life... What can you share with us? We, who are not speaking, we're not doing lightning talks, we're not doing conference talks - what can you share with us for us to take the first step?
+
+**Jessie Frazelle:** Yeah, I think that the first time that I actually spoke somewhere was at a Brooklyn JS meetup in New York. That was really cool, because it was all people that I knew there, so it was a super comfortable feeling. I would almost say that meetups are awesome as a start.
+
+Then I got asked because of Steve Francia to Gotham Go. That was my first big conference, and I was super nervous. I think that's the first time I also showed GParted in a container, which is super not related to Go, but I was just like taking up time.
+
+**Erik St. Martin:** They both start with a G...
+
+**Jessie Frazelle:** Yeah, it's around there. So yeah, I guess even having people to say that you should speak at certain conferences is huge.
+
+**Carlisia Thompson:** Yeah, I agree with that. My takeaway here is try to do it in a setting where you know people in the audience, to make effort to invite people who are not speakers to start speaking. I had that experience myself my first time; the first time that I did a lightning talk was my very first programming job, and I had to do it. It was so painful, but I didn't have an option; otherwise I'd be like, "No way!" And I did it.
+
+The second time that I did it again was a few years later and it wasn't painful at all. So having that person that would just say, "Hey, why don't you do this talk here?" I think it helps a lot.
+
+**Erik St. Martin:** I think nerves get to people, and coming from the other side, too... Brian and I, we're a ball of nerves stepping up on stage, and all we have to do is welcome people, we don't have to give a technical talk. So I think being comfortable with the fact that I think everybody is nervous, and then thinking the crowd doesn't want to see you fail; everybody's rooting for you, everybody wants you to do a good job, so I think getting over that, and more, you're talking to friends... The light you put yourself in sometimes helps. And having other people who speak a lot is also helpful, that can give advice and make people understand that it's normal to feel that way.
+
+**Carlisia Thompson:** Yeah, and there are a lot of people who want to help on that front.
+
+**Erik St. Martin:** There's been a number of people for GopherCon who have offered to help review talks and to give speaking advice and all that stuff. I'm actually quite surprised how much people rehearse. I never really thought about that.
+
+I was talking to Dave Cheney one time and he was talking about how many times he rehearses it to make sure he's got his timing down right. And he knows exactly when he's falling behind and has to speed up or slow down and stuff like that, because he knows from this slide how long it takes to get to the end. I never would have thought about it that way... So preparation is everything; if you're fully prepared then you're not nearly as nervous, because you've rehearsed it so many times.
+
+\[35:59\] I think people step up on stage and they get nervous, they rush and they don't realize where they're sitting, whether they should slow down or speed up, which only adds to the nerves.
+
+**Jessie Frazelle:** Totally.
+
+**Erik St. Martin:** Yeah, and anybody who's speaking... We can compile a list too, because I know we've had a few people for GopherCon offer help with people wanting to get up on stage and speak, and we can make connections there, where we can maybe give people advice on doing that. Did you submit a proposal to GopherCon, Jessie?
+
+**Jessie Frazelle:** I do not think I did, probably because I was so busy. In another year or so I definitely want to. This is my first GopherCon that I'm actually going to, and I'm so stoked.
+
+**Erik St. Martin:** It's gonna be awesome. Did you see that Jerod started a container tech room?
+
+**Jessie Frazelle:** Yes, I'm very excited for that. All he did was say 'containers' and I just popped into his mentions. You're like one of those people... \[laughs\]
+
+**Erik St. Martin:** I loved the response, "Yes!" The idea there is to get a bunch of people together who wanna hack on things like Kubernetes and various CoreOS projects, Docker and all that stuff. It's one of the rooms I wanna hang out in, if I can hide for long enough.
+
+**Brian Ketelsen:** There's too many cool things going on...
+
+**Jessie Frazelle:** Yes, hiding at conferences is key. \[laughs\]
+
+**Erik St. Martin:** But you see, I have a phone and they keep calling me. If I turn it off, they send people to come find me. There's only so many places you can hide.
+
+**Jessie Frazelle:** Totally.
+
+**Erik St. Martin:** Alright, so projects and news. Do you have anything exciting that you wanna talk about?
+
+**Carlisia Thompson:** Yeah, so talking about presentations... I got some help from Bill Kennedy recently to do my GoBridge talk at the Women Who Go event. So he gives me this formula that he - he was inspired by Dave Cheney's post, or they worked on it together, I'm not very clear on that, but it made me lay out my talk so quickly and easily. Then he reviewed it and I got a better idea of what the formula was.
+
+I got so excited about it that I submitted two lightning talks for GopherCon... One for GopherCon and one for the kickoff party. I was like, "Yeah, I've got this, no problem. I can write... I have a formula and I just fill stuff in, and voila!"
+
+Of course, I still need to put the slides together and I still need to rehearse, but just getting the abstract, the intro and the conclusion ready, once you've got that, you've got more than 50% of the content ready.
+
+We put it up on the GoBridge Park, it's a repo called "Presentation Help", and I hope people will add more to it, too. I've just put this up today. I would love to see people contributing with links to other stuff, and I'll do that too, with time, as I run into things.
+
+**Erik St. Martin:** I'll have to find some, too. Katrina Owen sent a bunch of links and videos and book suggestions on Twitter for public speaking stuff. I'll find those...
+
+**Carlisia Thompson:** I know you're super busy - if you give them to me I'll put it in. She's also on the Women Who Go channel and she has put a bunch of information. She opened a Trello board. Women, we have resources! I wanna get this thing kicked off. I know Cassandra Gil from Iron.io was looking for women to speak at the GopherFest recently, and she only got one submission from a woman, and it wasn't even technical enough. There are women Gophers out there, so let's get them speaking.
+
+**Jessie Frazelle:** \[40:04\] Totally!
+
+**Brian Ketelsen:** Speaking of women Gophers, that Women Who Go birthday party last week was awesome.
+
+**Jessie Frazelle:** That was so much fun!
+
+**Erik St. Martin:** I'm the only one who missed out. I was sitting home with FOMO.
+
+**Carlisia Thompson:** There were a lot of people I didn't get to talk to, Jessie included. The time just went by so fast. It was awesome.
+
+**Erik St. Martin:** I feel that way every year at GopherCon. It's like, "Yay, we're here! This is gonna be awesome!" And then it's like we're packing up and leaving.
+
+**Brian Ketelsen:** Yeah, and you missed talking to 1475 of your friends, because you only got time to talk to 20.
+
+**Erik St. Martin:** Well, I feel bad too, because it was like the first year we dealt with everything individually, but it's grown so big, and during the day jobs, too. I'll look and I'd be like, "There's speakers I didn't actually get to talk to." It's hard now. I wanna try and change that this year. If I don't find all the speakers, they need to come find me, because I don't wanna miss talking to speakers.
+
+**Brian Ketelsen:** And now I'm just laughing, because we know it's not gonna happen. We're not gonna get to talk to everybody, it's just not gonna happen.
+
+**Erik St. Martin:** Show up at my door at home if I don't speak to you at the conference. \[laughter\] It'd be kind of hard, I don't think I wanna publicize my address.
+
+**Brian Ketelsen:** I will. Erik lives at... \[laughs\] So another interesting open source project that got an update this week is GoKit, who has a fancy new pretty website, GoKit.io. A very nice website with good, clear explanation of the goals of the project and the details behind each of the packages. A long overdue update for the website, it looks really good.
+
+**Erik St. Martin:** That's awesome. We have to get Peter on some time too and check GoKit.
+
+**Carlisia Thompson:** Yeah, definitely.
+
+**Erik St. Martin:** I wanna talk about a post I saw by Francesc on... I forget what he called it; it was like analyzing code with BigQuery, or something.
+
+**Jessie Frazelle:** Oh yeah, that was so cool.
+
+**Erik St. Martin:** I love his wit too, because it's like "Two seconds and $7 later..." \[laughter\] I wanna work at that skill where you're just billing... Like, "Yeah, I need to run a seven-dollar query..." \[laughter\]
+
+**Jessie Frazelle:** It was crazy though... When I saw that thing I was like, "One query for seven dollars? Wow..."
+
+**Erik St. Martin:** I wanna see what the bill is to do that. How much did that blog post cost?
+
+**Carlisia Thompson:** What I wanna know is what is his budget?
+
+**Jessie Frazelle:** Oh, yeah...
+
+**Carlisia Thompson:** Right?
+
+**Brian Ketelsen:** Alright, Jessie, you're the insider now. You gotta tell us what his budget is.
+
+**Jessie Frazelle:** I have no idea, I don't even have a budget for my stuff, so...
+
+**Brian Ketelsen:** You will, soon.
+
+**Erik St. Martin:** There were some interesting things that came out of that, though. I mean, aside from the crazy regular expressions that were on there, it was kind of cool seeing what packages people use most often.
+
+**Jessie Frazelle:** Yeah, yeah.
+
+**Erik St. Martin:** It seemed like a lot of it was logging packages, like glog and logrus...
+
+**Jessie Frazelle:** Yeah, there was logrus and then another one that was like top two.
+
+**Erik St. Martin:** I think the one that surprised me was Assert. It was used more than anything. it was used more than the context package and a bunch of other things; I was really surprised to see that, the Testify framework, which I haven't actually used, but it must be used quite a bit for it to be up there. I tend to stick to old school, I use a lot of standard library.
+
+**Jessie Frazelle:** Yeah, I usually use the standard. I think that we switched actually to Assert... No, we use GoCheck and Docker... But I've seen Assert used as well, I guess.
+
+**Erik St. Martin:** I haven't used GoCheck either... Does that do mocking or anything like that, or is it just extra assertions on...?
+
+**Jessie Frazelle:** \[44:06\] It's just extra assertions. I think that we were gonna use the other one and then we found some weird bug and then submitted a patch, but then decided to use GoCheck... I have no idea what we did there.
+
+**Erik St. Martin:** Somebody picked it and everybody stuck with it.
+
+**Jessie Frazelle:** Yeah, and if we ever chose anything new today, it would become this huge monstrosity because so many people would have opinions. At some point you just have to choose it and deal with the people that are mad.
+
+**Erik St. Martin:** I guess that's the benefit of working on smaller projects, right? Because generally you can get more people to agree on stuff. The bigger it gets, you're almost guaranteed to have at least a couple people that you can't get consensus with, and people who won't move at all.
+
+**Brian Ketelsen:** The flip side of that though, the benefit of sticking with the standard library is you don't have to have fights about which testing library to use.
+
+**Jessie Frazelle:** Yeah, for sure.
+
+**Erik St. Martin:** It's like, we can all agree on one, or we can agree on none.
+
+**Jessie Frazelle:** \[laughs\] Totally.
+
+**Erik St. Martin:** I mean, I guess it's a couple extra steps to do your own assertions, but I haven't suffered enough to really go playing with another framework, and I think a lot of that is just time, too.
+
+**Brian Ketelsen:** Especially in testing, though... There's really nothing that I need to do in testing that I haven't been able to do with the testing package.
+
+**Jessie Frazelle:** Yeah, I completely agree. Because every single testing that I write of my own is only the testing package. It's just cleaner.
+
+**Brian Ketelsen:** Yeah. Easier to read, and that's what Go is all about - easy to read code.
+
+**Jessie Frazelle:** Totally.
+
+**Erik St. Martin:** The other thing I saw was... Who was it from CloudFlare that did the net/http timeout post?
+
+**Jessie Frazelle:** Oh, Filippo... I don't know how to say his name. \[laughs\]
+
+**Erik St. Martin:** That's right. That actually had a couple of things in it that I didn't even realize. He walked through basically how all the timelines and deadlines worked in the HTTP package, and there were a couple of them that actually surprised me. One of them was like your write timeout included the read during the TLS handshake, and you wouldn't expect that... But there's a couple of things like that. That's an interesting read if anybody's interested in internals of stuff.
+
+**Jessie Frazelle:** Yeah, their blog is so good. For a company blog it's very detailed and technical.
+
+**Brian Ketelsen:** It's deliciously technical.
+
+**Jessie Frazelle:** It's so good... And they go into Kernel stuff, too. There was one on getting the kernel to send packets faster.
+
+**Erik St. Martin:** Oh yeah, I remember that post. That was a while ago.
+
+**Jessie Frazelle:** Yeah, it's burned in my brain, it was so good. \[laughs\]
+
+**Erik St. Martin:** I love watching all those posts on it. There was one last month that was something to do with optimizing TLS that was really good, too.
+
+**Jessie Frazelle:** Yeah, yeah.
+
+**Erik St. Martin:** But I geek out over a lot of their posts, just because they're all super low level and technical.
+
+**Carlisia Thompson:** Well, now I'm gonna have to ask - do you ever read the Fastly blog?
+
+**Erik St. Martin:** No, I actually haven't.
+
+**Carlisia Thompson:** They have a very good blog, too.
+
+**Erik St. Martin:** You're giving me more stuff to read here... I don't have time for this.
+
+**Carlisia Thompson:** Well, just read the right thing then. \[laughs\]
+
+**Erik St. Martin:** So I need somebody to curate these lists for me. \[laughter\] Brian does it with GitHub projects. He just comes to me with a list of the cool ones, I don't have to dig through the whole thing. Now I just need somebody to give me a curated list of technical blog posts. The more technical, the better. I like when they make me feel dumb, because that means I have to learn stuff to understand it. Some of these - it's not hard to make me feel dumb either.
+
+**Carlisia Thompson:** \[47:57\] There is one more project I wanted to mention. Jesús Garcia Crespo, he mentioned Concourse and I hadn't heard about it. It's an open source CI system for Go, so if you wanna host your own CI, there you go.
+
+**Brian Ketelsen:** That's a good one. \[cross-talk\]
+
+**Erik St. Martin:** What was that?
+
+**Brian Ketelsen:** Oh, I was just jumping to \#FreeSoftwareFriday. If you've got something to add for Concourse, go for it.
+
+**Erik St. Martin:** No, I was just gonna say that I tend to lean towards either Jenkins or Bamboo just out of habit, but I need to give something else a try. I haven't run my own CI locally in quite some time. The other thing I actually just saw on Twitter just before we started the show was that etcd3 is now out.
+
+**Jessie Frazelle:** Oh wow, cool.
+
+**Brian Ketelsen:** What's changed there? Etcd2 brought gRPC, didn't it? I wonder what the big change is for etcd3.
+
+**Erik St. Martin:** One of them brought the new Raft protocol, what was that?
+
+**Brian Ketelsen:** Oh, maybe that was etcd2.
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** So maybe 3 is where they changed all the gRPC bits...
+
+**Erik St. Martin:** The one thing I know came in it was watches. So you can watch for keys to change.
+
+**Brian Ketelsen:** Oh, like Zookeeper style watches?
+
+**Erik St. Martin:** Yeah. Other than that, I'd have to look because I haven't kept up with the release. That's the problem with being excited about too many things, you can't one hundred percent know what's going on in all of them, but that's one I vaguely remember. I think you are right though about gRPC being used instead of protobufs.
+
+**Brian Ketelsen:** Nice.
+
+**Erik St. Martin:** Or, I'm sorry, using gRPC with protobufs rather. Before it was all HTTP and JSON, wasn't it?
+
+**Brian Ketelsen:** Right.
+
+**Erik St. Martin:** But yeah, we should look after this; I wanna see what else is in there. That doesn't help the listeners, but...
+
+**Brian Ketelsen:** Well, they're helping us out on the Slack channel, so I'll read off the list. Improved latency and through put, less protocol overhead via gRPC API layer, better disk utilization, new storage backend with less memory overhead per key, automatic TLS configuration, flat binary key space, getting key watch by prefix, getting key watch by interval... Lots of good stuff here, I'm excited to see what etcd3 offers. This is cool.
+
+**Erik St. Martin:** See, they don't even need us any more, we just need everybody who's in the channel.
+
+**Brian Ketelsen:** Yeah, thanks for feeding this stuff to us, guys.
+
+**Carlisia Thompson:** Talking about feeding, Jerod just reminded us that there is such a thing called Changelog Weekly; if you're looking for feeds of awesome stuff, there we go. Erik...
+
+**Erik St. Martin:** That is right, how did we not talk about Changelog Weekly?
+
+**Carlisia Thompson:** Yeah. It's every Saturday morning. Usually I sleep in a little, then I get up and I open my phone, and there it is.
+
+**Erik St. Martin:** Your sleeping in is like 6 AM. You're always up at like 5 AM.
+
+**Carlisia Thompson:** Yeah...
+
+**Brian Ketelsen:** That's funny, because I don't look forward to Changelog Weekly nearly as much as I look forward to Changelog Nightly, which I get almost midnight every night. That's when I know it's time to go to bed. I look at Changelog Nightly, which has a list of all of the bursting in interest things on GitHub; it kind of shows you the projects that are taking off on GitHub, and that's kind of a neat way to catch new and interesting projects. So the Changelog Nightly email is my cue to go to bed. When I see that come through, I read it and then I go to bed.
+
+**Erik St. Martin:** Actually, I don't think I'm signed up for the Nightly one. The weekly one I am, but not the nightly. That's terrible. I mean, how can you be a co-host on the Changelog podcast and not actually be subscribed to all of that stuff?
+
+**Brian Ketelsen:** \[52:04\] We're taking away your license to podcast.
+
+**Erik St. Martin:** Right? Next week it will just be Brian and Carlisia. \[laughter\]
+
+**Brian Ketelsen:** Yeah, I don't know how you can subscribe to those things. I suspect that if you went to Changelog.com and started clicking on buttons, you could find an email subscription for them there, but they're both well worth it.
+
+**Erik St. Martin:** Nobody needs us. Somebody's about to drop them in the channel.
+
+**Brian Ketelsen:** Yeah, just wait for somebody to tell us on slack what the URL is. On that note, we should probably move on to \#FreeSoftwareFriday. Every week we like to say a shout out to either the projects or the maintainers of open source projects that make us happy, and it's something that we enjoy quite a bit because we know that often times running an open source project or maintaining an open source project is a thankless job. So I'll start off this week with jq. It's the most awesome command-line tool ever if you need to deal with JSON. You can pipe JSON to jq and pull out a single element, you can reformat it, you can prettify it... Pretty much anything you need to do with JSON on the command-line, jq is your tool. It's written in C, it's super fast, and I think it should be installed just like awk and sed and grep. It should be a standard UNIX utility.
+
+**Carlisia Thompson:** That's pretty cool.
+
+**Jessie Frazelle:** Nice, I use that all the time. And yes, it should be in the core utils.
+
+**Erik St. Martin:** Yes, it should come on all Linux installs.
+
+**Jessie Frazelle:** Yeah.
+
+**Erik St. Martin:** Carlisia, what do you have?
+
+**Carlisia Thompson:** I have this tool called goconvey...
+
+**Erik St. Martin:** Yes!
+
+**Carlisia Thompson:** See, I had never seen this. I don't use it - just a disclaimer - it was mentioned to me by Ricardo Longa. It's a tool for testing Go, but if you haven't used it or don't know, you have to go on the repo to check it out, because it's impossible to explain. It just makes your tests run on your browser, and it's pretty and colorful.
+
+**Brian Ketelsen:** Yes, goconvey is really nice. There's two pieces to it - they have their own assertion, BDD sort of language framework, but the other piece is that they've got that beautiful UI for running your tests. You can open up your browser and you can watch everything be green or flash red when there are errors, and that doesn't require using their special test framework. You can use it with the standard testing package. So goconvey is really nice, we use that.
+
+**Erik St. Martin:** That seems to be the confusion for some people, unless they changed the website. It used to focus a lot on the custom assertion framework they had, and it wasn't as noticeable, but you can use that, which is standard library testing.
+
+**Carlisia Thompson:** Yes, thanks for the clarification, because being that I haven't used it, I don't know all the details. Thank you for that.
+
+**Erik St. Martin:** Yeah, it's cool. It does browser notifications and stuff that show you passes and fails and all that stuff, so you can just kind of keep running. It's a really cool project.
+
+Jessie, we're kind of blindsiding you here, but do you have an open source project you wanna thank?
+
+**Jessie Frazelle:** Totally. Okay, so I have one, and then I have a little small tidbit. \[laughs\] Okay, sorry, I got really excited because I really like this. There's this really cool project by Brian Redbeard from CoreOS, it's called GPGget, and it automatically does the whole get this GPG signature and check it against this file that I've just downloaded, without you having to do all that same curl typing crap. That's pretty neat.
+
+Then also my co-worker from Docker, Michael Crosby, he has the world's best gists, but they're undocumented and completely random, but you'll find yourself in this goldmine of something 75% finished but super epically awesome.
+
+**Erik St. Martin:** \[56:14\] So you're just searching around for treasures...?
+
+**Jessie Frazelle:** Yeah, and he's gonna be mad at me for stalking his gists.
+
+**Carlisia Thompson:** We need the link, what is the link, the account?
+
+**Jessie Frazelle:** The GPG get is BrianRedbeard/gpgget and then just CrosbyMichael on GitHub gists.
+
+**Carlisia Thompson:** Okay, cool.
+
+**Erik St. Martin:** I'll link Michael... We've seen a bunch of stuff by him before, too.
+
+**Jessie Frazelle:** Yeah, because you all know him.
+
+**Erik St. Martin:** Yeah, from back in the whole Skynet thing, that kind of got abandoned.
+
+**Brian Ketelsen:** Skydoc, that's right.
+
+**Erik St. Martin:** Yeah, so the only thing that lived through all of that was SkyDNS.
+
+**Brian Ketelsen:** But at least it lived well, and still lives.
+
+**Erik St. Martin:** Yeah, until somebody writes something better. Alright, so my project this week is Ranger, which is a file manager for Linux, and it has VI key bindings. It's all written in curses and all that jazz, so that's what I use on my system when I need a file manager. It has kind of cool previews, and stuff like that.
+
+**Brian Ketelsen:** Yeah, I have to admit I haven't seen that before, but when you put it in the show notes, I brew installed it on my Mac and I was instantly impressed, because command line file management is awesome.
+
+**Erik St. Martin:** Yeah, it's got multiple columns and all that good stuff.
+
+**Brian Ketelsen:** Like Midnight Commander.
+
+**Erik St. Martin:** But better.
+
+**Brian Ketelsen:** But better, yeah.
+
+**Erik St. Martin:** It has to be better.
+
+**Brian Ketelsen:** I am DOS age. When I was a kid we didn't have Windows, we had DOS, and we used Midnight Commander.
+
+**Jessie Frazelle:** I have a DOS computer in front of me right now. \[laughs\]
+
+**Erik St. Martin:** Nice...
+
+**Carlisia Thompson:** Of course you do!
+
+**Erik St. Martin:** That's not your work computer, is it?
+
+**Jessie Frazelle:** No, it's just everything else is stacked on top of it right now.
+
+**Erik St. Martin:** I don't think I wanna know what a C or C++ build takes on that.
+
+**Jessie Frazelle:** So bad, probably.
+
+**Brian Ketelsen:** It doesn't count if you're using it as a monitor stand, Jessie.
+
+**Jessie Frazelle:** \[laughs\] Yeah, it really has a computer on top of it, and then a plant.
+
+**Erik St. Martin:** Is that the San Francisco version of like a college apartment, rather than milk crates you have old 486 computers and stuff and like that as coffee tables?
+
+**Jessie Frazelle:** Pretty much. I'm like a San Francisco computer hipster.
+
+**Erik St. Martin:** A lot of people are getting back into collecting old hardware like that. And what was that new Kickstarter that just came out, that chip. That looked really cool too, being able to play retro games on it, and stuff.
+
+**Jessie Frazelle:** Oh, nice.
+
+**Brian Ketelsen:** I haven't seen that.
+
+**Erik St. Martin:** Yeah, I'll have to link to that. Dave just got one, he was all pumped; he sent me a picture. He was like, "Dude, it came!" \[laughs\] He's awesome. He's so addicted to hardware, too.
+
+**Brian Ketelsen:** He does the coolest projects.
+
+**Erik St. Martin:** What I wanna know is how people get the time for all this stuff. I feel like there's just not enough time in a day.
+
+**Brian Ketelsen:** I think it has something to do with no kids.
+
+**Jessie Frazelle:** \[laughs\] And no sleep.
+
+**Erik St. Martin:** Yeah, it's true. Well, I think we have the no-sleep thing covered.
+
+**Jessie Frazelle:** Oh, totally. Buy your kids the... \[laughs\] It's just using that time for something else.
+
+**Erik St. Martin:** Alright, does anybody have anything else that we wanna chat about before we wrap this up? I think we're about out of time.
+
+**Brian Ketelsen:** I don't think there's anything we didn't cover.
+
+**Carlisia Thompson:** This show was awesome!
+
+**Brian Ketelsen:** Did we miss anything on the whole internet today? I don't think so.
+
+**Erik St. Martin:** This is fun, I think we can hang out here all day. It's still early where you are, right Jessie? \[laughter\]
+
+**Jessie Frazelle:** \[59:59\] Yeah, it's like two.
+
+**Erik St. Martin:** Alright. I wanna thank everybody for being on the show, especially Jessie. This has been a lot of fun. I wanna thank the listeners, I definitely wanna thank our new sponsors, Linode and Equinox.
+
+**Brian Ketelsen:** Hurray! And I'd also like to thank Duncan for interrupting our broadcast when my kids showed up.
+
+**Erik St. Martin:** We have a new co-host.
+
+**Brian Ketelsen:** Yeah - Duncan, my dog. The kids think he's named after Dunkin' Donuts, but he's really named after Duncan Idaho from Dune. \[laughter\]
+
+**Erik St. Martin:** Alright, so if you are not subscribed already, go to GoTime.fm to subscribe. Follow us on Twitter, which is @GoTimeFM, you can find us on Slack in GoTimeFM channel, and we have a GitHub, which is GoTimeFM/ping if you want to suggest topics or guests. I think that's it...
+
+Show notes - we will have everything we've talked about, and we will put links to both Equinox and Linode and any discount codes that we have available for those.
+
+Oh, and next week we're gone, because all of us here will be at GopherCon, so we can have a live roundtable discussion. Not live like recorded, but live like come-talk-to-us discussion.
+
+**Carlisia Thompson:** It's not next week, though. Next week we have Beyang.
+
+**Erik St. Martin:** That's right!
+
+**Brian Ketelsen:** Don't take that week away from me, Erik. I need it! \[laughter\]
+
+**Erik St. Martin:** We're losing time! For some reason I'm thinking next week... Okay, so yes, next week we have Beyang from Sourcegraph on the show, and then it's GopherCon.
+
+**Brian Ketelsen:** Yes, and we will be live streaming GopherCon this year on Twitch, so if you're in the audience and you won't be able to make it to GopherCon, Twitch.tv/gophercon. That is gonna be epic.
+
+**Erik St. Martin:** I'm excited.
+
+**Jessie Frazelle:** I'm so stoked!
+
+**Erik St. Martin:** Yeah, come find us too, Jessie.
+
+**Jessie Frazelle:** Oh, I will. I will be finding everyone. You'll be sad that I'm there at one point, because you'll be like, "Argh, Jessie..."
+
+**Erik St. Martin:** We're gonna give you like a paper, like the head sheet or face sheet with pictures of everybody, and you're gonna have to mark them off when you find them.
+
+**Jessie Frazelle:** Yes, like Bingo!
+
+**Carlisia Thompson:** Bingo, yeah! \[laughs\]
+
+**Erik St. Martin:** And turn it into a whole game for everybody. They have to acquire something from each person on the list...
+
+**Jessie Frazelle:** Nice...
+
+**Carlisia Thompson:** So Jessie is not on the GoTime Slack channel, but Adam is saying, "Say hi on camera with us, Jessie." That's Adam from Changelog.
+
+**Erik St. Martin:** Oh yeah, that's right, Changelog will be there, because we love Changelog. They'll be there doing interviews with everybody, so yeah, come over and say hi on camera.
+
+**Jessie Frazelle:** Oh cool, okay.
+
+**Erik St. Martin:** I promise they edit it, so they won't make you look bad.
+
+**Jessie Frazelle:** Nice. I mean, there's so many bad shots of me in conference videos that it does not matter.
+
+**Erik St. Martin:** It's like DMV photos... The ones you wanna see never end up there.
+
+**Jessie Frazelle:** Yeah. I feel like it's just an ultimate troll.
+
+**Erik St. Martin:** If you wanna see the worst one, the state of Florida with their concealed carry permits...
+
+**Brian Ketelsen:** Oh my god...
+
+**Erik St. Martin:** ...everybody I've ever seen their picture on their concealed carry permit looks like they should not get a gun. You'll see the picture beforehand, it looks fine, and then it shows up at your door and it's all zoomed in, and weird, shadowy, your eyes look all dark, and you just look evil.
+
+**Brian Ketelsen:** Black and white... Mine makes me look like the Unabomber. \[laughter\]
+
+**Erik St. Martin:** Yeah... If you find us at the show, Jessie, Brian and I will show you. You'll look at it and you're like, "Yeah, I would not give that guy a gun. It doesn't even make sense."
+
+**Jessie Frazelle:** Nice.
+
+**Erik St. Martin:** I've seen worse, though. I have seen worse. Alright. Oh, I love Slack, this is awesome. Adam's reminding us...
+
+**Brian Ketelsen:** Everybody's just telling us what to do on Slack now...
+
+**Carlisia Thompson:** We are scripted. \[laughs\]
+
+**Erik St. Martin:** See, I'm telling you they don't need us. \[laughter\]
+
+**Brian Ketelsen:** \[01:04:03.21\] Just replace us with a bot.
+
+**Erik St. Martin:** So at GopherCon we will be giving out T-shirts, so if you want a T-shirt... Has everybody noticed the cool logo for GoTime now? It's like this cool little sphere thing, but if you look closely there's a hidden Gopher in it...
+
+**Carlisia Thompson:** No, no... NO!
+
+**Brian Ketelsen:** You spoiled the secret, Erik...
+
+**Carlisia Thompson:** You spoiled it, Erik.
+
+**Erik St. Martin:** It was supposed to be a secret?
+
+**Carlisia Thompson:** It was supposed to be something you discover on your own, like "Oh my gosh, there's a Gopher here! All along, for three years I haven't seen it!"
+
+**Jessie Frazelle:** That's so cute!
+
+**Erik St. Martin:** It's trippy, isn't it?
+
+**Carlisia Thompson:** I had such a kick when I noticed it.
+
+**Erik St. Martin:** I don't know, I think I see Gophers all the time, so it's like as soon as I saw the logo I saw the Gopher.
+
+**Brian Ketelsen:** it's like going to Disneyland... "Oh, look, there's another Mickey." There's another Gopher...
+
+**Erik St. Martin:** See, Todd's in the GoTime FM channel and he says it's not a secret. He noticed as soon as he subscribed.
+
+**Brian Ketelsen:** See? There's no secret. You didn't screw it up, Erik. Good job.
+
+**Carlisia Thompson:** No, it's alright.
+
+**Erik St. Martin:** Alright, so I think we're extending everything. We should probably wrap this up though. As we've already said all of our closing stuff, I guess all that's left is goodbyes, and we'll see everybody next week.
+
+**Brian Ketelsen:** Thanks, Jessie!
+
+**Jessie Frazelle:** Thank you for having me, this was cool!
+
+**Carlisia Thompson:** Thanks, Jessie. This was super fun!
+
+**Erik St. Martin:** Yeah, we'll have you back on when you get more into what you're doing at Kubernetes, and you can talk to us about it.
+
+**Brian Ketelsen:** No, we're not bringing you back until you have a budget. \[laughter\]
+
+**Jessie Frazelle:** Yeah.
+
+**Erik St. Martin:** You have to tell us somebody's budget. If it's not your own budget, it's gotta be somebody else's. If you make one up, we won't know the difference anyway.
+
+**Jessie Frazelle:** Okay. \[laughs\]
+
+**Erik St. Martin:** Alright everybody, we'll see you next week.
+
+**Jessie Frazelle:** That was fun!
+
+**Brian Ketelsen:** Goodbye.
+
+**Carlisia Thompson:** Bye!

Juju, Jujucharms, Gorram_transcript.txt

@@ -0,0 +1,369 @@
+**Erik St. Martin:** Alright, we are back for another episode of GoTime. It is episode number \#24. Today's sponsors are stackimpact and Code School. Today on the show we have myself, Erik St. Martin, we are down one Brian Ketelsen, who is a few thousand feet above us, making his way back home. Carlisia Campos is on the show today...
+
+**Carlisia Thompson:** Hi, everybody.
+
+**Erik St. Martin:** And our special guest today is Nate Finch. How are you doing, Nate?
+
+**Nate Finch:** Doing good.
+
+**Erik St. Martin:** Would you like to give everybody a little background about yourself?
+
+**Nate Finch:** Sure. I've been doing development for 16 years now, since graduating from college about four and a half years ago, right around Go 1.01, or something like that. I started looking at Go mainly as a way to not be pigeonholed as a Windows developer, because at that time I was a Windows developer, and I wanted to be more than that... And I met Go, and then I went into the community, and about six months later I saw Gustavo posting on Twitter that there was an opening for a Go developer at Canonical, working on Juju. I've interacted with Gustavo for a bit, and we sort of knew each other; it eventually worked out, and I started working on Juju. I've been there for just about three and a half years. I've done a bunch of Go stuff on the side, and I'm a big fan of Go.
+
+**Erik St. Martin:** So you were writing production Go code before most people knew about Go.
+
+**Nate Finch:** Yeah. It was fun.
+
+**Carlisia Thompson:** I wanted to confirm, that's Gustavo Niemeyer, right? He works at Juju.
+
+**Nate Finch:** Correct, yes. I skipped his last name because I was not sure how to pronounce it.
+
+**Carlisia Thompson:** I actually only know him because he's Brazilian, and I always think he works for Google, but he actually works for Juju. How do you say Juju, anyway? I say Juju because that's how you say in Portuguese, which is so cute... How do you say it?
+
+**Nate Finch:** Juju... It's a word for magic. That's what we think Juju does - magic stuff.
+
+**Carlisia Thompson:** Gummy bears in Brazil are called "jujubinha", so I always think of gummy bears when I see Juju. \[laughter\]
+
+**Erik St. Martin:** So Juju is basically an orchestration platform for tying together different services. I haven't used it myself, but it did look interesting. You guys have the Charms, which are the way applications are tied together.
+
+**Nate Finch:** Yeah, it's very similar to other orchestration platforms such as Kubernetes...
+
+**Erik St. Martin:** ...Docker Swarm, Mesos...
+
+**Nate Finch:** Yeah. We're not so tied to Docker, because we existed before Docker existed, so...
+
+**Erik St. Martin:** You win! \[laughs\]
+
+**Nate Finch:** \[03:47\] Right! There you go, we win. So we do support Docker - if you wanna use Docker, that's fine. If you don't wanna use Docker, that's also fine. What it does is it lets you make a very lightweight wrapper around either your Docker thing, or your raw application, and then you can deploy it to the cloud, or containerize it on your desktop or hardware, in racks, in your server room, and it makes it very easy to do very complicated stuff. Plus, I checked, it was one of the biggest open source Go projects someone's cut up by now. It's well over 500,000 lines of code, and that's just stuff that we wrote; it's big. We use MongoDB to store our data, which is okay; it stores our data, usually... \[laughter\]
+
+**Erik St. Martin:** ...most of the time.
+
+**Nate Finch:** Yeah. There's a couple known issues with the way that Mongo works, and if you're careful you can avoid them.
+
+**Erik St. Martin:** With the history of Juju and the length of time it's been around - I know Gustavo was working on it back in 2013-2014, so we're talking early Go days, pre-1.0. There have to be some lessons learned, how things evolved. We were talking the other day on the show about Kubernetes and the etymology... If you look through the codebase, you can kind of see the evolution of people's understanding of the language. It started out very Java-ish, and in other areas it's very Go-ish. Do you have similar things that you've experienced?
+
+**Nate Finch:** Oh yeah, definitely. A lot of the early developers were more familiar with Python, so there's a lot of Pythonisms, which is sort of worse than Java-isms... Because Java at least is strongly typed, whereas with Python people expect to be able to just curl in whatever... So there's a few spots where there's empty interfaces and reflection, most of that's been stripped out as we go along.
+
+I think one of the bigger lessons learned is we use Gustavo's GoCheck, which is a testing framework built on top of GoCast. It adds test suites so that you can have code that runs before a full suite of tests, and then code that comes before each individual test very JUnit, xUnit those things do that, too.
+
+That's actually been kind of a problem, because it means that we have a lot of code that runs that's invisible, which means it's hard to know exactly why a test actually works, because it's all this stuff to set up that you don't see, and then the unit tests take on a piece of machine a good 17-18 minutes. And that's just like running Go tests for all of Juju. That's a long time.
+
+**Erik St. Martin:** So this is just your unit tests and not integration tests, and stuff.
+
+**Nate Finch:** Correct. Our integration tests are even worse, but that's sort of understandable because our integration tests actually bring up machines in the cloud. Those take like four hours. That's doing a lot of work over the network, and machines moving, and so on. But unit tests - it's kind of inexcusable to have unit tests that take 17-18 minutes, at least in this day and age.
+
+\[07:46\] We have a lot of full stack tests that run against an actual Mongo database, which is great for making it a real-world scenario, but it's terrible when you make one small change and you wanna run all the tests. It's hard.
+
+**Erik St. Martin:** The hard part is it's like "What should that number be?" With a 500,000-line codebase, it's going to take a long time to do a good test suite, but 18 minutes does feel probably on the longer side.
+
+So you initially came up -- was this last episode or the one before, Carlisia? Where we were talking about Gorram. How do you pronounce that, anyway?
+
+**Nate Finch:** Gorram. It's from Firefly, it's actually a swear... "Those Gorram thieves!"
+
+**Erik St. Martin:** \[laughs\] That's awesome.
+
+**Carlisia Thompson:** Erik, I don't remember which episode it was, and I don't even remember talking about it, but I also don't remember a lot of things, so I don't know...
+
+**Erik St. Martin:** You're always the one who's... She knows exactly which episode that we talked to which person, she's so good at that stuff.
+
+**Nate Finch:** It was episode \#21, and the reason I know that is because I've listened to it last night. \[laughs\]
+
+**Erik St. Martin:** So it was a couple more episodes ago than I thought it was, but... Yeah, she's so awesome that I'll mention "We talked to somebody..." and she's like "Oh yeah, it was episode such and such."
+
+**Carlisia Thompson:** Oh, thank you... But I guess it doesn't work all the time.
+
+**Erik St. Martin:** If you ask me on Monday, I'll forget who we talked to last week. \[laughs\] So what was the motivation behind creating that? It's a really interesting project.
+
+**Nate Finch:** So it's very simple - there was one definite spot where I said, "I can make this!", and I was working with some JSON at work, and it gets spit out to the CLI in a big mess with no line returns or anything, and I was like "I need to make this look nicer." I was working with someone else and we said, "Let's do python-mjson.tool and pipe it into that." And that worked, and it made it all nicely indented and stuff, and I was like "That's great!"
+
+I don't want to run Python to do that, I wanna make my thing in Go to do that, because I don't know all the Python libraries and stuff; I'm vaguely familiar with some of them, but I know the Go standards and libraries, so I was like "How can I make this work with Go?"
+
+So first I figured out how it works in Python, because a vague big idea. In Python, each script actually has a bit at the bottom that says, "If I'm being run as main, then do this stuff." It wraps the actual package in some smart logic to do some stuff, and in the case of json.tool, it makes the JSON look nice. So I was like, "Okay, well I can't go back and add that code to everything in the standard library, but I betcha I could generate that code."
+
+I'm a big fan of generating code, because I don't wanna have to write the dumb code that's always mostly the same, I want something to write it for me; that way, I can write the good stuff. So I was like, "Well, okay, I can do that." I think I was lucky that that was my starting point. It was a fairly complicated thing of typing some JSON to a specific function to prettify it, so that was a difficult use case that I think made it much easier to do everything else that Gorram can do. So that's the story.
+
+\[11:42\] I started poking at Go types, the standard library package that reads code and understands what types are in there. Luckily, much of Go code has a lot of conventions that we can use to understand what type of action this function's gonna take; so like readers and writers, and returning N for the length, and returning errors, and stuff... There's all these conventions to make it very easy to just generate some code, because you pretty much know what each thing is going to expect.
+
+So I just started poking at that for like a week or so, and got some basic things working. Then I've been adding a few new features since then.
+
+**Erik St. Martin:** I just thought it was really cool, because I throw together little tiny Go programs to do stuff like that. Like, "Let me reformat the JSON", and stuff like that... So it was really cool to see that, because then I can actually throw that in my Bash script without having to pass around these little binaries.
+
+**Nate Finch:** Yup. One thing I noticed you mentioned in the last show was that it works with the standard library - it actually works with anything in your Go path. If you have some third-party thing, it will still work.
+
+**Erik St. Martin:** Oh, cool... So anything that's in the Go path of whatever machine it's being run on.
+
+**Nate Finch:** Yeah.
+
+**Erik St. Martin:** That's awesome. Bill Kennedy was asking us too what your experience with working on large code bases is, with it being that large and not the norm.
+
+**Nate Finch:** It's funny, there's a proposal for Go 1.8 about aliases that is just before support for bigger projects; that kind of a thing actually could be pretty useful for us. We have a lot of lines of code, but also we have a lot of different repos and multiple different applications building off those. So any major modification to an API can cause lots of problems. We have to have like four different projects all change at the exact same time. So aliases, at least one time that I can think of would have been a big help, but I'm also sort of on the fence for supporting aliases because they do make it difficult to know for sure that these two things are the same. Because you can have types that look like they're different and they're actually not, and that's not that great.
+
+**Carlisia Thompson:** I wonder... Can either one of you explain what an alias is, so we can frame this issue a little better for people who don't know? I have an idea, but I couldn't explain it well. And after we explain what it is, my question for you, Nate, is do you think it could be overused? I mean, it seems that it was already implemented, right? I don't even know if there is any going back. Does anybody know?
+
+**Nate Finch:** Yeah, I've been following that... So it has been implemented, but there's still time to roll it back if it's decided that we should. What aliases are is you can put a definition in your package that is, for example, "type Fu => some other package's type". The => looks like a right-facing big arrow.
+
+**Erik St. Martin:** That's like the Ruby Hashrocket.
+
+**Nate Finch:** Okay, and what that says is "references to this type and this package are the exact same thing as references to that thing in that package." So a question that takes one, take either. And more complicated constructions like a function that takes a function that takes that thing works with either one. And if it's that second-order function of a function, that is where you actually need it, because for types you could use interfaces directly. So you can pass a strings.Reader into something that needs an io.reader.
+
+\[16:06\] However, if you have a function that takes a string reader and something else that wants to take a function that takes a function of io.reader, that won't work. It's a little hard to explain without text.
+
+**Erik St. Martin:** Audio definitions of things gets difficult... But I guess the basic explanation of it is it's almost like a symlink where you're referencing one type from another package in your current package. Say you took one big monolithic repo and you needed to split it up. Well, you don't wanna break all the projects that may be referencing that package, so you may kind of create an alias so that the type still exists in the original package, but it basically refers to it in its new location.
+
+I didn't realize that it worked the other way. You said that basically the indirect works both ways, Nate, where if I took the type from the original package or I took the type from the new package, I could use either type pass in?
+
+**Nate Finch:** I'm pretty sure. I'm not one hundred percent sure, but I think that's sort of needed to make sure that you have full compatibility. But I'm not a hundred percent sure.
+
+**Erik St. Martin:** Yeah, and I think that... and Bill Kennedy is chatting here too. He pointed out the fact that this is supposed to be a temporary stop gap; it's not supposed to be a feature that people heavily use. It's supposed to allow people to put that alias and to not break CI for 20 projects that all depend on this one.
+
+**Nate Finch:** Yeah, that's what they say, but we all know that no hacks are ever temporary, right? They will stick around for years; that might be one of my concerns about this.
+
+**Erik St. Martin:** Yeah, I think it has a legitimate use, but I think that people are also concerned with... Go has done a very good job at removing the footguns, you know? This seems like one, and I think that's what heated the debate; it's really polarized. There's people who really need it for legitimate purposes, and then there's everybody else that's like, "Whow-whow-whow... People are gonna really overuse this."
+
+**Carlisia Thompson:** Yeah, that's what I wanted to know, because one of the angles of the conversation was this is adding a level of indirection that's going to make reading code confusing. And the other side is saying, "Well, but you know, it's very useful, and guess what? We have *goto* as well, which is not supposed to be used all the time, but we do have it and we use it in very specific and very sparingly." So Nate has this huge code base that he works with, and it is useful for him. What I'm wondering is if you, Nate, see the potential for this being thoroughly overused.
+
+**Nate Finch:** I think it's very valid to say that there are things in the language now which we say "Don't do that, except for very specific cases." Like using panics - you could use them exactly like exceptions, but then everyone will tell you that you're wrong. I do agree that as a community we seem to be pretty good at following conventions that we all pretty much agree on. There's actually nothing that forces anyone to go format their code, and yet everyone does.
+
+\[19:47\] I think this could be a similar thing. I think it could be abused, I am hoping that people won't. For most big code bases (like Juju) we review every line of code, so if someone was doing whacky stuff with this, we'd be like "No, don't do this!" But there are definitely times where it's very useful to be able to break up packages, move things around and not have to have a ten-thousand-line diff, which I've had to do; it was not fun. In that exact thing, aliases would have helped a lot.
+
+I think it's probably gone far enough, but they're not going to take it out. At this point, I think we have to be mindful of the way it's used.
+
+**Erik St. Martin:** And I think now is probably a good time for a sponsor break.
+
+**Break:** \[20:48\]
+
+**Carlisia Thompson:** Yeah, that looked really impressive. I was checking that out, that looked really cool.
+
+**Erik St. Martin:** Yeah, I was digging around in there, too. These are definitely things that when you're running their profiling tools you get this information, but you usually don't have it available to you once you kind of roll your app out into production. It was really cool digging around the web interface and seeing what was available.
+
+**Carlisia Thompson:** Yeah, and that's sort of where it really counts, right? When a thing is in production is when you really wanna see how they are doing.
+
+**Erik St. Martin:** Yeah, you can only simulate so much in your test and CI environment.
+
+**Carlisia Thompson:** So going back to talking about how we are using Go in the most useful way of using the features that we already have - at least that's how it was playing in my mind... I know Nate wants to talk about error handling, and how the way Go does it is different and maybe even better than in other languages, so I would love to go there.
+
+**Nate Finch:** Yeah, sure. So it's funny... When Go 1.0 was announced which was actually the first time that I had heard of Go, and at the time I was working in C\# for the most part with some Java and Python, and I was like "Oh, it's a language from Google. I should go and see what it's like." And the very first thing that I've noticed was no exceptions. I was like, "Wow, that's terrible... I'm not gonna use that." \[23:58\] \[laughs\] Then they announced 1.01 about six months later, and I was like "Let me look at it again", and the rest is history.
+
+Exceptions are hard... Hard, hard, hard. In my last job was another big code base, I think somewhere around 50,000 lines of C\#, and I remember one instance where I was modifying some code and I was like "Oh, this code can fail. I'll have to throw in an exception." And during a code review, someone was like "You can't have that throw an exception, that's way deep in the stack. We have no idea who will catch that." That was for the first time I was like "Wow, exceptions aren't that great. They're basically a go-to, except that you don't know where going to." You can figure it out sometimes, but it's very hard to know who is going to catch this error, and you have to clean everything up. And if you're looking at a function, you have no idea what can fail. Any function that you call could fail. What's worse is that it might not fail now, but in six months someone might modify it to fail, and that's scary.
+
+I remember one of the first Go programs that I wrote was just downloading a bunch of pictures off some website, and everything that could fail returned an error. It was this epiphany of, "Oh my god, I know what can fail. I can deal with all this, and I'd know exactly what my program's gonna do." I think dealing with errors is where Go really got it right, because the multiple returns means it's very easy to just say, "Okay, this thing returns an error, but also some actual useful data."
+
+Yes, you have to do "if error != nil, blah", but that's good, because that means you're saying, "I know this can fail. I'm gonna do something."
+
+People always talk about, "Oh, it makes my happy path look all messy", and I'm like "This is programming. There is no happy path."
+
+**Erik St. Martin:** Yeah, especially when you write network software, right? The amount of things that can go wrong is just... Anybody who's supported applications in prod is aware of stuff like that, the odd things that start happening to every application when different resources start hitting their level of saturation, when the out-of-memory killer starts going, or when you run out of disk space and the network drops, or somebody decides to take down a link and bring it back up, or assign a new IP address to it... Random stuff happens on the machine. Like you said, there's no happy path.
+
+**Carlisia Thompson:** That's very interesting, yeah.
+
+**Nate Finch:** Yeah, and the thing that I find is that in Go I'm a lot more aware of where things can fail, so instead of just programming for when things work, and then when things break everything dies... Things don't always work exactly the way I expect them do, and you have to deal with that. Things like the network being terminated is not terribly exceptional, it happens all the time, so what do you do? It's like, there's no happy path; there's also no sad path... There's just paths, it's just forks. Like, "Is this user's name Bill or is Bob?" It's not happy or sad, they're just different, and you do different things.
+
+**Carlisia Thompson:** \[27:47\] That's a very good point. I remember when I started looking at Go open source projects, especially the bigger ones, like InfluxDB, Docker etc., I got really intimidated by how long the files were. I was just thinking, "Wow, it must take a lot of mental energy to hold everything that's in this file in your head." Especially coming from Ruby, where people say "Don't make your file longer than a hundred lines", and here I was looking at Go files that were super long. Now, after I learned a little bit, I noticed that a lot of it is error. My first reaction was like, "I don't wanna be looking at error handling. I wanna look at the code, I wanna look at the happy path, because that was my frame of reference, that's how I used to think." Which is to say Go has a very different (prerogative, I wanna say) approach, and now that I'm used to it, I really find it very refreshing that everything is there. It's explicit, and it's right there, so I don't have to go to other places; I don't have to follow that chain of exception-throwing all over the place. Everything is right there.
+
+Now I find that it's the opposite for me. I love it. I find it super simple. Whereas before I used to look at a big file and think I have to hold it all in my head, now I look at a big, long Go file and I think, "Everything is here. It's so much easier for me to hold this in my head, because everything is right here." It's not a long file that it's that content and I have to go all over the place to look at where exceptions are being thrown; everything is right there, it's explicit, and it makes it a lot easier.
+
+**Erik St. Martin:** You know, the one thing that I like about it is if you use idiomatic Go, then your happy path typically is at the first indentation level, so if you're just trying to get an idea for what a function does, you can kind of just scan that level. And most of your edge cases and when things return an error are typically indented in; that's typically where you find your error handling, so it's easy to scan past it when you're just trying to get a rough idea, but like you said, you can focus more on it when it matters, when you're really trying to "Oh, why would this go wrong? I should look to make sure it's handling these scenarios I'm expecting it to."
+
+The hardest part is not knowing. It's the unknown unknowns, and I think that's why the whole crash-only software paradigm has kind of become more popular, especially with distributed computing and containers. And going back to Nate's point about people overusing panic, I wonder if it's that kind of crash-only methodology that's having people to use panic more...?
+
+**Nate Finch:** I definitely think there are a large number of people that think that once you get into a bad state, that you no longer know what's going to happen, so you should just bail out. That's fine, but one of the ways you can avoid getting into a bad state is by understanding what can fail and how things are able to fail. Even with Go, returning an error is sort of like failing... You're saying, "I couldn't do it, something went wrong. Make no assumptions about what I was supposed to do." Often times, that will just bubble all the way back up to wherever the start of your action was.
+
+\[31:43\] In Juju, we actually have things we call "workers" that are threads, which will get restarted if they fare out. It's very similar to crash-only software just per goroutine. But I don't think you need panics to do that. Panic is taking down the whole application, and I think applications these days are complicated enough that one small piece failing is not a need to bring down the entire thing. Usually.
+
+**Erik St. Martin:** I'll agree. You should allow the highest level possible to make that decision. You have some sort of RPC service, and there was some kind of network issue through jitter, like reordered packets that lost its state, or something like that; but you wouldn't crush the whole program. You would come back up a level and that would be like, "Let's close this connection and let it reopen", because we don't really know what state the connection is is, whether it's sending a header packet, or the body - we can't figure this out to reset it, let's just close the connection and reopen one. You don't have to crash the whole program because of it.
+
+Bill Kennedy actually asked, speaking of error handling, what your views were on wrapping of errors, because there's a lot of polarization there too, where people think you should, so you can get more context and get stack information. Then there's also the other side of it - whenever you're wanting to handle errors, trying to do error comparisons. When you wrap errors, you end up leaving yourself needing to compare strings or regular expressions against them instead of comparing actual types.
+
+**Nate Finch:** Well, we actually use a wrapper in Juju that we wrote a couple years ago. In the beginning we didn't use a wrapper, and that does kind of make things rough. If you don't use a wrapper, then you do have to just compare strings, if you're using it to format that error off and then just adding on more string to the string that you have. I like Dave's package - github.com/pkg/errors.
+
+The nice things about this is that he gets a stack trace; when you make the new error, you can still get the error that was the original error, so you can still check and see if it's an io.EOF without having to look at the string. You can see if it matches some interface.
+
+Juju's package also lets you do that. All these packages work basically the same, and there's a lot out there. We've looked at a bunch, and I'm sure more have been written.
+
+Basically, they all just store the original error and give you back a wrapper struct that goes around it. The problem with Juju is that you have to wrap it at every return, because instead looking at a stack trace per se, it marks where it gets wrapped on the return path up. The idea was that if you pass errors over channels, the stack trace per se may not be how you eventually get a hold of the error. In theory it was a good idea; in practice, it means that everywhere you return an error you have to do a wrapping. It was kind of a burden, mostly for when things returned multiple values, you can't tail call, like return a function, assign the values to variables and then wrap the error and then return both. That's kind of a pain.
+
+The difference with Dave's is that he actually grabs the stack trace the first time, so in theory you don't actually have to wrap it when you return it past that first time. So I think they're kind of good, and I think they're kind of not as useful as people think. In Juju, a lot of the time I can just search for the string and find a spot where it's made and figure out what's going on. I don't always need the whole stack trace. It's fairly rare that I get the whole stack trace.
+
+**Erik St. Martin:** \[36:07\] Yeah, I typically only want the stack trace if I don't know how to continue. If I know how to recover from the error, I don't really care about the stack trace, but when I'm actually taking down the application because I don't know how to recover it from the state, that's typically where I want a full stack trace.
+
+**Nate Finch:** Yeah, and I just haven't seen as much use out of the stack trace as I would like; it seems like a lot of work -- not really a lot of work, but more work for questionable benefit. So I'm still leaning towards saying it's a good idea, but it's not as strong as I would like. I'm not exactly sure how to make that better case, but it's a stronger "Yes, you absolutely should do that."
+
+**Erik St. Martin:** Okay, so I think it's about time for our second sponsor break, and then I wanna get into some projects and news, especially with the 1.8 freeze going on.
+
+**Break:** \[37:03\]
+
+**Erik St. Martin:** So next up, projects and news. So we have the 1.8 freeze - that just happened, and we're gonna be frozen for three months, right?
+
+**Nate Finch:** Yeah, I think so.
+
+**Erik St. Martin:** So I wanna talk about some of the stuff that's coming in there. We talked about one of them, which is the aliases, but there's some other stuff coming in, like they're leveraging the context package a lot more. One of the cool things I was interested in is the database SQL package will have cancelable queries now.
+
+**Nate Finch:** Yeah, I was looking at it, too. They've done a bunch of stuff with names and parameters and stuff. They're really puffing it up a bunch, because it was a little bare bones before, and it's nice to have people to do a lot more things. That's half of what most applications do - talk to a database.
+
+**Erik St. Martin:** Yeah, that's true, I don't know how much love I've seen in the database SQL package since early 1.0 release. It may just be because I haven't been looking for it, but I don't think a lot more functionality has been added to it, to my knowledge. One of the other cool things is the HTTP package - the server will actually have graceful shutdown by itself now, which is gonna save me a lot of boilerplate code when I build HTTP APIs.
+
+**Nate Finch:** Yeah, that is very cool.
+
+**Erik St. Martin:** And then they're gonna be doing the reverse proxy will have HTTP2 support. Nate, I hadn't seen this, but you had mentioned something about dynamic plugins.
+
+**Nate Finch:** I think that's coming in 1.8.
+
+**Carlisia Thompson:** Yeah, it is.
+
+**Nate Finch:** Okay, good. Dave and I have been working on this for a long time, being able to compile code as a plugin that can be loaded by other Go code. The other main application loads it using -- there's a new plugin package in the stdlib on [Tip](https://tip.golang.org/), and... It basically works like plugins, so we can load new data, you can call functions and stuff... It's very interesting.
+
+**Erik St. Martin:** \[40:09\] So this is basically loading it as a dynamic library, like a DLL or an .so file, for other languages.
+
+**Nate Finch:** Yes.
+
+**Erik St. Martin:** So how does that work for dynamically linking against it? Do you need to have the plugin at compile time, like you'd need the header files for C if you were gonna dynamically link against something? Or is this just completely generic because the information is available in the binary?
+
+**Nate Finch:** It's completely generic, which means you lose a bit of type safety going through it. I'm looking at the package now to remind myself... Basically, you can look up names of types and functions, and they get returned as an empty interface that you can cast them and call them.
+
+**Erik St. Martin:** Interesting. I know there's been a few use cases where people have really wanted plugins. Kubernetes is a good example, too.
+
+**Nate Finch:** Yeah, I'm a big fan of plugins. I wrote a package to work with plugins called Pi that really, at least partially obviated, which is fine. I think plugins are super valuable... That's half of why Kubernetes is so popular - you can swap things in and out as much as you want, and this will make it even better because then you can use real Go that you just drop in the directory.
+
+**Erik St. Martin:** I think it's really cool from the perspective that there's a lot of cool tools where we want them to support many different interfaces to other applications and architectures, but the core package starts to become very bloated with knowledge of all these individual versions of the same system, whatever that may be - databases, or things like that, so to be able to move it out into a plugin approach is really cool.
+
+A good example of this - and I'm gonna give away my \#FreeSoftwareFriday early - is CNI, the Container Networking Interface. You can basically just tell it, "This is the plugin I wanna use for my networking", and there's just kind of like a known interface between them. So having stuff like this is really cool because then you can start separating that logic from their core package, so there can be kind of individual packages that are more focused, as long as they expose the correct methods.
+
+So I'm not sure... Was that all the goodies coming in 1.8? Does anybody know of any other ones that are coming in?
+
+**Nate Finch:** The GC improvement - now it's down to maximum 100 microseconds - not milliseconds... Micro.
+
+**Erik St. Martin:** Yeah, which is awesome. And there's a new proposal... This isn't gonna be for 1.8, but I think it's future work, where they're trying to get it down to under 50 microseconds for the stop-the-world pauses.
+
+**Nate Finch:** Yeah. There's a caveat right now that individual goroutines may stop for longer than that. I don't know if it's a bug or just the way things work. So stop-the-world is that short, but they're working on making it better and better, which I think is just fantastic, because that's what half the world says when they look at Go - "Oh, it's got a GC. Well, I can't use that." Well, you can now.
+
+**Erik St. Martin:** See, what I love about Go is that I get a choice. Like, yes, there is a GC, but I can manage my own memory if I want to... If it's important to me and I wanna have full control over it, I can manage it. I can create my own byte slices and pointers, and just hang on to them and reuse them, and create a pool, so basically creating your own slab.
+
+\[43:54\] It's not like Python or Ruby where you have no option - you can have GC or you can have GC. It's cool, because you can write it one way first. For most people, coming to a compiled language, it's gonna be fast enough already. The number of times you're gonna drill down to allocation isn't as common as you'd like it to be. We all wanna think every piece of code we write we start working out pprof and looking at all the allocations, but that's not typically the case. Usually, you wait to see what performance bottlenecks you have and focus in on those areas, and areas that are very hot in the execution path where the allocations matter. Those areas you might start drilling into the number of allocations and start messing with that, but it's not like you're gonna go through your whole app and do that. If you do, then I wanna work on your team... Usually, you're still racing to deliver features, you know?
+
+**Nate Finch:** Right, exactly.
+
+**Carlisia Thompson:** So as far as Go 1.8, I just wanted to mention that there is a really great blog post listing in detail what's going to be in 1.8. It was Tyler Christensen... We'll place the link on the show notes and on Slack.
+
+**Erik St. Martin:** Oh, Tyler Christensen, yeah.
+
+**Carlisia Thompson:** Yeah, there are a bunch of nifty little things.
+
+**Nate Finch:** Cool.
+
+**Erik St. Martin:** So... Interesting projects. We mentioned a few shows ago the vuls (vulnerability scanner) that was written in Go; I was looking at it again recently, and I noticed that it actually uses a library called github.com/jesseduffield/gocui, which is actually really cool because you can build command line user interfaces in Go, and it has the concept of splits, and windows, and modal popups and stuff.
+
+I haven't built anything with it, but seeing it really makes me want to.
+
+**Nate Finch:** Nice, yeah. I used a different one for a small project... I can't remember now what the name was, but very similar. Maybe a slightly lower level; with this one you have a window and put stuff in it. The one that I used was more like your screen was a grid and you could put stuff in the grid. But this looks really cool, I definitely wanna try that one out.
+
+**Erik St. Martin:** See, I love graphical stuff. I don't know why, but I'm a command line junkie. Even at my development machine... I have a Mac and I do the podcast and stuff from that, and email and chat, but I primarily develop off a Linux box, and I run the i3 window manager. That's it. I don't need any of the fluff, just give me some terminal windows and I'm good.
+
+**Nate Finch:** Well, I did 13 years of Windows development, so I still at times want things I can poke at with a mouse but I also love the terminals. It's nice to put those both together and you have a lightweight windowy thing. It's pretty cool.
+
+**Erik St. Martin:** Yeah, I'm waiting to have some time to actually build something with it. Another cool project I found - they have a command line version for it too, but mainly for Vim and neoVim - is a fuzzy file finder that's written in Go. There's been a number of these written over the years for editors, but I thought that that was really cool. I like anything that gets rewritten in Go. Like, "Oh, here's a cool grepping tool. I'm gonna write one in Go." \[laughs\]
+
+**Nate Finch:** Yeah. I actually think that's a great first project - to take a small tool that you like in a different language and do it in Go. A lot of time, working on a project is like "What do I want it to do?" and what's nice about just copying something else is that you already know what it does, so you can just make it do that. I think that's a really nice way to learn the language.
+
+**Erik St. Martin:** \[48:02\] Because you spend your time learning the language, rather than trying to learn the domain and the language at the same time; you're already kind of familiar with the domain.
+
+How about you, Carlisia? Anything new you've come across this week?
+
+**Carlisia Thompson:** Yes. Well, actually not much... I wanted to mention Dave Cheney's talk, with the disclaimer that it was the only talk from dotGo that I have watched, so I'm sure there are a ton of other great talks. This one I watched and loved it. He talks about the functions as first-class citizens in Go. And I loved that he didn't take for granted that everybody knows how to use functions as arguments, basically. Am I saying this right?
+
+**Nate Finch:** Yeah.
+
+**Carlisia Thompson:** \[laugh\] Okay. And it's funny that he said... He talks to people and people say, "Well, I know how to use it, but I don't use it because I'm concerned that other people won't understand." That is definitely true for me, I haven't used it yet. But he walks through examples of how to use it. That was such a great thing, to have that resource there, to learn it.
+
+In the talk he also goes into the act of concurrency pattern. I didn't really get how the two fit together, but I also loved it because "Oh, great! There is a nice example of how to use that pattern." In the example that he gave, I think the purpose for that example was to show the first Go proverb; for people who don't know there is such a thing as a list of Go proverbs, of which the first one is "Don't communicate by sharing memory, share memory by communicating."
+
+For people who are new to this statically typed language with pointers in memory allocation and all those things, this might sound so cryptic. Dave's talk walks through an example that gets the idea across. It is a bit advanced, but if you are ready for that, I highly recommend it.
+
+He also mentioned that talk by Bryan Boreham from this year's Golang UK Conference; it's called An Actor Model In Go. I haven't seen it yet, but it will go deeper into what an actor model will do.
+
+**Erik St. Martin:** Yeah, there's a talk by Rob Pyke from one of the Gopher fests where he talks about the Go proverbs. I'll find that video and link that in the show notes, too.
+
+**Carlisia Thompson:** Yeah, good point.
+
+**Erik St. Martin:** An interesting thing about the functions as first-class citizens - I have not seen that talk, but speaking of 1.8 changes, the sort logic... Right now you have to have an interface on your type that you wanna sort, which has kind of been a pain, but in 1.8 you'll now be able to use a comparator, so you'll be able to just pass in a function to do the comparison and return basically which side is greater. So there's a use case right there for the first-class functions.
+
+**Carlisia Thompson:** Yeah, there we go. That's exactly what I was thinking... That's how I approach things - I accumulate a bunch of tools and every time I have a problem I reference to those and say, "Can I use one of these to solve this problem?" But it's helpful when people serve to you, like "Here's a use case", so you have that in mind. Good one.
+
+**Nate Finch:** Yeah, I am actually working with some code that uses first-class as function, so as a way to do validation of user data. I've got a function that's got all this logic for getting the data, and then you just pass it in a validation function, and then it can run that to make sure that the data is valid.
+
+\[52:02\] I was working on that while I watched Dave's video; I was like, "Yes, that's exactly what I'm doing."
+
+**Erik St. Martin:** Yeah, I haven't actually seen that video. I'm gonna put that on my list. Actually, all the dotGo videos need to be on my list to watch. Alright, so what else do we have on our list before we move on to \#FreeSoftwareFriday?
+
+**Carlisia Thompson:** One more thing I wanted to mention - Peter Bourgon emailed the mailing list (I forgot which one) and they have the draft spec for package management ready, and they are calling for comments; they are soliciting comments either on Gophers Slack, the vendors channel or on a mailing list. And they started implementing another prototype too, so that's definitely moving along.
+
+**Nate Finch:** Yeah, I looked at that and honestly, it's so long and so detailed... I need like a TL;DR version so that I can have some idea of what the overall meaning is, because it's seven pages long. I don't know that I can get all of that.
+
+**Carlisia Thompson:** Yeah, maybe the prototype they're starting to implement will be helpful in that regard. Sometimes it's easier to look at code.
+
+**Nate Finch:** Yeah.
+
+**Erik St. Martin:** Alright. Ready for \#FreeSoftwareFriday?
+
+**Carlisia Thompson:** No, I'm sorry... I have one more thing, the last thing.
+
+**Erik St. Martin:** What is it?
+
+**Carlisia Thompson:** GoBridge has a community newsletter called Go Pulse. Amy jumped in and took this on, and she did a fantastic job with the first issue. We have sections for different things that people can suggest, and every month there is an editor. So if you feel so inclined, raise your hand and volunteer and suggest things. The newsletter came out really good.
+
+**Erik St. Martin:** One thing I liked was the Gopher Mic section, where you kind of hand it over to somebody.
+
+**Carlisia Thompson:** Yeah, she made it very inclusive... It was awesome.
+
+**Erik St. Martin:** And this is monthly?
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** Awesome. So before we move on, where should people go to sign up for that if they are not already signed up?
+
+**Carlisia Thompson:** It's basically the GoBridge blog, and I want to correct myself - her name is Amy Chan. We need to remember to say people's last name. So Amy Chan, thank you, you did an amazing job. People can sign up at the GoBridge Blog.
+
+**Erik St. Martin:** Awesome. So \#FreeSoftwareFriday. Today is Thursday, but we do it for Friday. We like to give shout outs to people or projects that are making our lives easier. Carlisia, do you wanna kick it off?
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** What do you have this week?
+
+**Carlisia Thompson:** I'm gonna mention a project that I actually solicited on the GoTime channel, because I didn't have one, but I definitely wanted to give a shout out to somebody. And now I didn't write his name here, I forgot, the person who mentioned it. The package is called Kinetic, and it's an easier way to access Kinetic shards, and for pulling and for doing other things. So if you're using AWS, that's something you should check out.
+
+**Erik St. Martin:** Oh, interesting.
+
+**Carlisia Thompson:** Yeah. The official description says "high-performance AWS Kinesis Client for Go."
+
+**Nate Finch:** Nice. So my shout out is to Hugo, which was originally written by Steve Francia. It is the static website generator that I think most people know about, but that's what I use to pick my blog. Lots of people do, and there's been a ton of work on it.
+
+\[55:59\] Lately a lot of it is being done by Bjorn-somebody (Bjørn Erik Pedersen) Sorry, I don't have his name in front of me. It's gotten even faster, and it's really a great way to build a website. It looks nice and it's easy to update, and very usable.
+
+**Erik St. Martin:** Yeah, Hugo is really awesome. It's actually what the GopherCon and Gopher Academy sites are all running. And even if you're not familiar with Hugo itself, you're probably familiar with some other projects that came out of it. Cobra and Viper were both by spf13, which is Steve Francia. They are both out of Hugo; they were kind of abstracted lessons learned along the way. So a super-cool project.
+
+Mine today is actually called CNI, the Container Networking Interface. I wanna give a shout out to everybody who is involved in that project, because it's really cool for Kubernetes for networking logic; it allows you to inject your own executable into the flow to allocate an IP address or set up routes when containers respond up on things, which makes a complex problem much easier. You don't have to go and hack in Kubernetes or Docker or Rocket. They all leverage CNI themselves, too.
+
+With that, we are out of time unfortunately.
+
+**Carlisia Thompson:** Can I make two quick thanks?
+
+**Erik St. Martin:** You certainly can!
+
+**Carlisia Thompson:** So many thanks... Huge shout out to everybody in Brazil who are there for GopherCon Brazil.
+
+**Erik St. Martin:** Yes...
+
+**Carlisia Thompson:** I already see people having a great time. The conference starts tomorrow, so it's tomorrow and Saturday. And Erik is giving a great talk about Kubernetes; Erik, you didn't mention that, so I have to. The talk is entitled -- I'm trying to find the name of the talk here...
+
+**Erik St. Martin:** It's called Kubernetes As Seen On TV.
+
+**Carlisia Thompson:** Yes! So check it out, it's gonna be at KubeCon November 8-9, but Erik's talk is on 9th November.
+
+**Erik St. Martin:** Speaking of which, because of that we won't have a show next week. I'm traveling for that, Brian is traveling - I think he's in Amsterdam next week... I think everybody's traveling, so we will be skipping next week's show unless we can find time to squeeze one in not live in off time, but let's assume there's no show next time.
+
+With that, I wanna thank everybody for being on the show today. Huge shout out to our sponsors, both to Stackimpact and Code School, thank you to all of our live listeners and future listeners. Definitely forward this to your friends.
+
+We are @GoTimeFM on Twitter, we have a GoTimeFM channel on the Gophers Slack. If you are not subscribed already, go to GoTime.fm, our website for email. If you wanna be on the show or you have ideas for guests or topics for this show, hit us up on github.com/gotimefm/ping. With that, everybody goodbye.
+
+**Carlisia Thompson:** Thank you, Nathan. Goodbye!
+
+**Nate Finch:** Thank you!

Kubernetes, Containers, Go_transcript.txt

@@ -0,0 +1,395 @@
+**Erik St. Martin:** Okay, we are back for another episode of GoTime. It is episode number 20. Today on the show we have myself, Erik St. Martin, we also have Brian Ketelsen here - say hello, Brian.
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** And Carlisia Thompson...
+
+**Carlisia Thompson:** Hi, everybody!
+
+**Erik St. Martin:** And our special guest today should not be unknown to anybody. He's really well-known in both the Go and Kubernetes community. Please welcome Kelsey Hightower.
+
+**Kelsey Hightower:** Hey, I'm happy to be here.
+
+**Erik St. Martin:** For those who may not be aware of who you are, would you like to give a little background on who you are and what you're working on?
+
+**Kelsey Hightower:** Awesome! My background is I'm currently at Google, working on Google Cloud technologies, mainly around some open source projects that I've been a fan of for a very long time, mainly Golang and Kubernetes, which is kind of a distributed systems framework for doing Google-style deployments - that's a quick way to sum it up. I also spent some time with CoreOS and Puppet Labs.
+
+I consider myself a syst admin who can code.
+
+**Erik St. Martin:** \[unintelligible 00:01:32.18\] the syst admin part; you're more a syst admin than a coder.
+
+**Kelsey Hightower:** Well, for the last five years I've been doing primarily full-time development amongst other development roles, but I also started my career as a system administrator, so I always bring that level of thinking into it. If I'm writing code that I'm going to connect to a database, I'm going to implement retry logic; I'm not gonna throw that over the wall, because I know who sits on the other side of the wall.
+
+When I'm writing code these days, I'm always keeping that... Not just building the app, but who has to actually manage the app and what does that side look like? I'll never forget where I started in tech.
+
+**Brian Ketelsen:** Doesn't that kind of fit into the serverless category? Everybody's talking about serverless computing, which drives me insane; I think we've covered that a couple times. Don't we have opsless now, where you're just throwing it over the wall to Kubernetes and nobody has to worry about it?
+
+**Kelsey Hightower:** Yeah, so to me Kubernetes is what happens when ops people take their expertise and codify it into a system. To be honest, it's gonna take ops people or someone in an operational role to deploy Kubernetes and keep that running and upgrade it. We saw that from an announcement today about the whole Pokémon GO stack. The Google SREs did a lot of work in upgrading them underneath the covers.
+
+So you always have ops, but I think even in a system like Kubernetes where you're not necessarily interfacing with an operations person to get a deployment done - you kind of have an API for that - but there's still some operational thing that you can do to leverage even a system like Kubernetes. The way you log, the way you retry connections, the way you handle yourself in a clustered environment are all operational concerns that I think being a syst admin in the past really helps me embrace these platforms when they show up.
+
+**Erik St. Martin:** And learning to create abstractions - that's one of the beauties of Kubernetes... We've had the virtual machine world for a while, that kind of started getting people used to being abstracted from the physical hardware, and now we're starting to be able to abstract people more from kind of the cluster operation side of things where they don't really have to be concerned with all the failover and things like that.
+
+\[00:03:47.08\\\] But like you said, you still have to focus on how you retry your logic and making sure that you're doing things in an item-potent manner, but you don't have to be so concerned with your failover strategies and scaling as much, because a lot of that is handled for you.
+
+**Kelsey Hightower:** Yeah, I think Kubernetes can really appear to people kind of like the Go runtime. Most people don't even know the Go runtime is there; they have the statically linked binary, and a lot of people forget that the Go runtime just happens to be embedded in there and handles the garbage collection. It handles scaling across multiple cores for us. And Kubernetes is very much that way. You put Kubernetes on top of a group of servers instead of a group of cores, and Kubernetes' job is to run your application in a way where you don't have to think about garbage collection. When you delete an application from Kubernetes, under the hood we're cleaning up the images and processes, making sure that resources aren't being wasted.
+
+Just like we do in the programming world, I think Kubernetes represents putting a runtime on top of infrastructure.
+
+**Erik St. Martin:** That's actually a really interesting way to look at it.
+
+**Brian Ketelsen:** I've heard several people on Twitter talking about Kubernetes almost being analogous to the Linux Kernel of the cloud. How do you feel about that concept?
+
+**Kelsey Hightower:** Yeah, it's one I repeat quite a bunch. I think Mesosphere really made that term popular. I've read about it years ago in a white paper from Urs at Google about the data center as the computer, and if we're starting to subscribe to that notion - the data center as the computer - then it needs a kernel, it needs an operating system. I'll be talking about this at one of my keynotes coming up here at KubeCon, this very idea that if Kubernetes is a kernel, then what would a system call interface look like? And to me, that's where we start to get into applications that deploy themselves.
+
+On a UNIX system you launch an application and it will bind to a socket. In Kubernetes, a deployed application can create a load balancer with a public IP address, and clients can bind to that. We wanna scale out... On a machine you can create multiple processes; in things like Kubernetes we have APIs for that. On a UNIX system we have a syscall interface; maybe you interface that with some libc or something. But in Kubernetes it's just a REST API that lets us do very similar semantics you would do on a regular operating system; we just do it at a cluster level.
+
+I think Kubernetes does a great job of fulfilling the contract between hardware, in this case multiple computers, and software - your application running in the cluster.
+
+**Brian Ketelsen:** So what do you think it is about Go that makes Kubernetes so special? Do you think there is a good relationship between the fact that Kubernetes is awesome software and it's written in Go?
+
+**Kelsey Hightower:** Yeah, I think a lot of people... The programming language, or even the spoken language - my wife is a bit of a linguist herself and she does ESOL here in Portland; I think the language and the community that surrounds those languages influences the way you think and build things. In the Go world it's very easy to build these cross-platform, statically linked executables, and if you think about the way Kubernetes is deployed, we have a bunch of independent executables that can move at various versions, or we can upgrade them as we will, and it's really built around the way Go works. We have these small binaries that we just drop in or replace to do upgrades, we are not afraid to do things using some kind of parallelism or concurrency... Most of the components in Kubernetes are able to scale because Go really makes that super easy. We don't have to play a bunch of tricks with our API server or tricks with the agents.
+
+The other benefit is most of the tools we rely on in Kubernetes - Etcd, Docker, some of the other plugins - it just so happens that they are also written in Go. So we have this strong ecosystem that makes Kubernetes special, mainly the community, and most of them have Go skills either from Docker, Etcd, and those skills transfer right over to Kubernetes with little effort, which has been really key to our adoption.
+
+**Erik St. Martin:** \[00:08:01.28\\\] I think Flannel is also written in Go, isn't it?
+
+**Brian Ketelsen:** Yes.
+
+**Kelsey Hightower:** Yeah, Flannel... Pretty much every tool in the stack - Weave, Prometheus, InfluxDB... You name it; almost everything that's being used, even Fluentd, I believe. So it's across the board, we seem to just land on tools with little effort just happen to have a chance that they're written in Go. Vault from Hashicorp... It just goes on and on.
+
+**Carlisia Thompson:** So are you using a plugin architecture for Kubernetes?
+
+**Kelsey Hightower:** With Kubernetes we embrace the whole distributed system model. There are parts of Kubernetes that do have a plugin model. If you think about the agent that runs on the machines, there's somewhat of a plugin model there. We interface with different container runtimes - Rocket or Docker. On the API server, the plugin architecture is more of a contract with APIs. If you wanna build a custom scheduler, you don't have to recompile Kubernetes. There's no monolith binary there. You can just build another scheduler, and as long as you conform to the APIs and you follow along there, you become a first-class citizen in Kubernetes.
+
+We like to think of plugin models as two different things. Some things that are local to a particular component or service, you'll see more of an in-process, in co-base plugin model to extend the system, but we're moving more and more towards a model where all functionality extensions could be done with external binaries that interface via a well-defined API contract.
+
+**Carlisia Thompson:** Gotcha.
+
+**Erik St. Martin:** Yeah, so when you look at Kubernetes from kind of like a generic perspective, there's resources that are managed, and then there's generally some sort of service or component that's responsible for watching, Etcd, for changes to that resource, and then reconciling the cluster - updating the pod or things like that, based on what it's observed as the changes.
+
+So to Kelsey's point, you'd have a pod that's been submitted to the API and it's sitting there and it doesn't actually have a pod running. Well, the system notices that that's been added to Etcd, and then the scheduler basically finds the ideal node to put it on, and then it finds the resource that's in Etcd to that node, so that it knows that it's assigned. Then basically we come back up for scheduling. You can kind of replace any of these pieces.
+
+Another concept is a replication controller. It kind of sits a layer above a pod and says how many of those you need to have running. There's basically just a loop that's running and watching for changes to the cluster, and basically queries a label to see how many of them are running, and then fires up another pod. So you can kind of inject yourself in any of these points and create your own systems out of it, or tweak the behavior to be more in-line with your use case. This is kind of what I'll be talking about at KubeCon as well, thinking about things in those terms where it's not just deploying an application, but building applications on top of it. Because you can kind of replicate these same concepts. I have some resource definition of something I want, I'm asking of the cluster, and then I have some sort of controller or scheduler that's reconciling the cluster to move toward that desired state.
+
+**Kelsey Hightower:** Yeah, I think if we draw connections to the Go community, it's just like some function returning your channel. The implementation details about what's coming through that pipe, that's implementation detail, and I think the observer - just like in Kubernetes, these objects can be observed. So if you're listening to a channel and you get a strut from that channel, what you do with it is up to you. It's a very similar model in Kubernetes - multiple processes are watching for things coming out of essentially a channel, and taking action and also responding to change the behavior of the overall system.
+
+**Brian Ketelsen:** \[00:12:10.23\\\] Kubernetes was one of the first times that I saw a system where you described resources in a desired state, and saw that reconciliation process in the background. That's really interesting to me. Have you seen patterns like that prior to Kubernetes, where you say "This is what I want, go make it happen", as opposed to a model where you just make a request for a thing that happened? I've never seen that desired state before with a reconciliation model.
+
+**Kelsey Hightower:** I think we've seen this in a lot of somewhat declarative systems with a DSL in front, like Puppet, CFEngine, Chef - all of those tend to have an intermediate state where you as a user, and in those cases infrastructure as code, you would write in these DSLs, and they had a compiler that would compile it down into a service catalog. I think the difference with Kubernetes is that Kubernetes is more of an online system where you're sending state changes to a central authority that has consensus amongst all the other components, and whenever the state transitions to something else, all the components are kind of notified at the same time. So it's a very reactive system.
+
+In other systems, even though you have this desired state idea where you would write code in one language, it would be compiled to something else that will be consumed by the agent running on the machine - those are always in some kind of loop, of like "Every 30 minutes go check back for a new version of the user's desired state." Kubernetes is declarative, so in the Kubernetes world when you create an application, either using a pod manifest, and when that pod manifest is deleted, the corresponding process or container is also removed from the system. I think that combination of a declarative system that's driven by desired state makes Kubernetes feel vastly different from other systems, even though there is some overlapping functionality, but the experience is driven by those two things in combination.
+
+**Erik St. Martin:** Yeah, my brother actually just messaged me - a prime example of that would be Ansible, right? You're setting a desired state of what a file should look like, or what packages should be installed, and things like that, and it tries to reconcile state. But again, that's not real-time, it's not reacting to the changes live.
+
+**Kelsey Hightower:** And it's also not declarative in many ways, because usually with Ansible if you were to put a resource let's say to add a file to a system, the first run of Ansible with that declaration in your Ansible playbook and you run it, the file would be created on the other side. But if you were to remove that resource from your Ansible playbook and run it again, the file will not be removed.
+
+I think the difference with Kubernetes is that we handle and we store all the state of the world for the entire cluster, so when something gets removed, we know exactly what to do to clean it up. We have the entire view of the cluster in a central place.
+
+**Erik St. Martin:** And I've been finding it really interesting to work with some of these concepts and start thinking about building applications in those terms, and the concept of label and things like that, where you can make your containers and pods attracted to some nodes, and repelled by others. Now with 1.4 I get to delete scheduler logic that I had written, because now they have the concept with soft and hard requirements for labels which basically solves one of the problems that I had.
+
+\[00:15:55.11\\\] As an example - this is actually kind of streaming cable... A soft label would be that any of these nodes are capable of running this particular video stream, but they're preferred on these nodes. Basically, you could have a hard requirement on a label for a given zone or collection of machines, and then you would have another label that is the preferred set because maybe there's additional bandwidth to come from the other nodes. Then basically it would try its best effort to schedule onto the nodes that are preferred. In the event there's just not enough space on those nodes, it would fail back to ones that come at the cost of bandwidth, or something.
+
+It's really interesting to be able to do that by just applying labels to a machine, and you can do that with public vs private clouds and stuff like that, where you could try to run in your private, but move onto public.
+
+**Kelsey Hightower:** Yeah, that's right. Kubernetes is definitely meant to put, like we said, that runtime on top of a set of machines. It doesn't matter if those machines are a Raspberry Pi cluster under your desk, or some cloud provider, or your own bare metal machine. Kubernetes really makes sure that we stick to the script. We sit in the middle, on top of gear, and you can do whatever you want below that, you can do whatever you want above that, and you kind of end up building your own platform.
+
+I always refer to Kubernetes as a framework for building distributed systems, and one popular use of that framework for most people has been deploying applications via containers. But nothing's stopping you from imagining new systems that do different things.
+
+**Erik St. Martin:** That's one of the things I'm particularly interested in, seeing what comes from Kubernetes as a continues to scale outward. Like you said, the current consensus from most people is that you just set it up on your machines and you throw your containers at it. And I'm really happy to see more use cases coming up, where people are kind of starting to interact with it closer, and writing their own tooling to look at the state of the cluster and to make changes to the cluster based on that.
+
+I think we're gonna see some really interesting things come out over the next couple years. Even Kubernetes itself has changed a bit. Things like PetSets are getting introduced...
+
+**Kelsey Hightower:** I'm gonna touch on that topic for a second... So in my view, Kubernetes is super, super small. Just like Golang has a standard library, but the core language itself is really small. So if we were to think about the core of Kubernetes, it's also super small. We have maybe four or five - depending on how you look at it - core object types. We have a node object, that is normally backed by a real machine (bare metal, VM, what have you), but that is an object that runs in Kubernetes. You need a node because we bind the other object called a pod where you express "Here's my application, here's its volumes." You express those in terms of a pod, and pods run on nodes. So those are the two kind of core objects to Kubernetes.
+
+Then we have this other object, something that says "Keep one of those pods running at all times" or "I would like to have five of those pods running." That would be another object type.
+
+The other objects, it's very debatable whether they're really core concepts or not, because you see that we have extensions in Kubernetes. A deployment will be an extension. A service will be more of a core thing, so something that drives "This collection of applications belong to the same service." So once you have the service, the pod, the controller and the node, if you look at everything else, even DNS is just driven by what we see in the service.
+
+\[00:19:51.03\\\] A deployment or a PetSet - those are more workflows on top of those other objects. Those become kind of like the standard library; they become the patterns that allow people to leverage the low-level objects in new ways, where everyone doesn't need to learn how to bind to a raw TCP socket, interpret the bytes for an HTTP request. You just import net/http and off you go. So I like to think of the other objects in Kubernetes as very much that standard library that most people wanna see in their cluster. So as we start to evolve Kubernetes and it's growing over time, I think it's more of our standard library is growing on top of the Kubernetes core objects that have enabled us to do all of these new things like scheduled jobs, deployments, and anything else that anyone would like to cook up.
+
+**Erik St. Martin:** Yeah, I'd agree with that. It's mostly abstraction layers on top to help facilitate tasks that you would want to accomplish with those lower-level objects. When you see a list of all these things it supports, it probably does look overwhelming, but like you said, they're just really workflow-type scenarios. "How do I make sure that five of these pods that look alike stay up, so that there's always five running, no matter what?" and that's really a replication controller.
+
+You guys are kind of trying to deprecate that for the replica set, right?
+
+**Kelsey Hightower:** Yeah, just a naming convention. Now that we're on the topic of objects in Kubernetes, it's very much like in Golang where there's core types inside of the Go standard language specification. But you're also able to crack types yourself, right? You can have a type that may be a collection of other types, and pretty much the same thing works in Kubernetes. So view it like, in my case I've built a tool that allows people to integrate with Let's Encrypt. In order to do that, I could just drop something in there and just start scripting and automating a bunch of things, but in Kubernetes we also support user-defined types at runtime - we call them third party resources.
+
+You as a user or as a vendor, you can craft a new Kubernetes object type and send it to Kubernetes through the third party extensions or third party resources, and we will automatically take your type definition in some ways and we will automatically generate the API endpoints, storage in Etcd and the integration with kubectl, which is the Kubernetes command-line tool. So now you have the ability to start creating these certificate objects.
+
+The schema is up to you or the developer of the tool that will be observing these objects, but that will allow you to extend the system in ways that we haven't even imagined, but still feel first-class to people that are used to using Kubernetes and the core types.
+
+**Brian Ketelsen:** Now, if you were interested in spinning up your own Kubernetes cluster, fire up a web browser, go directly to Linode.com/gotime, get two months for free with the GoTime20 code, and you can start your own Kubernetes exploration using awesome Linode cloud servers. Eight data centers across the world, plans starting at just $10/month. You can get full root access, which means that you get to deploy Kubernetes. They've got native SSD storage, 40 GB network and fast Intel Xeon E5 processors. It would be a perfect way to get started playing around with Kubernetes, with just a few Linode nodes.
+
+And you could go to Kelsey's Learn Kubernetes The Hard Way repository... What's the repo for that, Kelsey?
+
+**Kelsey Hightower:** It's kelseyhightower/KubernetesTheHardWay on GitHub.
+
+**Brian Ketelsen:** Yeah, that would be the pefect place to get your feet wet with Kubernetes - Linode and Kelsey Hightower together.
+
+**Carlisia Thompson:** \[00:23:47.20\\\] Kelsey, you were talking about something that the developers can do, and a lot of this is going over my head because for the last four years I've worked at companies of sort of mid-size, that had actually very good DevOps teams. As a developer, I always work closely with DevOps, however I don't get to play with these tools unless I do it on the side. I haven't done it on the side, so I can't even comment too much. So just to have an idea - yesterday was the first time that I used Docker, and I had a very strong motivation to do it because some stuff on my machine wasn't working and I didn't want to spend the time. I was like, "Okay, I'll figure out Docker. It can be a solution for me, it can be a solution for the other devs on my team if they wanna use it, so I'm not solving the problem just for me. Once I solve this, everybody can use it because it's replicable", and that's one of the beauties of using containers.
+
+Of course, once you have containers, you have to manage them. Now, from a perspective of a developer, what should we be looking at? Because what I'm thinking is, "Well, what if my DevOps team is not using Kubernetes, and what if that's not available to me?" How do I explore this in a way that I can maybe integrate it with my apps and make good use out of it? How would one approach it, or should we not - as developers who are not handling DevOps, is there nothing there for us? Or is there something there for us of benefit?
+
+**Kelsey Hightower:** I think that's a good question, and if you think about who's building these systems, they're mainly developers these days. I would like to see more ops people, and we do see them building features around it, but I think you're thinking about this world where the developers are now spending a lot more time in operations, building operations-specific tools. Stepping back, it's just all software. This software just happens to deploy other software. It's kind of like writing your own unit tests, right? You're writing software to test your application, so in this case it's software to manage applications, but it's just all software.
+
+As a developer, you may be less interested in deploying and managing a Kubernetes cluster. There are different roles on the team for that, and if you're in a position where you have a dedicated group of people who are using a hosted system, that's great. As a developer, what you kind of care about is "I have this application, an application running on my local machine, and Docker's a fantastic piece of software that lets you take a Linux machine and abstract away the needs of SSH, systemd unit files, logging - all of that kind of goes away, but it's still there underneath the covers." Docker sits on top of a single machine and gives you this really nice API, you're packaging the app, push it through a repository and running it anywhere that you find a Docker. This is perfect.
+
+But in production, you have a lot more concerns than just starting and stopping an application. Who's going to collect the logs and push them to a central place? How do you express the need of "I want this application to run across multiple machines, multiple data centers." That particular set of requirements needs a higher level tool or language in order to express and enforce to make it happen. A lot of those concerns - you start to get into this idea of clustering. I have multiple machines, and the machines that we're using these days, these are mainframes; they're not built to last forever. So we're dealing with these machines that are going to fail. If you're in a cloud provider, the VMs are ephemeral, so you have to plan that the machines that you're running on can be blown away at any given time. They can die, like migration, so you probably want a system that can account for that.
+
+\[00:27:54.03\\\] From history in general, the core principle, even if you're not using Kubernetes, your team is going to have to build something very similar. How do I decide which machine my application runs on? Well, if you have a DevOps team and depending on how they do things, they may be recording that decision in a spreadsheet, in a tool like Ansible where you say, "This app runs the database. This server runs my web application." That would be manual scheduling, right? That concept of scheduling, as a human you would say "Well, we know that's the database server, because it has this name or it has this storage." That act of scheduling in Kubernetes is an automated process where you as a developer can craft one of these manifests where there's a deployment manifest. You can say, "My application needs one CPU and let's say 16 megs of RAM. That's enough to handle this many requests per second. If you want to scale above that, then give me more of those instances running and then we can actually scale horizontally." So as a developer, there's that dev test cycle, which is great for a single machine, but when it goes to production, as a developer you need a new set of concepts to express "I need five copies of these applications running, with these resource requirements. And oh, I'd also like to expose these to our customers over this particular port, not that port."
+
+So if you think about it, Kubernetes takes a DevOps team and rolls it into a system, and in return gives you the developer an API that you can use to express what your application needs to run in production.
+
+**Carlisia Thompson:** Very cool. I wanna go into this right now. \[laughs\]
+
+**Brian Ketelsen:** One of the things that I think the concepts behind Docker and Kubernetes bring, even if you don't use them, is the DevOps world and the Twelve-Factor application ideas are so important even if you're not using containers, but you get so much more benefit from them when you are. When you inject your configuration using environment variables, your life becomes drastically easier in Kubernetes and Docker. When you write all of your logs to STDOUT, your life is easier in Kubernetes and Docker. Those are all practices that you should be doing, whether or not you're using a container manager or a scheduler, and it makes your life drastically simpler when you are.
+
+Those are the kind of things that I think are complementary in the container and orchestration world, that we should be doing regardless.
+
+**Carlisia Thompson:** Brian, how do we get the Twelve-Factor implementation of those ideas, facilitated by using something like Kubernetes?
+
+**Erik St. Martin:** As an example, if you have a token that needs to be exchanged between two services or you wanna verify a TLS certificate, if they are passed into your application through an environment variable, then what happens is when you create your pod specification, your pod manifest to give to Kubernetes, you can map in a secret that's stored out in the cluster, which contains these things as environment variable into your pod.
+
+**Kelsey Hightower:** I wanna interrupt there... Kubernetes doesn't really care about Twelve-Factor at all. If you have a set of data that you wanna consume, a synchronous object in Kubernetes can be stored into a file that you name and will be injected into your container at runtime, or you can prefer to put them into an environment variable. That's kind of your pick.
+
+\[00:31:43.22\\\] To Brian's point, a distributed system like Kubernetes, which has the liberty to reschedule your application in the face of failures automatically for you - a node were to die, or say you have three nodes, and you have your application running, and you say "I would like three copies of my application running in Kubernetes." Maybe by default we put one application on each server, but that's more of an implementation detail.
+
+If one of those servers were to die, you don't need to change anything. We will automatically move that third instance to one of the other nodes that have room to run your application. Now, the fact that his will happen in the automatic fashion is in your best bet or benefit to adhere to some of the things around Twelve-Factor, which, to sum up all 12 other factors, decouple yourself from the machine.
+
+If your application is looking for a specific file on a specific server, you're going to run into trouble and you're gonna be unable to benefit from Kubernetes' ability to move you to another machine.
+
+This is why in Kubernetes when you have a token or a database username or password, you have the option of taking that secret that you or the DevOps team can define as key/value pairs in Kubernetes, but you as a developer - we talked about that API... The API also extends it to like a YAML file, if you like to think of it that way. It's a big YAML file where you can say "My app needs this container version, it needs these five secrets. But you know what? From my application I don't consume configuration over environment variables. I consume configuration over files on disk", and you as the developer can say "I wanna reference this secret, this username or password, and I wanna put those secrets in this file."
+
+Kubernetes will do that automatically. It will make a callout to the API server runtime, pull in that secret, write it to a temporary file, inject it into your process. When you process starts, it will just see a file like it has always been, but we still stay true to the Twelve-Factor way of doing things. We don't write that file to the underlying server. If we move your process to a new server, we go back through all of those steps I've just mentioned, to make that configuration available.
+
+So in some ways, Twelve-Factor really was talking about a system with a few limited capabilities. It comes from the Heroku camp, and Heroku was a great system for moving us forward into giving people constraints and a contract. In Kubernetes we almost give you a few more contracts to let you have a little bit more flexibility on how you build your process; maybe we give you a 13th or 14th factor, but the idea here is to decouple your application from the machine. If you do that, then you're allowed to benefit from what Docker does, what Kubernetes does... Because in the Docker world we don't talk about RedHat versus Debian, we talk about application images, container images. In Kubernetes we don't talk about installing applications to servers, we talk about installing applications to clusters. The machine doesn't matter.
+
+**Erik St. Martin:** The interesting thing about injecting configuration config maps or secrets into a pod as a file - there's some trickery because it's not actually that file that changes, but you can still watch the file system for changes to realize that your config has changed, that somebody within the cluster has modified it.
+
+**Kelsey Hightower:** That's right.
+
+**Erik St. Martin:** This is kind of what Kelsey's bringing home... You can build applications the way you typically will as long as you're not coupling yourselves too much. I think people get a lot of the fear of missing out. Kubernetes is just wickedly cool, it does a lot of stuff for you, but not everybody needs it either, and it comes with a cost. You have lots of stuff to administer, and now you have a distributed data store, Etcd that has to be managed and maintained and backed up. There's a lot of things that you need to do to kind of maintain the cluster itself, so getting ahead of yourself can also be a bad thing, too. If you build a well-designed application, you can containerize it and put it out in Kubernetes with minimal effort.
+
+**Kelsey Hightower:** \[00:36:10.15\\\] And on that note as well, it's just like goroutines - you can go a long way in Golang without ever touching goroutines. If you're building a web app, the goroutines that are being used by net/http are kind of hidden from you in many ways, but you can go really far. Some people abuse it; they just start using these things for no apparent reason, and there's a lot of overhead. Now you have to worry about locking... All of these issues that come from dealing with goroutines, if you choose to go that route prematurely. On the flipside, having goroutines, when used correctly and get out of your way, just like net/http, you can handle multiple requests from a single process, and if you have multiple CPUs, like I said, it will be in parallel, but that's hidden from you. But it's just an added benefit that was just added as part of the core thing that the Go runtime does for you.
+
+I think over time, even though most people would say if you look at Kubernetes, it is kind of overkill, it is a lot of overhead, but I think the entire industry will rebase to expect "My app should be able to run in multiple data centers and have tooling that allows it to stay available", because all customers now just assume any website will be available quickly from anywhere in the world, and it will be up 24 hours. Anything less than that, people complain, regardless of how big of a company you are.
+
+**Erik St. Martin:** Yeah, I think that's fair. People have become accustomed to this whole five nines uptime. They kind of expect it out of every site, and completely lose their minds anytime their mobile app doesn't connect right away.
+
+There's a lot of services too, so I say that the maintenance of Kubernetes comes at a cost too, but a lot of people aren't maintaining their own Kubernetes clusters either; they're using public services that offer Kubernetes. GKE and CoreOS has an offering, and there was somebody else that I remember has a Kubernetes offering.
+
+**Brian Ketelsen:** Speaking of GKE, how about the blog post that was just released about Pokémon GO? Have you read that yet Kelsey?
+
+**Kelsey Hightower:** Oh, you know I read that, man! \[laughter\] I live that! Our Google SRE team is amazing, and they represent why... You know, there's really no such thing as no ops. Even though the teams behind Pokémon GO... You know, they have their ops people as well, they interface with our ops people, but they didn't necessarily need to invest in a huge operations team thanks to being able to partner with Google's operation team. GKE, for those listening, is kind of the commercial offering of Kubernetes. We just put some deep integrations to the Google Cloud, but it's the exact same codebase and open source project that anyone else is allowed to use, or use in their own environment.
+
+So that was a big win for the entire Kubernetes community, because Google doesn't build Kubernetes by itself, just like Golang; there are tons of contributors. And with any new system, especially around infrastructure tools, it isn't real until it's in production and people really are sending production and meaningful traffic, right? On the surface you will say, "Oh, it's just Pokémon GO", but trust me, that game makes a ton of cash. And whenever cash is involved, it's all the same - no one wants to lose revenue.
+
+A game like Pokémon GO, that was used worldwide, globally, and it was a big sensation for a lot of people that were playing the game, it had revenue attached to it, so it became a very business critical situation that it ran well, and it was really nice to see Kubernetes shine in real life, in real workloads.
+
+**Brian Ketelsen:** Yeah, there are articles about that. We will put that in the show notes, it's a really impressive read. I'm curious... One of the things that when we talked about having you on the show - you said if you had a free weekend to hack on something, you would wanna hack on self-deploying Go applications. Tell me about how you would go about that? What would you spend that weekend doing?
+
+**Kelsey Hightower:** \[00:40:07.19\\\] I actually did that weekend like two weekends ago when I was in New York. I was thinking about Kubernetes and all these platforms as a service tools, and the thing that made Go awesome to me, regardless of the syntax, the features or the standard library, was this idea that you could just do a compile from your Mac, spin on a Linux binary that was self-contained, SCP it to a server - that was one of the first things I did at my first GopherCon talk. To me, that idea made programming fun again, and made it easy to consume other software that was written in Go.
+
+And to think about it, now when we move on to Kubernetes and then we turn back and say, "You have to create all of these YAML files, you had to learn what goes in those YAML files...", we feel like we're back in that world of "Alright, now you wanna do a deployment, you have to do all of these steps to get there." I built this little app, and you'll see it at KubeCon as part of my keynote, where the app itself now can say, "Oh, I know how to generate my own deployment. I can expose flags on my binary that will say <<I would like five copies running>>" The user can decide how much memory it should ask Kubernetes for.
+
+What I've done in my prototype - it was actually on GitHub - is called "Hello, Universe." "Hello, world" is old school. "Hello, Universe" is the whole thing, right? So "Hello, Universe", when it launches this stuff onto Kubernetes, using the API, I go find all of my pod instances that are running, I attach their STDOUT to my STDOUT, so even though the binary is running on my laptop, you see all of the STDOUT going to your laptop. And when you hit Ctrl+C to kill the process, I clean up all the resources in Kubernetes and I shut down the service, I shut down the deployment, I even remove the secrets. On the command line you give a few flags to say "Here's my TLS cert, private key, and public key"; all I do with this library is upload those to Kubernetes so they're secrets. So transparently underneath the covers, you can scale an application across one or more clusters, but it feels like it's just a simple app running on your laptop. To me, that is game-changing.
+
+Imagine that experience, if someone told you "Download my project, run it on your laptop to kick the tires and when you're ready just give it a Kubernetes flag and the URL of a Kubernetes cluster or a federated cluster", and it will deploy itself across all your clusters and give you a dashboard, a UI where you can actually interact with how it's running. Just kind of like PS on a real server, but imagine your application becoming the userland for a thing that's running in the cluster.
+
+To me, that is something that would move the industry forward and really show people the power of these stacks, with little effort.
+
+**Brian Ketelsen:** That's insanity. I know what I'm reading tonight.
+
+**Erik St. Martin:** Alright, I've already got the GitHub repo pulled up. \[laughter\] It's really interesting to start thinking about these things. One of the things that I'm talking about is taking basically deployments of apps, same thing but using third party resources. So taking basically a configuration for what is a channel lineup or cable television, submit it to the Kubernetes API - there's a controller that watches those things and is like "Hey, I need to spin up a pod that does video streaming. I need to map in its configuration for this and I need to make sure that there's one copy of that that stays alive." Likely there will be two, there will be a failover location, but from a generic perspective it's just insuring that, as the person responsible for doing channel lineups and doing cable television streams, I don't have to care about hardware or software or anything. I'm just posting the same thing, desired state. "I would like this group of channels to be streamed towards this area, and go!"
+
+\[00:44:05.23\\\] And when I don't want that to happen, or I wanna change it in some way, I just update that resource and the cluster adapts. It's really kind of changing the way you look at building applications, and it's really interesting.
+
+**Kelsey Hightower:** And for our Go developers listening here, this is where the parallel is. Before I started writing code in Go, I was doing mainly Ruby and Python. With those languages, you always have to do a pause before you start thinking about concurrency. Like, "Oh, Ruby - I wanna do concurrency. Alright... Let me put paths and \[unintelligible 00:44:35.26\] in front of this thing, let me go and get NGINX, and oh man, I gotta go get this Redis queue thing", just to do something in parallel. Whereas in Go it's kind of there for free, so you take on more ambitious projects, like "I'm going to write my distributed database using Golang." Because now you don't have to worry about the facilities of accomplishing that goal; it just seems like it's there. The community is already building these things, you can go get inspiration.
+
+So anytime you can free up that mental overhead of doing something really hard and it's provided for you, that gives you the courage or time to go and build these more challenging things. I think Kubernetes does the same thing for these large, complex deployments. Now a lot of that is pushed lower, and you can just focus on getting that done.
+
+**Erik St. Martin:** I love gaining the Kube control command for stuff, too. That's one of the best things about third party resources like that. Now I'm not asking Kubernetes about pods and replication controllers and things like that, I'm asking it about my thing, you know? Get certs, get streams, get whatever, and I get to just kind of see that; and if you have some sort of controller running, monitoring the state of the cluster, you can just be updating a status on your resource and then you can see, "Hey, this is the state of my TLS or my LetsEncrypt, or..."
+
+**Brian Ketelsen:** ...or my cable TV channel.
+
+**Erik St. Martin:** Or my cable TV channel. Technically, it's a group of channels. It's between two and eight, two and ten, and one multiplex screen.
+
+**Brian Ketelsen:** I can't wait to hear this talk. But first, we do need to talk about a new class on Code School.
+
+**Break:** \[00:46:14.11\\\]
+
+**Erik St. Martin:** So Kelsey, what's next for Kubernetes? Anything you're particularly excited about that's coming down the pipe?
+
+**Kelsey Hightower:** The community, and... You know, we have the Cluster Federation. I was just doing a presentation earlier this morning about making it easy to manage multiple clusters. Today, Kubernetes makes it easy to manage multiple machines; Kubernetes Federation will make it easy to manage multiple clusters, so in the 1.4 release, and I also have a tutorial on GitHub called Kubernetes Cluster Federation that shows you how to actually build multiple clusters and then join them together, and then start interacting with more than one cluster as a single cluster, using the new Federation capabilities. So go check out that tutorial if you want to play with that.
+
+\[00:48:05.17\\\] That to me is one of the most interesting things, because we want people to feel comfortable having multiple clusters, so that you don't have one big cluster trying to span multiple data centers - that's gonna be a disaster - but enable to make it easy for people to do the right thing. The Kubernetes community has to step up - and we did - and Cluster Federation enables you to do the right thing. It's a game changer in my opinion.
+
+**Erik St. Martin:** Yeah, I know for my particular use case it threw away a whole area that I was going to have to build when the Federation stuff came out, because the same kind of problem is multiple data centers spread out across the world, and they're kind of divided up by different groups who maintain them. So the Federation thing, I haven't started building that out yet, but I'm super impressed by that. It's like every release I get to delete some code, which is awesome.
+
+**Brian Ketelsen:** Well, speaking of game-changing, let's talk about Kelsey and his live code demos. If there's anybody in the entire history of conferences that has changed the game, it's Kelsey and his off-the-cuff live demo on the screen. I don't know if you had done this before GopherCon 2014, but you shook the world when you were booting containers off of a slide.
+
+**Erik St. Martin:** He PXE booted a VM from a container...
+
+**Kelsey Hightower:** Yeah, to me honestly, I'll tell you guys... I didn't go to college to learn this stuff and so as many other people, and for me to really learn some of these concepts, especially early on, the only way I could actually get it was to get it running, and once you make it work for the very first time - you guys can probably relate to this - you start doing that little dance; you've got your headphones on, your family is looking at you crazy, and that feeling is when I think technology proves itself that it's working for you; it's not something that you're working for.
+
+So when I present or get a chance to be given the stage and I really want people to feel it in the shortest amount of time possible, I think the live demo keeps me honest as a presenter to stick to the facts, stick to actually what works, and it also lets everyone else feel and relive that moment when I got it to work, and they see it work. I think a lot of people are getting inspired when they see this, like "You know what? If he just did that in 20 or 30 minutes and he just put the steps on GitHub, there is no reason I need to put off doing the exact same thing." I think that's very inspiring to people, myself included.
+
+To me the live demo is a requirement for me, just to make sure that I'm doing my job as a presenter, and it's one of my things that I kind of use as a crutch. The live demo is risky, but the payoff seems to be huge.
+
+**Erik St. Martin:** I'm not gonna lie, last night I was having a conversation with Brian how I could one up the PXE booting by live launching a cable TV stream, but then I had to worry about the bandwidth concerns. Bandwidth at conferences is never good.
+
+**Kelsey Hightower:** Yeah, but now that the challenge is set, I look forward to you doing it. Now if it fails... \[laughter\] You'd better be ready to handle that.
+
+**Brian Ketelsen:** Generally, presenters get their own hardwired Ethernet access. It's not only Wi-Fi networks. I don't think you can use that crutch, Erik. I wanna see like TV, broadcast from your laptop, on stage...
+
+**Erik St. Martin:** If I limit it to one program in the stream, I might be able to do it over a hard line. But typically it's a 38/8 stream.
+
+**Kelsey Hightower:** Anyone out there listening, the way you prepare for a live demo is not the way Erik is doing it right now. If you're gonna do it, you need to do it. You gotta own it. \[laughter\] Pick the use case, and then you do whatever it takes to make it possible. Because at the end of the day - just do it, man! All of this psyching yourself out, and if this and if that - nobody wants to hear that, man. You get on stage, you do your thing... Don't tell us about it. I'll see it at KubeCon, and make sure you deliver.
+
+**Brian Ketelsen:** Gauntlet thrown.
+
+**Erik St. Martin:** Right. I think that you have a really creative way though of explaining stuff to people, too. It's not just the live demo stuff. This year's GopherCon you did the talk about writing your own scheduler, and using Tetris. That was awesome! You take something that seems complex, right? When most of us think about how do I take these resources and efficiently place them on nodes - we think that that's a job we wouldn't want. I wouldn't wanna write the scheduler. But then you kind of break it down into these manageable ideas, thinking about things in Tetris terms. Everybody can relate to Tetris.
+
+I think that's why people love watching your talks - you take things that seem out of reach for people and bring them down to levels that everybody can connect with.
+
+**Kelsey Hightower:** Thank you. That's kind of the goal there. I try to spend as much time as possible not learning something, but understanding something. And if I feel that I get to the point of understanding that I can articulate it with a video game, then I know I think I've done my preparation job.
+
+**Carlisia Thompson:** I wanna ask you Kelsey, maybe switching gears a little bit - where would you like to see Go going as a language as it matures, to support a project like Kubernetes which is obviously very sophisticated and very on the larger side of things? I'm interested to know where do you see you could get most support, from the community, from the language itself and from the ecosystem.
+
+**Kelsey Hightower:** I think we've already had some good support so far. When we would run into issues where we had to stay stuck on, like Go 1.4 and some of the issues with 1.6, I think for us having the Go Team step in and use Kubernetes to actually help find and locate performance issues has been a huge help. People in the Go community just using the project and giving us feedback, or even looking at our code and saying, "Hey, there's a much better way of writing" some of the implementations that we've done in Kubernetes.
+
+And I think for Kubernetes also package management is highlighted to the next degree. For small projects not really having a one blast solution for dealing with packages, third party dependencies - that can be handled, but in Kubernetes the interdependency chain is pretty large, even the interdependencies for the project. So I think the native vendoring directory went a long way, but I think all the progress that is made on the third party dependency management front will be a big help to Kubernetes in our community. And also just better examples for people that are... If you write Golang and you use Kubernetes or you're even interested in distributed systems, it will very much be to the benefit of our community and the project to get more Golang experts contributing to Kubernetes.
+
+I think our project has a lot of people that were also new to Go. That's not necessarily a bad thing, but we always can benefit from other people of Go expertise, helping refactor, clean up the codebase and also just teaching our community some of the best practices that we've seen over time.
+
+**Erik St. Martin:** Yeah, and there is a lot of Special Interest Groups too, if there's particular areas of the Kubernetes project that you're interested in. If you're interested in a scheduler, or app deployment, or the networking side of things... I can't even remember all the different special interest groups that are out there, but you can kind of hang out... Most of them do weekly meetings and things like that.
+
+It's a big project with a lot of things that it does, but it's easy to kind of find a little area that you're excited about and get with other people who can help you pick up that particular part of Kubernetes much faster.
+
+**Kelsey Hightower:** \[00:56:00.20\\\] I should be mentioning too that I'm a very pragmatic person. I'm not going to complain about missing features in the language, like seriously. Go does a really good job of handling 80-90% of the use cases. There's always gonna be a gap from a different language or someone's preference. I've kind of got to the point where any shortcomings in Go do not stop me from executing the things that I wanna do. Easy that you can walk by and complain about them, I see a lot of that... "If only Go had generics", or "If only Go had X..." And I get it. If that will help people improve, I can understand the ask, but I don't see any glaring holes that Go has that have prevented people from executing on their ideas, and I think that is really how Go should be measured.
+
+Were people able to execute the things that they wanted to do? How did Go help them? And in some ways we could talk a little bit about how Go prevents them, but as people are shipping these products, you can see that Go is definitely doing a great job of enabling us to do that.
+
+**Erik St. Martin:** I think that that's a good point too, working solution over no solution, right?
+
+**Kelsey Hightower:** Right.
+
+**Carlisia Thompson:** Going back to something you said, Kelsey, I can only imagine the amount of best practices and good practices that you have acquired as a group of contributors to Kubernetes. Is there any chance we can get a compilation of these best practices? I think the community needs something like this. Everybody keeps asking and it's sort of a mystery. You know what it is when you see it, but it'd be nice to have some sort of list somewhere.
+
+**Kelsey Hightower:** I don't know if we necessarily have all the Go experts and all the best practices. I think the Kubernetes team will tell you first hand. They're learning as they go as well. If you think about it, both projects aren't that old, so I think a lot of people that are contributing to Kubernetes, some of them learned Go for the very first time in order to contribute to Kubernetes. I think we're in a position of... We're kind of a microcosm of what's happening in the Go community itself. We have some long time Go users who contribute to the project, we have some people that are new to the language, but I think that kind of speaks to one of Go's strengths, that you can kind of jump into a very large Go codebase and contribute.
+
+But also on the flipside, since Go is relatively young, we do have some best practices, but even Kubernetes challenges some of those best practices because they may not work for the way we want to do things. So I think there's a big tradeoff and I think a lot of that is starting to be surfaced in some of these conversations at the Code Bubble.
+
+**Brian Ketelsen:** One of the things that I had put in the show notes about interesting Go projects and news, which is generally our next segment, but it makes really good sense to bring it up here, is the Go Build Template that Tim Hawkin put out, which is extracted directly out of Kubernetes. The Go Build Template is a make file and Go project structure. Together, it allows you to have a Go application that will build itself in Docker containers on every platform that Docker supports, and the make file is beautiful, and all of the code is beautiful. Really all you have to do is clone that Go Build Template, add your code to it and you have some of the really nice best practices for building and testing and structuring your application. I loved that when I saw it; I think he just released that two or three days ago, and I starred that immediately because that is one of the things that's come out of Kubernetes - how to manage a Go application from a building and testing perspective when it comes to containerization. That whole make file is a piece of art, really nice.
+
+**Kelsey Hightower:** \[00:59:52.20\\\] Yeah, along those lines I also think our end-to-end testing Kubernetes are magnificent. We have this big distributed system, tons of moving pieces, but we have these very elaborate end-to-end tests that take real versions of our code and from the tree, and we are able to test end-to-end user functionality. We don't rely strictly on unit tests and mocks. We simply just launch all the components and run things straight through Kubernetes to find real issues that people would have in production. That has been a goldmine in keeping Kubernetes relatively stable - we have a good reputation for being stable; we're very liberal about introducing new features...
+
+So one best practice there would be liberal use of alpha. We are very clear in our API, "This is an alpha feature and is subject to change to API and implementation." Then it moves to beta, and that beta period could be months or even a year if necessary, and then it goes to stable. I think that's a really good practice that any large, well-adopted project, any size project should really consider this idea of propagating your APIs from alpha to stable, and then once they become v1 stable, you gotta own it and not change it and rip it off from other people; then they will actually start to trust your project and their APIs.
+
+**Carlisia Thompson:** That is a beautiful concept. I was looking a little bit at your tests for the APIs, I think I saw a little of what you're talking about. It sounds to me it would be a beautiful way to just maintain integration tests, like you're saying, through production environment light in a cluster, and use that as your test phase.
+
+**Brian Ketelsen:** One of the training modules that I'm giving in the training class up in Boston next week is how to test real-world applications, and how real Go applications do testing, and there are probably four references to Kubernetes in there, because Kubernetes testing is just top notch. It's really impressive how well they've managed to test the really hard things that are in a distributed application. They're testing them in Kubernetes; you don't see broken Kubernetes releases. You don't. That's real-world best practices right there.
+
+**Erik St. Martin:** I think a good thing to note too when we think about the idiomatic use of a language in these large projects is I don't think it's right to put a lot of expectations on these big projects to have nothing but idiomatic Go. There's lots of contributors coming from many places with many different backgrounds, and we can look to anywhere... Like Ruby on Rails - if you look through that codebase, I'm sure you will find lots of examples of non-idiomatic Ruby code, too.
+
+That's just kind of a thought, that while we desire to have these things be there, it's not all that odd to find large projects in a language that don't have the best uses of the language.
+
+**Kelsey Hightower:** Right.
+
+**Carlisia Thompson:** That's why it would be great for somebody to extract the examples of, "Well, these are the good things, the good ways that we found to write Go that turned out to be easy to work with." And like Katrina was saying in the last episode when she was here with us, she was saying that she found a bunch of reputable things that people were doing that were wrong and non-idiomatic; they were correct implementation-wise, in the sense that they would work - I'm talking about the Exercisms in Go... And she started doing a compilation of those things, so people know "Okay, these are not desirable ways to do it", which I think is also a good contrast.
+
+**Erik St. Martin:** I get what you're saying... Kind of look through and find the patterns and the anti-patterns and kind of document those so that people continue to do the good things, and at least stop doing the undesired things.
+
+**Carlisia Thompson:** \[01:03:54.03\\\] Yeah. I'm thinking... Also, this would go for people who are veterans on the project, that have run into these things and could maybe contribute to the list.
+
+**Erik St. Martin:** You know what's really interesting though, outside of the implementation details, the way it's written in Go, what Kubernetes does have really good documentation on is the conventions of the design of the system. It's easy to find -- like, if you're implementing your own object to be represented in Kubernetes, these are the types of things you use. You expect fields here. You have a spec property on your resource and that represents the desired state, and you have a status property... And even though this is your own whiteboard and you can do whatever you want, there's still these conventions they like you to follow within, so that the system can work to your benefit, and there's lots of documentation on API conventions and things like that. I need to find the links to those.
+
+**Brian Ketelsen:** This is the segment of the show where we like to give a shout out to free software maintainers and projects. The OSS maintainers are groups that make projects that you love; there are so many of them that make our lives easier, and it's something that's important to us, to give a shout out to the people and the groups that make the things that we use every day, and maybe take for granted.
+
+I'll start off today... I have actually two of them from Dave Cheney that I've been using a whole lot lately. His github.com/pkg/errors is a beautiful way to wrap your errors without losing the original error type. I know that there has been a little bit of talk about merging that into standard library - I hope that happens, because it's just an amazing package for managing errors without losing the history of the errors. It's propagated up the stack, I love that.
+
+And then in the same GitHub repo, a package profile. If you wanna profile your application, there is no easier way to do that. I know Go tool pprof is very powerful, but not so easy to use. So thanks Dave Cheney for all of the awesome work you do for our community.
+
+**Erik St. Martin:** And how about you, Carlisia?
+
+**Carlisia Thompson:** I am going to mention this project that I found this week, it's a compilation of blog posts called... Oh my gosh! Where is the link...?
+
+**Erik St. Martin:** Are you talking about the Golang Spec?
+
+**Carlisia Thompson:** Yes, thank you. It's sort of like a walkthrough, but really short and I think really gentle too, on different aspects of the specification for Go. There are posts about initialization dependencies in Go, simple statement notion in Go, anatomy of a Go source file... So just little, short posts that give you boring sites, things that maybe you wouldn't think about, and I thought that was pretty cool. I see that is started in 30th July, and there have been a few posts, so I hope this person keeps going with it. I thought it was pretty cool.
+
+**Brian Ketelsen:** Nice. Erik?
+
+**Erik St. Martin:** It's me?
+
+**Brian Ketelsen:** It's you.
+
+**Erik St. Martin:** So I've been knee-deep in Kubernetes the past couple weeks, so I don't have a whole lot new, but I'm totally gonna steal a package that made Brian's life much easier, which is this PID controller library that's written in Go. PID controllers take a target value, current value and then basically try to do some calculus and determine changes to be made. We've been kind of behind the scenes of designing this PID controller for controlling barbecue grills and temperature, so that prevented any of us from having to write one, which was awesome, because my math is not so good.
+
+**Brian Ketelsen:** \[01:07:58.10\\\] Yeah, you didn't have to write any calculus. That's at github.com/felixge/pidctrl, and if you wanna see our implementation of it, that's at github.com/bbqgophers/qpid, and there might even be some videos of my barbecuer over the weekend running from a Raspberry Pi using Go to control the grill. Perhaps.
+
+**Erik St. Martin:** Yeah, this is gonna be really interesting as we expand out on it and do meat probes and dashboards...
+
+**Brian Ketelsen:** \[laughs\] It's all a hundred percent Go, too. It's got Prometheus in there, it's running in Docker on all this great Go code. Good stuff.
+
+**Erik St. Martin:** And then we deploy Kubernetes to it, right?
+
+**Brian Ketelsen:** Well, I was thinking about that, you know? Since we were talking about this, one of the problems we have with the Raspberry Pi is the limitation of the number of things you can plug into it. But what if we federated the whole thing and made it a cluster of Raspberry Pi's? I happened to have like 20 of them in a drawer... Why not have a federated cluster of Raspberry Pi's, each reporting a piece of the information so you could have meat thermometers in each of the different barbecue items in your grill, and just have them all together? Let's go big or go home.
+
+**Erik St. Martin:** Is it eating up a lot of resources right now?
+
+**Brian Ketelsen:** Are you kidding me? I think I posted a screenshot of top running while both Prometheus and Qpid were running at the same time, and it was at 0.03, or something... Just no resources at all. We're not even touching what a Raspberry Pi can do with that.
+
+**Erik St. Martin:** And you're already worried about needing to federate?
+
+**Brian Ketelsen:** No, not worried. I just think, if you can, you should. \[laughter\] Go big.
+
+**Erik St. Martin:** We're kind of catching you off guard here, Kelsey, but do you have a project you would like to give props to?
+
+**Kelsey Hightower:** I'm gonna say documentation is the thing that is killing everyone. Ops, devs, everybody is being destroyed because of lack of documentation, period. We all spend this time reverse-engineering libraries as we find them, so I wanna give a special shout out to Ben Johnson taking time from some of the fabulous libraries and managers like BoltDB - which I use in many of my projects - but the shout out needs to go to his documentation. If Medium was a repository, then the documentations that he's checking in there is crazy.
+
+I think now people are starting to really learn what this stuff is, and as much as we like to use all these libraries, documentation is what really levels people up and gets them to the point where they can also start producing some of the things that we're giving a shout out to. So we don't often give enough credit to the other part of the tools we build. They need instruction manuals, right? So a documentation shout out to Ben Johnson. The many posts that he's done over the last few months are awesome. So that's me.
+
+**Brian Ketelsen:** Awesome, that's a good one.
+
+**Carlisia Thompson:** Couldn't agree more. Who's got the idiomatic Go thing there?
+
+**Erik St. Martin:** I'm sorry, was that the...?
+
+**Carlisia Thompson:** In the Projects and News?
+
+**Kelsey Hightower:** Yeah, he just deep dives on what bytes are, and just different packages in the standard library, taking the time to detail how these things work. Not in a way that you would find in the standard library, but just in the way like from human to human communication. Like, "Here's this thing. Let's do a deep dive and give you some concrete things to think about", which has helped lots of people, even experienced Gophers like myself. When you read it from that angle, you start to get a better understanding of these things. So anytime people in our community can do that, it goes a long way - whether it's documentation for your library, or projects, examples on how to use it, or documenting someone else's library. Those contributions are greatly appreciated, even though they're not the thing that people import into their source code.
+
+**Erik St. Martin:** Yeah, and examples. Example code. Because you can see these things and not connect with it until you see an example of code somebody's written using a library or even a project in general.
+
+I think that we are 10 or 12 minutes overtime, which means we should probably cut the show.
+
+**Brian Ketelsen:** \[01:12:15.20\\\] Oh, man...
+
+**Erik St. Martin:** Unless we all want to be hang out here all day.
+
+**Brian Ketelsen:** Oh, man...!
+
+**Carlisia Thompson:** \[laughs\] Another one...
+
+**Erik St. Martin:** Well, you say you'll be traveling, right Brian? So you won't be at KubeCon.
+
+**Brian Ketelsen:** No, I think I'll be in Amsterdam.
+
+**Erik St. Martin:** I'll get to hang out with Kelsey. You'll be in another country.
+
+**Brian Ketelsen:** But I'll be thinking of you.
+
+**Erik St. Martin:** So now that you can feel a little more jealous that we have to end this show and I get to hang out with Kelsey and you do not...
+
+**Brian Ketelsen:** Oh, man... \[laughter\] \[sighs\] FOMO>
+
+**Erik St. Martin:** So I wanna thank everybody on the show... I definitely wanna thank Kelsey for taking time out of his busy schedule to come on the show and chat with us about all things Kubernetes. Thanks to all the listeners, to everybody who's listening live right now and has been interacting with us in the GoTime FM channel. A huge shout out to Linode and Code School for sponsoring this episode; without them we wouldn't be on.
+
+A shout out to Carlisia's employer, Fastly, for the CDN which will be leveraging for this show and all of Changelog's shows. Definitely share the show with any fellow programmers that you think might be interested. You can subscribe at GoTime.fm, and we are @GoTimeFM on Twitter. I think I've covered everything, so with that said, goodbye everybody!
+
+**Brian Ketelsen:** Thanks, Kelsey.
+
+**Kelsey Hightower:** Thank you guys for having me!
+
+**Carlisia Thompson:** Bye! This was awesome!

Matt Holt on CaddyServer, the ACME Protocol, TLS_transcript.txt

@@ -0,0 +1,541 @@
+**Erik St. Martin:** We are back for episode number 14. On the show today we have myself, Erik St. Martin, we also have Brian Ketelsen. Say hello, Brian...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** ... and Carlisia Campos.
+
+**Carlisia Thompson:** Hi!
+
+**Erik St. Martin:** And our special guest today is Matt Holt, who we're gonna talk a bit about TLS, ACME and his own project, Caddy. How are you doing, Matt?
+
+**Matt Holt:** Hi there, good.
+
+**Erik St. Martin:** So we're having a little bit of déjà vu here because we did have you on the show when we were kind of kicking things off and doing some dry runs and all that jazz, so this is actually fun because you've had some new things come out for Caddy recently.
+
+**Matt Holt:** Yeah.
+
+**Erik St. Martin:** And we're a bit more seasoned now, so I think that works well.
+
+**Matt Holt:** Yeah, the timing is good.
+
+**Erik St. Martin:** So wanna kick it off with Caddy? Because I think that's probably the most common thing everybody knows you for. You wanna talk a little bit about what Caddy is and kind of your motivations behind creating it?
+
+**Matt Holt:** Sure. And that will be a good way to segue into the TLS and ACME conversation. Caddy is an HTTP2, HTTPS default web server. It's written in Go, of course. About two weeks, we released Caddy 0.9, which was a pretty big release because I rewrote it from scratch, as a whole new architecture, inverted all the dependencies... But this is actually really cool, because the idea about Caddy now is that it's not just about serving the web -- well, it is, it is first and foremost a web server, but the goal here is that other applications written in Go that use the network can take advantage of Caddy's features, such as its easy configuration with that text file called the Caddy file and its magic TLS features. So any server type, whether it be HTTP, which it currently is, or if someone writes say, I don't know, maybe a Git server or a mail server, it can take advantage of Caddy's TLS features. There's actually a DNS server on its way, so you can use Caddy to serve DNS pretty soon.
+
+**Erik St. Martin:** This is Meek's Core DNS project, right?
+
+**Matt Holt:** Yeah.
+
+**Erik St. Martin:** It's kind of his rewrite of Sky DNS.
+
+**Matt Holt:** Yep, so that's a Caddy plugin which will be available soon.
+
+**Brian Ketelsen:** Also, this is a plugin to Caddy, rather than core DNS kind of leveraging shared libraries; it's actually the other way around, where Caddy takes plugins. Am I understanding that correctly?
+
+**Matt Holt:** Right. I was really excited when he forked this, thinking that it would be beneficial for a DNS server and it turns out that it is. But the problem is that you have a bunch of duplicated code, you have to maintain a fork, and so to alleviate some of that pressure and to help Caddy serve a wider audience and really do what I want people to do, and that is use TLS. I redesigned Caddy so that it can handle different server types other than HTTP, so now the DNS server is a plugin. Well, it will be. The HTTP Server is a plugin, and so it can do all those things now.
+
+**Erik St. Martin:** \[03:53\] Wow, that's awesome. So I wanna kind of circle back for one second, because you happened to mention that 0.9 was a complete rewrite, so how long did that take and what was the motivation behind kind of just scrapping and starting over? Was it new functionality and new ways of looking at your project?
+
+**Matt Holt:** Yeah, so people's feedback really expanded my vision a lot of what they wanted and what was possible and what Caddy really was. On day one for me, Caddy was just a web server that makes it easy to spin up a new website in just a matter of seconds, but after the launch of Let's Encrypt and more people using Caddy, I realized that what people really want is just an easy way to configure their standard web services and to do so securely, without having to worry about it. Caddy 0.9 makes that possible, but I had to redesign a lot of it to handle more... Because before, the only thing that a plugin could do is handle HTTP requests, basically. But now, Caddy can be extended so that plugins can do a number of things, including serving something completely other than HTTP. So that was kind of the goal, and that rewrite took almost six months. There was a lot of code to splice over piece by piece.
+
+**Brian Ketelsen:** Wow.
+
+**Matt Holt:** But I love Go, and it was a pleasure.
+
+**Erik St. Martin:** And this is all while maintaining and doing bug fixes to prior releases, right?
+
+**Matt Holt:** Yeah, one or two... Admittedly, I started maintaining the older release once I got about two months into the rewrite.
+
+**Erik St. Martin:** PR's accepted. \[laughs\]
+
+**Brian Ketelsen:** That's right.
+
+**Matt Holt:** Yeah.
+
+**Brian Ketelsen:** So we get awfully excited about Caddy around here, mostly because -- well, actually, there's two reasons. One, everything that I serve on the web is served through Caddy and it has been for, I guess, about a year-and-a -half now, almost since Caddy was released. So we love Caddy a lot.
+
+But I think another reason that I get particularly excited about Caddy is because to me Caddy is kind of the poster child for how awesome and easy it is to do something in Go. When you look at the features that Caddy has and then you look at the Caddy code base, the code base isn't as big as you would expect it to be and it's kind of this great, big bucket of awesome.
+
+**Matt Holt:** Yeah, I think it's a good showcase for some of Go's capabilities, at least the web and maybe some of its crypto portion, super easy to do things. Most people and most Go developers don't really need Caddy if they just need to serve static files; Go makes that one or two lines, and it's so easy. Use Caddy if you want more integrated environment.
+
+But it's a really good showcase for these people who come from Node or Python or PHP environments and they're working a lot in those languages, to use something like Caddy is a breath of fresh air for them from what I've heard. Because they're used to installing runtime environments and dependencies and setting up process managers and everything, but with a Go program like Caddy it's a good showcase, I think, because you just set it, run it and forget it.
+
+**Erik St. Martin:** I think even from using it as a customer kind of perspective, we serve the GopherCon and GopherAcademy sites using it. Some of the stuff just makes it so easy, like the Let's Encrypt functionality; it's just easy to get certificates.
+
+**Matt Holt:** Yeah, and Caddy is designed to be -- if you're familiar with web servers like Apache or Nginx, you configure a web server. With Caddy when you configure it you don't think about servers so much, you think about sites. You can think of it this way, every 10 years or so, a new layer or abstraction comes along to build upon another layer or technology that's existed.
+
+\[\\00:08:08.18\] For example, recently we're seeing chat bots that are emerging on top of messaging platforms. And so you might view those chat bots as kind of another layer of abstraction on top of another technology, the messaging protocols. And in a way, I think, in a similar way Caddy is that layer above the web layer or the server layer, in that you don't have to think about the server so much, you can just configure your sites and think about it from a site perspective. And these site configurations give you the added functionality that you need as a website owner.
+
+So again, its ability to render markdown as HTML on the fly is something that is really helpful and productive for site owners these days, but that's a layer above the web server. I'm hoping that we can step up from just worrying about the web layer and focus on your sites and what you wanna get done as a site owner. Does that make sense?
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** It makes a lot of sense, yeah.
+
+**Matt Holt:** So all the security stuff is just taken care of, because that's the layer below your site; all the TLS stuff - you don't have to worry about it so much. And features available to you like Markdown or Abiola's Git plugin that allows you to deploy your site with the git-push, that kind of builds upon an existing layer of technology that now you don't have to -- it's not a separate thing anymore, because site owners find that productive and useful.
+
+**Brian Ketelsen:** Yeah, that was the biggest appeal for me once we started playing the hugo-plugin with the git-plugin. It replaced a ton of ugly workflow that I had previously. Every time we did an update to the GopherCon site or we made a new blog post on blog.gopheracademy.com, that was minutes of work that I could've done something else. You talk about the security being a layer below the web service; the real boon for me in Caddy is the layer above those plugins that make my life drastically easier.
+
+**Matt Holt:** Cool, yeah. I hope there will be more plugins with time.
+
+**Erik St. Martin:** There was one I remember seeing that was WebSockets, where you kind of balance STDIN and STDOUT to a Web Socket.
+
+**Matt Holt:** Yeah.
+
+**Erik St. Martin:** I'm interested to see some use cases there, but I thought that was kind of interesting.
+
+**Matt Holt:** Yeah, that was inspired from a project called WebsocketD, which is devoted to doing just that…
+
+**Erik St. Martin:** Okay.
+
+**Matt Holt:** …which is also written in Go. Pretty cool project.
+
+**Erik St. Martin:** See this goes to that -- who claimed it? Somebody named it Ketelsen's Law. \[Laughter\] Somebody just this afternoon called that Ketelsen's Law, the whole everything interesting in the web world.
+
+**Brian Ketelsen:** I think that might have been Scott Mansfield.
+
+**Erik St. Martin:** Yeah. Brian said it on the show a long time ago and someone claimed it as Ketelsen's Law.
+
+**Carlisia Thompson:** I also said that the whole Internet is being rewritten in Go, so you can quote me on that \[laughs\].
+
+**Erik St. Martin:** It seems that way. Have you looked at any stats to see how many websites are running Caddy these days?
+
+**Matt Holt:** No, I don't know where to get that information. I mean, reliably. A lot of people that are security-conscious will hide the server header, and it doesn't phone home. I know that there is an estimated 30,000 downloads, but that doesn't include any that are automated installs from scripts.
+
+**Erik St. Martin:** Right. It'd be interesting to see... But for a lot of us, it's just so easy to just get up and going. And like I said, one of my favorite things is the kind of Let's Encrypt in SNI support.
+
+**Matt Holt:** \[11:51\] Yeah, we should talk about that, because there's no reason that only Caddy can do this. I think every Go program that uses the network should do this, for a number of reasons. Well, Brian, you write a lot of network software, do you think about this?
+
+**Brian Ketelsen:** At Backplane we do distributed load balancing and we definitely think about it, and we use Let's Encrypt to get certificates for all of our clients; so yes, we think about it a lot.
+
+**Matt Holt:** Cool. How do you do that?
+
+**Brian Ketelsen:** I didn't write it, I don't know. Magic happens... Anthony wrote it, Anthony Voutas.
+
+**Matt Holt:** That's good. I guess the reason I ask is because... So Let's Encrypt is a service that lets you get free TLS certificates, and the thing is that it's an automated service, so you don't point-and-click your way through a checkout form and then check your email and click a link, download a certificate and install it. You need code to use this, and there are some great Go libraries out there that make it possible to add this layer of security to your application.
+
+You know, it's interesting because I was talking to some people, and some people dispute the need for it, saying their application, in their use case they don't TLS at all. Others are saying that -- actually I was just talking to someone, a project or a team leader at a large organization here recently, and he was extremely skeptical of Let's Encrypt and their certificates. And so there seemed to be a lot of, I don't know, a lot of confusion about the topic as well that I think it would be good to clear up a few things.
+
+**Carlisia Thompson:** But when you say skeptical in the case of this person, do you mean in terms of how much security it is actually adding, or what exactly?
+
+**Erik St. Martin:** I think in this case you're referring to whether the Let's Encrypt organization can be kind of trusted with being a root CA. Is that what you're referring to, and not necessarily the security of TLS itself?
+
+**Matt Holt:** For that particular person, yeah, it was the legitimacy of Let's Encrypt, but I've seen conversations all over the board, from "Their certificates are not secure, for some reason" to "TLS is broken, in general" to "Let's Encrypt is not a long-lived organization", or something. And all of these claims or disputes are actually really irrelevant. I'm gonna go out on a limb here and I'm gonna say that every application that uses the network - which is many Go applications, I'm sure - need transport layer security, unless your threat model assumes that your transport is already trusted.
+
+Is TLS broken? If you do it wrong, yes, it's broken. But the current modern standards are pretty good, and with TLS 1.3 coming out, there is one or two concerns about it, but it's not finalized yet, but TLS 1.3 looks really promising, as well.
+
+If you have a problem with TLS, it's probably more due to the problems with PKI (Public Key Infrastructure). No, PKI isn't perfect, but it's pretty good what we've got right now. So for you to assume that your transport is already secure is a really big claim, and I think that only few use cases can really make that claim.
+
+**Brian Ketelsen:** I'd go out on a limb and say that anybody who thinks their transport layer is secure is probably deluding themselves. There is no secure network anywhere.
+
+**Matt Holt:** \[15:50\] So one exception perhaps is the loopback interface. Your loopback interface is probably safe without TLS.
+
+**Erik St. Martin:** Yeah, the loopback probably is, and even though I wouldn't do this at Comcast, I know at least for the cable side they have their own backbones and private internet. And that's, of course, segregated from other networks. It's like -- I think in some cases there, but still, there's multiple...
+
+**Brian Ketelsen:** I'm gonna argue.
+
+**Erik St. Martin:** I'm not advocating that you don't encrypt there, but it is kind of one of those, "You know, depending on the service and how well...", but I think it's just a good idea to use TLS in general. I mean, thinking about things like Kubernetes and all those that's using TLS in between all of the services, there's just no reason not to use it. And especially, like as Matt was kind of advocating too, with all this tooling it becomes much easier to do that and to set this up.
+
+And a lot of reason why people avoided it before is getting certificates or stuff, and wildcard certificates and installing these things, it was really time-consuming and most of the time people were generating their own certificates and then you'd have to set up your applications to trust them or just use insecure, and then kind of what's the point if you're doing that? So I think we live in a different space now, where it becomes easier and there's no real reason why you shouldn't, even if you think that bad actors aren't on your network.
+
+**Erik St. Martin:** They are, Brian. I'm gonna beat that dead horse. They are.
+
+**Matt Holt:** Assume they are. If you believe your transport layer is secure, you need to kind of guarantee four things: integrity, confidentiality, nonrepudiation at a technical level at least, and authentication, of course. You need to know who you're talking to. So confidentiality is obvious. You don't want people snooping on you. Now, if you can trust that your private network is actually private and that people who have access to the network aren't bad actors - okay, maybe that is covered.
+
+Then you've got authentication, so you need to make sure that each machine knows who they're talking to. Again, if you can trust your network hardware and all the other software that interacts with your network, maybe you have that covered.
+
+Integrity is one that people often forget. If they have a site or service that they say, "Oh, there is no private information here. There is no sensitive information. I don't need TLS.", that's false because your application will break if it gets malformed data probably, or your website is a liability if you're displaying content that you shouldn't be displaying. So integrity guarantees that it's not modified in transit.
+
+And then nonrepudiation is more complicated, but at a technical level it basically means that the use of a private key has been invoked, so that the parties who are involved in this authenticated transmission, they have proved -- they can't deny that they were part of it. Now again, at the technical level that's true, but those are all valuable properties, those for things. If you're not going to use TLS, you need to be really sure and careful about that.
+
+**Brian Ketelsen:** Use TLS.
+
+**Carlisia Thompson:** I was gonna ask earlier, for the people who do want to use TLS, what are the things that people need to watch out for? I also wanted to ask you - and I'm trying not to jumble a lot of questions in one sentence - to talk about the ACME protocol. Because apparently Let's Encrypt is one entity, and there are others, like StartEncrypt, and they are not all the same and not all of them implement the ACME protocol. Is it relevant that these entities implement this protocol? Was is so special about this protocol?
+
+**Matt Holt:** \[19:54\] Okay. Yeah, great question. The first question was what should you watch out for if you're using TLS - is that what you asked?
+
+**Carlisia Thompson:** No. If you're getting a TLS from a particular CA - Let's Encrypt is one, but there are others... There are different places to get a certificate from.
+
+**Matt Holt:** When you get a certificate, cryptographically it doesn't matter what kind of certificate you get, as long as the certificate authority is trusted by your users. There are certain certificate authorities that I would favor more than others or not favor less than others, based on their business practices... You'll be the judge, right? So the whole point of getting a certificate is to have that third party validate you, to speak for you in that sense and to put out a good word. So you wanna choose a certificate authority that you also trust, and not just because you can buy certificates from them, but because you believe that they're doing business well and that their mission is good, and that you can trust who's on their team.
+
+**Erik St. Martin:** So let's actually talk about that for a second. I mean anytime we talk security, that's always gonna come up, this trust. That's ultimately what it comes down to, is who do you trust? So let's talk about some of the things that can go wrong if you chose a certificate authority that may not be trustworthy, like the types of things that are certificate authority is able to do on your behalf or man-in-the-middle type things that can take place by using a certificate authority that they themselves are issuing certificates on your behalf to other parties, or their keys have been stolen.
+
+**Matt Holt:** Yeah. I'll use an example, and this is just a recent news item. I'm not endorsing or I'm not suggesting one way or another, but recently Symantec issued certificates that were SHA1 signed. Now, SHA1 is officially deprecated for TLS certificates, because of weaknesses with collisions that have been recently found. So they issued certificates that were SHA1 signed, and then they revoked those certificates because they said it was a mistake and, you know, they were called out on this as well, because certificate transparency logs raised the alarm.
+
+And then when they officially asked after that for the issuance of seven SHA1 signed certificates as a special case, the request contained unusual strings in one of the fields in the certificate. And that was concerning, because at least the security researchers say that a collision attack could likely include such unusual string somewhere in the certificate. Their explanations for why those strings were there was considered insufficient. I'm actually taking this - I should give due credit -paraphrasing from the Bulletproof TLS Newsletter, the Feisty Duck TLS Newsletter, and it's fantastic. You know, on Twitter it does a really good job curating this.
+
+Anyway, so here you have the certificate authority whose practices are disputed. Now, in the end they issued the certificates, but they took out those questionable strings. I mean, you be the judge of who your certificate authority is, but cryptographically remember that no certificate is better than another. You can make your own certificate. The only difference is that your certificate isn't trusted by everyone out there.
+
+**Carlisia Thompson:** \[23:50\] Exactly, but how... Let's say I'm a developer, and for some reason I don't wanna use Let's Encrypt. Let's say I don't wanna pay and they renew every three months, and I don't wanna go through the renewal process every three months.
+
+**Matt Holt:** Why not?
+
+**Carlisia Thompson:** Let's say I have reasons, let's say I at least consider other entities. How do I go about trusting an entity? What are the rules of thumb that I need to think about? Are there things that I can look at? Like, this company does this, or …
+
+**Matt Holt:** You know, the way I do it is I just follow the TLS news, TLS-related news. Certificate transparency logs is like a raw source of who is issuing what certificates. Whether a certificate authority even submits to certificate transparency is probably a good indicator. I just Google Security research. They do some really good investigations into certificate authorities and kind of a good alarm system there, and they'll publish a blog post when something alarming happens, especially related to Google services. I just follow the news, I suppose.
+
+**Carlisia Thompson:** And how about the ACME protocol? I was thinking... It sounds like a big deal. I also noticed that not every company that issues certificates implements this protocol. What is it and does that even matter?
+
+**Matt Holt:** Okay, yeah. The ACME protocol - this is a really big deal, because it automates away the job of certificate authorities. Now, we still need certificate authorities, but the manual process of interacting with them goes away. The ACME protocol stands for Automated Certificate Management Environment. This was developed after three years of research at the University of Michigan.
+
+J. Alex Halderman was one of the researchers there. The project, as it came to fruition, it came through the Internet Security Research Group and Mozilla funding and their brand now is Let's Encrypt; it is really making the ACME protocol shine. And so what this means is that you have the certificate authority Let's Encrypt, that is trusted by all the major browsers and vendors and their only way of issuing certificates is automated using this ACME protocol.
+
+So this protocol allows them to verify your claim that you own a domain name and they can issue you certificates. And the protocol has been vetted pretty thoroughly for flaws and bugs. Is it perfect? No. They found a couple, but they fixed it. They're still in beta. But this protocol basically automates in two seconds what normally would take you half a day or more to do manually.
+
+**Brian Ketelsen:** At least, yeah.
+
+**Matt Holt:** So the certificate authority is actually irrelevant here. The fact that Let's Encrypt is the automated certificate authority is just a matter of circumstance right now. But any certificate authority can implement ACME. It's an open protocol, it's published. I see the link here in Slack for the spec. So I'm hoping that over the next few years, we'll see several ACME-capable certificate authorities appear. No reason to let Let's Encrypt be the only one, although they are doing a fantastic job pioneering it.
+
+**Carlisia Thompson:** That's also important because, as I understand it, you can be a CA, but the rules of how you validate a certificate's authority, they are very loose, correct?
+
+**Matt Holt:** Certificate authorities have pretty rigid guidelines. I don't know a whole lot of details, because I don't work for one. The ACME protocol is not any more lenient in issuing certificates than traditional certificate authorities.
+
+**Erik St. Martin:** \[28:05\] It automates the process, really. If we think about the traditional approach of getting a certificate, they typically want you to add a DNS record to show that you have control of the authoritative zone, or they make you add something to the web page, or there's some sort of process to validate that you own a domain. A lot of those things can be automated, so is it so different than having a protocol? And I'm not familiar with exactly how the protocol works, how it vets who owns the domain.
+
+**Carlisia Thompson:** Exactly. But this process of validation, if there is a protocol and the company is following that protocol, we know that that protocol validates in a secure way and we can trust it. I think it was a very good initiative, because you can have implemented a validation process that's either manual, or it can even be also automated, but not be very secure, and that's happened before.
+
+**Matt Holt:** Right. In fact, we saw a similar problem with StartEncrypt, where they had an issue with their API, a security issue, and they don't use ACME, they do something else. So you have to be careful, it's not easy. ACME is pretty good, it relies on the integrity of DNS, just like traditional domain-validated certificates. I mean, DV certificates get their name because they are issued based on validating the domain name, ownership of the domain. So if your DNS is compromised, it's not any different now than it was before. So ACME, again, just speeds it up. You can see Caddy do it in 2 seconds. Your own Go programs can do it in 2 seconds using Go libraries like LEGO and so.
+
+**Brian Ketelsen:** Alright, well, this is a good opportunity for us to take a break and thank our sponsor Equinox. Many of you probably create applications that you need to ship to end users or customers, and if you've been in that boat like I have, you'll know that there are two things that are pretty important: the first is making the installation experience easy and the second is keeping the customers up to date. Equinox solves both of those problems.
+
+The installation experience is dead simple because they create Debian, RPM, Microsoft Installer, Mac packages and they have a Brew Install option that lets your customers get your application pretty much any way that they're comfortable doing it. They also have a hosted download page for your application. So any way that you want to get your customers that app, Equinox supports it.
+
+That second feature of keeping your customers up to date is probably the harder part of delivering your application and Equinox lets your programs self update, which is I think probably the neatest thing ever, because they just give you library code that you can use to automatically add an update flag to your command line app. That's really cool. They deliver binary patches, right in line, so your apps can self-update. Equinox is free for community and personal projects and you can see more about Equinox if you go to equinox.io/gotime. I use Equinox and I strongly recommend it.
+
+Now that we've talked about our sponsors, I have a question for Matt again, which is the economics of the certificate space. You know, just two years ago before Let's Encrypt existed or was doing anything, certificates, especially on the website, were insanely expensive and a big money maker. How do you feel the landscape has changed now that Let's Encrypt is out and giving everybody free certificates for nothing?
+
+**Matt Holt:** \[32:08\] Well, I'm not a certificate authority, so I don't know financial numbers exactly, but I'm willing to bet that they're probably scrambling. A couple of certificate authorities I've observed have made rash moves in terms of public relations that I wouldn't deem wise or sensible, because I think the idea that people can now get certificates and masks for free is concerning to them.
+
+I don't think that automated certificates, whether free or not, I don't think they're going to -- because ACME, by the way, it doesn't say the certificates have to be free, at least as far as I know. I don't think the automated certificates are gonna put CAs out of business. I do think it's going to make them more accountable, which is a good thing. It will make them focus their business on actually the valuable part.
+
+There wasn't ever a whole lot of technical or business value in plain domain validated certificates, especially since everything on the CA side is automated; it was just the customer that had to mainly do everything. I think once everything rolls out as HTTPS, because certificates become ubiquitous, I think that once everyone starts getting that green padlock, then maybe no one will get the green padlock except for the people who are paying for the extended validation certificates, which really does have business value, because it adds trust for those banks and those other institutions that need to earn their customer's trust.
+
+**Brian Ketelsen:** Well, didn't one of the web browsers just make that change recently? I wanna say maybe it was Chrome. There was an update I saw just a few weeks ago, that standard DV validated certificates were going to be shown gray and EV would be green. They'd still have the padlock, but I agree that the enhanced validation is where the money is going to be in the CA industry.
+
+**Matt Holt:** Yeah, that's the plan.
+
+**Erik St. Martin:** I think I have two concepts there. One is the free certificates. What percentage of that is taking away from paid certificates? This may be new people coming on that didn't want to go through the burden of setting up certificates or financial pain for them and wildcard certificates because they want more than one subdomain. So some of it I don't think it's taking business away, and I think the other side of it is -- I think your big guys are going to pay for extended validations and stuff. I think then it just becomes like a tier of how much validation did you go through to get your certificate and your banks and financial institutions and healthcare providers are going to pay excessive amounts of money for these extended validations. That's kind of my take on it.
+
+I don't think it's gonna put them out of business, but I don't think that they're gonna make the money that they currently are. And the other side of it is if TLS is almost free, maybe the domains cost more if they're wanting to keep the same income. It's kind of hard to tell.
+
+**Matt Holt:** Right, it will cause the CAs to have to be a little agile here to stay relevant. But again, extended validation is really valuable, you can't automate that either. So I say charge for that, and I think businesses will pay for that.
+
+**Brian Ketelsen:** As long as the consumers perceive value, they will.
+
+**Matt Holt:** Right.
+
+**Brian Ketelsen:** But as we educate more about what TLS is, what encryption is, what security is in a web browser, you know, maybe those extended enhanced validations matter less. It'd be interesting to see.
+
+**Matt Holt:** \[36:00\] It's possible. Yeah, it will be interesting to see what happens.
+
+**Erik St. Martin:** Now, before we move on to our news and interesting projects part of the show, I did wanna touch back on ACME for a second. We kind of talked about what the model is to manually validate your domain to get a certificate. Do you wanna walk us through how ACME does that?
+
+**Matt Holt:** Sure. So ACME relies again on the integrity of DNS and the spec presents three different challenges that you can solve to get a certificate to prove your ownership of domain name. So for example, Caddy will solve two of these challenges for you by default, just out of the box, it will just work. The third one is for special cases some people prefer. So the first two are the HTTP challenge and the TLS SNI challenge.
+
+The HTTP challenge is basically where you serve up a resource at an HTTP endpoint on your server. The ACME CA will do an authoritative DNS lookup, make a request to your server for that special resource, and if it can find it there then it proves you own the machine or that you own the domain name, and so you can get the certificate.
+
+Caddy does this one. It does the TLS SNI challenge as well, which is the same idea as the HTTP challenge, except that it performs a special TLS handshake. And if your server, which is the client, in this case, can complete that special handshake with the special server name in the SNI extension, then the ACME CA will validate for you and give you the certificate.
+
+So Caddy can do both of those for you by default, automatically. There are Go libraries that can do at least the HTTP challenge. That seems to the standard one. The problem though with these two is that it requires opening a port. The HTTP challenge requires Port 80 and the TLS SNI challenge requires port 443. Those are the hardcoded into the spec, you can't change it. If you wanna use a different port, you have to forward it. If you use TLS termination, you can't do the TLS SNI challenge obviously, or if you're behind a load balancer or other complicated infrastructure, the outside ACME server may not be able to reach your machine inside.
+
+Then there is the third challenge, which is the DNS challenge. And this one, you have to set a record in your zone file on your domain name for a special name on your host, that validates that you own the DNS, that you have access to that. And the ACME server will perform an authoritative lookup for that special record. - it's a text record - and if has the right value then it will issue a certificate. The nice thing here is that the ACME server doesn't need to communicate directly with your server, so you don't need to open any ports or anything.
+
+The downside is that you either have to do this manually or you have to give your ACME client credentials to your DNS provider, and they have to have to have an API to allow you to set records. Now unfortunately, lots of DNS providers have an API of some sort. Caddy, for example, ships with support for 10 DNS providers, especially the most common ones - CloudFlare, Namecheap, Digital Ocean etc. And you can specify these credentials in your environment variables, so Caddy can perform the DNS challenge as well as of 0.9.
+
+Those are the three challenge types, and if you're having a hard time with Let's Encrypt or with the ACME protocol in general, I'm willing to bet it's probably because your tooling has not quite arrived yet or it's not mature yet, or you're asking a lot from the Let's Encrypt servers, and that's when people run into rate limits. But honestly, this covers 95% to 99% of the use cases.
+
+**Erik St. Martin:** \[40:11\] So is there anything else that a listener should know about either Caddy or TLS or ACME before we move on? Is there anything else you'd like to add?
+
+**Matt Holt:** Encrypt - just use TLS. Do it right, do it well, look into the tools. We'll probably have links in the show notes for some of these TLS resources.
+
+**Erik St. Martin:** Yeah, we definitely will.
+
+**Matt Holt:** But if you think you don't need to encrypt, think again and think really hard about it.
+
+**Brian Ketelsen:** Yay! Retweet that, quote it.
+
+**Carlisia Thompson:** You mentioned that there are Go libraries or a library that will help people put TLS on their servers - did you mention what it was?
+
+**Matt Holt:** I didn't. I can do that, yeah. So the default of course is Go's built-in listen and serve TLS. The NET package also has a TLS listener that you can use. Now, that is if you have your certificates already; you just pass in the file name of certificates and it will load and use those. Now, your service may run for a year and then your certificate expires and you need to renew it and you have to reload your Go application.
+
+So if you wanna use ACME and automate all of this and forget about it, there is a library by Russ Cox, rsc/letsencrypt on GitHub, that I believe solves the HTTP challenge at least. And then there is a really cool library that I like, called ACME Wrapper; that's dkumor/acmewrapper on GitHub. That's really cool, because it's a lot like HTTP listen and serve, but with just one line of wrapping code to automatically manage your TLS features.
+
+Of course, Caddy does all of this too. All of its TLS features are available for your program to use, especially if you wanna integrate with Caddy. If your web service is configurable and you want to just serve over TLS without having to think about it, you can do that with Caddy, too. I'll be talking about this more at dotGo later this year, at least for few minutes.
+
+**Brian Ketelsen:** Good plug.
+
+**Erik St. Martin:** That's in November?
+
+**Matt Holt:** In October.
+
+**Erik St. Martin:** There's another one is November.
+
+**Matt Holt:** That's the Brazil one, right?
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** Yes, it is.
+
+**Carlisia Thompson:** But GothamGo is also in November …
+
+**Erik St. Martin:** That's right.
+
+**Carlisia Thompson:** November 18th.
+
+**Erik St. Martin:** And then Brazil one is early November, I believe.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** So again, perfect timing for interesting Go news, right? GopherCon Brazil...
+
+**Carlisia Thompson:** Exactly, I'm so excited about that. It's going to be the first GopherCon Brazil. The first GopherCon in the whole Latin America, so we're expecting it to be very, very exciting. It's gonna be on November 4th and 5th and Bill Kennedy is going to do a workshop on the 6th. Bill Kennedy is going to be a speaker. We also have Francesc as a speaker, and we have CFP, the CFP is open. We have submissions in English and in Portuguese. It's all on the website, the links are there. We - and when I say we, I'm helping out a little bit, so I feel very proud.
+
+**Erik St. Martin:** You're joining the list of insane people who have decided to organize or co-organize a conference?
+
+**Carlisia Thompson:** I don't know. I don't know how that happens. I'm trying not to …
+
+**Erik St. Martin:** We tried to warn you and you still did it.
+
+Carlisia Campos:… I know, I know.
+
+**Brian Ketelsen:** We did. I swear, we pulled you aside at GopherCon and said, "Don't do it, don't do it!"
+
+**Carlisia Thompson:** I know, I just can't help it. Everybody is so excited and doing such hard work. Sponsors are welcome. It's going to be a great way to reach awesome developers in Brazil. What else? We expect 300 people, we can even fit more than that, but we think 300 will be easy to get.
+
+\[44:00\] CFP is open, the registration is open, the sponsorships are cheap, cheap, cheap, cheap, cheap, because it's a small conference and the exchange rate is crazy. So take a look at the prospectus. Support is so appreciated and needed, especially for this first one. We really wanna set the standard for it to be a yearly event and a technical landmark in the tech community in Brazil.
+
+**Erik St. Martin:** And for anybody in the US wanting to travel internationally, I did the math on what it cost to go and it's actually not bad. The ticket itself -- what was it Carlisia, was it like $30 US?
+
+**Carlisia Thompson:** The ticket is like a meal price, it's very low. If you get in now it's $15, and if you get the day off, it will be $30.
+
+**Erik St. Martin:** And the hotel was I think $50 a night and then plus airfare. I mean, it's probably like $800 or something to fly from the US.
+
+**Carlisia Thompson:** And the location is an amazing island in Brazil in November summer time. I cannot stress that enough, it's gonna be beautiful.
+
+**Erik St. Martin:** Hey, somebody was asking for GopherCon Hawaii. This is probably as close, I mean …
+
+**Brian Ketelsen:** That's right, it sounds pretty awesome. Now I'm feeling like I need to go. I'm getting some FOMO.
+
+**Erik St. Martin:** I know. I told Carlisia that I wanna go, but I'm also gonna submit a talk to KubeCon so I need to see how that goes first, because I think I would literally fly out the last day of the conference to make it over there.
+
+**Carlisia Thompson:** Submit it to both. And I also wanted to say there will be simultaneous translations, so if you are an English speaker and you don't Portuguese, we are totally ready and expecting you.
+
+**Brian Ketelsen:** That's awesome.
+
+**Erik St. Martin:** So Go projects. I have one that I saw come through - I think I saw it on Twitter a few days ago, but it goes along with this whole security mindset that we're talking about this episode, which is Hewlett-Packard released a library called [`gas`](https://github.com/HewlettPackard/gas) - a command line tool, anyway - to statically analyze your code for common security or vulnerabilities, and some of which were actually validating the TLS ciphers and protocols within your project, and then there was some SQL injection vectors it looked for, and I think using some crypto primitives and stuff that were weaker. There is a whole slew of things, and it will actually be interesting now that this is here to see how many more security checks people add to the code.
+
+**Brian Ketelsen:** Yeah, I saw that. It looks really cool.
+
+**Erik St. Martin:** Did you take a look at that, Matt, at all?
+
+**Matt Holt:** Yeah, I saw that. I haven't used it yet. Laura looked at it in detail. With a few of the comments that were posted, I could understand how it might come up with some false positives, but that's probably better than false negatives.
+
+**Brian Ketelsen:** Any static analysis tool you're gonna end up with checks that might be false positive or don't apply. I mean, even Govet has some that don't really work all the time, but it's better to have them and know that you're ignoring them than not have them.
+
+**Matt Holt:** Right, yeah.
+
+**Erik St. Martin:** Yeah, so that's the only problem I think I find with false positives, is you accept them, and I would rather have them and not have them. But the difficulty comes in how they're addressed, because you ultimately want to ignore them, right? Because you don't wanna keep looking at the same thing and being like, "Oh yeah, I already determined that's not an issue."
+
+You also don't wanna ignore it, because that may actually become a real vulnerability. And I think I struggle with that, like how do you trim the fat on the warnings being thrown, without continuously ignoring what could become future problems?
+
+**Brian Ketelsen:** \[48:04\] That might be a show of its own, right there
+
+**Erik St. Martin:** So somebody write a library for that/ \[laughter\] Like, so many runs, or if the line changes, or surrounding lines change - I wanna know to look at it again.
+
+And then also along those lines, Stripe has a package called SafeSQL which also looks for some SQL injection vulnerabilities - which I haven't run, but I'm interested to see how that works from the static analysis side. So I see it's using tools like sqlmap and stuff from the client side, looking for SQL injection vulnerabilities that are exposed.
+
+**Brian Ketelsen:** So one that I saw that I thought was very exciting was sync.errgroup, which was released by the Go Team a week or two ago. That is a pretty slick package that kind of helps you do all of the right things when it comes to synchronization, concurrency and organizing a bunch of goroutines to do stuff, and lets you get the errors back out of them easily, it lets you cancel them nicely.
+
+So it's a thin shell around sync.WaitGroup and the context package, but it's nice that it's all done correctly and you can count on that to do the right things when you're doing concurrency. That's one of the things I think in Go that's awesome, their concurrency, but it's really easy to do it wrong. So that's a great package to use - sync.errgroup.
+
+**Erik St. Martin:** So this is kind of like an HTTP request coming in and you're kind of fanning out to do multiple units of work kind of concurrently, and possibly those fan out even further, and this helps kind of propagate the errors back up to the kind of originating Go routine as well as cancelling all other goroutines in the event that one of them errors out?
+
+**Brian Ketelsen:** Exactly. So you can use it for just that concept, the cancellation; you can use it to run lots of goroutines in parallel and keep them synchronized, or you can use it as a pipeline to run pull data between goroutines and still capture all of the errors in between them. So it's a neat package. I intend to use it.
+
+**Erik St. Martin:** I now intend to use it.
+
+**Carlisia Thompson:** So I was gonna say about the functest one. Did somebody keep that on purpose?
+
+**Erik St. Martin:** No. What's the functest one?
+
+**Matt Holt:** I put that in there. I thought that was pretty cool, too.
+
+**Carlisia Thompson:** Yeah, talk about it.
+
+**Matt Holt:** So it makes it easier -- well, less mundane to write table during test. This is by Brad Fitzpatrick. I haven't actually used it yet, but looking at it, my mouth is watering. I write table tests all the time.
+
+**Erik St. Martin:** Yes, so do I.
+
+**Carlisia Thompson:** I agree, my mouth is watering too, because I'd love table tests. This makes it a little bit easier, just cleaner. I'm wondering, so if it's from Brad, it's sanctioned, we can use it? Like, no worries about having that extra dependency?
+
+**Matt Holt:** Well, I mean I guess you weight the cost... But for little projects it seems like a really great thing at least.
+
+**Brian Ketelsen:** That's neat.
+
+**Carlisia Thompson:** It looks pretty neat.
+
+**Brian Ketelsen:** I haven't seen this yet, it's very sleek.
+
+**Erik St. Martin:** Now I'm gonna wanna play with this. Can we like pause the show for a few minutes so I can mess around with this?
+
+**Carlisia Thompson:** I'm lucky I have a bunch of new tests to write, so I'm gonna probably using it.
+
+**Brian Ketelsen:** So here's one I stumbled across on Twitter the other day, and I'm gonna butcher this poor guy's name, but github.com/matiasinsaurralde/go-dotnet. It is a Go wrapper for .NET that lets you do basically see Go-ish things using .NET assemblies. The first thing I thought was, you know, "Put down the crack pipe and walk away slowly", but I can see that there are definitely opportunities for the Go world to communicate with all of the amazing software that's in the .NET ecosystem, especially now that .NET is multiplatform. So a very interesting tool, I look forward to seeing that one mature.
+
+**Erik St. Martin:** \[52:23\] So this is so that you can call out to the .NET runtime from your Go code?
+
+**Brian Ketelsen:** Correct. And it may work the other direction. I haven't tested it, so I don't know, but it may work the other direction, too - calling to Go from .NET; I don't know.
+
+**Erik St. Martin:** It is interesting, though. I mean it's similar to kind of Cgo. We'd prefer not to write Cgo, but it does afford us the ability to operate with code that already exists and is well vetted and performant. So yeah, this will be interesting.
+
+**Brian Ketelsen:** So one thing that came to mind immediately for me is that it's relatively simple to write user interfaces in the .NET world. You can write some pretty decent GUI screens in .NET and having a Go wrapper to that might make it a little less painful to do a GUI application if you really needed one in the Go world, I don't know.
+
+**Matt Holt:** Brian, that's black magic right there.
+
+**Brian Ketelsen:** Yeah, I'm telling ya. I'm not willing to try it myself personally, but I would love it if somebody else did and let me know how that worked.
+
+**Matt Holt:** That would be an interesting proof of concept.
+
+**Erik St. Martin:** And just kind of like a cross-platform GUI library to have native interfaces, so if you could interface with .NET here to kind of do a native Windows interface and GTK or QT or something on the Linux side. I've never written a GUI application for Mac, is it Cocoa, is that what the library is underneath?
+
+**Matt Holt:** I think so, yeah.
+
+**Brian Ketelsen:** Yeah, you have to use interface builder, it's ugly.
+
+**Erik St. Martin:** I don't know what's under the covers there. I know I use Xcode to do so. What the library is underneath, I have no clue. And then outside of projects and news, Carlisia is now a convert to Vim, right?
+
+**Brian Ketelsen:** This is a big deal.
+
+**Erik St. Martin:** It is.
+
+**Carlisia Thompson:** So let me clarify. I have been using Vim for the last few years and I've used just straight up Vim for a few months, but then I went back to an IDE and used Vim inside an IDE, and that was Atom. And I broke up with Atom last night - and that's not Adam from the Changelog, it's Atom \[laughs\]. I just cannot hear the difference. So the editor Atom - him and I, last night, we split.
+
+**Erik St. Martin:** Not the robot from Real Steel?
+
+**Carlisia Thompson:** Also not that. \[laughter\] So basically, last night I broke up my Vim... I already was running Jessie's dot-vimrc.
+
+**Brian Ketelsen:** Jessie Frazelle?
+
+**Carlisia Thompson:** Yes, I was running her dot-vimrc file and I went through Fatih's tutorial notes. He gave a tutorial at GopherCon. I was not there, but he wrote it out, it's all spelled out, it's beautiful. So I didn't even finish the whole thing, I just skipped around for the things I wanted the most and I'm gonna go back and do the rest.
+
+So basically, he tells you exactly what to do. Jessie already had a bunch of the shortcuts that he was suggesting to do, so I was like, "Okay, cool, I'm just cruising through this", and now I've got vim-go going, I'm not going to go back to an IDE, and I'm very happy. And if you are interested, I suggest you take the jump into it, because it's very easy, relatively; if you know what things do, you just copy and paste stuff and done.
+
+**Erik St. Martin:** \[56:13\] I'd actually like to see those notes, because I feel I've been using Vim for entirely too long. I'm kind of like stuck in my ways and I feel like maybe I'm antiquated. I should look at Vim with fresh eyes again and change what plugins and things I use.
+
+**Carlisia Thompson:** You definitely should. I always do that, every once in a while I go back and look. And that reminds me of another good point, that he's always releasing things. He's always batch releasing a bunch of Go features. I've talked to him this morning, and basically this is the rundown. He has a changelog file on the repo and there he will list things that will be released. And as long as your package is refreshed to whatever the latest master wrench, that is the released version.
+
+If you check the repo, you see that something new has been released, you refresh your master and then you run the Go install binary, because some of the stuff he does is related to Go tools, and some of the stuff is related to Vim. So you just update all of those things and you've got fresh new shiny features.
+
+**Brian Ketelsen:** Freshies.
+
+**Carlisia Thompson:** And I also discovered that the right place to go talk about Vim-go is the Vim channel on GopherSlack.
+
+**Brian Ketelsen:** Awesome, welcome to the fold.
+
+**Carlisia Thompson:** \[laughs\] Thank you.
+
+**Erik St. Martin:** You can't leave now, otherwise Brian and I are gonna be upset.
+
+**Carlisia Thompson:** No, it's pretty awesome. And I like it because everything is there, everything is released as one package, so there is no conflict. Because for me, I'm gonna work today and I can't have surprises, I can't update my IDE and have, "Oh, this thing is now conflicting and I don't have my shiny feature that I rely on so much." I can't have that, and that kept happening with Atom.
+
+So with vim, it's gonna be consistent. The way Vim-go is released is as a unit, so that doesn't happen. And now the advantage is I'm now working with Vagrant box on my machine, I can just upload that there and there I have my Vim, my IDEs, it's beautiful...
+
+**Brian Ketelsen:** Happiness.
+
+**Carlisia Thompson:** Happiness.
+
+**Erik St. Martin:** See, now we have our free software Friday, but I feel we've all given Vim and Vim-go love. Like does that count?
+
+**Brian Ketelsen:** It counts as some, for sure.
+
+**Erik St. Martin:** I think we should still list some.
+
+**Brian Ketelsen:** Alright, so if you're not familiar with our Free Software Friday plan, it's just our way of taking a moment to say thanks to all of the people who released software packages in the open source world that we use, that we love. They don't have to be Go-related at all; not often are they all Go.
+
+Today, I'm choosing Python, which is a language that I never personally use, but it powers two-thirds of everything I do. I don't know how many times I look up at the terminal window at the title and see that it's actually Python behind Neovim or its Python behind some other thing that's running, like Supervisord. So thank you to the Python team. Python is ubiquitous, it's out there everywhere, and even though I don't use it intrinsically, I use it a lot. So thanks, Python team.
+
+**Brian Ketelsen:** How about you Carlisia?
+
+**Carlisia Thompson:** So I wanted to talk about one thing that I can't believe I haven't mentioned before, which is Exercism. It's double good, because it's open source, of course, and you can work on it if you're looking for an open source project to practice or help out. Also, you can use it to learn Go or get better at Go. And I also found out that there are a bunch of issues labeled "good first patch."
+
+\[01:00:03.07\] So for people who are looking to contribute to open source doing Go and they don't have experience or they're shy or they want a beginner project, this is perfect. And you'll also be helping, you know, this project which also is kind of meta because it teaches people. You're trying to learn and you're helping people teach Go, and of course other languages as well, that's why Exercism is extra super good.
+
+**Brian Ketelsen:** And then how about you, Matt?
+
+**Matt Holt:** Yeah, I have been really happy -- it's a Go project with a quick implementation in Go by Lucas Clemente. I don't know, I'm a huge fan of modern web technologies, and this is the first and only working QUIC implementation I've seen in Go. QUIC is a protocol that Google is experimenting with that is built on UDP and offers faster HTTP as communication basically, and with some other benefits.
+
+One of my favorites is if you change networks - let's say you're downloading something on your phone and then you switch from WiFi to cellular, the download will continue without interruption. Even though you have a new IP address and you're on a totally separate network, it's because UDP doesn't have a connection to break. And it still has reliable transport and stream multiplexing and security. So I'm really looking forward to where QUIC goes with QUIC Go. \[laughter\] Did you see what I did there?
+
+**Erik St. Martin:** So that actually kind of reminds me of a project that I used -- I don't even know how long ago this was. I think it still exists, but it was called Mosh, which was mobile shell.
+
+**Matt Holt:** Oh yeah, I've seen that.
+
+**Erik St. Martin:** Yeah, I think it came out of MIT and it used kind of the same concept of using UDP; that way if you have lag or you close your laptop and move, you could stay connected.
+
+**Brian Ketelsen:** I use Mosh, every day, Erik. It definitely still exists and it's awesome.
+
+**Erik St. Martin:** Oh yeah, look at this. It doesn't look like it has a new release recently, but still, that's awesome. I'm gonna drop a link in the channel too, because it was pretty cool. I'm gonna have to use that again.
+
+**Brian Ketelsen:** Yeah, Mosh is great. Thumbs up.
+
+**Erik St. Martin:** So you're actually still using it?
+
+**Brian Ketelsen:** Yeah, I keep a Mosh session open to my Linux machine from my Mac and it doesn't matter whether I close the lid, whether it suspends, hibernates or whatever. It's just always there.
+
+**Erik St. Martin:** So we get extra projects this week on our shout out. So for me, I wanna actually thank Wireshark, because in the past couple of days I've had to be dealing with it quite a bit. And I guess also a huge shout out to TCP Dump too, because Wireshark uses libpcap under the covers, but so nice to be able to just follow TCP strings and diagnose network protocol issues. In this case, there was actually unpegged streams, but still... Any network connectivity, Wireshark is awesome.
+
+I'll have to shoot out some links and stuff, but there's actually a lot of nice kind of custom configurations and filters and things like that that you can set up to make it more usable for diagnosing specific things. I think I even saw a GRPC one a while back, too. You can kind of hand it your certificates to be able to read the connections as it passes through.
+
+**Brian Ketelsen:** So if you spend a lot of time in Wireshark, can you actually see the matrix? \[laughter\]
+
+**Carlisia Thompson:** If you squint. \[laughter\]
+
+**Erik St. Martin:** \[01:03:55.18\] I use Wireshark enough to be familiar with it; I use Wireshark not enough for me to completely lose my mind and memorize all the filters and things like that. But I imagine a lot of people do spend a lot of time in there, especially if you're reverse engineering network protocols.
+
+**Carlisia Thompson:** So I wanted to ask you, because I've looked at Wireshark before, it's definitely a tool that I need to master. If you have links to extra good tutorials... I've gone through the manual, it's always kind of dense. If so, drop those links there, please.
+
+**Erik St. Martin:** Actually, there's two books I used to have on my bookshelf, and I actually lent them to a friend a couple of months ago. I'll send to you a link in the show notes. One of which is actually like walking through particularly troubleshooting scenarios. It's almost like example uses, rather than looking at documentation.
+
+It's like, "Oh, well if you were trying to discover X, here's what you do", and it itself came with some nice configurations out of the box too, which might be nice for me to look through. I'll go steal the book back so that I can look through some of those configuration things that I used to like. Because I don't have any of that stuff, I didn't commit it to like my DOT files. But yeah, I'll show you some good tutorials or books and stuff like that for Wireshark usage.
+
+And TCP Dump is good to use too, because you won't always have GUI access to stuff, so you can use TCP Dump, you know, on the server from a container and things like that, and kind of poke around and filter and look for things going on. Wireshark also will read the TCP Dump logs too, so you can kind of run TCP Dump elsewhere and transfer over your pcap and look at it through Wireshark.
+
+**Carlisia Thompson:** Awesome, awesome. Thank you.
+
+**Erik St. Martin:** So with that, I think that we are about out of time.
+
+**Brian Ketelsen:** I think this show wins the award for the most protocols discussed. I think we covered all of them.
+
+**Erik St. Martin:** Right.
+
+**Brian Ketelsen:** Or at least nearly. There will be a test.
+
+**Erik St. Martin:** I hope not.
+
+**Carlisia Thompson:** We should do that, we should have a quiz.
+
+**Erik St. Martin:** We should not have a quiz.
+
+**Brian Ketelsen:** The only person that's gonna pass is Scott Mansfield. I think we should just give him a star now and move on.
+
+**Erik St. Martin:** \[laughs\] No commentary. I'm actually surprised. He must not be listening live anymore.
+
+**Brian Ketelsen:** That's too bad.
+
+**Carlisia Thompson:** He gave up on us.
+
+**Erik St. Martin:** So I guess unfortunately, it is time to close out the show for this week. I definitely wanna thank everybody who is on the panel here today, Brian and Carlisia and especially Matt for coming on and talking with us about half of the protocols that we discussed today, and Caddy, which is a fantastic project. If you haven't used it yet, definitely go download it and give it a try.
+
+I definitely thank the listeners, those listening live and those who will be listening live. We've dropped a few more episodes, so everybody can catch up and hopefully here in the next couple of weeks we will be -- or even days, depending on how fast we do stuff, we'll get as close to real time as possible, and then we don't have to be trolled by Francesc anymore. \[laughs\]
+
+If you've not subscribed already, go to GoTime.fm. We have a newsletter that we'll be starting there, so you can go ahead and sign up. We are on iTunes and Android. The best way to get us is @GoTimeFM on Twitter or github.com/GoTimeFM/ping if you have ideas and suggestions for the show, or just updates to things that might go on our show notes, things that we got incorrect or additional things that might help people.
+
+With that, thanks everybody and goodbye.
+
+**Brian Ketelsen:** Goodbye. Thanks, Matt.
+
+**Matt Holt:** Goodbye, yeah.
+
+**Carlisia Thompson:** Thank you. Thank you, Matt, and goodbye everybody.
+
+**Matt Holt:** Goodbye.

Monorepos, Mentoring, Testing_transcript.txt

@@ -0,0 +1,465 @@
+**Erik St. Martin:** We are back for another episode of Go Time. This is episode number 17. Today on the show we have myself, Erik St. Martin, Brian Ketelsen is also here...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** And Carlisia Campos...
+
+**Carlisia Thompson:** Hi!
+
+**Erik St. Martin:** And today as our special guest, the man who needs very little introduction - everybody knows him from both the Go and Ruby world - Bryan Lyles.
+
+**Bryan Liles:** Hi, how are you doing?
+
+**Erik St. Martin:** So today we're gonna talk about monorepos, mentoring, movement building and anywhere this conversation goes, because you've been around the tech scene, in the public eye for quite some time and you have many interesting things that we can talk about -- wherever the conversation takes us. Do you wanna tell the audience a little bit about yourself, for those who may not be familiar with your work?
+
+**Bryan Liles:** Yeah. I'm Bryan, and who am I? Well, I actually have the great pleasure of being able to say that I've been in tech for 20 years. I've only had tech jobs, mostly in the cloud industry or what we call the cloud industry. I actually started off in ISP land, then moved to server land, then to security land, and now I'm in cloud land.
+
+Also, what I like to do is I like to make sure that tech is fun and inviting for everyone. I've worked in a lot of places and I've seen a lot of things, and I just like to go out and say that, "Hey, you know what? It doesn't really matter who you are, you can do this!" I worked with a lot of people, and throughout the years I've seen that anyone can have the aptitude to do what we do, and I just want to encourage everyone to do it.
+
+**Erik St. Martin:** It's interesting that you say that; I was actually just having a conversation with a friend that's town-visiting, and he drives truck and he's been interested in tech, but he feels like he's not cut out for it, like he just doesn't have the natural ability to do that. We actually probably had a half an hour conversation that's similar to that; that's it's really about time investment and interest than it is sheer ability. That we kind of pedestal people and we think that only geniuses are capable, but if you put in the time -- anything, learning to play the guitar... You're not going to read one book and then be a master.
+
+**Bryan Liles:** No, no. And really what it comes down to is how you learn. I had a little bit of a boost... My father was in the military and he got to see things that normal people wouldn't see. One day, he came home with computer books. They were C program language; I was 11 or 12. He said, "You should learn this."
+
+I put a lot of time into it. My first language was C, my second language was 6502 Assembler, and my third 8080 Assembler. And that's weird. Who would ever do that? But what I see is that it's all about context. What I'm doing right now is thinking of ways to teach people machine learning just as a beginner thing. One of the things you need to learn for machine learning is linear algebra and graphs. Everybody hates graphs and matrices and thinks they're really hard, but you know what? Whenever you learned that, in high-school or in college, what they probably didn't do was give you context. If you understood the problem that you were solving in a context of words that you could understand, anyone can learn this. It's the same with computer programming.
+
+**Erik St. Martin:** \[03:47\] I think though too that a little bit of "There's so much to know..." When you're first coming into the field, you feel like because you can't grasp all of those things, that you're not cut out to do it. I think over time you start to embrace the unknown. As developers, we're presented with new and challenging problems every day. Many times we start the project and we're not even sure how we're gonna do it yet.
+
+People who are trying to get into the field and break into it, they start trying to do something and they feel that because they can't figure it out, that they're just not cut out for it, and they wait for that moment that they know everything they think they need to know to do the job.
+
+**Bryan Liles:** Well, I look at it like Double Dutch. Have you ever double dutched before? It's really hard, actually, if you look at it. There's two ropes, they're moving in two different directions, and you always see the person who's getting ready to go next; they're always rocking back and forth, rocking back and forth. And then they just jump in. That's generally how I approach almost everything.
+
+I solved problems that I've heard afterwards from PhD statisticians "You shouldn't have been able to do that without that knowledge." What I've learned from that is you have to be pretty naive in the way that you think about yourself. There's nothing you can't do. I live that life. I could go out and I could beat Usain Bolts, but until I get on the track and actually beat him, in my mind I'm actually winning.
+
+It doesn't work for everything, but for computer things, it allows you to at least get the confidence to go out and figure out what you need to do, rather than be overwhelmed with all the complexities.
+
+**Brian Ketelsen:** I read a book two years ago called Guitar Zero, about a PhD guy who had zero musical talent and just no aptitude for music, couldn't tap his foot to a beat. He took a sabbatical and decided as a learning project to write a paper about whether it was possible for someone with absolutely no musical talent to become a good musician, and it turned out that really it is just a matter of learning, and knowing what to learn is a key of that.
+
+I think in the computer world, when you start off with nothing and you say, "I'm gonna become a programmer" that's great, because it's easy to make a Hello World app, but we have so many peripheral things that we have to know and learn to make real-world applications. I think that might be the hard part for people really starting off. So you can make Hello World and you can compile, but you don't know anything about talking to data, or databases, APIs... There is a really steep learning curve in terms of getting actual work done, versus just getting started. I think that's a frustrating point.
+
+**Bryan Liles:** I agree with that. One of the problems that a lot of people who use methods to teach programming is we use programming as a means to an end, and that's actually not it. Programming is a tool - it doesn't matter what language it is. What you are trying to do is solve something. Right now, this is a project; I'm writing a Slack bot. I don't know much... Well, actually now I know more about Slack Box, but I know what a bot does, and I know what the inputs are, and I know what I want it to do on the output. Once you understand that, then you can just peel back one layer and figure out, "Well, how do I print something in an output?"
+
+What we try to do whenever... I've seen some of the curriculums from these boot camps and other programs where they're just teaching, "This is a variable. In a web browser, this is how you make this happen." Even if you go down to Go, we can say "This is a goroutine", but we don't ever tell people the mindset or what it feels like to be happy whenever they get it right. They don't even know how close they are to getting it right, so they can't make those bridges themselves.
+
+And do you notice what I'm saying? It's all the same things as just teaching, but really what I'm trying to do is paint the happy path for everyone, so they can understand what it feels like to succeed. People want to succeed, so they'll fight harder to get there.
+
+**Erik St. Martin:** \[07:53\] I think there's a lot of stigma in it too, because we're constantly comparing ourselves to the rest of the world. A highly curated list of the best that the world has to offer, so it's easy to feel like you'll never get there, but there's also kind of being comfortable in your own skin and accepting that. There's plenty of people way smarter than me, but that's okay. I tell people what my number one skill is - being able to be thrown in the deep end and figure out how to swim. Being comfortable with learning and not knowing and exploring. Like you said, you start off on these projects you know nothing about.
+
+I often try to get into electronics projects. I know nothing about electrical engineering or electronics engineering, but I just kind of explore away, make mistakes and learn along the way and that's okay. Like you said, people don't know how to figure out what was a success; that they have acquired some knowledge. Even though they don't feel like they learned web development yet, they've learned something. That's a check mark on the list of that foundational knowledge that you need. Katrina Owen spoke to this at the GopherCon talk - to start drawing those connections between things.
+
+When you first get into the field, there's just too much to know.
+
+**Bryan Liles:** Yeah. And you said that you don't have to measure yourself against anyone else - I have a problem with that. I measure myself against myself. When I'm doing okay, I'm exactly one Bryan; then when I'm doing a little bit less, I'm maybe nine-tenths of a Bryan. Hopefully, the measure of Bryan actually increases as time goes on. What I don't ever do is compare myself to anyone else. The reason why is no one else grew up like I did. We didn't grow up poor, but we didn't grow up rich. I didn't get to go to all these good colleges. My parents were like, "You're gonna pay for it if you're gonna go. And by the way, you're gonna go."
+
+I had a lot of distractions, but what I learned to do is realize, "Who's gonna get you there? Bryan's gonna get you there, not that person I'm comparing myself to." So I just stopped comparing myself to other people. And it helps your ego whenever there is Jeff Deans out there; when I read his papers... You know what? Jeff Dean and Bryan Lyles are two different bases; we just don't compare each other.
+
+**Brian Ketelsen:** I really like this conversation, because talking about Bryans in the third person just makes me feel strange. \[laughter\]
+
+**Erik St. Martin:** That's a conversation that I can't have. I can't talk about Bryans in the third person.
+
+**Brian Ketelsen:** ...it just makes me wonder if I'm half of a Bryan or two-thirds of a Bryan today, and which Bryan am I half of.
+
+**Bryan Liles:** Well, you know, we've discussed this before. There is definitely the superiority in the concept that my name has a Y versus an I, so you know where you stand.
+
+**Brian Ketelsen:** I do. I'm at most 95% of a Bryan.
+
+**Bryan Liles:** But, like I said, don't compare yourself to me, compare yourself to Brian K.
+
+**Erik St. Martin:** I think that that's probably a good takeaway too, to constantly be evolving yourself and not look to other people. Like you said, you're comparing yourself to your perception of somebody else. Because they're smarter than you in one area, you assume they're smarter than you in all areas, and that's impossible. Everybody's gonna have specialties. It's all about where you put your time and energy and how you evolve as a person, and in your career. You're gonna be a natural at some things.
+
+I can do server-based stuff pretty well, distributed systems-type stuff. But you put me working on a game engine, I'm gonna be clueless.
+
+**Bryan Liles:** It's all triangles, don't worry about it.
+
+**Erik St. Martin:** It's all triangles. \[laughter\]
+
+**Brian Ketelsen:** Polygons everywhere.
+
+**Erik St. Martin:** Bringing back Katrina Owen's talk, because I think it ties in a lot to this, how to teach and how to give people small wins - what was your take on that talk?
+
+**Bryan Liles:** \[11:59\] Well, my number one take is, first of all, I adore Katrina. I've met her many times throughout the years and I love to see her speak. The second thing that I took from that was I liked the visualizations, I loved her slides.
+
+**Brian Ketelsen:** Oh yeah, weren't they beautiful?
+
+**Bryan Liles:** It was one of those talks where, "Well, someone put some thought into that." I speak a lot, and I never use pictures in my slides, so every time I find that someone uses a lot of pictures and they use them well... I was pretty impressed.
+
+The third things is that I find that we... This is a point that I think she brought up - who owns tech? Who is tech? What is tech? We need to work on making tech more relatable to certain people. Some people want to just run up the hill. They're those free rock climbers who don't need any type of bracing or anything like that. But other people - I don't know, maybe my children will actually want to take the stairs... Or actually, the upwardly-facing escalator ramp, where it's slow, but it still gets you to the same place. What I've been meaning to do is figure out how to break those barriers down, and I'll be the first person to let you know I don't know how to do that. But what I do know is that we do have a need for it. And I'm not scared to take a step back sometimes and say that my way is not the best way, and that we should be evaluating more, because yeah, I am a person of color, I'm the representative person, a minority, or whatever else you wanna call me - a brown developer - my path into this was weird. I don't meet a lot of people who look like me, but that's not to say that another black woman, another Latina or anything else will have the same path.
+
+We need to work on breaking these down to make them more relatable, or these concepts down, to make them more relatable to more people. Like I said, this is not easy. It's extremely hard, and we're not gonna find answers this generation. It's gonna be a generation or two down the way, but we need to make it better.
+
+**Carlisia Thompson:** I'm listening to you talk about how you don't compare yourself to other people. I totally compare myself to other people.
+
+**Erik St. Martin:** I do, too.
+
+**Carlisia Thompson:** ...and I think it's useful for me to do so. I hope it's in a healthy kind of way that I do that. There is totally the unhealthy aspect to it, that I'm thinking "I'm not as good as that person and I should be." But I also try to make it in such a way that I am looking at the happy path for myself, just like Bryan Lyles was saying, what he's trying to teach - he's trying to show the happy path, what's possible for the person to achieve. I think that's awesome, it's very productive to try to teach people that way.
+
+Because, to make a side note, it is hard to do something until you see what's possible; then you just go for it. At least for me it happens like that. But as far as comparing myself to other people, when I look at other engineers and I see, "Wow, they have ten years of experience, or they have five experience and look how much they accomplished." And I look at the projects they worked on and I'm just in awe. I start thinking, "Wow, I should aim for that as well, because that looks interesting to me. I'd love to know those things. How do I get there?"
+
+For example, I've just covered Jack Lindamood. He spoke at GopherCon as well. He was not on my radar until recently, and I'm totally in awe of the things that he has done; how well he writes his blog about Go is amazing. And I'm thinking, "How did he get to work on those projects? How did he get there?" Because I didn't run into those opportunities. Do I have to carve these opportunities out? How do I do it? Do I need to get a mentor? Do I need somebody to pull me in? How do people get to that point?
+
+\[16:06\] I'm trying to find a way... For example, I look at people who are at a certain level, for example Ines Sombra (she works at Fastly as well). I am totally an admirer of hers. She speaks at conferences, she runs the Papers We Love, she reads papers... So I'm trying to emulate the things that she does, to try to become that type of professional. So I'm always trying to emulate people whom I admire, people who work on things that I find interesting, like "Okay, how do I get my chance to work with projects that these people are working with because they sound so interesting to me?" And I don't know how, other than just trying to emulate what they do.
+
+**Bryan Liles:** I have a thought on that, and specifically with Ines. I enjoy listening to Ines speak. If you ever get a chance to hear her speak in person, it's amazing how fast she speaks and how information-dense it is. It's actually quite an event. But one thing that I would ask Ines is not really how she does what she does, but why? Ask her the feelings that she gets whenever she does Papers We Love, or talks about all the crazy computer sciency stuff.
+
+Because we look at her success and how far she's come, but we don't understand her impetus for doing it, and that's what we need to understand. I tell people all the time, it's not the How, it's the Why. Why do we do what we do?
+
+Once you understand why she does what she does, or why someone else does what they do, then you can understand how they're doing this and how they're getting the success.
+
+**Carlisia Thompson:** Yes. Just to clarify, because I don't want to leave people with the wrong impression. I run into a lot of things, I run into a lot of people, and a lot of things don't resonate with me. For example, when I started getting to Papers We Love, we'd just started a chapter here in San Diego - that resonates with me. I want to have that kind of knowledge, and that medium appeals to me. So I know how I feel when I run into these things.
+
+When I look at somebody's work and that work resonates with me, I know how I feel and that's all I need to know. Maybe asking them how they feel would help me a little, too. Maybe they feel awful about it; that would dissuade me... But the point is there are things that we could be working on, that resonate with me, and then I do want to note the How. I want to go to the next step - how do I get involved with that? How do I get enough knowledge so that if that project's going on in my company I can be one of the people working on it because I have the skills?
+
+**Erik St. Martin:** There's two points to that, that I'd like to point out. You said how this person was relatively unknown and within five years became this... I think we see that with businesses too; it's the myth of overnight success. You see people and it looks like they were completely off the map, and then in five years they became somebody prominent, but you don't see the ten years before that. For instance, before I got a really good paying tech job, I had been programming for fun little stuff on the side for something like five years before I even had a programming job. So there's all this stuff that leads into it, and we see what happens afterwards. We don't see everything that happens before the spotlight is pointed in that direction.
+
+To the other point, I'd like to start seeing people share their stories. How did you get into tech? Because I think that humanizes people and you start to see that it was a long, hard road to travel; it wasn't just this immaculate thing where they just in two years became some prominent engineers. There was a long line of things before that, that we just didn't see.
+
+\[20:06\] And even backgrounds - as Bryan Lyles pointed out - the way you grew up... I didn't grow up with a lot of money; I dropped out of high-school, I went back for a GED, completely self-taught... So, like Bryan said, everybody has their own path, and there are many paths that lead to the same place. Just because yours is different doesn't mean it's wrong. I think the passion and the desire to do well and the interest in the topics that you're working on is what really gets people successful. Because you can get lost in your work. You can go home after whatever your day job currently is, and you can lose five hours into it just because you're drawn to it.
+
+**Carlisia Thompson:** Yeah, I like that idea a lot. Cassandra Gil from GoBridge had the idea of a blog post series where people will write blog posts anonymously, telling about their story. We are going to be seeking people who will have what we would call a different story from the mainstream. And I think they're probably the mainstream more than what we think is mainstream, because there is so much diversity, and I don't think we tend to talk about it.
+
+**Erik St. Martin:** I love the Why question, too. I think that's a very good point, Bryan, that a Why is really what matters. Because it's always probably gonna end in passion. If somebody did something that really became a hit, it's probably because they were just really driven, for whatever reason; the technology interests them, the problem that it was solving interests them, things of that nature. I think that's what it's gonna boil down to.
+
+**Brian Ketelsen:** Yeah, you almost never see technology succeed just on the basis of being cool technology. That's, at least in my experience - in fact, that might even be the kiss of death for a technology. Just because it's amazing technology, if it isn't solving an interesting problem or causing you to think differently, then it's just great technology, but not necessarily something that could be successful.
+
+I think that same thought pattern goes with learning and programming. You could have a person who's a brilliant programmer; if they don't care about what they're doing, they're probably not gonna stay a programmer long.
+
+**Carlisia Thompson:** I always say this... When people ask how I got into programming, I always say you have to really love it, because if you don't love it, you're not going to last a long time. You have to love it because it's very rigorous and demanding. I think you have to have a certain aptitude to dig deep and take the next step, even though a lot of times it's not easy. You have to keep doing it, otherwise you don't get anywhere.
+
+**Erik St. Martin:** I think people need micro-successes too, to develop the love for it. Most people probably got into programming for one reason or another and then they did something, and that feeling that "I've built this" came out of it. This is a similar thing to a contractor. Long, hard working days, you bang your thumb with the hammer and all that stuff, but the exciting part is when you step back and you look at that finished product, and you're like, "I built that..." People need those wins.
+
+Then I think it takes a different frame of mind, but I don't think that you have to have it to begin with. You can shift it.
+
+\[23:43\] As an example, I had a friend over one day and we have these crazy RC cars, and you break them more than you drive them. So we're sitting there working on them, and he's getting really frustrated with his. He's like, "I don't know how you do this. How you can sit there and take it apart, put it back together and then keep tweaking and not get frustrated." It's like, I just look at it differently. Rather than feeling like the act of doing this is preventing me from what I want to do, which is driving the thing, I enjoy the process. I like sitting around, working on stuff and figuring out problems, having a beer, chatting with a friend while we're working on it...
+
+I think that you can shift your mindset too, to where something not working doesn't cause you anxiety but it causes excitement, where it's a puzzle to solve. "I'm gonna figure this out." Once you shift that mindset, things become much easier.
+
+**Bryan Liles:** That's a pretty important point there. I use this a lot in my life. I'll give you a good example of something that I've done more times over the years than I can actually count. The impression is that Bryan is some super programmer... And yeah, I do know a lot of languages - I think I'm up to about 20 now - but the reason why is because it's never because of the languages; it's always because I wanted to learn something.
+
+The first GopherCon that I went to, I didn't know Go. But I saw all these nice people, and I knew Brian from before, and I knew of a couple people from before, and I'm like "Well, this is kind of cool. If these kinds of people wanna come to this kind of conference, I think that I should learn their language."
+
+So what did I do? I said, well, I work at DigitalOcean. What can I do at DigitalOcean with Go? Because we weren't actually using Go. There was maybe one tiny Go project at that time. So I said, "Well, I wanna benchmark something with our cloud." I said, "Well, can I write an API in Go? Can I write this code in Go?" Because I didn't wanna write it in Java or Ruby or anything like that. No, it wasn't there. That was my first project right there. My first project was writing an API client for DigitalOcean in Go. Was it good? No, it was horrible. But does it still exist? Yes, it still exists. But it has also allowed me to move on.
+
+I've been able to take my little win from writing this a few hundred-line thing in Go, to writing now the official API client for DigitalOcean in Go. Where did that come from? Well, I actually have the ability -- I boot up hundreds of virtual machines some days, and I got tired of writing software to do it, so I said, "I wanna do this for command line, because I love command lines."
+
+So I just started writing it. In my spare time, when I was on the airplane, when I was at a conference speaking, when I was not doing something else. That evolved into our official command line client. And that's the thing you see. You see the success of the software that I wrote, but you didn't see that this came from an idea that I had two years ago, and I just slowly made it happen. I think that's what people need to realize. We don't need big wins.
+
+I have this whole theory about being rich, and I can tell you why you don't wanna be rich. You just wanna pay all your bills and actually have one more dollar than you need to spend every month. I'm talking about after you pay yourself, after you save for vacation, after you pay for retirement, after you pay all your bills. Because guess what? If you have ten more, what are you gonna do with that money? If you're just gonna sit on it, it's not doing society any better; you might as well just give it away.
+
+So what I'm saying here is that we just should build up slowly. We build up our savings slowly, we build up our knowledge slowly, we build up our personalities and our brand slowly. All these things that I've been doing, I've been doing almost the same things since 1994, and it took ten years for people to realize who I was. Now, ten years later, people are seeing me in multiple language communities and they're saying, "How did Bryan do this? Where did his ideas come from?" I just had a lot, and I played with them forever.
+
+**Erik St. Martin:** \[27:44\] Yeah, that's a valid point too, financially and knowledge-wise to slow down and enjoy the journey. That's one thing that I know myself I've been trying to get out of. I raced and raced and raced... I wanted to reach what I felt was a level of success, and when you put yourself into that mindset, you never get there. You will always keep drawing the finish line out further and further. In the recent years, I've started to embrace that, but I'm working all the time. I'm missing out on family time, and that's the stuff that matters. You can't get that back. In the past couple of years I've been kind of going backwards.
+
+I don't want or need as much money; I wanna slow down, I wanna be happy day to day, spend time with my family. But the knowledge thing, it kills you; you constantly feel like you don't know enough, so you learn... And you don't take a step at the end of the year and realize how far you've grown yourself, because you've drawn that line out further.
+
+**Brian Ketelsen:** Maybe that's the hard part for beginners to understand, the non-linear curve of measuring your success. I agree with almost everything we've said. Everything starts really small, just having a tiny little Go API app that works against the DigitalOcean servers, turns into DigitalOcean's DO control, which I've seen countless people point out as one of the best examples of how to do an HTTP API client in Go.
+
+**Bryan Liles:** Yaay!!
+
+**Brian Ketelsen:** Yeah! More than once I've heard people say, "If you're looking for a way to do an API client, go copy this code." That didn't happen because you sat down one day and wrote the best code in the world; it happened because you did uglier stuff earlier and learned from it each time. There's a progression for all of us that we forget. It's easy to forget that we were all in that spot some time ago, and we're where we are today because of all of the things that we wrote before. As a beginner, you don't have that experience. You don't understand that these small steps each build upon each other and allow you to become better and better, because you don't understand the scope of what you don't know.
+
+**Bryan Liles:** Yeah. If I were to write a book, this is what I would write a book about. The neat thing is that what I'm talking about translates well to programming, specifically Go, but it also translates to everywhere else in life. If you want to have a religion of Bryan, that's what it is. It's not my old religion, where I was characterized as someone who had a potty mouth, but this is the real religion of Bryan.
+
+Actually, that's a great segue into something else that I wanted to talk about, where a lot of people know me from. About 8-9 years ago I did a talk about testing. I'm actually really interested in testing as a theory. I don't think that just having tests makes your code any better, but I do think that the act of testing and thinking about how your code works does make you a better developer, so I like testing.
+
+I had this talk that was a sidebar talk at this conference, and he said "You have ten minutes. Make it good." I said, "Alright." So I went back to my slides and I put an F-bomb on every other slide. And not because I have a particularly bad mouth - actually, I kind of think that I don't have a bad mouth - but what the point was is that if you see somebody on stage pointing at you, cursing like a sailor, you're going to listen to what they're saying.
+
+What I happened to be talking about was not politics or anything crazy like that, it was testing. I knew this was gonna resonate, and it still resonates 8-9 years in. When people come working with me now, they're like "I know of you because you did Test all the effin' time." And I'm like, "That's crazy! But do you realize what I did to you? I taught you something and you didn't even know it." And it's not about me talking about TDD or anything like that; what I did was I communicated the good passion that I felt about testing and I gave that to you as a gift. You took that gift and you want that feeling, too. So you went and found out, whether you liked it or you didn't like it.
+
+\[32:06\] I'm not telling you to do TDD all the time; I really don't care, it's not my code, you don't work for me. What I'm saying is that I want you to have those opinions, and I'm giving you the field to go build those opinions. I think that's been my method over these years, and that's what when you see these talks that I do, that's what I'm trying to do. I'm just trying to get you interested in something that you might not have known about.
+
+**Brian Ketelsen:** That's interesting. When I wrote my talk for abstractions I wasn't trying to convey information, I was trying to convey my feeling about the outcome of a particular technology. It's exactly what you just said. I didn't want people to learn about the subject that I talked about, I wanted people to understand the feeling that that subject gave me, because I think that was more important than the actual technology in my talk.
+
+**Bryan Liles:** Yes. You know, I've used that. Just recently I spoke of abstractions as well. I didn't go into it, but really what I was talking about during that whole entire talk was a finite state machine, but I wasn't using those words. I was just talking about it, about what it allowed me to do, what this code allowed me to do, and "I was able to do this and then I could easily do that." But to get those words out there and explain to somebody this concept without using those terms, that's what I find the big challenge is, and that's why I like to speak. I speak about bots. And it's not because I really care about chat bots - I kind of like them - but I like all the technology that goes into them. If you have a chat bot and it goes to more than one server and you have multiple websockets connecting, because you're using Slack, how do you manage that? Guess what! That's a distributed systems programming problem. But I don't talk about it that way; I talk about it as "I just have to have multiple binaries, and I need to orchestrate those over multiple machines, or maybe multiple data centers." That gets people excited, whenever you talk in a language they like.
+
+And I'm getting older, I don't like all the hip things anymore, but I will say that I do know developers, and when we learn to talk to developers in a language they can understand - and it could be sometimes really technical, from a paper - I can't read papers, they make me fall asleep - but also to a very light conference talk. What we're trying to do is make everybody engage so they can progress to the next goal. That's how I think about that.
+
+**Brian Ketelsen:** This is a good time for us to take a quick break and talk about our sponsor today, which is Backtrace.
+
+**Break:** \[34:39\]
+
+**Erik St. Martin:** Awesome. I actually remembered you from TAFT too, Bryan, when we met at GopherCon. How can you forget that video...?
+
+**Carlisia Thompson:** Same here.
+
+**Brian Ketelsen:** It's funny, because I didn't remember TAFT, I remembered Smartacus \[35:55\] I spent so much time reading Bryan's blog posts about testing...
+
+**Erik St. Martin:** That's true too, yeah...
+
+**Bryan Liles:** \[36:01\] Yeah, I used to blog. You know, this day Twitter killed the blog star... \[laughter\] I really would love to blog again, and I know a lot of people say that, but I'm just not in that mood anymore. But I love to share. I do love to share, it's one of my favorite things.
+
+**Erik St. Martin:** That's kind of why I like the podcast thing. The writing thing... I've never been a very good writer, and I struggle with organization and I feel like I revise it too many times, and then I just give up on finishing the post, but I like the freeform nature of podcasting, where you kind of just get to have conversations about stuff.
+
+**Brian Ketelsen:** It's a nice way to share all of my opinions without having people be able to comment on my blog either. \[laughter\]
+
+**Erik St. Martin:** They will comment on their blogs, though.
+
+**Brian Ketelsen:** That's right.
+
+**Erik St. Martin:** So you've been traveling a lot, Bryan, doing some talks at a number of conferences. You're doing LinuxCon, Velocity... I know you were at Abstractions...
+
+**Bryan Liles:** I did all of those... This year I think I spoke maybe 10 or 15 times, and then I have something coming up next week. I'll be in Buffalo at a conference called CodeDaze. They're allowing me to give a keynote, which means I won't talk about anything specific; and I will not. Then, there's always the big conference, Web Summit in Lisbon, Portugal this year. I'll be there in November.
+
+The reason I do this - and I've been thinking about this over the last minute - is years ago I heard something about the 10x developer. I don't know why it really grinds my gears and hurts my ears; I'm trying to be a 10x developer, and what I'm trying to do is be 10x - raise the group's productivity by 10x. Whether I'm a mentor, motivator or antagonizer - I can be antagonizer - it's really why I do all this stuff. I really just want the community, in whatever community I happen to be in, whether it's my home family community, my DigitalOcean work community, or the greater programming communities, dev-ops communities that I'm in - I would just like them to be better; that's really what it all comes down to. I want people to be the best that they can be.
+
+And then you know what? At the end of the day, give me credit for it; and then we all win.
+
+**Brian Ketelsen:** Amen! Preach it.
+
+**Erik St. Martin:** Yeah, the 10x thing isn't actually as crazy now as it was. I remember when everybody wanted a 10x developer... I feel like even 10x people are not 10x people, right? You're 10x people for three days a week, and then you're a X/2 person for the other two. It's impossible to sustain that level of energy. And I think it's highly based on what you're working on. If I'm presented with new and challenging problems, I'm an animal. You give me monotonous stuff, I'm just not nearly as productive because I'm not excited.
+
+**Brian Ketelsen:** Did you just call me a half-ass developer?
+
+**Erik St. Martin:** \[laughs\] Half X!
+
+**Brian Ketelsen:** Oh, half X. I misheard... \[laughter\]
+
+**Erik St. Martin:** This is a PG show, Brian.
+
+**Brian Ketelsen:** No, it doesn't have to be.
+
+**Bryan Liles:** I'm very PG.
+
+**Erik St. Martin:** I try to be... I think that comes with age. You start realizing that you don't sound professional or intelligent speaking those ways, and you only further other people talking that way. It's kind of contagious. You have people over and they're all swearing, so everybody else starts swearing.
+
+**Brian Ketelsen:** Well, there are just so many better ways to get a point across than swearing, although I do agree - I don't remember who made the blog post, it might have been DHH... Somebody said recently about the science behind swearing and how it does cause you to instantly pay attention to that particular topic, and I agree with that; I just don't think it's required most of the time. If you need that to bring attention to what you're saying, perhaps you should be saying more interesting things.
+
+**Bryan Liles:** \[40:15\] Well, that was the whole point of the "Test all the effin' time", because testing is boring inherently; no one wants to do it, especially not in Go. I could go back and forth about my perils of testing in Go, but I want people to do it and not feel that just because it's hard, to do it poorly or not at all.
+
+I think this is one of the things that the Ruby community got really well, is that, yeah, we had a whole bunch of testing frameworks, from RSpec to whatever else, but people thought about it. In Go, I think we dismissed it quite of quickly with the whole "no dependencies" movement, where we just didn't even think about, "Hey, Google is big, they have lots of engineers, lots of smart people, but guess what? They have not solved all the problems." AWS is still beating them in cloud, other people are still competitive in other places. Google doesn't have all the answers, so we need to go out and find those answers, because they can't even give us good dependency management, so why do you think they're gonna give us good testing management? And that's not a dig, that's just reality; I love you all.
+
+**Carlisia Thompson:** Are you saying the test package in the standard library is not good enough and that we should be using others?
+
+**Bryan Liles:** How about this - I will say that it is not always good enough. I can compare two things, I can use DeepEquals, I can write out all that stuff, or I could, on other projects, like I do in DO, control, CTL or whatever you want to call it - what I do is I use the Testify package, and I use their mocking package. Is it better? I don't know. It makes me move smoother sometimes, but then there's things I can't do with it.
+
+This is the fallacy of smart people - we like to think that whatever we think, as a smart person, is the smartest thing. But that's not true. It might be the smartest in this situation, but who can account for all situation? So I would rather say that, "Hey, you should try these things and find something that works for your team." We do have the sticklers, and then we have the people who say, "You know what? I'd rather be doing something else other than writing three-line test cases when I can just write one and move on.
+
+I'm never gonna say who's right and who's wrong. I'll say that we should be more pragmatic about it, and not fall into dogma.
+
+**Carlisia Thompson:** Yeah, I like this philosophy of being pragmatic. Maybe because the Go community is relatively still new, there is a lot of purism and you're never sure if you should veer off the beaten path... So it's good to hear that message too, from experienced people.
+
+**Bryan Liles:** It's religion. You know, I like the concept of religions and I'm not anti-religious, I'm just not very religious myself. But I do feel that once you get on the soap box and start saying that we need to do it this way or that way, it's like the difference between Christianity, Judaism and Islam. There are differences, but they're awful lot alike as well, and we need to work on celebrating our alike rather than your differences.
+
+**Carlisia Thompson:** That's a very good point. In the Ruby and Ruby on Rails community they did an excellent job in bringing developers into the testing mentality, and I wanted to ask you where does the Go community stand, as far as you can tell, on the testing philosophy? You already gave some hints, but in more practical terms, what do you see?
+
+**Bryan Liles:** \[43:45\] Well, I will tell you this - I can go to look at the github.com/stretchr/testify and I'm sure there's a lot of stars there. That alone says that there is a lot of things going on. But then you have the other integration-style testing things that are in Go. Yeah, they're a little bit weird - they're not quite Go... I'm thinking of Gomega.
+
+**Brian Ketelsen:** Yeah, Ginkgo and Gomega.
+
+**Bryan Liles:** Yes. It's a little weird, but guess what? It works. And then you have another one that's kind of like Gomega, but they have the cool little web page inversion of it...
+
+**Brian Ketelsen:** GoConvey.
+
+**Bryan Liles:** I'm thinking more of an integration-style testing... What I'm saying is don't dismiss those; understand the reason why they exist and why somebody will sit down and spend all that time writing them, before saying you don't need that. That's the problem that I have with just "You should do it this one way", because guess what? It doesn't work this one way whenever we don't have all the other things exactly the same.
+
+And you know what? Adding a test dependency on Testify or whatever else - is it a really big deal? Probably not. Not as a big deal as you actually making a big deal about using it. It's something that can happen.
+
+I hate to get lost between those kinds of differences, rather than "Hey, we're actually doing too many allocations" type things. When we get lost in the testing battle, we actually lose sight of what's important.
+
+**Brian Ketelsen:** It's funny, the Ruby community was so strong on testing; that was such a big message, such a big thing that came out of Ruby and Rails. And I didn't like testing in Ruby, and I didn't write tests in Ruby, and it wasn't until I came to Go where I actually learned to really enjoy testing. Now, I often do TDD, where previously I wouldn't even have considered that. I just thought the whole idea of TDD was such a crazy religion. And I don't do it because I think there is business value to it, I do it because I think there's a practical value to it. Sometimes I don't know how I'm gonna solve a problem, so I write a test to determine whether that problem is solved and explore ways to do it. Go helped me get there far better than Ruby did, which is not a digging against Ruby at all, because it's really easy to test in Ruby; I just didn't enjoy testing in Ruby, and I enjoy testing in Go, which is so strange.
+
+**Bryan Liles:** Yeah... I like to do TDD, but sometimes I just write software. I have a project in front of me right now where I just started writing because I wasn't sure if my abstraction was right; generally, whenever you get to the point where you're starting to lay down test, people are much more reluctant to change their way. So I said, "I'll just write for a little bit, and I'll write some tests to make sure that some things are working right, and then I'll go back through and I'll have these high-level tests to make sure that the application works right, and then I'll work down towards the units."
+
+The reason I work like that is because it works for me. This is not a prescription for anyone. But what I'm saying is that we need to understand, once again, why do we have tests? What are tests for? Are we using them to prove correctness? I'm actually using it to make sure that I can move faster and I don't have to swap this whole HTTP library out that I use. Because I knew I was gonna mess up, and I'm gonna have to replace it with something else. I just wanna make sure the rest of the code works whenever I swap it out.
+
+That's the only reason I write tests - because I don't trust future Bryan; or actually, I don't trust past Bryan. He's a jerk.
+
+**Brian Ketelsen:** The past Bryan, exactly. It's always past Brian getting me in trouble.
+
+**Erik St. Martin:** I like the safety of refactoring by having a test suite. I've never been a hundred percent test-coverage person because I think that that just makes people write tests that just hit the code and they don't actually truly exercise the program. Also, I've never adopted that whole red-green-refactor thing; that just felt not like typical programming workflow, I just never cared for it. I'm a little bit, like you said -- I'll develop some stuff, I'll write some code that kind of tests it so that as I'm adding new features I don't have to keep going back and checking the things that I already knew worked; I can see when I break those by adding the new features... But I mean, that's about it. I try to get as best a test coverage as I can, but I'm not going through testing every single edge case.
+
+\[48:15\] And typically, through the development and through the usage of an application, I'll throw in tests as issues come up, to prevent regressions. I like testing, but I'm not a "test first" all the time. There's some problems where I will start with the uni-test first and kind of build from there, but there's other times where I'll just build the application first and then kind of start building some sanity checks.
+
+**Bryan Liles:** Yeah. Red-green-refactor is hard, and I like how books have it and they're like, "That's how you do it." I always use something different, and I know this is valid because before Jim Weirich died, he said "Bryan, this is a good idea." And I stuck with this one.
+
+So what I've done is I write a little code, and maybe I write a test first or maybe I write the test last; I run the test, and hopefully it fails, because you should try to make those tests fail. Then I change a little bit of code and I run the test again. I don't think about red-green-refactor. I do red-green-red-green-red-green-refactor-refactor-refactor. I think once we start prescribing this method, this will make a lot of sense to people, and people start losing interest.
+
+Just remember, all we're trying to do is write code faster. If I can write code fast with no test and it was a hundred percent correct, would I write tests? No.
+
+**Erik St. Martin:** Yeah, until future Bryan has to deal with past Bryan, and tries to refactor.
+
+**Bryan Liles:** Well, past Bryan is a jerk, and we know past Bryan is a jerk, so I don't expect him to be better.
+
+**Carlisia Thompson:** For me, one thing that I have adopted at some point and since then I always use it, and it has been tremendously helpful, is to have the red there at some point. I don't care if I'm writing the test first or not, but making that test fail makes a huge difference, because you could be writing and everything's passing -- guess what? It's not passing what you think it is testing, so making sure it fails with the proper case makes a difference. Because it happens... Sometimes you write a test to fail and it doesn't fail, and you're like "Whoops! I'm not even testing what I thought I was testing..."
+
+**Erik St. Martin:** There's also some unit tests... I know in Ruby they have it - I forgot the name of the library now - where it inverts your test to basically make sure that it would fail without it. They have fuzzying tools and stuff like that.
+
+So we talk about having those tests there for refactoring; unless it's a large refactor that I have to do, it doesn't always bother me to write the tests before I do the refactoring. If I'm looking at some small library with very little surface in the API, I'll write a test, test out a couple of scenarios that I wanna make sure work, and then I go in and I refactor stuff. So it's not always a bad deal, but like you said, the general consensus is we should test as much as we can, as much as it adds value to the project and to your development time and the safety there.
+
+I think if you're on a large team and lots of people are touching the same code, I think it benefits you more to have a lot of test coverage, because there's a lot of risk there, that I start stepping in and making changes, but then, you know... Brian and Carlisia are working on stuff and I break them because I'm not testing the area that they're working on, and stuff like that. So for large projects and large teams I think it benefits more.
+
+**Carlisia Thompson:** And testing is something that really pays off to learn how to do well.
+
+**Erik St. Martin:** Without a doubt.
+
+**Carlisia Thompson:** \[51:47\] Right? I'm not there yet, I keep learning, but you look at a codebase and it has a ton of tests, and most of them are useless. It consumes time from everybody - they have to read... I mean, when I look at a new codebase, the first thing I read is the test, because it will tell me the business logics for the system. If you find everything is so convoluted, and once you start learning the codebase, you figure out, "Oh, these are all useless." It's a major waste of time.
+
+**Erik St. Martin:** Yeah, if they not valid tests, they're just trying to hit lines of code, then there's no point in having them. But I think the takeaway is you should try to test as best as you can. If you've got a one or two-line function that does something very clear - formats a string, or something - I don't know whether you should feel guilty that you didn't get 100% coverage because you didn't test that method.
+
+**Bryan Liles:** Obviously, I have one last thing for people that think about testing and they always say to me, "I'm gonna go look at the Go standard library and see of a test." You realize that if you were writing the standard library, that would be a good place to go look for tests. But if you're writing an application, the way they do testing in the standard library is not always helpful to what you're doing. So really what we need to find in the community is better examples of how to do certain kinds of things, like testing an application at this level.
+
+If you look at a project like Kubernetes, it's a little convoluted, but they have a good way of testing it. They have a great end-to-end set, and they have a great set of unit tests. And they're pretty religious about that. I'm not saying it's the right way, but if you wanna look for something that's better than the standard library for application-type things, look at Kubernetes.
+
+**Erik St. Martin:** Yeah, that's fair, because the standard library is gonna be mostly unit test style, it's not really gonna be end-to-end and integration tests where you have multiple components that need to be stood up and communicate with each other.
+
+**Bryan Liles:** Yeah.
+
+**Carlisia Thompson:** That's a very good point Bryan, because I have just started to realize a lot of the blog posts out there, a lot of the examples, a lot of the sample codes are applicable to libraries if you're writing a library; but if you're writing an application or an API, you have to do things a bit differently. It's different. And that's a good tip, so I definitely will need to look up that codebase.
+
+**Brian Ketelsen:** We need to take a break and talk about our next sponsor. Bryan, I'd like it if you just closed your ears for a moment, please?
+
+**Break:** \[54:25\]
+
+**Brian Ketelsen:** You can open your ears back up, Bryan.
+
+**Bryan Liles:** \[laughs\] You know, I will offer some commentary and they'll be very positive. I think a lot of developers need to understand this. Unless you own your company - I don't own my company; I just work there for a paycheck. I like to hear about all the stuff going on in our market. That validates that our market works; it validates the idea that the founders, the execs at my company are doing the right thing. But I'll tell you first thing - I'm gonna speak for Bryan Liles, I don't speak for anyone else.
+
+\[55:56\] I think that more people need to realize that you should champion yourself without trying to be a detriment to your employer, but realize that when push comes to shove, they're gonna push you off, because they need to win. A lot of people don't realize that - the allegiance is with yourself and with your family. You always need to make sure that you're gonna come out on top (without hurting anyone else; don't be a jerk). Definitely think about that when you're moving forward.
+
+**Erik St. Martin:** But you already said that past Bryan is a jerk, so...
+
+**Bryan Liles:** Past Bryan is a jerk, but he's not here anymore, so we can talk about him. \[laughter\]
+
+**Erik St. Martin:** Past Bryan isn't here because he was a jerk.
+
+**Bryan Liles:** That's right.
+
+**Carlisia Thompson:** Talking about your company - how about the monorepo deal with DigitalOcean? Let's talk about that.
+
+**Bryan Liles:** Oh, I'll give you where that came from. We were doing Go; let's say I did start doing Go in the middle of 2014. We started doing Go, everybody started doing Go, but the problem is that we had our internal GitHub and then we had about 15 projects inside of there and actually making sure everything mounted up just didn't work.
+
+I remember us talking about this in the fall of 2014, but then what happened is I ran into some Google people at a conference - it was Gotham Go - and I happened to speak there, and I said "I'm not gonna lose this chance to talk to Google people about, "How do you all do this? Because what we're doing makes no sense, and I think your language is dumb because it doesn't provide these concepts for us." So they walked through how they did the monorepo, and I took that information back.
+
+We converted what we do at DigitalOcean and we created this thing called cthulhu. I didn't know what a cthulhu was, I had to look it up. I'm not quite sure I understand what it is now, but it's where our Go code goes. Really all it is, the monorepo is -- and we don't do it quite like other projects do it. We have two Go paths, but we have two items in our Go path. The first item is our third-party directory, and the second one is where our Go code goes. Really what we do is whenever you go get, the software goes into the first part of the path, which goes into our third-party, and then underneath Go code we have something called Doge, which we'll talk about in a second. And then we have where all of our teams confederate and do whatever they need to do.
+
+Back to Doge... A standard library in Go is actually pretty good, there's a lot of things in there. But unfortunately, it doesn't do a lot of things that we like to do. We're pretty deep in things like gRPC, we have the way that we log, we have the way that we do metrics... So what we did is we wrote another standard library on top of the original standard library, that allows us to do all those things.
+
+One day we might open source it; it's actually kind of neat the things we have in there. But what it allows us to do is you download the whole Go repo - it's like 200 MB, it's actually pretty big... But whenever you download it, you have the whole environment. The reason that I like it - and then I'll tell you the reason that I hate it - is because it does allow us to use all the Go tooling on there. We have a custom version of Go Imports, because some people have a crazy way of organizing imports. But also what I like about it is that when you make a change, we know if it's gonna break. You could actually run the test for the whole entire environment on your box. You probably don't wanna do that because it will take a little bit, but you can.
+
+Then when we reintegrate to master, we pretty much know if it's gonna work or if it's gonna fail; there's no guessing. And that's what I think is the real win, is that it takes the guesswork. We know if all our Go tests pass. The bad side is that yes, Go does compile quickly, but not if you have a metric crap ton of packages it actually has to pass again and again, so our Go test suite takes about 45 minutes. One day we'll open source this (almost there), we have a tool called GTA, and I don't know why it's called GTA; somebody must have been a gamer. But really what it does, it just allows you to test the portion that just changed. It actually uses the Go type stuff to actually figure out what's changed and only touch the things in that graph. If you touched a piece of software and then you touch something in our Doge, it would only compile those two things and test those things, rather than testing the whole thing together.
+
+**Erik St. Martin:** \[01:00:27.08\] I'm gonna go out on a limb and say that the name is Grand Test Auto, how's that?
+
+**Bryan Liles:** Yeah, we'll just say Grand Test Auto. It's a weird thing, developers... But I will say this, it's allowed us to move faster, but as we've grown to a hundred engineers, it's actually made things slower; integrating people into it, getting new projects started has been difficult. But one thing we've done is created quite a bit of tooling around it to allow it to have owners look inside the monorepo to make sure that the tests run fast, and to make sure that we have a way to build artifacts out of there.
+
+I will say this, you can explore the monorepo, but realize that it's not a panacea. Like having children - they're amazing when they come out, that first second, but for the next three weeks or three months they suck, because they cry all the time. \[laughter\] Then they get older and they're amazing again. That's about where we are right now. We're right at the point where it stopped crying and it started getting amazing again, and we can see where it's going to be a really awesome adult.
+
+**Carlisia Thompson:** Do you ever talk about breaking it out?
+
+**Bryan Liles:** Some people talk about it, and I would say there are projects that aren't in the repo for reasons political or technical, but we're just trying to make sure that everyone keeps it in there for the greater good of the team; we keep all the Go in the same place. And you know, this is another thing that comes down to dependency management in Go. Since it's not a thing that we know about, it's not a solved problem for us, we chose to solve it by just blocking everything in and burgeoning the dependencies along with everything else.
+
+**Carlisia Thompson:** A question for you - what is your ratio of commits to merge conflicts?
+
+**Bryan Liles:** Merge conflicts? Never.
+
+**Carlisia Thompson:** Really?
+
+**Bryan Liles:** Never. No, we don't have merge conflicts. The reason we don't is because if you think about it, we have our standard library Doge, and then all the teams... So, in any particular section of the code, there might only be like 3 or 4 developers. It's not like everybody is in there, killing everything at one time. It's one repo, but there is a lot of pieces that are being touched at once, and not everybody -- there's no hot spot inside the codebase.
+
+**Erik St. Martin:** So the monorepo thing though - it's much more popular than people think, especially in bigger companies. My first exposure to it was working for Disney, which has a massive perforce server. And it had everything on there, and not just the division of Disney I worked for, but the artists, and things like that; everything was in one place. I thought it was odd at first, but the way all of that stuff works together and you can ensure the stuff...
+
+The way I see it is it's like software - you have to look at coupling and cohesion. If you've got two different repos that need to know a lot about each other, and changes in one often require changes in the other, that becomes a beast to maintain. How do you submit a pull request? Docker is one that I've contributed a patch to, and it's a similar thing - in one pull request you have to mention a pull request in another repo that's required for this pull request to work, and it just becomes a much bigger problem than it needs to be, if kind of all those things lived in one space.
+
+**Carlisia Thompson:** \[01:03:58.05\] Yeah, that is true. I've been there too, and you have to put a "Work in Progress, no merge please, until this one is merged. Then we can merge the other one."
+
+**Bryan Liles:** And we do that. Sometimes you will see a tweet come through that says, "Please do not merge", and no one merges it. But I think as long as communities or the teams talk about these things, it's okay. The good thing about having the monorepo is that it defeats the tribal mentality that... Developers love to get information and then not share it; but if everybody is developing in the same repo, that tribe gets way larger and we don't have such tiny, compartmentalized information. No one has to worry about the build system. You know how you can just have builds? You just put it in this repo, and it will get builds. You know how to get a binary? Mention it in this JSON file, and it will get built and published.
+
+I'll say one last cool thing - we don't worry about version. Internally, we don't do software versions. We just push out the latest thing, or the latest working thing.
+
+**Carlisia Thompson:** How about the peripheral work? For example, do you get build notifications for every single build?
+
+**Bryan Liles:** Yeah, in a different Slack room called Golang-build, and you just look for your name in there.
+
+**Carlisia Thompson:** Wow, that would drive me crazy.
+
+**Bryan Liles:** No, I just turn off all the notifications -- actually, my Slack is weird; I turned the notifications off for everything. I join all the channels and then turn all the notifications off, and then I can go look when I wanna look. But generally, I only look in there whenever I care. The only time that you will see a notification in the main Go room is whenever Master Build builds; that's important. But other than that, who cares?
+
+**Brian Ketelsen:** One thing that I noticed with a really large monorepo that I had a year or so ago, which was actually inspired by your post, was that the Go tooling really slowed down. It became much more difficult for things like Vim Go and Go Imports to work when you had such a gigantic codebase. I found that really frustrating.
+
+**Bryan Liles:** Yeah, yeah. I will say that Go code and a few others don't like large codebases; it's a little bit slower... I mean, I have my beefy Mac here, with 32 GB of memory and lots of CPU; it's pretty fast on this one, but on my laptop it's horrible.
+
+So what's the answer? The answer is we need more people to use it like this, so that someone can go in and fix Go code to make it work better, because the person who wrote it didn't look at it to a base this big.
+
+So I'm not gonna not use those tools because it's a little slow. But also, I'll give you a hint here. I know people are gonna hate this, and my co-workers are definitely gonna hate this. The stuff in Visual Studio Code, all the Go stuff in there - way faster than Vim.
+
+**Brian Ketelsen:** Yeah, Visual Studio Code is awesome, I won't disagree with you at all.
+
+**Bryan Liles:** And my co-worker, he actually writes Vim Go. We have a huge amount of people internally that use it, and I'm like one of the only stalwarts; I'm like, "I found this thing and it's amazing. I want to configure it, because I can see me using that." And it's not that bad. Everything pretty much works, though sometimes when I rename it's a little bit slower, but that's okay.
+
+**Erik St. Martin:** I still haven't tried Visual Studio Code. I know a lot of people rave about it... I'm just a creature of habit.
+
+**Carlisia Thompson:** I've tried it twice and I couldn't wrap my head around it.
+
+**Brian Ketelsen:** I use it in my training classes, because it's a really easy thing to configure and people can see what you're doing while you're clicking, rather than wonder what you're doing while you're typing strange Vim movement commands.
+
+**Erik St. Martin:** That's fair.
+
+**Bryan Liles:** Yeah.
+
+**Erik St. Martin:** I think we're actually overtime, so we should probably roll into \#FreeSoftwareFriday. For anybody who's new, we basically try to give shout outs to projects that are currently or have made our lives easier in the past, to show them love instead of just opening tickets when things don't work. \[laughter\]
+
+\[01:07:57.08\] I think somebody mentioned that we should start opening tickets just to tell them how much we love the project, but I feel like that would flood the issues system.
+
+**Brian Ketelsen:** That was me. That was my blog post last November, that started this whole thing. I said, just open a ticket and say "I love this project. Please close this ticket." And actually I haven't had anybody complain about that, because I do it a lot.
+
+So I'll kick this off. My \#FreeSoftwareFriday mention for the day is PfSense, open source router and firewall. I've been running one for three or four years now, and every time I have to touch it, it just makes me happy because it's so fast, it works so well and it's got so many awesome tools built into it; I can see what the heck my kids are doing... It's a great thing, so thank you to everybody who is behind the PfSense open source router and firewall.
+
+**Erik St. Martin:** Yeah, it's got a nice web interface. You can do IPsec VPN... It's built on top of FreeBSD, but it's got IDS and IPS in there, snorts built in, lots of cool things.
+
+**Brian Ketelsen:** It's good stuff.
+
+**Erik St. Martin:** And they're relatively inexpensive. You can put them on a small Intel Atom computer in your closet, or you can buy one that's pre-built with a PfSense already loaded on there. But yeah, for a home firewall, if you want something... I mean, they're used even outside of home; there's a lot of businesses that use them just because they're cost-effective...
+
+**Brian Ketelsen:** ...and powerful.
+
+**Erik St. Martin:** And you can put it on your own beefy box if you want to. How about you, Carlisia.
+
+**Carlisia Thompson:** I don't have one today.
+
+**Erik St. Martin:** Okay. I have one. I have been dealing with it a lot. Ansible. I love Ansible. I still struggle too, because Puppet and everything has its own appeal, but I'm still just a big fan of building out scripts for deployment using Ansible.
+
+**Brian Ketelsen:** I love Ansible too. I'm with you there.
+
+**Bryan Liles:** I'm a fan of Ansible. I use it quite a bit, and I do like it.
+
+**Erik St. Martin:** Yeah, the hardest part I think is just managing all this stuff, when you have these complex build-outs. For example doing a Kubernetes cluster - there's just so many components and certificates that need to be set up in Docker, and Flannel, or OpenContrail...
+
+**Bryan Liles:** One of the secrets is to use module. So have a common module, have a Kubernetes master module, have a Kubernetes node module, and use it in a more modular fashion, rather than having some long YAML file, because then you'll get confused.
+
+**Erik St. Martin:** Yeah, which is basically what I do, and then I'll default within the modules and then I'll override them up in my inventory files or group files.
+
+**Brian Ketelsen:** Ansible is nice because you can get a lot done without knowing a ton about Ansible. It's when you wanna get really crazy complicated that it's harder, but it's more than enough for what I need, and I enjoy that.
+
+How about you, Bryan? Any shout outs you wanna give?
+
+**Bryan Liles:** Okay, so I'm not choosing a project, I'm choosing a person and a blog series. Ben Johnson has done a lot of things in Ruby land, BoltDB, making Influx better, and a few other things. He's writing this series about Go's standard library. The last one came out about two hours ago. It's about strconv. He just goes through it and says, "This is how it works. This is how you would use it. This is why this is there." It's kind of neat, because with Go we've got the standard library, we've got the language document, and then we've got this Getting Started guide, but we never understood why things are there. This kind of explains all of the different pieces way better than the documentation does, and I'm very thankful for him making this series.
+
+**Erik St. Martin:** \[01:12:03.07\] Yeah, we actually had him on the episode before the last - the one that basically just got released - and we were talking to him about these things. We love these walkthroughs. It was actually kind of surprising because it was a shift from the types of stuff that Ben's been talking about. First year at GopherCon he was talking about high-performance databases; the second year he spoke about static single assignment, and now here's kind of like a "back to the basics; let's break down the standard library, what's in there, how do we use it and why do we use it." I'm loving this series. I have not seen the latest one.
+
+**Brian Ketelsen:** That's because we've been recording.
+
+**Erik St. Martin:** Not for three hours we haven't... So I think that is it, unless Carlisia thought of one at the last minute? No?
+
+**Carlisia Thompson:** I can +1 what Bryan Liles said.
+
+**Erik St. Martin:** That works.
+
+**Carlisia Thompson:** Ben Johnson's posts are awesome.
+
+**Erik St. Martin:** I love these posts like this, and I'm really loving that we've reached a point in the community's growth that we're seeing a lot more content now than we have in prior years. Lots of people are stepping up and talking about things. I love all the new stuff by Dave Cheney with the solid design, and all these things... You remember, Bryan, coming from the Ruby world, all that stuff was exciting; we were talking about patterns, testing and things like that.
+
+**Bryan Liles:** People hate it, but we need it as a community. It's a great place for us to be right now.
+
+**Brian Ketelsen:** Amen.
+
+**Carlisia Thompson:** Yes. And we're going to have Aaron Schlesinger on the show and we're going to talk about design patterns; I'm looking forward to that.
+
+**Erik St. Martin:** Yes, that will be next week.
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** So with that, I guess we have to say goodbye... At some point we have to, because we're out of time. I wanna thank everybody on the show, and especially I wanna thank Bryan for coming on the show and talking to us about all the great topics today. Thanks to everybody who's listening now; if you're not subscribed, you can go to GoTime.FM. We will be setting up a weekly email at some point; we're kind of acquiring content at the moment. You can follow us on Twitter, @GoTimeFM and hit us up on our GitHub, which is github.com/gotimefm/ping, if you wanna be on the show, or you wanna recommend a guest or have questions. With that, goodbye everybody.
+
+**Brian Ketelsen:** Goodbye, thanks Bryan.
+
+**Bryan Liles:** Thanks for having me.
+
+**Carlisia Thompson:** Thanks, Bryan.

Open Sourcing Chain's Developer Platform_transcript.txt

@@ -0,0 +1,635 @@
+**Erik St. Martin:** Alright, we are back for another episode of GoTime. It is episode \#23. Today's show is sponsored by Linode and Code School. On the show today we have myself, Erik St. Martin, we also have Brian Ketelsen - say hello, Brian.
+
+**Brian Ketelsen:** Hello, Brian.
+
+**Erik St. Martin:** And Carlisia Campos.
+
+**Carlisia Thompson:** Hi, everybody. \[laughs\]
+
+**Erik St. Martin:** She's already laughing... And today's special guest is Tess Rinearson. Why don't you tell everybody a little bit about yourself, Tess?
+
+**Tess Rinearson:** Hey. I am a software engineer at Chain, which is a San Francisco startup that builds blockchain infrastructure, and we do almost everything we do, all of our infrastructure is written in Go.
+
+**Erik St. Martin:** This comes the fun part - I wonder how many people are familiar with what blockchain is.
+
+**Tess Rinearson:** Yeah...
+
+**Erik St. Martin:** Can you give a little background of what blockchain is and what it's used for?
+
+**Brian Ketelsen:** Something-something Bitcoin.
+
+**Tess Rinearson:** Yeah, that's usually where I start. My house party explanation always begins with "Do you know what Bitcoin is?" 95% of the time people say yes, so I'll just take it from there. The blockchain generically is the infrastructure that powers Bitcoin. It's all of the distributed systems and cryptography in that design, that powers Bitcoin and allows for this decentralized ledger. And the decentralized ledger is the blockchain.
+
+You can use that infrastructure to power all kinds of other things. The system that I work on at Chain is sort of like a blockchain for generic assets. We work with financial institutions like NASDAQ or VISA, who have other assets (non-Bitcoin assets) that they would like to put on a blockchain to get a lot of those same decentralized benefits without using Bitcoin itself.
+
+**Carlisia Thompson:** Right this second this question came up for me - is blockchain a protocol? I didn't get it.
+
+**Tess Rinearson:** Yeah, that's actually a funny question. I would say no, it's not a protocol... To be honest, the word blockchain right now is a little bit like the word cloud, where maybe if you have seven or eight characteristics and if some product or service matches six of those seven or eight characteristics, then you could reasonably consider it to be a blockchain. So it's kind of like a fuzzy word to begin with.
+
+**Carlisia Thompson:** I guess Chain implemented its own blockchain, right?
+
+**Tess Rinearson:** That's right. We actually have our own protocol as well. Maybe you can think of a blockchain as like the generic category of protocols and services, and then we wrote this protocol called The Chain Protocol, which is a blockchain protocol designed for financial services. Then, we also have an implementation of that protocol called Chain Core, which is what I work on.
+
+**Carlisia Thompson:** \[03:56\] Makes sense.
+
+**Erik St. Martin:** From what I saw, it was designed more in line with Bitcoin's implementation, where there's kind of like the UTXOs...
+
+**Tess Rinearson:** That's right, we have a UTXO model. A UTXO is an unspent transaction output - somehow you get the TX from "transaction." So that's the basic system that we use, which is the same mechanism that Bitcoin uses.
+
+You can think of the UTXO model as a little bit like being a series of boxes. So if I want to send Carlisia five dollars, I have to go through all of the outputs of previous transactions that I own. I put five dollars into her box, and then that box is an unspent transaction output for Carlisia that she can then unlock using her keys, and transfer to Brian, for example.
+
+**Erik St. Martin:** The UTXOs are kind of interesting because basically when a transaction occurs, you basically absorb the UTXO that they had before and then generating a new one to go to the person that the transfer is going to.
+
+**Tess Rinearson:** That's right, yeah. Every transaction uses up UTXOs and creates new UTXOs that can be used in a later transaction.
+
+**Erik St. Martin:** And the general idea of that is the double-spend problem, right?
+
+**Tess Rinearson:** Right. One of the things that is interesting or tricky is, like you said, this double-spend problem. The double spend problem would be like if I claim to send the same five-dollar UTXO to both Carlisia and Brian, that would be a double spend of that UTXO, and that would be invalid. So that's one thing that blockchains have to track - which UTXOs are still valid and which ones have been consumed already.
+
+**Erik St. Martin:** And now the other implementations you're talking about, I think there's some that just kind of use a ledger and no UTXOs...
+
+**Tess Rinearson:** Yeah, I actually don't know much about the mechanics of non-UTXO blockchains, but certainly there are... I mean, like I said, a blockchain is one of those things where if you meet a certain number of criteria, you call yourself a blockchain, and one of those things could be a UTXO model. So there certainly are blockchains that don't use a UTXO model.
+
+**Erik St. Martin:** I guess from a generic perspective it's a distributed system that maintains some sort of ledger that they validate previous transactions in order to confirm a transaction taking place, and many parties have to go through their own ledgers - whether they're using UTXO or something else - and determining that this is accurate. I guess if you serve that purpose, then you're kind of a blockchain...
+
+**Tess Rinearson:** Yeah, that seems fair. I mean, I would say that also there's an inherent transfer of value in them, but not everyone thinks that, too. I think when you look at a blockchain, you can almost think of the assets (Bitcoin, or whatever other asset you have issued on a blockchain) as tokens of value, and you're transferring them. You have the value if you can prove ownership of the tokens, which you do with your private key.
+
+**Carlisia Thompson:** I have a question. The Chain Core - is it meant to be used by financial institutions that are brokering initial transactions? Or is the idea that there will be a hosted version of blockchain somewhere and the financial institutions will use that?
+
+**Tess Rinearson:** \[08:00\] Right, so we're working with these financial institutions to spin up a variety of different blockchain networks. In the case of VISA - VISA is running a blockchain network of Chain Cores, and all of their clients have nodes in the system. You asked about a hosted blockchain somewhere - generally, we actually deploy Chain Core into our partner's data centers. Generally, these financial institutions have data centers that they know well and have invested in and are fond of, and so we generally deploy our software in there for them.
+
+That said, we also have this thing called the testnet. Sometimes I joke it's the TessNet, but it's the testnet. \[laughter\]
+
+**Brian Ketelsen:** It's all about you, Tess.
+
+**Tess Rinearson:** Yeah, I know... That's a term that we also borrowed from Bitcoin, where there's a Bitcoin TestNet that sort of runs parallel to the actual Bitcoin system and is reset at fairly regular intervals, and basically just has fake money on it. So we have this Chain testnet, and it's validated by us and Microsoft and IC3, which is this university blockchain research group based at Cornell. We run this system, and people who are just trying to have a node and get on a blockchain can download Chain Core and connect to the Chain testnet without actually trying to spin up their whole entire network. So we sort of have that as almost like a hosted "blockchain" that people can just like log on and play with, without having to start up their whole own network.
+
+**Erik St. Martin:** And now you said most of your customers are using this for financial stuff where they're tracking bonds or actual cash, or things like that?
+
+**Tess Rinearson:** Yeah. What people are using it for is any asset that holds value. That can be stocks, that can be currencies, that can be credit card points, frequent flier miles - all kinds of stuff.
+
+**Carlisia Thompson:** It sounds to me that an entity that could benefit from Chain Core wouldn't necessarily have to be a big financial institution, or even a small financial institution. It could be a business like LivingSocial, if they want to use it for loyalty points, or Groupon. Is that right?
+
+**Tess Rinearson:** Yeah, I think, potentially. We're definitely starting with financial institutions, and we're starting with financial institutions that are well-known enough that they can power their own networks and people will want to join them. That serves the power of this partnership. We just on Friday announced a partnership with VISA and the network that we're working on with them to do business-to-business payments, and it's really valuable to go be part of these well-respected financial institutions, because people trust them enough to wanna join their networks. So we're starting there, but I do think that, generically, anything that holds value is a good candidate for something that can be issued and transferred on a Chain block chain.
+
+**Erik St. Martin:** Yeah, and I think anything that you want validated to ensure that it hasn't been tampered with is also a good candidate.
+
+**Tess Rinearson:** Yeah, I think that's less of a problem that we are solving right now. Obviously, when you're looking at things like validating UTXOs, you have to make sure that transaction history hasn't been tampered with, and things like that. There are so many cool things that you can do with a blockchain...
+
+\[12:04\] If you look at something like the Bitcoin blockchain, which is this public distributed ledger where everyone has a grade on the history of it, you can do crazy things like prove that you have copyright -- or, I shouldn't say "prove that you have copyright", because that's probably technically-legally something, but prove that you had a piece of IP at a certain time.
+
+If I wanted to prove that I wrote a paper, I can hash that paper and stick that in the metadata of a Bitcoin transaction and then put that on the Bitcoin blockchain. And if anyone's like, "Oh, did you actually have this paper at this time?", I could just point them to that transaction and give them the hash function and give them my original paper, and be like "Hey, validate this for yourself.
+
+And because in Chain's case we're not talking about public networks, we're talking about private networks, you lose that ability. But there's other benefits to having a private network.
+
+**Erik St. Martin:** Right.
+
+**Carlisia Thompson:** And when you're generating keys, who is actually validating those keys? Is Chain an authority to validate those keys, or is some distributed system...? How does that work?
+
+**Tess Rinearson:** Yeah, every node in the system can validate every transaction, and then there are certain -- I don't wanna get too much into the mechanics of all of it, but every node in the system can validate transactions, and then when it comes to actually creating new blocks and adding those new blocks to the blockchain, we do use a federation of signing nodes that are actually responsible for checking every transaction and signing of a block, and saying, "Hey, this block is cool. You can add it." Every node can actually validate, if they want. They just don't get to add their signature; they can just validate themselves.
+
+**Carlisia Thompson:** Who has control over this federation?
+
+**Tess Rinearson:** In the case of the testnet it's us, Chain, and Microsoft and IC3. We are the three signing nodes in that network. But that's configurable on a network-by-network basis, and actually in the protocol we have a field for the consensus protocol, which can be changed on a network-by-network basis. For testnet, a block can see signatures from Chain, from IC3 and from Microsoft, but there's definitely space in the protocol to refine our consensus system.
+
+**Carlisia Thompson:** Cool.
+
+**Brian Ketelsen:** So what's the application for GopherCon? That's the real question here. Can we start making chains of things that we can give out to gophers and let them trade value? We can have like gopher points... Trade them in for plushies.
+
+**Tess Rinearson:** Yeah, that's definitely a thing you could do. You could have every attendee at GopherCon have their own asset that's issued by their... One thing I didn't really talk about, but if you're familiar with Bitcoin or you're probably familiar with mining - which is used for consensus, but it's also the process by which new Bitcoin is created... And because you have a system for generic assets that often tie to real assets that are held somewhere else, assets on a blockchain are issued and are tied to a private key. Then, basically, to redeem your asset, you have to take it back to the asset issuer and say, "Hey, I see that you signed this with your key."
+
+\[15:58\] So what you could do at GopherCon is every attendee could issue their own asset, tied to their own key pair, and then maybe for each person you meet, you can issue them one token, and then whoever has the most tokens wins, or something.
+
+**Erik St. Martin:** I say we go bigger. We call GitHub, and contributing in Go gets you -- that's how you mine, by committing in Go. \[laughter\]
+
+**Tess Rinearson:** Oh, yeah...
+
+**Brian Ketelsen:** Interesting.
+
+**Tess Rinearson:** Yeah, I feel like every year at GopherCon... I make all these big plans to do some open source work, and it hadn't happened until Monday, when we open sourced new stuff. But I definitely think GopherCon gets me in the open source spirit, and then generally I fall through on that.
+
+**Brian Ketelsen:** Well, you delivered big for this year, so you've done your part. We need to take a quick sponsor break, but when we come back, remind me to ask you about how this differs from the blockchain that IBM announced earlier this year.
+
+**Tess Rinearson:** Okay.
+
+**Break:** \[17:03\]
+
+**Brian Ketelsen:** Alright, so how does your blockchain differ from the one that IBM released? I saw a press release - it was really early this year - that IBM had released some sort of business-oriented blockchain. Is that different? I think there was Go code and Java code... I don't remember all of the details.
+
+**Tess Rinearson:** Yeah, I don't actually know exactly what they're working on. There are a lot of different blockchain systems out there, and I tend to be pretty heads down on what we're doing here. One thing definitely - and I don't know if this is the case with their blockchain, but definitely one reason why we open sourced was to really just show our hand and communicate our ideas as effectively as possible. We've been planning on publishing our protocol for a while...
+
+One thing about blockchains, like I said, is there's a lot of them. With some of them it's just hard to know what's really going on beneath the surface. There's a lot of press releases or white papers, but not too many in-depth protocol documents and even pure implementations. So one reason why we went open source is just to really communicate our ideas about what a blockchain can and should look like as clearly as possible, and also to show the world that we have something very real. And also to show the world that you can just go download a Chain Core node and write it on your computer, and connect to testnet and it all just kind of works. I mean, knock on wood, it all seems to be working.
+
+**Brian Ketelsen:** So you're telling me blockchain technology is a little bit like vendor management solutions for Go - there's a lot of hype and not a whole lot of action?
+
+**Tess Rinearson:** It's a hot subject, to be sure... \[laughter\]
+
+**Erik St. Martin:** I think anything academic like that is. Before Raft, trying a distributed consensus - it was mostly white papers and things, and you're like "This sounds cool, but how do I build it?"
+
+**Tess Rinearson:** \[19:55\] Yeah, totally. It's funny that you bring up distributed consensus, because obviously that's a huge part of blockchains as well. There's so many papers on different consensus algorithms, and a lot of blockchains are using PBFT (practical byzantine fault tolerance) as a backbone, if not actually implementing PBFT itself... And I found this funny academic paper from 2011 that was discussing the realities of using PBFT in production, and there's this little line hidden in the middle of the paper, that's like "As far as we know, nobody's actually done this in production." \[laughter\] That was in 2011, so you know... There's a lot of speculation, and we're trying really hard to move ourselves and move our corner of the industry out of that speculative, white paper, (sometimes) PowerPoint-based world, and into this place with servers and code and real networks, and people actually transferring things to one another.
+
+**Erik St. Martin:** What did you end up using for your consensus protocol?
+
+**Tess Rinearson:** We use something related to PBFT, but we basically have - again, without getting too into the nuts and bolts of it - a single node that we have been calling the generator node, although we've just started discussing changing that to the block proposer, that is responsible for gathering the transactions along the network and creating a new block. This is in a lot of ways a single point of failure, but the other nodes in the system basically can audit it and can halt the system if the block generator fails.
+
+In the case of these financial networks, that's actually not a bad thing, because if some institution in the network is going rogue, you have a bigger problem than the state of your databases; you have sort of an organizational problem that has to be dealt with offline. So the fact that we use that as our consensus model, again, for now, there's room in our protocol to refine and improve. That system gives us much better performance than something like proof of work, which is what Bitcoin uses.
+
+**Erik St. Martin:** So by putting it out there open source, were you hoping for contribution, or is this mainly to get people using it and coming up with use cases...?
+
+**Tess Rinearson:** Yeah, we're not looking... It's this funny thing - we are not looking for contribution in the same way that a lot of other open source projects are. It really is about communicating ideas as much as we can.
+
+It's this funny thing, where we have a product roadmap and we're very driven by our work with our partners, so if people have things that they wanna contribute, or find bugs or things like that - that's awesome. But it's not the driving force behind open sourcing.
+
+**Brian Ketelsen:** I think your license choice kind of proves that point - it's AGLP license, isn't it?
+
+**Tess Rinearson:** Yeah, it is. That's something that we've actually gotten a lot of feedback - especially from the Go community - about. This is a community that we respect and that matters to us, so that's something else that we've been discussing and we're talking to our lawyers about. It's this balance between... This is like our product, that we are selling, right? So I think the business team is reluctant to choose too permissive a license, but at the same time we don't wanna discourage people from playing with it and hacking on it and building cool things with it.
+
+**Brian Ketelsen:** \[24:03\] I saw a Twitter exchange two days ago between two unnamed Gopher Google employees who said they couldn't even open it. They're prohibited by their company from even looking at AGPL source code. That's kind of sad.
+
+**Tess Rinearson:** Yeah... I mean, I think it's both... Disclaimer - I know very little about licenses. I sort of have been blessed with not having to think about licenses very much at all until this week, actually. But yeah, I think it's a balance between figuring out how much of that is caution or maybe even paranoia on the part of a company, versus something that is actually like a real concern for a lot of people. So we're figuring it out... We'll iterate.
+
+**Brian Ketelsen:** Well, it's a tough topic to tread, I totally get that. As a business, you don't want to give away the thing that makes you a business...
+
+**Tess Rinearson:** Exactly.
+
+**Brian Ketelsen:** ...but you wanna participate in the open source. It's not easy. I don't mean to sound like I was picking on you, I'm just curious.
+
+**Tess Rinearson:** No, I'm glad you brought it up. I'm glad I get to say... We have been talking about it, and we definitely have heard this community, and the Go community matters to us, so we're figuring it out.
+
+**Erik St. Martin:** And for anybody who's not familiar, my understanding of the differences between the AGPL and the GPL is that the AGPL kind of adds a clause where... So, in a typical GPL application, if I run a web service and I have users of my web service, I'm not required to give them the source code. But if I package it as a product and give it out, then I need to give out the source code. And the AGPL adds a clause where basically if network people are even using your application over a network, then you're required to provide... So I think that's kind of why people are reserved, because if they feel like if they use it or they see the code and are influenced by it, that if anybody touches their code through the network, then they have to give up the source code.
+
+**Tess Rinearson:** Right.
+
+**Erik St. Martin:** And I think that's where the concern comes in. But again, I'm not a licensed person either, but I just remember that being kind of a... But from your standpoint, it kind of makes sense too, right? Because people could take this, stand it up somewhere, offer a service and compete with you, right? Because they're not offering it as a product that's being put... I guess you couldn't do on-premise, because then they would have to give the code, but...
+
+**Brian Ketelsen:** I don't know... I've always had the argument that it's not all of the source code that makes the business, it's the people and the business knowledge in those people that makes the business. You can give away all of the source code you want; it takes a lot more than 2,000 lines of code to turn that into a real money-making business, and that's why entrepreneurs are rare, and successful companies are rare. There's a lot more to it than just standing up a couple servers and borrowing free open source code somewhere.
+
+**Tess Rinearson:** Yeah, I mean... I don't know where we're gonna land on it, to be totally honest, but it's an interesting problem and it's one that we're thinking actively about, I'll put it that way.
+
+**Erik St. Martin:** So let's talk about things we do know, which is Go. What's your experience been building this in Go?
+
+**Tess Rinearson:** Oh, I'm so glad I'm building this in Go. It's funny, because part of the reason I joined Chain was to write more Go. I think Go is obviously a natural choice for a distributed system, and... Yeah, I don't think I really have anything too concrete to point at, but...
+
+**Erik St. Martin:** \[27:56\] Have you had any stumbling blocks, things that you ended up having to implement because they didn't quite exist?
+
+**Tess Rinearson:** I don't think so. Go actually kind of saved my butt last week in an unexpected way. I was working on writing this Windows installer. I'm not a Windows user normally; I have a lot of love for Microsoft, I interned there, but I'm not a Windows user in my current incarnation, but it turns out a lot of financial services people are. So I was working on this installer that would basically take our Go binary and stick it in application files and give you a shortcut on your start menu, and all those things. And I was just struggling so much with this unfamiliar Windows installer system, that what I ended up doing was writing another Go program that shells out and does all the hard work...
+
+**Brian Ketelsen:** Oh, nice...
+
+**Tess Rinearson:** I cross-compiled that from my MacBook and packaged that in with everything else in the Windows installer, and then that kind of just runs and does all the heavy lifting. So after a few days of wrestling with various unfamiliar Windows concepts, I was like "Oh, I have this great multi-tool in Go", and I just used that.
+
+**Brian Ketelsen:** Let me just bust out my Swiss army knife here.
+
+**Tess Rinearson:** Yeah, totally. It was pretty awesome actually how easy it was once I leapt to that.
+
+**Brian Ketelsen:** It is kind of awesome. I was as OSCON last week teaching the Kubernetes class, and it was a whole room full of people that had never seen Go before. I was on my Mac, and I had an app - I built it on the Mac, I ran it and then I cross-compiled it and deployed it to a server and ran it on a Linux server. And somebody sitting in the back goes, "What did you just do there?" and I said, "I compiled it for Linux, and SCP-ed it up and ran it on the server." They were just blown away... "How can you cross-compile something that quickly?"
+
+**Tess Rinearson:** Yeah, it's so easy...
+
+**Brian Ketelsen:** Go... Go. Big hugs for Go.
+
+**Tess Rinearson:** Yeah, it's freaking easy.
+
+**Erik St. Martin:** I don't even think about the pains of cross-compiling anymore. Before, any time you had to support multiple architectures and operating systems, you were like "Oh, Jesus...", especially with things like C... Now, I don't even think about it, I just write code. I might have to fix a bug or two when I try to deploy it out to Windows, but...
+
+**Brian Ketelsen:** That's because you forgot to use the correct file path thing, right?
+
+**Tess Rinearson:** Yeah, fortunately I don't have quite enough career history, but I have battle scars from that. It sounds awful, and I'm so glad... I sort of feel like I've come of age with this language that makes it so easy...
+
+**Erik St. Martin:** I think this language is really good for making systems-level programming more approachable to people.
+
+**Tess Rinearson:** Yes. In a lot of ways, it's my first systems language. Before I was at Chain, I worked at Medium, and I was pretty full stack. Eventually, I had to learn Go to work on a new service. It was the social graph service - if you recommend something on Medium, then all of your followers can see it, the infrastructure that powers that kind of thing. I was a little bit reluctant to learn a new language. It was just silly. I was 20 years old and already curmudgeonly about it... But I was like, "I've been doing everything in JavaScript, I'm comfortable with this."
+
+\[32:03\] Learning Go and writing this new service in Go gave me a whole new perspective on building web services, and it was this sort of sweet spot of usable, but still reasonably close to the metal; not too abstracted, so I could still understand what was going on, especially coming from Node, where there's a lot of frameworks and things tend to be very abstracted... Scraping some of that off, and being able to have that perspective on building web services was very empowering to me. That sense sort of spurred this interest in systems that has lead me to working at Chain.
+
+**Erik St. Martin:** So getting into Go has kind of brought you more into systems programming and learning about distributed systems?
+
+**Tess Rinearson:** For sure, yeah. Absolutely. I mean, it really did help make things more approachable and more tangible. I went to college but I didn't finish, so I didn't take a lot of the distributed system classes and other things like that, that you might take in your third or fourth year of school. So all of this has been very "What am I going to learn on the job, with the tools that I have?" and Go has been a very good tool for making all this stuff approachable and tangible.
+
+**Erik St. Martin:** You're in good company, I never went to school for any of this either...
+
+**Tess Rinearson:** Cool!
+
+**Erik St. Martin:** ... and I learned a lot more about distributed systems and stuff after moving to Go... Because that's what everybody's doing with it. Especially early on, with the codebases, you were kind of looking around to learn the idioms and stuff, so you started kind of picking stuff up along the way, like "Oh, what's this? I wanna learn more about this!"
+
+**Tess Rinearson:** Totally.
+
+**Carlisia Thompson:** One thing with open source, if you're building a project that you are planning to open source, I think you would be thinking to be more careful in the way you are structuring the project and best practices, maybe more than a project that's not open sourced, and I'm wondering if Chain has a set of guidelines that the team uses for design and for implementation?
+
+**Tess Rinearson:** Yeah, so it's funny... We actually didn't know we were going to open source this until July, and we've been working on it for over a year. It's funny... This is kind of corny, but when I think about the lifecycle of this project, I actually think about GopherCon a lot, because we started building our own system after a conversation I had with our CTO at GopherCon 2015. Then, at GopherCon 2016, this year, I basically got a phone call from my team - I was the only one at GopherCon, so they call me, being like "Hey, we're planning on open sourcing"... So both GopherCon 2015 and GopherCon 2016 were milestone moments for this project in this funny, coincidental way.
+
+**Erik St. Martin:** You're counting in GopherCons...
+
+**Brian Ketelsen:** Milestones for everybody, though... It's not just the project, it's GopherCon.
+
+**Tess Rinearson:** Right, I think that's how the world measures time now, right? By GopherCons...
+
+**Brian Ketelsen:** Yeah... That was three GopherCons ago.
+
+**Tess Rinearson:** Right. \[laughter\]
+
+**Brian Ketelsen:** Actually, Brad Fitzpatrick did that to me two or three days ago -- no, last week. I hacked Docker into Go's present tool, so I could run a Docker container inside a slide, and I was so proud of myself... So I tweeted it, and Brad's like "I did that three GopherCons ago." I was like, "Oh, son of a gun!"
+
+**Tess Rinearson:** Harsh!
+
+**Brian Ketelsen:** Yeah... Boy, did that hurt.
+
+**Erik St. Martin:** \[35:59\] Not only were you late to the party, you were three years late to the party.
+
+**Brian Ketelsen:** The first GopherCon. That's how we measure time now - three GopherCons.
+
+**Tess Rinearson:** Yeah. Anyway, to jump back to Carlisia's question about open source versus non-open source codebases and the way that you build them - we did not start building Chain Core with open sourcing in mind, but we always had pretty rigorous guidelines around even like commit style. And early on we had a lot of conversation about what should go into our style guide, and some of that actually made it into the formal style guide and some of it just sort of became community knowledge at the company. But really, the only things that we had to do when we open sourced were 1) we did not open source everything.
+
+What we open sourced we called Chain Core Developer Edition, and that's most of the guts, most of the logic, most of the interesting blockchain stuff is in there, but we do have other features around security and scalability that we withheld from the open source project. If you are a financial service paying us for an enterprise license, you get all of that good stuff too, but we didn't open source that. So we had to figure out how to split out monorepo for that, and then additionally we also had a small amount of company confidential information that we had to scrub from the Git history, but that wasn't too big of a deal either.
+
+Ultimately, it was a little bit of cleanup around the edges, but the code itself really didn't change. Oh, I think we also wrote some more package docs before open sourcing, but by and large we didn't have to change too much.
+
+**Brian Ketelsen:** Yeah, that's always my big thing. I write a bunch of code, and I think "Oh, I should release this on GitHub" and "Oh, I can't do that... There's no Go Docs. Can't do it." And I spent two days...
+
+**Tess Rinearson:** Oh my god... Wow.
+
+**Erik St. Martin:** See? Brian does the reverse to me, though. Like "You should open source that." "No. There's not really good test coverage, there's no docs, I'm not all that proud of the code..." "You should open source that", and then he'll open source it for me. \[laughter\]
+
+**Brian Ketelsen:** Just once.
+
+**Tess Rinearson:** That's so funny.
+
+**Brian Ketelsen:** Maybe twice.
+
+**Erik St. Martin:** Once he did it and then wrote a blog article about it. Like, "Oh, man..." \[laughter\]
+
+**Tess Rinearson:** Surprise! \[laughs\]
+
+**Brian Ketelsen:** Erik doesn't take enough credit for his awesome work. I'm just helping him.
+
+**Tess Rinearson:** It's always good to have a friend who does that.
+
+**Brian Ketelsen:** See? You need a champion in your corner.
+
+**Erik St. Martin:** I just wanna build stuff.
+
+**Brian Ketelsen:** Well, that's a good segue into our next sponsor.
+
+**Break:** \[38:41\]
+
+**Erik St. Martin:** So in prepping for this, you had sent an email and you were mentioning a side project that you had, and I always love fun side projects.
+
+**Tess Rinearson:** Yeah, this is kind of a funny one. I almost even hesitate to call it a side project, because that suggests sustained work over months, building towards something really awesome, and this is just something I play with. But you asked if I were going to hack on something this weekend, what would I hack on, and the answer is this funny thing I wrote, this little app that connects to Twilio. So when anyone rings the buzzer to my apartment building, it actually calls a Twilio number which then goes through this Go app, and then calls my phone... Maybe.
+
+**Brian Ketelsen:** \[40:11\] Nice!
+
+**Tess Rinearson:** Yeah... The reason this is cool -- so when I wrote it initially, I just wrote it because I have a Seattle phone number. I grew up in Seattle phone number, I'm really happy with it, proud of it, I don't wanna get rid of it, but the call box to my apartment requires a local San Francisco number. So the reasonable solution, the easiest solution is probably just to get a Google voice number and set up call forwarding, but I was like "No, no... What if...?"
+
+**Brian Ketelsen:** We have a much better solution for this!
+
+**Tess Rinearson:** Right! So part of it was like "What if I wanna do something else with it in the future?" Then, the other part of it was like, "Oh, but it would be so much more fun to write this myself", so I actually recently came up with the "Oh, here's actually why this is useful" piece of it, which is that I tried to sign up for a CSA, a grocery box, with this company... It's pretty cool, actually - they take vegetables that don't meet FDA standards for aesthetics and they sell them...
+
+**Erik St. Martin:** It's got a brown spot?
+
+**Tess Rinearson:** Yeah, totally. Or an onion that's too small, or a carrot that has two legs, or all these things that make something inappropriate for a grocery store, but they're still totally edible and delicious. I kind of got into this when I was living - this is also a cliché - in Berkeley, and my roommate in Berkeley has a food startup, and he'd bring home these big boxes of these "ugly" vegetables. So I was like, "Okay, great. I'm gonna sign up for this", but they only deliver between midnight and six in the morning, and I live in a part of San Francisco where if someone leaves a box of vegetables on the steps outside the apartment building, it will be gone in like 15 minutes.
+
+So the solution that the company suggests is that you give - this is turning into a very long backstory - a key to your building to them. And I was like "Yeah, I work at crypto... I don't feel good giving a key that I can't rotate to some company." So I was like "Oh, I know... I will write a code into my callbox app", so that if someone comes up, dials a number and then puts in the code within ten seconds, the Twilio app plays back a dial tone that I found online that matches the right, you're supposed to press nine, so it plays the tone for nine back to the buzzer, and the buzzer unlocks the door. So I can get deliveries in the middle of the night without getting woken up.
+
+This will be a problem when the person delivering the vegetables does not enter the code in time and then I get a phone call anyway. But until that happens, that's my grand plan. So that's what I've been doodling around with lately.
+
+**Carlisia Thompson:** Wow.
+
+**Erik St. Martin:** And you can audit log. You get to know when the door opened and they came in.
+
+**Tess Rinearson:** Yeah, I should definitely build that in. It's funny... That's like a really obvious...
+
+**Carlisia Thompson:** And then, of course, build the dashboard. Maybe use Prometheus.
+
+**Tess Rinearson:** \[43:48\] Yeah, these are all v2 things. Honestly, I haven't worked really on anything but Chain stuff for the past two months, just because we were trying to get everything in ship shape, and we had some product... You know, in addition to open sourcing, we had product stuff that we were announcing too, so I've been pretty heads down on the Chain codebase for the past two months. But yeah, I'm excited to get back to my doorbell project.
+
+**Carlisia Thompson:** Did that involve a screwdriver? That's what I wanna know.
+
+**Erik St. Martin:** Did that involve a screwdriver? \[laughs\]
+
+**Tess Rinearson:** It does not involve a screwdriver yet. \[laughter\] How did your screwdriver thing work out, by the way?
+
+**Carlisia Thompson:** It worked out. I needed to do some exercises with my hands, but it worked out in the end.
+
+**Tess Rinearson:** Awesome. \[laughter\]
+
+**Erik St. Martin:** Well, your Twilio makes doing phone stuff so awesome. Prior to that I had done some stuff with Asterisk and FreeSwitch. You had to build in and talk over a socket to these things, and stuff like that, to build IVR - Integrated Voice Response is what they call the systems where you call in and interact with them. But then you had Twilio, and there's another one - Plivo - that I know of since they've come out; you just get an API and you just have to expose a web service for it to call out to. It's so much easier to just throw stuff together.
+
+**Tess Rinearson:** Yeah. It's funny, Twilio is a little bit - as I learned on this project - of a pain in the butt in Go, because there's no Go SDK, and I think most people generally use SDKs, and everything else is XML.
+
+**Erik St. Martin:** Right, yeah.
+
+**Tess Rinearson:** So on this project I learned about... You know, I've never had to use Go's XML tooling before, but I learned a little bit about that, too.
+
+**Erik St. Martin:** Just kind of using structs and encoding it to XML.
+
+**Tess Rinearson:** Exactly.
+
+**Brian Ketelsen:** It works... I've done it once. It's painful, but it works.
+
+**Tess Rinearson:** Yeah. I mean, it's not the most fun, but it works, and there's not really any surprising behavior, which I feel like sometimes with web stuff is as good as it gets - no surprising behavior. \[laughter\]
+
+**Erik St. Martin:** I think people now live in a time that's much easier... Like, I remember web development when you really had to test individual browsers, because you had to write CSS that accounted for the differences between them. Like, "No more IE 6"... I remember when people had icons on their website for that, you know?
+
+**Tess Rinearson:** Yeah...
+
+**Erik St. Martin:** It was like their badge of "I refuse to support IE 6 just because of how much time it takes to make it work in IE 6." So glad that's over.
+
+**Brian Ketelsen:** When I was a kid, we only had one browser. \[laughter\] And it was Lynx.
+
+**Erik St. Martin:** I thought you were gonna say Netscape.
+
+**Carlisia Thompson:** Netscape, that's what I thought.
+
+**Brian Ketelsen:** Well, Netscape wasn't the first browser.
+
+**Carlisia Thompson:** But then, if you think of Gopher and Lynx, those were browsers, too.
+
+**Tess Rinearson:** I don't think I have even heard of Lynx before.
+
+**Erik St. Martin:** It's basically the console-based web browser for Linux.
+
+**Tess Rinearson:** Wow.
+
+**Carlisia Thompson:** Yeah. No image, just text.
+
+**Brian Ketelsen:** Just text.
+
+**Erik St. Martin:** I still use it sometimes, I can tell you. When I SSH-ed into some server and I need to curl or wget a file, and I don't obviously know the whole address to anything, I'll open up Links through the SSH session and go to the website and find that link that I need to download in.
+
+**Tess Rinearson:** I'll check that out and just play around with it.
+
+**Brian Ketelsen:** Don't do it. Really, I don't recommend it.
+
+**Tess Rinearson:** Wow, okay...
+
+**Brian Ketelsen:** It's not worth it.
+
+**Erik St. Martin:** You know you're only making it more tempting, right Brian? \[laughter\] Like, "What is it that's so bad he doesn't want me to see?"
+
+**Carlisia Thompson:** I'm like, "Do it, do it, do it!" \[laughs\]
+
+**Tess Rinearson:** I know. It's like all of us young kids who don't know how good we have it, we have to go poke at it.
+
+**Brian Ketelsen:** \[47:54\] It's funny, I was thinking... My first website was some place I had to spend $10/month to buy a shell account on a Unix system. That was back in the days when you got a username and they put the little tilde in front of it, and that was your website. BlahblahblahHosting.com/~BKetelsen. You couldn't change your username, you couldn't have a domain name pointed at it, and you had a public HTML directory in your home folder and that's where you put your files.
+
+**Erik St. Martin:** With FTP...
+
+**Brian Ketelsen:** Those were the days.
+
+**Carlisia Thompson:** I was sort of lucky in that way, because when the internet started - and by that, I mean nobody knew about it, but it existed - I was in school, so I got all of that for free. A modem connection for free, a dial-up number I could call for free, I got my web space, I got my email account - everything through school and it was free.
+
+**Tess Rinearson:** Sounds awesome.
+
+**Brian Ketelsen:** Nice.
+
+**Erik St. Martin:** My favorite story about young years and internet coming out was I stayed home sick from school one day and we had this CAD class; it was the room that had the most computers in it because they were doing computerated design on it. And I stayed home... I had basically backdoored one of the computers and I put trojans on all of them. \[laughter\] And I turned off the screens in series, because the computers were named in order, and then opened up the CD-ROM drives and then went back the other way... Back then it was funny; you didn't go to jail for stuff like that.
+
+I came to class the next day... My teacher's like, "Very funny. You know you're coming in after class and removing whatever it is that you put on these machines, right?" \[laughter\]
+
+**Brian Ketelsen:** Yeah, today you'd be in a federal prison.
+
+**Erik St. Martin:** Yeah.
+
+**Tess Rinearson:** Yeah, I have a good friend who in high-school got in trouble for even pointing out security vulnerabilities in his school's network. They were like, "Oh, if you've noticed these things, it's totally predictable..."
+
+**Brian Ketelsen:** You're hacking.
+
+**Tess Rinearson:** Yeah, yeah. And this was maybe like six years ago.
+
+**Carlisia Thompson:** Yeah, I used to... When I joined a new company, I would browse around just to see what level of security this company has, and what kind of engineering this company has. So I'd browse around, and one time I browsed through my manager's -- it was a Microsoft system and everybody's folders were right open; I was browsing through my manager's folders... I saw them, but I didn't go into them, because if I see something, I can't unsee it, and then I don't have plausible deniability. Of course, nobody knows me, but I didn't look at the things. But I told her. Man, did I get in trouble. It was not fun, so I'm like "Okay... You're welcome." \[laughs\]
+
+**Erik St. Martin:** Most people get the basics wrong... You know, SQL injection, cross-site scripting, cross-site request forgery, remote and local file inclusion issues... Because most of it all comes down to not sanitizing inputs. You take a form field and then just stuff it in your command that you run on the command line, and don't really think about what could be done there. Those typically tend to be the things that people find.
+
+**Tess Rinearson:** Yeah.
+
+**Erik St. Martin:** There's the true elite stuff, where somebody spends six months to reverse engineers some odd protocol for your piece of hardware, and then manages to hack you. But for the most part, these things are the basics everybody skips over.
+
+**Tess Rinearson:** Yeah, or they're social. I feel like so many stories I hear about people's accounts getting hacked have to do basically with hackers lying to customer support people.
+
+**Erik St. Martin:** Oh, yeah... Social engineering.
+
+**Tess Rinearson:** Yeah... Forget not sanitizing your inputs; people are people.
+
+**Erik St. Martin:** Well, it's easy though. Like... Acrobat. I remember there was one Defcon where they threw a zero-day party where you could attend the party if you had a zero day for Acrobat. There was that many zero days that they threw a party for people who had one. So it's things like that... All I have to do is get you to open a PDF in Acrobat, and done.
+
+\[52:14\] Even Excel has remote code execution issues where you can... Yeah, so it's that type of stuff that people get hit all the time with, and unless you live in a paranoid world...
+
+**Tess Rinearson:** Right, right. Sometimes I think about security stuff and I'm like, "Being secure is so much work." It's just exhausting.
+
+**Brian Ketelsen:** Well, there's no such thing as security. All there is is different levels of risk. There's no system that's completely secure, especially when there's humans involved.
+
+**Tess Rinearson:** Totally.
+
+**Erik St. Martin:** Yeah, I mean every bit of security comes at a cost of usability. I have problems too, even at home... I'll have two isolated Wi-Fi networks. I have one for people who come to my house and I have my own. And then at some point I forget what the guest network is, or I'm just lazy, and I'm like "Here, let me put you on the regular one." And that's the stuff that bites, it's because that kind of laziness and not following the process.
+
+So who wants to talk about any news?
+
+**Brian Ketelsen:** Oh, I've got some news. Hang on, let me get my guitar.
+
+**Carlisia Thompson:** Yes!
+
+**Erik St. Martin:** Oh, no...
+
+**Carlisia Thompson:** Oh, yes!
+
+**Brian Ketelsen:** Alright. So the word on the streets is it's Bill Kennedy's birthday... And here at GoTime we love us some GoingGoDotNet, so everybody is going to sing with me Happy Birthday To Bill.
+
+**Erik St. Martin:** I am totally not singing with you.
+
+**Brian Ketelsen:** Are we ready?
+
+**Carlisia Thompson:** Let's do this!
+
+\[singing Happy Birthday, accompanied by guitar\]
+
+**Erik St. Martin:** The lag is so bad!
+
+**Brian Ketelsen:** I don't feel like we're synchronized here.
+
+\[continuing the Happy Birthday song\]
+
+**Brian Ketelsen:** This is the most pathetic birthday song ever... Sorry, Bill. \[laughter\]
+
+\[finishing the Happy Birthday song\]
+
+**Brian Ketelsen:** Alright, there you go.
+
+**Tess Rinearson:** Wow, that was really hard.
+
+**Erik St. Martin:** Yeah, you don't notice the lag until you try to do something...
+
+**Brian Ketelsen:** Remind us not to sing on a podcast again... That was bad.
+
+**Tess Rinearson:** Yeah, alright. I'll check that one off my bucket list and never return.
+
+**Brian Ketelsen:** Put that one in the show notes, "Don't sing on podcasts together." \[laughter\]
+
+**Erik St. Martin:** So the fun thing though is I think in post-production they can realign everybody.
+
+**Tess Rinearson:** Wow!
+
+**Brian Ketelsen:** I don't think it's possible to realign that mess.
+
+**Carlisia Thompson:** We're not a bunch that can be realigned...
+
+**Tess Rinearson:** Can they autotune it, too?
+
+**Erik St. Martin:** \[laughs\] Oh, now I really wish I did sing, because then I could have been autotuned, and that would have been hilarious...
+
+**Tess Rinearson:** To be clear, I was asking for myself. But yeah... \[laughter\]
+
+**Erik St. Martin:** Yeah, so each of our channels is recorded individually I believe, so that would allow them to shift everybody to cut that part out and then shift...
+
+**Brian Ketelsen:** ...and get the autotune out. Somebody's gonna have to autotune me.
+
+**Erik St. Martin:** So for anybody who's listening to this, the recording of this - if that did not sound terrible, thank Jonathan Youngblood who does the post-production. \[laughter\]
+
+**Brian Ketelsen:** Well, it's gonna sound terrible no matter what.
+
+**Tess Rinearson:** I mean, it'll be charming, like an elementary school fingerpainting kind of thing.
+
+**Brian Ketelsen:** I think it will.
+
+**Erik St. Martin:** Just terrible in a beautiful way...
+
+**Brian Ketelsen:** It comes from the heart, Tess. As long as it comes from the heart, it's all that matters.
+
+**Tess Rinearson:** Yeah, exactly.
+
+**Brian Ketelsen:** \[55:49\] Alright, let's talk about some interesting Go projects and news out there. So the one big thing that came out across my desk was the review dog software, which is kind of slick. It's a Go application that allows you to add vetting to your Git repositories, and it will automatically do whatever level of vetting you choose, and then add those vet hits as comments to your Git pull requests. Kind of slick... It works not just with Go, but with any language that has a vet tool, and I think it ships with vetting capabilities for most of the popular languages. It looked like a really slick little addition to keeping your codebase clean.
+
+**Erik St. Martin:** Yeah, it was really cool because it adds... It's like having an automated person do code reviews and it adds comments to the line in the PR, or these things that got caught in the vet or lint. It looked like there was a way to run it locally too, to see what it was gonna do. You could pass in your gifs and things like that, and then it basically uses the error format (kind of like Vim) so that it can display it to you in a pretty way.
+
+**Carlisia Thompson:** I love this.
+
+**Tess Rinearson:** That sounds awesome.
+
+**Brian Ketelsen:** Yeah, it's really cool.
+
+**Tess Rinearson:** I wanna look into that for our project.
+
+**Carlisia Thompson:** Same here.
+
+**Brian Ketelsen:** So another bit of news... There is now a default Go path for Go 1.8, when Go 1.8 goes out. /go in your home directory; whether that's on Windows or a Unixy system, /go will be your default Go path if you don't set one, which means you now no longer need to explicitly specify a Go path. I don't really like /go as a choice, but I don't really care what color that bike shed is, because it's gonna make it a lot easier to get beginners onboarded with Go now, and I'm really excited about that.
+
+And I'd like to that personal responsibility for that, because I sent a ping on the GitHub repository, and the next responder was Rob saying, "Okay, let's do this!"
+
+**Carlisia Thompson:** Nice!
+
+**Brian Ketelsen:** So I think I pushed him over the edge.
+
+**Carlisia Thompson:** Nice, good work. I wonder what people are thinking about when they see the Twitter, so many people so excited about this. Because on one hand, I think you have people thinking "What's the big deal? It's not so hard to set your path." On the other hand, people might be thinking, "Oh my gosh, it must be so hard to set up Go that people are so excited about this." So they are both right, but from the perspective of a beginner or somebody who does code but is not necessarily dealing with the bash profiles of the file, or setting up requirement variables... This is a big deal. It's not so hard to set up Go; basically, that's all you need to do - you have to install and do that, and you're ready to go, as opposed to other languages I know.
+
+**Erik St. Martin:** I think it's just another step, right? Every time you have to take multiple steps just to be able to try something out.
+
+**Carlisia Thompson:** But it's not just another step, I think. For people who don't do that on a consistent basis, for them it's far... And even if they have done it in the past, it's just something so far, and they're like "Oh, where is it? How do I even save it? How do I edit it?" And just eliminating that is, "Wow!" Now, it just cannot get any easier than this, I don't think.
+
+**Tess Rinearson:** Although I do feel like in order to really make the most of a lot of the things that make Go awesome - like Go fmt - you need to configure these things and you need to noodle around in your Bash profile or set up your editor to run these things. So I'm totally with you, Carlisia, in that I'm really glad that for a lot of people this removes the need to think about that level of your system setup, but at the same time I'm looking forward to maybe more elements of the Go ecosystem being that automatic for beginners.
+
+**Erik St. Martin:** \[01:00:07.26\] Yeah, anything we can do to make the language itself and the tooling more approachable... And it's funny, because when you're in that area you think about it as like, "What's so hard about setting a Go path, because you're so used to it?" I like to compare this to the Ruby on Rails world; I came from there. Ruby was awesome, I used it for years, and it's like it's so easy until I tried to have a friend who wasn't familiar with it set his environment up. It's like, "Well, first you have to install rbenv, and then Bundler, and then you gotta do this..." Getting lost along the way, and it's like this hour-long process just to get set up to teach him some Ruby. It's like, wow...
+
+**Brian Ketelsen:** And then it fails.
+
+**Carlisia Thompson:** And it's hard to even explain what you're doing... It's like, "How do I even explain this?" \[laughs\]
+
+**Brian Ketelsen:** Yeah, somebody on Twitter the other day said, "Well, if you can't set an environment variable, you have no business programming", and that infuriated me.
+
+**Erik St. Martin:** That's not fair.
+
+**Brian Ketelsen:** Actually, I walked away from feeding the troll, but I was so mad... Because everybody has to start somewhere, and I'm sure the person on Twitter who said that started somewhere too, and it just frustrates me that we can't have nice things because elitists have their terminal issues.
+
+**Carlisia Thompson:** Yeah, it's hard for people sometimes to put themselves in other people's shoes and see that people have different entry points into things.
+
+**Erik St. Martin:** Yeah, I tinkered with C and things like that when I first started learning programming, but then I went those couple of years where I did PHP development, and I learned the most there because it was easy to just get started and drop files onto a server, and you didn't focus on everything else. And through doing that, I started learning a lot more about systems and stuff like that. But when you don't have that foundation to build on, it's much harder.
+
+**Carlisia Thompson:** But I also wanted to mention that what Tess was saying is a very good point. Sometimes we're so into doing what we're doing, and to us it's easy because we're doing it, but that is a good point - there's still stuff that can be done to make Go easier to use for beginners. I think what we are talking about is the workspace tool that Andrew Gerrand was talking about.
+
+**Erik St. Martin:** I don't think I've seen that.
+
+**Brian Ketelsen:** Well, it doesn't exist. It's a PowerPoint.
+
+**Erik St. Martin:** Okay.
+
+**Carlisia Thompson:** It doesn't exist... We talked about it before. He's not working on it. He got it started, and it's out there for somebody to take over. I don't have a link right now.
+
+**Tess Rinearson:** I think one thing that is really one of Go's strengths - I mean, you're talking about this troll who said, "Oh, this person has no business programming" - is that even though right now the community consists largely of people where Go was definitely not their first language; people have been programming for a long time. There's an interest in making it accessible. And the people who are visible and are leaders in the community, like the three of you, really have actively said that this is important. I think there are other languages or other technical communities where you don't have that, so I think that that alone is enough to get all of it going, I hope.
+
+**Carlisia Thompson:** I think it has the potential for going in that direction.
+
+**Tess Rinearson:** Yeah.
+
+**Brian Ketelsen:** Alright, so we're running overtime, we need to get to our \#FreeSoftwareFridays.
+
+**Erik St. Martin:** We are... So who wants to start?
+
+**Tess Rinearson:** I have one.
+
+**Erik St. Martin:** Go ahead.
+
+**Brian Ketelsen:** Go, Tess!
+
+**Tess Rinearson:** I wanna give a shout out to the go-torch project and the Uber engineering team who worked on that, and Prashant (whose last name I'm now forgetting). We used that tool a ton when we were doing performance work here at Chain. Just really easy to use, and super helpful.
+
+**Brian Ketelsen:** \[01:04:05.27\] That's awesome.
+
+**Erik St. Martin:** Yeah, it's amazing how fast that took off. I think it was Brendan Gregg who started doing the Torch graphs. He's like THE performance guy.
+
+**Brian Ketelsen:** I taught a whole segment on performance measuring, and everybody in the class was just blown away by the whole Torch graphs and how easy it was to do. So yeah, +1.
+
+**Tess Rinearson:** Yeah, talk about making things accessible.
+
+**Brian Ketelsen:** Totally +1 on that one. My \#FreeSoftwareFriday shout out is to Andrew Gerrand, who wrote the Go Tour, which I forked this week and used for my own devilish purposes. But what a well-written piece of code. An absolute breeze to go through and bend it to my will... So thank you, Andrew, for writing The Tour and making it open source. It's such a nice piece of software.
+
+**Erik St. Martin:** I'm actually really surprised that there hasn't been more contribution to the Go Tour, to kind of expand on it. Because that's like a call for help.
+
+**Tess Rinearson:** \[laughs\]
+
+**Brian Ketelsen:** Well, there's a readme in the repository that even gives suggestions for tours that should be submitted. I just think people haven't tried to learn the format for it, which is disappointing because it's the same format for Go's present tool, and that's a great way to help people onboard into the community.
+
+**Erik St. Martin:** I'm gonna volunteer other people.
+
+**Brian Ketelsen:** Somebody should do that! \[laughter\]
+
+**Tess Rinearson:** That's the kind of thing that seems like a great way to contribute to the community. I mean, I think I have found myself in this position where I'm like "Oh, I don't know what I could contribute to", and I definitely know people who are interested in contributing... So that's a good one, I'll keep it in my pocket. I won't volunteer people to the project, but I will volunteer the project to people if they are doing the "Where do I contribute to...?" thing.
+
+**Brian Ketelsen:** There you go...
+
+**Erik St. Martin:** And how about you, Carlisia.
+
+**Carlisia Thompson:** I don't have one today... Forgive me.
+
+**Erik St. Martin:** Alright. So mine - I've just recently found this tool, and I don't know whether they pronounce it all as one, Cinf. It's actually a cool tool for inspecting containers. If you're not familiar, like Rocket, Docker and all these things - they mainly use cgroups and namespaces. I'll link it in the channel for anybody who's listening along.
+
+So it basically allows you to inspect a process and look at the cgroups and namespaces that the process is running with, so you can kind of inspect the CPU stats and things like that from the cgroups, and you can do the reverse too, to see which processes are a part of a namespace. So it's kind of a cool way to inspect your containers and see how they're wired up.
+
+**Brian Ketelsen:** Nice.
+
+**Erik St. Martin:** I've only recently started playing with this, but especially looking at cgroup values for a container or a process running into a container; I'm still used to going into the sysfs directory or in the proc directory and kind of poking around to get the values. So this is really cool.
+
+One of the cool things is there's like a monitor flag where you can sit there and just watch, so you can kind of see your CPU stats change for the cgroup.
+
+**Brian Ketelsen:** Approved. Good one.
+
+**Carlisia Thompson:** I do have one, actually... Can I go?
+
+**Erik St. Martin:** Yeah.
+
+**Carlisia Thompson:** There is a repo from Cory LaNou, it's called "OSS help wanted", and it's a repo for... Basically, you can edit the readme file and list your project. There are projects there organized in all kinds of ways, for example there is one that's "Beginner/intermediate/expert", another one is "All help wanted", "Help wanted/Easy"... So basically, throw your project up there if you need help, with a link to your project, and let's get to it.
+
+**Tess Rinearson:** \[01:08:09.06\] That's awesome.
+
+**Carlisia Thompson:** Go Tour included. We can include it there.
+
+**Erik St. Martin:** Awesome. So we are definitely over time, so I guess it's time to say our goodbyes. I definitely wanna thank everybody who's on the show today, thank you for everybody who's listening live, and everybody who's listening to the recorded version of this. Huge thank you to our sponsors, Linode and Code School for keeping us doing these things. Definitely share the show with fellow Go programmers.
+
+If you haven't subscribed, you can go to GoTime.fm, and we are @GoTimeFM on Twitter, and you can also find us in the GoTimeFM Slack channel.
+
+**Brian Ketelsen:** And we promise we won't sing anymore... \[laughter\]
+
+**Erik St. Martin:** Not overtly anyway... So I think with that, goodbye everybody. See you next week.
+
+**Brian Ketelsen:** Bye.
+
+**Tess Rinearson:** Bye.
+
+**Carlisia Thompson:** Bye, this was fun!

Programming Practices, Exercism, Open Source_transcript.txt

@@ -0,0 +1,575 @@
+**Erik St. Martin:** We are back for another episode of GoTime. This episode is number 19. Today on the show we have myself, Erik St. Martin, we have Carlisia Campos also here...
+
+**Carlisia Thompson:** Hi !
+
+**Erik St. Martin:** ...and Brian Ketelsen...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** ...and our special guest today is none other than Katrina Owen.
+
+**Katrina Owen:** Hello!
+
+**Erik St. Martin:** Why don't you go ahead and give everybody a little bit of background about yourself before we get started.
+
+**Katrina Owen:** I work as a developer advocate at GitHub on the open source team there. I do a lot of community stuff - I go to conferences, meet people, and a lot of open source work. I have a project named exercism.io, which is a platform for practicing programming in a number of different languages, including Go.
+
+**Erik St. Martin:** Yeah, Exercism has been taking off recently. I look probably like two weeks ago and was completely astonished by the number of languages that are supported there now.
+
+**Katrina Owen:** Yeah, we hit 32, which was kind of a big number - two times two, times two, times two, times two, I think... \[laughter\] We passed that a few weeks ago when we launched I believe MIPS Assembly, which was kind of cool.
+
+**Brian Ketelsen:** So is there big deband for MIPS Assembly?
+
+**Katrina Owen:** It turns out that Assembly language courses at universities often use a textbook that uses MIPS Assembly.
+
+**Brian Ketelsen:** Ah-ha!
+
+**Erik St. Martin:** Interesting. I would actually like Assembly, because... I mean, most Assembly books that I've read or seen are very much documentation and not "How do you write idiomatic Assembly?" I don't think anything I've looked at with Assembly does more than teach you the individual instructions and what they do. You don't really learn patterns from that. So that would be kind of cool.
+
+**Katrina Owen:** It is pretty cool.
+
+**Erik St. Martin:** And all my free time to learn new languages... \[laughter\]
+
+**Katrina Owen:** A language a year. You've got the next 33 years all laid up for you.
+
+**Erik St. Martin:** Right, but by then, how many new languages will you have?
+
+**Katrina Owen:** Yeah, that's the problem.
+
+**Brian Ketelsen:** Yeah, your hockey stick growth is slowing us down, I can't live that long.
+
+**Carlisia Thompson:** Actually, I just remembered that a lot of people and myself included keep wondering what is idiomatic Go, because there is no such thing as a listing of what idiomatic Go is, and it sounds like it's a mythical thing to me. Exercism actually guides you through that. The comments that you get back on your solutions are very much geared towards helping you write idiomatic Go. So just by doing it, you start understanding what it is, and the comments are very helpful and very empathetic, so I highly recommend it.
+
+**Erik St. Martin:** So let's actually step back for a second for anybody who's not familiar with Exercism.io. Do you wanna give a brief introduction to what that is, Kristina?
+
+**Katrina Owen:** Sure. It's basically a platform for practicing. It's different from a lot of other places where you do coding challenges and katas in that there is not competition; you're not competing with anyone, there's no leaderboard, there are no prizes or badges or anything like that. This is really about the day-to-day practice of getting better at the craft of programming, or it could be a very quick little ramp up that you need when you're going to suddenly start a new project at work, in Scala, or Java or some other language, and you need to get into that language and get your head wrapped around the syntax of a language and the conventions of that language quickly, so that you can start producing code in a more complex environment.
+
+**Erik St. Martin:** \[04:24\] This is basically bite-sized problems to be solved that you submit and then are reviewed by people who have more experience in the language, that kind of guide you through how you might do that.
+
+**Katrina Owen:** Yeah.
+
+**Erik St. Martin:** Is that done anonymously?
+
+**Katrina Owen:** No, it uses your GitHub username and avatar. We've talked about making it anonymous, but for the moment we have just not gone down that route. As you said, the format of the exercise is bite-sized, it's very small, trivial programs like "Calculate whether or not a year is a leap year"... It's mostly 20 to 50-line problems. We give you a working test suite so that you know when you're done - though 'done' is just the first iteration - and then given feedback, you can produce a new solution, iterate on it and improve things.
+
+**Carlisia Thompson:** Those test suites are awesome, by the way. My first encounter with Go, right after I started doing the exercises, and immediately I wanted to learn how to do tests, and I'm like "Oh, look at that, there are tests right here", and that's where I started learning tests from. It was perfect. They were simple, they were clear, they were concise, and they were all I needed to learn the basics, the fundamentals of how to do unit tests with Go.
+
+**Katrina Owen:** That's awesome. I talked to someone at GopherCon who said that they learned Go -- so they were a game developer in Lua, and when they were switching to Go they used Exercism to learn it. When they started their new job at Fastly, they were the only person on their team that knew how to write tests in Go.
+
+**Erik St. Martin:** Oh, wow.
+
+**Brian Ketelsen:** That's awesome. Validation right there for you.
+
+**Katrina Owen:** Yeah.
+
+**Erik St. Martin:** And now the reviews are kind of crowdsourced. These are people with more experience who are kind of volunteering their time?
+
+**Katrina Owen:** Yes.
+
+**Erik St. Martin:** So people also sign up to kind of do that, as well?
+
+**Katrina Owen:** Yeah. It's hard... There's this asymmetry where people want feedback but don't necessarily want to give feedback or know how to give feedback, how to do a correct review. And it's really intimidating to come in and say, "Oh, I'm gonna give someone feedback on their code, but maybe I'm not really good at Go, or I don't really feel like I know what I'm doing, or when I look at some code I might not feel like I know... Like, it's just code - how do I know what's good or not good, or idiomatic or not idiomatic?" There's a barrier to entry on actually providing feedback.
+
+**Erik St. Martin:** I think there's some emotional side of it too, where somebody's trying to step out of their comfort zone and learn something new, and you want to support them in that and not beat them down on what feel like trivial things, too. But you commonly see that with people that are new to code review. They see something that they'd say something to a fellow programmer that they've worked with for years, but they don't wanna say it to somebody new, because they don't know how they're gonna take that.
+
+**Katrina Owen:** \[07:34\] Right, and that's part of the thing of being on the internet - you probably don't know the person, you don't know their learning style, you don't know why they're there learning Go... Maybe they're learning programming for the first time and Go just happens to be that language. Maybe they have been programming for 20 years and Go is just for fun, maybe they need Go desperately for a project... It's hard to know.
+
+**Carlisia Thompson:** But there is also the positive reinforcement type of feedback, and there is a lot of that on Exercism. Regarding comments, I heard the Request For Commits episode number four, which is about building successful open source communities, and the guy said "Well, I have this community, I've built it, and one day I went on vacation and I came back and I saw people commenting using my voice." On Exercism, because Katrina comments on things and her style is a very solid, professional way of commenting, very kind... You definitely notice it's a good comment, if you are not familiar with code review. So you also notice people using her voice on their comments, and I thought that was so amazing; it totally blew my mind when I started noticing that.
+
+**Erik St. Martin:** That's interesting... So they kind of picked up the review style and the way to speak to people and are kind of mirroring that?
+
+**Carlisia Thompson:** Yes, and then I even told Katrina at one point, "Wow, this is so amazing. You come for the code, and you stay for the comments", because you also learn how to comment on code. You can be giving correct feedback and you can also positive feedback, and how you do it... Katrina is a pro, and you will learn that, either from her or from the members who are also learning from her and from each other. It's amazing.
+
+**Brian Ketelsen:** I love that.
+
+**Erik St. Martin:** I guess anybody who want's to take time out of their day to help review these challenges more than likely really care about trying to evolve people, and aren't going to be rude, right? Most people who are gonna be rude don't wanna waste their time anyway.
+
+**Katrina Owen:** Yes, they're elsewhere.
+
+**Carlisia Thompson:** But you can be rude without meaning to be rude. For example, I know how to do code review and I know what good, empathetic comments look like, but when I'm tired, I comment on things and then I look at it and I'm like "Oh my gosh, I could have said that in such a much nicer way, and I didn't. Ugh!" So it takes practice... You exercise that muscle so that even when you're tired you do it the way that you think is a good way, the way that you want to. So I totally see how somebody commenting and it seems it's coming across as rude, but maybe it wasn't intentionally rude. Obviously, there are those that are blatantly rude and you can see the intention behind it, but in some cases they just don't know.
+
+**Erik St. Martin:** I think an important thing to remember from both sides, and I tell this to some of the guys who are new to code review, is when you're thinking about it, solving the problem is the hardest part, right? So looking at somebody else's solution and telling them how they can refine that to make it a little cleaner or a little more performant, that's significantly easier - especially if you're already knowledgeable in the domain - than it is to solve the problem.
+
+So if I reviewed your code, I may have a ton of things to say about your code, but if I was presented with the problem without ever seeing anybody else's solution, I may have suffered from the same things, right? So I think having that empathy and keeping that frame of mind that this evolves as somebody's understanding of the problem evolves, and you weren't there for all of the small decisions along the line that lead to this. You're looking at it as a completed product, and thinking "How can I make this better?"
+
+**Katrina Owen:** \[11:57\] And especially when you're learning a new language, you're not familiar with the standard library functions and the packages, you're not familiar with how scoping works or constants work, so you'll often see a lot of flailing around as people try to figure out how to even get the syntax right. Then once it compiles, it's like "Oh, it work. Wonderful!" and submit that and then it turns out that you've done all this extra stuff that turns out to just be noise. Once you start understanding the underlying implementation and the underlying language syntax, you can start simplifying and removing some of the complexity, and you need human feedback for that.
+
+**Erik St. Martin:** I think that's a fair point. And even with refactoring... Refactoring is its own skill set. There's people who can look at this and they're like "Oh yeah, I just have to check this one method and do this", but it's a whole new world that most people aren't presented with.
+
+**Brian Ketelsen:** I used to call that "running it through the Erik machine", because I would write horrible code and then I would give it to Erik and he would make it beautiful and performant and work. Erik's good at that part.
+
+**Erik St. Martin:** Well, I'm not always... I mean, I look at a lot of code too that even I have written, and I'm like "This doesn't look clean" and I'm not quite sure how I wanna start to make it prettier and more abstracted. Sometimes it takes a fresh pair of eyes.
+
+**Katrina Owen:** It really does. I talk about refactoring a lot, and I've just realized recently that when I do a talk about refactoring, I'm showing someone the clear path, the obvious path, the one that's obvious in hindsight, and almost always when I'm actually refactoring for the first time, I have no idea where it's gonna end up. I just recognize specific red flags, or code smells, or there are things that I don't like, and I choose to go down a path of exploring a cleaner solution or a better abstraction, but I don't ever know -- half the time, or maybe more than half the time, I back out the thing that I tried and I end up going in a different direction.
+
+Whenever I talk about this in public, I forget to mention that part, so it looks like I have this godlike view of the end product, and it really isn't true.
+
+**Erik St. Martin:** I commonly, for problems I'm not certain on where I'm going with them, I commonly will spike out something that kind of works, and then throw it away and start completely over now that I have a better view of the actual domain.
+
+**Katrina Owen:** Yeah... One of the things I've been learning over the past few years is how to take much smaller steps so that everything is passing the whole time, and as soon as I decide that I don't wanna go down on one route, I can back it out and the test suite's always green.
+
+**Erik St. Martin:** The whole red/green/refactor?
+
+**Katrina Owen:** Yeah, mostly like "Stay green when you're refactoring." A lot of people will -- something will break, and then they're like "Oh, I know what to do. I know where I'm going with this", and then it will be broken for a long time, sometimes hours or even days at times, until they get everything back under control. I've been trying to avoid that just as an exercise, to see what happens if I take a small step and I keep things passing the whole way. Can I add more duplication? Can I do something a little bit weird temporarily to keep things green, so that everything goes more under control?
+
+**Erik St. Martin:** That's a fair point. I'm guilty of some commit bombs myself. I refactored a ton of stuff and the test suite's not quite passing for a while...
+
+**Katrina Owen:** Well, in Go, with the compiler telling where all your types are wrong and where you need to update the APIs, it's actually a lot easier. I'm more reckless in Go than I am in Ruby.
+
+**Brian Ketelsen:** \[16:02\] That's interesting to hear, because I think I was significantly more reckless in Ruby than I was in Go. Maybe I was writing poor Ruby, or maybe I'm writing poor Go, I don't know. Which do you think it is for you?
+
+**Katrina Owen:** I don't think it's either, I think it's just the style.
+
+**Carlisia Thompson:** I think I'm less reckless at this point in Go than I ever was in Ruby, even after a few years of doing Ruby, because of two things. One, the syntax is so short, it's so easy to memorize what you have to do. And two, although you haven't memorized it yet, the compiler is giving you feedback, so you're kind of seeing what the errors are and again, going back to the first point, there are just so few errors that you memorize them quickly. So pretty much I don't get a whole lot of compiler errors because I know what to do with the syntax.
+
+**Katrina Owen:** I wonder if 'reckless' is the wrong word here, because with Go I trust that the compiler is going to tell me about every single mistake. So if I do some complicated rename or start working on changing a type, I know that the compiler is going to tell me about every single location where I have to make that change. In Ruby there was nothing that was gonna tell me everything, and I couldn't trust that my tests had all the changes, so I had to tread my way much more carefully. In Go I think I just feel safer with the compiler at my back.
+
+**Brian Ketelsen:** It's almost like you're more carefree.
+
+**Katrina Owen:** Yeah.
+
+**Erik St. Martin:** You tend to, rather than looking at it from the negative side, like "Oh, you can be more reckless in Go", maybe it's just you don't have to scrutinize your refactorings as much; you don't have to examine them and think about all the dynamic places that might cause problems during runtime.
+
+**Carlisia Thompson:** Yeah, I can see that.
+
+**Erik St. Martin:** Before we move on to other things, I wanna go back to Exercism real quick because I think we really should try to shout out and get people involved. There's multiple ways to be involved, right? By submitting exercises for languages you're familiar with and by helping to review code. Where is the best place to send people to do that?
+
+**Katrina Owen:** There is a third option, secret door number three, and that is go to the Go language track repository on GitHub and watch it. Then when issues come in, help respond when pull requests come in, help review them. That would be an immense help to keep the language going and the people happy. So that's this sort of secret path to maintainership route.
+
+The other pieces that you've already mentioned - doing the exercises, submitting them to the website... Once you submit, you get access to all of the other solutions to that particular exercise, so you can browse around and look at what other people have done, how that's different from yours; you can learn from reading their code and you can learn from comments that other people give on these solutions.
+
+I have a little bot that does some linting and a little bit of static analysis in Go, to give feedback. It's mostly stuff that I was giving feedback on over and over again, so I just added this to the bot so that it automates that a little bit. But yeah, do the exercise and get feedback. In order to give feedback on an exercise, I would encourage you to do the exercise first, just to get a little bit of a feel for what the problem is and the different types of issues that people might run into with it.
+
+**Brian Ketelsen:** Can you give us the link to that GitHub thing again, so we can make sure we get it in the show notes?
+
+**Katrina Owen:** Yeah, for sure.
+
+**Brian Ketelsen:** Awesome. So this is a good opportunity for us to take a break and thank our first sponsor, Linode.
+
+**Break:** \[20:04\]
+
+**Erik St. Martin:** Okay, so we were talking about Exercism. The other thing you recently did was the GopherCon talk, which blew many of our minds. I think you really were able to capture and put into words what a lot of us feel about breaking into the language, that we're too close to the problem sometimes because we already have history there and we don't really think about... Like, I loved your graph analogy. That talk was probably one of the favorites there. I know a lot of people felt really close to it.
+
+**Brian Ketelsen:** That was an amazing talk.
+
+**Katrina Owen:** Thank you so much. It was a terrifying talk to do and to prepare.
+
+**Erik St. Martin:** I don't know, I think you looked like a master up on the stage.
+
+**Brian Ketelsen:** Not only did it resonate with almost everybody in the audience personally, but it was one of the best delivered talks and most compelling slide decks, too. It was the total package: it was a great message, it was a great delivery, and a beautiful slide deck. First time I've seen a presentation where there was very little text on the screen, but instead images that were emotionally evocative towards the points that you were trying to make, and I thought that that was a very strong artistic use of slides. It drove home for me how much visually you can impact a presentation without words. I was really, truly impressed with the whole thing.
+
+**Katrina Owen:** Thank you.
+
+**Erik St. Martin:** I died with the Twinkie analogy, too. \[laughter\]
+
+**Katrina Owen:** The Twinkie analogy is something I think about a lot. For anyone who didn't see the talk, when I read the language spec, I felt like I knew all the words - or almost all the words... There were some that I was completely unfamiliar with, like ebnf notation; that was something I had never actually been faced with before. And I really felt like I was reading the ingredients list for some complicated food or candy, and was expected to be able to draw a conclusion of how to produce that complicated food or candy from reading the ingredients list, and it made me feel pretty inadequate of a human.
+
+**Erik St. Martin:** I've read the language spec a number of times and I continuously go back to it. It's hard to remember all that and put it in context sometimes. It's hard to just kind of read through it. It's small, and most of it we understand, but applying it is completely different.
+
+**Katrina Owen:** Yeah. The purpose of it isn't really to tell you how to write Go code, it's more to tell you how to implement the Go language.
+
+**Erik St. Martin:** That's true too for alternate compiler implementations.
+
+**Brian Ketelsen:** \[24:04\] We mentioned a little bit earlier about idiomatic Go, and I remembered that we had a Wiki resource; there's a code review comments section on the github.com/golang/go/wiki Code Review Comments, and it's what Google uses internally for their code reviews. So if there were no other canonical source of what idiomatic Go code should look like, that might be a really good place to start.
+
+**Katrina Owen:** It's an awesome document. That and the Effective Go document/project as on my website - both of those are things that I refer to constantly when getting feedback on Go code. It's amazing.
+
+**Erik St. Martin:** I need to look through the code review comments more often. I know I've looked at it in the past, but it's probably been a long time since I've look at it. It's amazing, especially as you get older, that "out of sight, out of mind." I'll be busy and I'll do stuff and I won't write code for a couple of months, and then I feel like somebody should put me through code review boot camp again, just to ensure that I'm still doing things correctly.
+
+**Katrina Owen:** I actually did an experiment based on one of the exercises on Exercism. I started collecting some solutions that were typical - there might be 10 or 12 different directions that people take a solution in. As I put all of those in a document with the typical feedback that you might get if you go in that direction, and I kind of feel like it's a code review boot camp, a very small code review boot camp. You get reminded of where the resources are that refer to certain idioms or conventions, or why you might explain how the language works in this way and why you might choose this syntax over that syntax. It was an interesting experiment, I wish I could spend some more time developing that.
+
+**Erik St. Martin:** So all of this stuff that you're doing really is kind of driving towards teaching people programming, and not just the language, but idioms and how to refactor talks you've done in the past. It seems like a lot of your motivation is to help people learn, and to learn in ways that work for them.
+
+**Katrina Owen:** Yeah, I'm fascinated by how people learn, and I'm also fascinated by how often we teach people badly. The tools that we put in place, or the systems that we use often work for some people, but not for others, and the result is often that some people are left behind or left out, and left feeling that they're not smart enough or good enough, or competent, or they can't become programmers or they can't become whatever it is. And I feel that that's a tragedy really, for not just the people who are left behind, but for the community itself. We lose so much richness of experience, so much richness of all of these people with all of these experiences and points of view, and these ways of solving problems, and we don't have access to that if we only teach people in one way.
+
+**Erik St. Martin:** Yeah, I love the approach of the small wins and kind of working on these things. We talked to Bryan Liles in the episode prior to the last and some of the same stuff was coming up, too. We talked about needing to have some of those small successes, because if you're just approached with one problem, or maybe ten different things you have to learn and understand to pull your website. What's DNS? What's HTTP, HTML, CSS, JavaScript?
+
+**Katrina Owen:** \[28:07\] What's a text editor? \[laughs\]
+
+**Erik St. Martin:** Yeah. Now I need to store stuff in the database, now I need to learn SQL. You get hit with this, and it's easy for us to talk to friends or family or somebody who's interested in it, and be like "Oh yeah, all you gotta do is learn HTML and CSS and a little bit of JavaScript. From there, pick a backend language and a database..." Then they're sitting here trying to figure out how tot get their web page showing up in a web server, and they feel inadequate and that it just takes natural ability. We forget that we learned all of these things in small wins, a little bit at a time.
+
+**Katrina Owen:** Yeah, we weren't born knowing it either. We forget that sometimes, I think.
+
+**Erik St. Martin:** And there's so many other things, too. Git and GitHub, that's almost a necessity now, right? Oh, I wanna work on this thing... Before, you just had to unzip something. You just went to the website, you pulled down the TAR files (or the file, depending on the architecture you were working on) and you had the code.
+
+**Katrina Owen:** Yeah.
+
+**Erik St. Martin:** Now here's this whole other thing, cloning and...
+
+**Katrina Owen:** Yeah. I'm helping someone learn how to program, I've been doing that for a while, and they're like "Okay, so I made my first website." It's on their computer and they look at it in their browser using the File:///, right? "How do I put it on the internet?" I was like, "Oh, that's easy. You use GitHub Pages." \[laughs\]
+
+**Brian Ketelsen:** Just register DNS...
+
+**Katrina Owen:** No, it's way easier than the DNS, you don't have to know DNS. You can use GitHub Pages, but of course, then you have to know Git, and that's a painful process.
+
+**Erik St. Martin:** Right.
+
+**Carlisia Thompson:** My thinking when I tell people who want to learn to program or are not super experienced yet is "Master your editor and learn Git." Carrie Miller has a great talk about the need to fail to learn things, the need to experiment, and knowing your editor well and knowing Git well will help so much towards that goal. Because with Git, you add things to Git, you keep track and you change, when you wanna go back you go back, you jump around, you wipe things out, you reset things... So knowing Git well - or at least well enough - is such a big help. It makes you go from 2 to 8 as a developer, I think. Not to mention that it's super useful; you're gonna need it anyway to put things on the web, and things like that.
+
+**Katrina Owen:** Yeah, I completely agree. There's a new series by Michael Hartl that he and some of his colleagues are working on called "Learn Enough to Be Dangerous" (learnenough.com) The very first thing that he gives you is a tutorial for the command line. Like, "Get just enough command line to be dangerous." Then the second thing is a text editor, and the third thing is Git - that's super important.
+
+**Erik St. Martin:** I have a friend that's breaking into programming, and I have him developing off of just an Ubuntu Linux machine, just so he can get enough basic commands - moving around, copying files... It's almost a necessity these days. One thing I like about the evolution of Linux is that it's much more approachable for people, but I think one drawback to that is many of the lessons I learned in tech were through diagnosing problems in Linux... \[laughter\] Why is the networking not working? Each one of those little problems is a learning lesson, but the problem is giving people problems that are easily approachable with their knowledge, so that it's just beyond their boundaries, and not something totally off the wall, like having to recompile your video driver in Apache because it doesn't work with the newest Kernel version, or something.
+
+**Katrina Owen:** \[32:13\] Yeah, that's not very friendly towards newbies who learn to program for the first time.
+
+**Erik St. Martin:** Yeah, I think a little bit of Linux knowledge... At least being able to SSH and understanding what SSH is. In this day and age, security is a big thing, so understanding a little bit about how firewalls work, cross-site scripting... You can't think about too much of it at once, that's the problem. I wish there was like a steps thing, because that's always the hardest part I find. I could write down all the things you need to learn to write a production site, but what order to approach those? Because it feels like circular dependencies.
+
+**Katrina Owen:** It's easy to make small adjustments for syntax and for standard library stuff, but it really isn't easy to figure out which order to teach those. Like you were saying, DNS and SSH, networking, debugging, troubleshooting...
+
+**Erik St. Martin:** Yeah, understanding HTTP protocol, and cookies, and things like that. And now, I mean, TLS is becoming almost a requirement, so now you have to understand a little bit about that; it feels like we're evolving, but we're making it harder to break into. I used to just throw caution to the wind and drop PHP or Perl files upon a shared hosting site... \[laughter\]
+
+**Katrina Owen:** ...which, let's say, it totally worked.
+
+**Erik St. Martin:** Yeah. You needed to know how to use an FTP client and that was about it.
+
+**Brian Ketelsen:** Those were the days... Just make sure it's in the right directory, and everything was taken care of.
+
+**Erik St. Martin:** This is actually an interesting thought, too - would something like Exercism work in learning Linux basics, configuring Apache, or NGINX, or little micro successes there to help people learn the systems level of the field?
+
+**Katrina Owen:** I think it would work, but I don't know how we would do feedback. I think we could make a lot of very small challenges that people could be successful with, but I don't know how we would look at what they did and say, "You could do it better in this way."
+
+**Erik St. Martin:** Yeah, you're right, the feedback part, aside from the fact that it works would be difficult. I suppose if you're looking at different ways somebody wrote a systemd unit file or something, you could say "Well, you don't actually want to modify the original, you can do with the overwrites." So I suppose there's stuff like that, but the hard part would be transitioning that, because I feel like you'd wanna start with some sort of base VM or container that had most of the stuff there, and they just needed to complete some task for it for, say, the site fork, or something like that.
+
+**Katrina Owen:** That is actually really useful, having something that basically works, and just change one thing. Or that almost works, and just find the one troubleshoot, one change you need to make - I think that would be a fantastic model.
+
+**Erik St. Martin:** Here's a container that has a Caddy setup with your blog auto-generating, but a service doesn't start when the container starts, and go!
+
+**Katrina Owen:** Yeah, exactly.
+
+**Erik St. Martin:** Yeah, that would be interesting, to start thinking about some other things like that that are kind of ancillary bits of knowledge that are required to do what we do.
+
+**Carlisia Thompson:** Talking about ancillary bits of knowledge... Read the errors.
+
+**Katrina Owen:** \[36:00\] YEAH! \[laughter\]
+
+**Carlisia Thompson:** It's not until you become beaten up by years and years of programming and debugging that you really give in, and "Okay, reading the error log is profitable. I'm going to do it." It's amazing... When people are new to programming you tell them, "Read the error log", and they don't. And you tell them, "Read the error log", and they don't... It takes a while for you to really convince yourself that is super profitable.
+
+**Katrina Owen:** I would actually ask people, "So what does the error say?" and they would flip back to their terminal and say, "I think what's wrong is...", and I was like "No, no, no... What does the error say?" They're like, "Well, it says that there's...", and I'm like "No, read it out loud, word for word. Tell me the words." \[laughter\] Because it's so important.
+
+**Carlisia Thompson:** Yeah.
+
+**Brian Ketelsen:** But how many times do we catch ourselves not reading the error? I do it at least once a week. Or the error message is staring me right in the face, telling me exactly what's wrong, and I change 16 other things trying to fix it before I realize what I've done.
+
+**Katrina Owen:** Yeah, I'm always making assumptions.
+
+**Brian Ketelsen:** And then I feel foolish.
+
+**Katrina Owen:** Yeah, because we are all foolish; let's just be honest here.
+
+**Carlisia Thompson:** I think we are in a hurry more than anything else.
+
+**Katrina Owen:** Yeah, I think we are. About six years ago I was freaking out basically, because I thought I had to learn everything. Like, every new article that I saw was another thing I had to learn, and I had this backlog of hundreds and hundreds and hundreds of articles, tutorials and technologies I had to learn.
+
+And I finally decided that I was gonna give up. I was not gonna learn anything. I was gonna only do research or learn something new for one of two reasons. The first one was if I had an error, I would slow down and figure out exactly why I have the error. No more jumping on Stack Overflow and guess, like copy and paste and see if maybe the error goes away, whether or not I understand how it went away. And the second reason was I'm just too curious and I can't not learn the thing. But the error thing is kind of the most important.
+
+**Brian Ketelsen:** Yeah, that's a good rule to live by.
+
+**Erik St. Martin:** Yeah... I need to go through and clear out all my bookmarks of things that I wanna learn, and accept that some of the stacks of books that I bought I'm just never gonna get to. Because I tend to want to dive in; there'll be some new thing that I'm challenged with, and I'd be like "Oh, that seems cool", and I wanna know everything I can about it, so I'll buy books and I'll bookmark sites, and then I start to realize that I don't have time to make it through one of those books, much less five.
+
+**Katrina Owen:** Yeah. I try to put off actually bookmarking or searching or buying until I sit down and decide to do it, because it's like, I know how to google, I can find those links if I want to; I can find the books if I'm ready. If I have a whole weekend to spend on something, I'm sure I'll find good resources. I don't have to save it off ahead of time.
+
+**Erik St. Martin:** That's true. You just kind of do it real time, rather than pre-plan your learning flow.
+
+**Katrina Owen:** It's hard though, because it's tempting.
+
+**Brian Ketelsen:** Speaking of errors, our other sponsor is Backtrace.
+
+**Break:** \[39:28\]
+
+**Erik St. Martin:** That was perfect. If felt kind of right in.
+
+**Carlisia Thompson:** We planned it. It was all planned. Everything we do is planned.
+
+**Erik St. Martin:** We all knew the way the topic was gonna flow. So I think we've got about 20 minutes left, and I wanted to get to a technology you had mentioned in the email, Katrina, which is the GraphQL API. That's been something that has been on my radar for probably a year or two, the whole notion of GraphQL. I'd love to talk about that more.
+
+**Katrina Owen:** Let's do it. Should I start?
+
+**Erik St. Martin:** Yeah.
+
+**Katrina Owen:** I was gonna write a little tool a couple weeks ago, and this was a tool that the idea is to use the GitHub APIs to get more data about the health of a repo or the health of a project. By health, the things that I'm thinking about the most are how responsive are the maintainers. If you post an issue or if you submit a pull request, how long will it take you to get someone from the core team to comment on that or give you some idea that you are not posting into a black hole? That's one thing.
+
+The other thing is, are there any people actually commenting on pull requests and issues? It doesn't even need to be the maintainers. If someone's giving code reviews, it doesn't really need to be someone who has a commit on the project. So I wanted to use the GitHub APIs to find this information, because it's not obvious just by looking at the repo.
+
+I realized that I was gonna have to make basically a bajillion requests, and for every request that I made, I was gonna have to make an extra request to figure out some ancillary information that I needed in order to do this analysis. This was like a week before GitHub announced the GraphQL integration.
+
+So the thing about GraphQL is you can now design your query upfront and get all of the data back and not have this N+1 problem when talking to the API. That's pretty exciting.
+
+**Erik St. Martin:** I didn't even realize that GitHub had GraphQL APIs now. The only place I had really seen leveraged was through Facebook where it came out of, but it's really cool, the way you nest the information that you want, and then kind of have these little -- I don't know what you would call the little additions where you can kind of do the first/last; they probably have naming for those little operations or directives, or whatever they call them. Then you can mutate the data...
+
+It was really cool thinking about that, where you have this highly nested data where you don't wanna have your looping problems, and stuff like that. So have you actually had a chance to work with GraphQL?
+
+**Katrina Owen:** No, it's on my list for when I get home from this trip.
+
+**Erik St. Martin:** \[43:45\] I have to admit I have yet to work with it, but it seemed interesting. A couple of years ago Brian and I were working on a project that had that kind of nested data where you wanted to get this tree of information and do counts on some of them, and things like that. We ended up designing something different; GraphQL wasn't released yet, right Brian?
+
+**Brian Ketelsen:** No.
+
+**Erik St. Martin:** It was something that Facebook had started talking about.
+
+**Brian Ketelsen:** It was unreleased at that point. It probably would have worked, but maybe it wouldn't have been fast enough. I don't know.
+
+**Erik St. Martin:** So in your concept of doing this intelligent querying against the GitHub API, it's just to kind of rate the contributors to a different project to kind of determine who should have what role, or...?
+
+**Katrina Owen:** Yeah, there are two things. One is where do I need to put my attention? I might have 70 repositories, and it's really hard to know what the state of everything is, and I get 500 notifications every week about issues that I need to look at. So I need to know if there are repositories where the maintainers are on top of things; I can put that in a different filter in my inbox, and I can check in once a week for every other week, and just make sure that they don't need me for anything, but they've got this.
+
+Then for the ones that don't have responsive maintainers, I can spend more time. I can filter that into something that I check every day and make sure that I give the feedback that needs to be given on a regular basis, and much more aggressively. The other thing is for a repository where someone is giving feedback and they don't have commit, it would allow me to find people who probably should have commit on that repository, or they're doing the work of a maintainer but they haven't been recognized as such yet.
+
+I had a working prototype where I was sucking down the data, but I was using the old APIs, not the GraphQL APIs, so it wouldn't work to get me all the..It wouldn't scale.
+
+**Carlisia Thompson:** Besides the use cases that you just gave us for the maintainer, for the consumer of the project, I think it would be super awesome. Every time I run into a project that I'm considering, unless it's a super well-established and well-known project, there is a checklist of things that I do. I go through the issues list, I see if there are issues abandoned, I see if there are PRs abandoned, or I see people commenting, I see if PRs are being closed, I see how many issues and how many PRs are open... Of course, if it's an active project there can be a ton of PRs open, but they are being cycled through quickly, that's fine; if things are stale... I wanna know those things, and I do them manually. So that would be so awesome, if we could have that.
+
+**Katrina Owen:** Yeah, this would potentially... What you said - run it against the repo and say, "Yes, people are getting responses." That would actually work even if there's not a lot of activity. If people get a response very quickly, even though the project is mostly stable, then it's still a good project to contribute to. Whereas if it's a project where the average response time is months or years, you might not wanna contribute.
+
+**Carlisia Thompson:** Super cool.
+
+**Erik St. Martin:** Yeah, that's awesome. Although I have to say I've never worked on a project so big that it would require hitting the API to determine the state of my project. That's a whole new world.
+
+**Carlisia Thompson:** But sometimes you might not be a maintainer that works on a project that's so big, but you might have a ton of little projects, and it takes a lot of time to be on top of everything.
+
+**Katrina Owen:** \[48:02\] Yes.
+
+**Erik St. Martin:** Doing open source stuff on the side and also holding down a day job, it's a struggle for a lot of people, so anything that can kind of help organize things and tell them where their minimum amount of time is best spent, I definitely think it's advantageous.
+
+**Katrina Owen:** There's a really good question in the chat right now: what if the project is run by someone who closes the issue instantly and dismisses them? That's really not healthy behavior at all, and I don't know if we could surface that with the data. Are they also giving a response when they close it? If all of the issues are closed within... There's a difference between responding to an issue and closing an issue. I don't know, it's definitely something that is very interesting to look into.
+
+**Erik St. Martin:** Yeah, because I think there's a lot of factors that go into that too, right? Maybe they're quick fixes that require commits, maybe it's a duplicate of other issues... There's probably somebody who's better at math than I that can figure out some insights into whether it's unhealthy closing of issues, or maybe they can do some text analysis on it, do sentiment analysis on the text and determine if they're closing them with very negative comments all the time.
+
+**Katrina Owen:** Yeah, so thanks for the question, Florian; the question was mentioned in the GoTime FM Slack channel.
+
+**Brian Ketelsen:** Yeah, how awesome is it that our guests are answering questions live on Slack while we broadcast? This is 2016, folks. This is it. This is 2016. We have reached the future.
+
+**Carlisia Thompson:** Katrina, you also have a blog that you post to... Maybe not super frequently, but the content is amazing. I know you have one blog post that coincidentally last week Aaron Schlesinger took one of the concurrency examples... Three Trivial Concurrency Exercises For The Confused Newbie Gopher. He took exercise number two out of that and he did one episode of Go In 5 Minutes.
+
+**Katrina Owen:** That's awesome, I didn't know that.
+
+**Carlisia Thompson:** Yeah, I'll link to it. It's super helpful.
+
+**Katrina Owen:** That's great to know. I just kind of write... Sometimes I'll run into a question that it seems like there should be a good answer, but there is no blog post that really does that, so I try to just write that blog post that somebody might stumble on and could be useful to them. The most recent thing I posted was how do you take a static hand crafted website and turn it into something that Hugo generates, if you discover that what you needed wasn't a brochure site after all and you're actually adding things to it regularly. It becomes really tedious if you're copying and pasting headers.
+
+The Hugo documentation and reference material is awesome. However, if you haven't really gotten into Hugo, it's hard to figure out when you have a more focused... Like, "I just want to figure how to do X. I wanna take my website and convert it to Hugo."
+
+Anyway, that's the type of blog post that I try to write - the little thing that you stumble across that was tricky and really does have a simple answer.
+
+**Brian Ketelsen:** I've gotta go read that. I've probably done 15 Hugo website cut-ups now, and I'm getting really good, but I wish I had your blog post two years ago.
+
+**Katrina Owen:** \[51:59\] Well, the first time it's so hard...
+
+**Brian Ketelsen:** It's painful.
+
+**Erik St. Martin:** So I think we've got about ten minutes left, and I'd love to move on to some projects and news. Brian's got a good one.
+
+**Brian Ketelsen:** I've got some big news I'm itching to share. One of our prolific listeners, Chase Adams, had a brand new baby girl L, and he's constantly tweeting pictures of him and her listening to GoTime FM, so we want to congratulate Chase and mom and baby L. Congratulations on the new Gopher addition to your family. There's no better news than babies, that's so exciting.
+
+**Erik St. Martin:** He was reading Go books to the baby while it was still in her stomach.
+
+**Brian Ketelsen:** That's how you do it.
+
+**Erik St. Martin:** That's commitment.
+
+**Carlisia Thompson:** She'll be on GoTime giving us tips pretty soon. \[laughter\]
+
+**Brian Ketelsen:** Soon enough.
+
+**Erik St. Martin:** Guest on the show at two. Brian, I think you sent this out somewhere, and I'm stealing it because it was pretty awesome. There's this GitHub project that's completely written in Go, but it takes a picture and then creates geometry shapes and rebuilds the image with it. It's just awesome. It's far beyond my ability, but this thing is pretty sweet. It's called Primitive.
+
+**Brian Ketelsen:** Oh, that's right... Fogleman?
+
+**Erik St. Martin:** Yeah.
+
+**Brian Ketelsen:** github.com/fogleman/primitive. They have a Twitter feed too, they've just posted something on Twitter, so I started following the Twitter feed too, because it's really neat. They take these images and turn them into a very low number of polygons using Go, and they're surprisingly artistic and fun to look at, so I followed their Twitter feed, too.
+
+**Erik St. Martin:** I love it when people come up with these creative uses for things that you totally would not have thought of.
+
+**Brian Ketelsen:** I did this this morning, I did a primitive rendition of the barbecue gopher from our Gopher Barbecue Slack channel. I will drop that into our Slack here while we're talking, so that everybody can see how cool Primitive is while we're poking around here.
+
+**Katrina Owen:** Wow, that's beautiful.
+
+**Erik St. Martin:** Yeah, I don't know who thought of this, but this is just crazy. I wanna go through a picture collection and just run all of it through there. I need to write a script, see what emerges.
+
+**Katrina Owen:** Awesome! This might have to be my next slide deck for my next talk.
+
+**Brian Ketelsen:** The neat thing about it is that you can choose to output a regular file, or if you choose a .gif, it will create an animated .gif for you and show the process while it creates all those polygons, and that is just so cool to watch. I'm really enjoying that.
+
+**Erik St. Martin:** That's actually a fun idea - take your slide deck, run your slide deck through this, and then get new images.
+
+**Katrina Owen:** Cool.
+
+**Erik St. Martin:** Alright, anybody else have any fun projects and news?
+
+**Carlisia Thompson:** I wanna mention something that I thought was super interesting and cool... Sameer Ajmani, he managed the Go language team; he posted on Twitter a couple days ago that he's looking for people who are using Go to teach university courses, because he wants to help them have better resources. I'd really like to see Go moving in that direction. I also then found out that there was a Wiki page on the Golang Wiki that lists a bunch of CS courses that are already using Go; I had no idea.
+
+**Katrina Owen:** That's brilliant.
+
+**Carlisia Thompson:** \[56:00\] Yeah, right? I had no idea. So spread the word, because I think Go is such a good language to learn how to program. I might be biased... I don't know. I think it is.
+
+**Brian Ketelsen:** I was just having a conversation two days ago with somebody who's name I've already forgotten, who teaches Go at a college in California, and he loves it. He says it's the perfect teaching language.
+
+**Carlisia Thompson:** I know, it's Todd McLeod's.
+
+**Brian Ketelsen:** Maybe that's it. I don't know. I've slept since then, so I've forgotten.
+
+**Carlisia Thompson:** He teaches in Fresno. He recently did a GoBridge workshop in Fresno, it was very cool. Actually, that is a good segue into my next thing that I want to mention, which was mentioned by Florin Patan in our ping repo (thank you!). It is Better Go Playground Chrome Extension. This thing is so cool. Basically, you install it in the Chrome and just leave it there, and every time you go to the playground, you're gonna have syntax highlighting; it gives you the option of having a dark or light theme, and it also says that it has autocompletes, but I haven't figured out how to activate it.
+
+Also, if you run your code and you have errors, there will be an indication in the line, telling you where the error is. When I got the extension, I remembered that Todd had a bunch of snippets from the Go Playground, and I just went through the list and opened them in a Go Playground to test out this extension. \[unintelligible 00:57:44.28\] That's what I wanted to mention for projects and news.
+
+**Erik St. Martin:** This is like one step closer to Brian's ultimate goal, which is to just deploy a VM in a cloud and develop off of it.
+
+**Brian Ketelsen:** Oh, don't get me started. I am there. Maybe we should have an episode on that, because I completed it today, Erik. My goal is done. It is complete.
+
+**Erik St. Martin:** That's awesome.
+
+**Brian Ketelsen:** In fact, I showed it off to somebody today, and he was pretty impressed. So the one thing I wanted to bring up was Gallium, which is the framework for building native web apps in Go, much like React Native, but Go Native, and that is totally awesome. I can't wait to dig into that some time in 2018 when I have some free time. It has all of the native app bits that you need, and then you can just start up a Go web server and serve your UI through the native app. Super excited about that... We've needed a Go solution for that problem for a long time. That's at github.com/alexflint/gallium. Go play with it.
+
+**Erik St. Martin:** This is very much similar to Electron, but in Go.
+
+**Brian Ketelsen:** Yes, exactly.
+
+**Erik St. Martin:** This is really cool. This was a while back, but I was attempting to do something with Go and Seth, which was the Chrome embedded framework. I never took off with it too far, I think mostly because of time. But this is really cool.
+
+**Brian Ketelsen:** Yeah, I wanna play with it. A lot. I won't, because I don't have time. \[laughter\]
+
+**Erik St. Martin:** Our first episode in mid-2018, we will talk about what you did with it. \[laughter\]
+
+**Brian Ketelsen:** \[59:45\] So maybe that's a good segue into \#FreeSoftwareFriday. \[laughter\] Familiar listeners will know that we love to shout out to open source projects and maintainers, and just let them know that we care, we love them, we love the work they do and we appreciate their projects, so I will start out today with something that's probably a little bit cheesy, but dammit, I love Go, and I've spent so much time this last week or two building a lot of tooling for my training classes, and I just don't think there's a way in the world I could have done it without Go.
+
+A couple hundred lines of code and I've got a fully automated solution to bring new students online, on a server, with a Go environment and a web IDE with two clicks. It's just amazing. I love Go. Thank you, Go. Thank you, Go Team, thank you everybody who's contributed to Go. Big hearts everywhere.
+
+**Carlisia Thompson:** And you have a pretty cool course to teach people how to do that, right?
+
+**Brian Ketelsen:** That's true, I'm teaching a lot of classes, upcoming in October. Boston, I've got an online class 24th or 23rd October, both through O'Reilly. If you're listening live, you can use discount code Ketelsen to get 25% off either one of those classes.
+
+**Carlisia Thompson:** I really wanna take your online class. Online because I'm not in any of the places you'll be teaching.
+
+**Erik St. Martin:** They have planes. \[laughs\]
+
+**Carlisia Thompson:** Well, I'll be lucky if Fastly pays for it, so I'm definitely gonna be asking. Because I think I'm right there, needing to master everything that's listed there. I feel like I'm close, but it's also very confusing to figure out what the idiomatic way is, and you spend a lot of time trying to figure that out, as opposed to just learning what the damn thing is. So I think the course is perfect for me, for where I am, so I definitely wanna take it.
+
+**Erik St. Martin:** So this is the thing that Brian's been trying to show off to me for like the last week, and I've been too busy. It creates a user, sandboxes them inside of a container, copies over the training material... It did a whole bunch of stuff; it has a little command line tool for it...
+
+**Brian Ketelsen:** Everything. You go to a web page with an invite code, and it creates you a complete online Go development environment with a web shell and a web IDE. It's all Sandbox, it's got Docker, and all you really have to do is fill in your name and an invite code and hit Go, and it just works.
+
+**Katrina Owen:** Brilliant.
+
+**Brian Ketelsen:** It almost falls into what we were talking about earlier, that idea of building environments for people to learn it. I noticed Andrew Gerrand posted a slide deck about an idea today, the Go workspace tool that he's working on. The same concept - how do you get somebody from, "Okay, I've installed Go" to "How do I start using Go?" There's a gap there, and I'm aiming to narrow that gap with my students. With some time I'd like to make it open source, because I think it's powerful enough that it would be helpful for other people teaching.
+
+**Carlisia Thompson:** And for the record, he's not working on it... I think he's putting it out there and trying to entice people to take on the work where he left off. He's done some work, but he doesn't seem to have the bandwidth to continue. He explicitly said he's not working on it.
+
+**Brian Ketelsen:** Well, that's too bad.
+
+**Erik St. Martin:** Alright. Carlisia, do you wanna go next?
+
+**Carlisia Thompson:** Yes. I definitely wanna give a shout out to Exercism - how could we not? It's awesome. Katrina is awesome, everything about it is awesome. If you haven't checked that out...
+
+**Erik St. Martin:** I don't think I wanna know how much time she's invested into that... It's probably scary.
+
+**Katrina Owen:** Yeah, I don't wanna talk about that. \[laughter\]
+
+**Erik St. Martin:** \[01:04:00.09\] Those battle scars...
+
+**Carlisia Thompson:** And I also wanna give a shout out to GoConvey. I have been using it a lot. I don't use it as a test package, but I use it to -- we were talking about refactoring, red/green. If you put it up on your project and you open it on your browser, it just gives you that nice green-red-green-red. I don't have my editor set up to check compiler errors on tests, I check it on GoConvey and I feel super productive like that. I'm changing things, either on the tests or alternative file or on the corresponding file, and I just get the notification from GoConvey. It's quick, and it's been great. I love it. I love color-coded things as well, that makes me so happy!
+
+**Erik St. Martin:** I used to use it a lot, and I'm actually ashamed to say I haven't used it very much lately. I think it's like you jump in and you try to start doing stuff quickly, and then that kind of becomes your pattern and you fall off from some of these things. I need to start using it again.
+
+**Brian Ketelsen:** But it's so pretty, having that dashboard.
+
+**Erik St. Martin:** Yeah, and the browser notifications.
+
+**Brian Ketelsen:** Yeah.
+
+**Carlisia Thompson:** Yeah, and the green is such a pretty green; you wanna see that green all the time. \[laughter\]
+
+**Brian Ketelsen:** I long for the green.
+
+**Carlisia Thompson:** Another thing that I love about it is that it gives you a percentage of your test coverage. On the left it keeps track, and you see a bar inching up as you add tests. And everytime you change a test, if there was a change to the code coverage, if it was an increase you would see an up arrow with a notification, and if it was a decrease, you would see a down arrow with a notification. It's sort of like a game, you just wanna see the up arrow all the time. You wanna see an arrow there. Because if you change something and there is no change in the code coverage, it doesn't give you anything. So you just wanna keep seeing that up arrow there all the time.
+
+**Brian Ketelsen:** It's like that stupid fuel economy gauge in my car - every time I see it I'm like "Oh, I need to back off the gas..." \[laughter\]
+
+**Erik St. Martin:** The hard part with that though is by gamifying it like that you can also get bad habits too, because you can increase code coverage with meaningless tests, too. Code coverage just means that every line is executed, it doesn't necessarily mean that you're actually testing real-world use cases and paths to a good program. That's the hard part with the aiming for 100% code coverage. You can get there and not necessarily have a good test suite.
+
+**Brian Ketelsen:** That's a show all on its own.
+
+**Carlisia Thompson:** Yeah, that is true. But Go also has a very good test coverage tool. If you haven't exercised that path, you know you should. Maybe you write a test and it's not gonna be the best test; maybe it's gonna be misleading, but at least... I think not having the test is bad; having tests that are not good tests is like, "Okay, it's not good", you gotta make it better. The next step then is having tests that are meaningful.
+
+**Brian Ketelsen:** Yeah, any tests are better than no tests.
+
+**Erik St. Martin:** Agreed.
+
+**Brian Ketelsen:** It's funny, because I think we talked about this an episode or two ago... In the Ruby world, where testing was religious, I didn't like writing tests and I didn't write a lot of tests. Now in Go I very frequently do TDD and I test everything, and it's strange... And I have that compiler backing me up too, I don't know. It's strange.
+
+**Katrina Owen:** \[01:08:05.12\] In Ruby a lot of the tests were so slow that it was just painful. In Go the tests are much quicker.
+
+**Brian Ketelsen:** You know, maybe that's it - it's the nearly instantaneous response time. I'm impatient.
+
+**Carlisia Thompson:** Fast tests is what hooked me to Go. Go had me at fast tests.
+
+**Katrina Owen:** Yeah, fast tests was my motivation to learn how to refactor, so that I could have less decoupling and load fewer dependencies when I was testing my code.
+
+**Erik St. Martin:** That's kind of a big goal of mine. I always find it hard when I'm up against something that requires a lot of mocking and stubbing in order to fake out backend, but I can't stand that having to require having some Etcd cluster for this thing to run against. I don't want that. It means I can't just run it on my laptop while I'm on an airplane.
+
+**Brian Ketelsen:** Well, that brings up a completely random thought about the Gopher Slack - we have a barbecue channel, and we are building a PID controller for our barbecue grills, which will automate keeping the grill at a particular temperature by controlling the air flow into the fire pit. And the first thing I did when I started writing the code was build out the interfaces, because seriously, I don't wanna have to test I2C interface on a Raspberry Pi. I just don't.
+
+**Katrina Owen:** You shouldn't have to.
+
+**Brian Ketelsen:** Yeah, those are things that I want to mock immediately. So I built all the interfaces first, and I'm building mocks now for all of them; even without having all of the hardware, I'll be able to prove most of the application logic is good before we get it put together.
+
+**Erik St. Martin:** Now, the benefit of doing only end-to-end testing... So, granted, development time is longer, but it tastes way better. \[laughter\]
+
+**Katrina Owen:** It's part of a slow go movement...
+
+**Erik St. Martin:** It's actually surprising how many people are really jumping in on the project, too.
+
+**Katrina Owen:** Awesome.
+
+**Brian Ketelsen:** That's github.com/bbqgophers, if anybody wants to jump in and join. We're having a ton of fun. Raspberry Pi's, little bits of electronics and lots of Go. And barbecue, don't forget the barbeque part; that's the important thing. We might have won the best name ever. The PID controller that we're writing is called Qpid. \[laughter\]
+
+**Katrina Owen:** Yeah, that's adorable. You win.
+
+**Erik St. Martin:** You win the internet. My project this week is Bosun, which came out of Stack Overflow. It's this really cool library that can kind of go up against time series databases, OpenTSDB, Elasticsearch, InfluxDB, and basically has this kind of like expressive language that you can use to do counts and aggregates and things like that, and then do alerting based off of that. It's great for monitoring...
+
+**Brian Ketelsen:** Barbecue?
+
+**Erik St. Martin:** ...which might also be very good for monitoring barbecue.
+
+**Brian Ketelsen:** Is that how it came up?
+
+**Erik St. Martin:** That is exactly... Well, Comcast is using it too internally, so I have to be fair. That's what we're using for Kubernetes monitoring and alerting. But it came up for this episode because somebody suggested another one, and then I suggested this one for monitoring the grill temperatures.
+
+**Brian Ketelsen:** Metrics or it didn't happen.
+
+**Erik St. Martin:** Alright, I don't wanna blindside you here Katrina, but did you have anybody you wanted to give a shout out to?
+
+**Katrina Owen:** \[01:12:02.09\] I do. I would love to give a shout out to the Hoodie team. They are an open source project who... So this is someone who knows how to do community. They have possibly the healthiest open source community and healthiest open source project that I have ever seen in my whole life, and I aspire to basically become them, if I can, when I grow up. A lot of communities struggle with things like communication, triage, issues and prioritization and documentation, and the Hoodie team has built tools around the entire onboarding process to become a contributor, to mentor contributors, and they value the whole contributions equally; it's not like your measuring who gets commits into master. They help build out the tools so that it's clear that they value mentorship, value documentation and value triage and project management.
+
+I think that what they've done with their communities is absolutely amazing. One of their team members was on another Changelog episode not too long ago, Jan Lehnardt. He was on the Request for Commits episode \#4, talking about building healthy communities. Absolutely worth a listen.
+
+**Carlisia Thompson:** That's the person I was referring to when I mentioned that he went away on vacation, then came back and people were talking in his voice. I was comparing him to you, Katrina. I noticed that pattern as well with Exercism.
+
+**Katrina Owen:** I'm so flattered... I want to be him when I grow up. \[laughter\]
+
+**Carlisia Thompson:** Let's not end this show... Can we just keep going?
+
+**Brian Ketelsen:** Let's just keep going, just let it roll.
+
+**Erik St. Martin:** Unfortunately it has to end sometime. I think we would all get hungry.
+
+**Brian Ketelsen:** Well, soon my kids will be knocking on the door. "Feed us, feed us, feed us!"
+
+**Erik St. Martin:** Alright.
+
+**Brian Ketelsen:** Well, it's been a very awesome show. Thanks so much for coming on, Katrina.
+
+**Katrina Owen:** Thanks so much for inviting me, it's been a lot of fun.
+
+**Brian Ketelsen:** I think we've really covered a wide gamut of things on this show. That's atypical, but we've covered a lot of territory in this show.
+
+**Erik St. Martin:** Choosing the headline for the episode will be fun, like which things to mention. But yeah, definitely thank you for coming on, this has been a lot of fun.
+
+**Katrina Owen:** Thanks so much for having me.
+
+**Erik St. Martin:** And thanks to all the listeners and everybody who's participating live in the Slack channel. For next week, if anybody else wants to participate, we're on the Gophers Slack in GoTime FM. We are @GoTimeFM on Twitter, we are GoTime.fm online if you want to subscribe if you haven't already subscribed. Big shout out to our sponsors, Linode and Backtrace for this episode. If you wanna be a guest or you wanna suggest guests or topics, github.com/gotimefm/ping. I think I covered everything... Alright everybody, it's been fun.
+
+**Carlisia Thompson:** Thank you, goodbye!
+
+**Brian Ketelsen:** Goodbye!
+
+**Katrina Owen:** Thanks, bye-bye!

Raphaël Simon on goa, the Framework for Building Microservices_transcript.txt

@@ -0,0 +1,305 @@
+**Erik St. Martin:** It's Go Time! A weekly podcast where we discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+Alright everybody, welcome back for another episode of Go Time. It is episode number 7. Today we have Brian Ketelsen here with us. Say hello, Brian.
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And Carlisia Campos is also here.
+
+**Carlisia Thompson:** Glad to be here, hi everybody.
+
+**Erik St. Martin:** And we also have a special guest here with us, Raphael Simon, who is the creator of a framework called Goa for generating APIs, which Brian is particularly excited about.
+
+**Raphaël Simon:** Hello.
+
+**Erik St. Martin:** You want to give us a little bit of background, Raphael?
+
+**Raphaël Simon:** Sure, yeah. So let's start with my who am I. So I'm a platform architect at [RightScale](www.rightscale.com). RightScale is a cloud management platform. I've been working there for almost eight years. When I started, the whole product was basically a single Rails app, and the platform has grown a lot since then. The last time I counted there were about 52 different services running in production, running on about a thousand VMs. So I've helped design, develop and debug a lot of them.
+
+Part of going from this single Rails app to all those distributed services, we felt a lot of pain in having to design API's the right way. What I mean by that is being able to come up with APIs that are consistent and have standards that are enforceable, so that we can come up and say, "Yep, that API looks good. It follows all standards and we'd be able to integrate that service with the rest of the fleet."
+
+As you probably know, once an API is alive it's almost impossible to change it. Once you have customers that start using it or once your internal services rely on it, then that API is gonna be there forever. So it is very important that you spend the time designing it properly.
+
+When we looked at what was available to do that, there just wasn't much. There were a few tools here and there, but nothing that we felt would be enough for us. So we ended up creating a framework at the time, a framework in Ruby called [Praxis](http://praxis-framework.io), that basically allowed you to write the design code and then the framework would leverage the design in runtime.
+
+Going fast forward, RightScale kind of shifted towards Go, and I thought it will be good to see if we could do something like that in Go. To be honest, I wasn't sure initially that will be possible. We played around with a few things, and it took me about a year really to come up with something that started to look like it may work. There were two big a-ha moments in that kind of research phase. One was the realization that code generation was the perfect approach for achieving the goal of keeping the design and implementation separate. We were making sure that the design is directly enforced.
+
+\[03:51\] The second realization was that the design should be written in a DSL, so that the language used to describe the API used the right terms. You want to talk about resources, actions, responses, requests, and you don't want to have to deal with programming language artifacts, so that DSL will have to be a Goa DSL obviously, so that it could be understood right away, and also so that it's still possible to use the legal language when it's needed.
+
+Fast forward a year and a half, I have to say that the result turned out a lot better than I thought it would be, and I think the credit goes to the Go language. The Go language provides a very simple and powerful mechanism to create the DSL. It also has as very good code analysis support, which is essential and a very good code generation package, the template package in particular.
+
+So all of that put together, I think, we end up today with something that is actually very interesting, and we have started using Goa fairly extensively here at RightScale.
+
+**Erik St. Martin:** That's great. So just kind of like a high-level detail... So Goa is a framework for using a kind of DSL that's written in Go to generate HTTP APIs?
+
+**Raphaël Simon:** Yeah, exactly. From that design, from that DSL which is Go code... Basically the DSL you can think of it as a lot of package-level functions that you invoke and that are recursive. So you call a top-level function, let's say Core API, and you then embed other function codes in it while you define every single property of the API, like title, description, etc. When you look at it, it's actually not too ugly. You can actually understand it fairly well and follow what it is trying to do. And from that design, what happens is when you load the design, when you start the process that has that package linked in, because all of the design code lives in global variable, the Go runtime takes care of all of that for you, and you wind up with a lot of in-memory data structures that describe your API. And those are simple, nothing special Go data structures that you can look at, inspect, and use to generate pretty much anything. So it's quite nice, because you start from a language that is easy to use from a human point of view, and you end up with data structures that are very nice to handle from a programmatic point of view.
+
+Goa comes with a few built-in code generation outputs. One is the glue code that bridges the role of an HTTP server with the user-provided handlers, and that code takes care of validating the incoming requests according to the validation rules describing language. It also builds convenient data structures for accessing the request state and writing the response. So you end up with code that you have to write as the user, which is fairly small. You don't have to do all the validation that you usually have to do, and you don't have to bind the request body to some data. All of that is done already. You end up with what is called a context data structure, and that data structure has everything laid out in a way that's very easy for you to access and consume. So your code is very terse and very clean.
+
+The Go agent tool that comes with Goa, which is the code generation tool, also generates a client package and a client tool. That's also been very neat, because one issue is when you create an API, obviously the point is for the API to be consumed, and what tends to happen is that every team consuming the tool will develop their own client, and they will all become out of date and they will all have small discrepancies and things start creeping up, which makes the whole thing more difficult to evolve.
+
+\[08:16\] So having that being generated automatically means that the team that provides the API also provides the client, and everybody uses that one client, and so it makes everything consistent and helps other teams consume the API.
+
+GoAgent also generates documentation in the form of Swagger and JSON schema so that you can at any point in time share the design to other people that may not be familiar with the Goa DSL. You can use that also to document the API once it's in running production; so all of that makes for a very nice way of developing APIs, and a very efficient way of doing it.
+
+**Brian Ketelsen:** So I have two comments. I found Goa in October or November, I guess, of last year and two things struck me immediately when I saw Goa. The first was that the generated code looked hand-written, and I have to commend you for that, because for me, that was the most impressive part of the project; all other code generation facilities I've seen before, it's really clear that it's generated code and it doesn't feel idiomatic, it doesn't feel like Go, it feels like somebody generated some Go code. So having that generated code in Goa looks so handwritten, it was very impressive for me.
+
+**Raphaël Simon:** Well, thank you. Yeah, I mean that was definitely a design goal. When I started Goa I was a little bit - not afraid, but I was a bit worried about the reception that the Go community will have, because I know that the Go programmers are very, not picky, but they like the Go code to be idiomatic. They like the code to look a certain way and behave a certain way. I didn't want the generated code to be an issue, basically; I wanted that to be a non-issue. I wanted people to look at it and say, "Yeah, okay. It looks good enough. It's not terrible", so I definitely tried to put some efforts to make that a non-issue for the adoption of Goa.
+
+**Erik St. Martin:** Now, speaking of the kind of idiomatic Go and reception from the community, what's the reception like for the actual DSL itself? Because I've seen the generated code, which I think is highly idiomatic, but I don't know whether the DSL is so much. Do you get a lot of slack about that or are people pretty comfortable with that?
+
+**Raphaël Simon:** Yeah, so there has been a few comments on the repo on GitHub of people trying to make it look more like Go, but then I'm always very... I kind of have a hard line, saying "This is not Go, it's a DSL. It's a different language. It's implemented in Go, but it's not Go." So for example one thing that you sort of have to do when use DSL is use .imports, and there are a lot of people who don't like that. And I agree, I don't think that imports are good either. I think if you write Go code, you shouldn't use them and nothing else in Go uses that, but for the purpose of implementing a DSL, that ends up making the whole thing a lot nicer, feel a lot more natural. So there is a little bit of that pushback, but then my response is "Well, this is not Go and I'm not trying for DSL to be idiomatic Go because it's not Go in the first place."
+
+\[11:47\] You should think about it, some of the target outputs for the DSL is documentation. There is also a JavaScript client that you can generate from that DSL. And in the future there can be pretty easily written to generate clients in other languages. So if the language has to be agnostic, it has to remain independent of any target that it generates, and sure Go is the main target for sure, but still a language should try to remain as agnostic as possible.
+
+**Erik St. Martin:** Right. So people just need to disconnect a little better, right? It's kind of like gRPC; the DSL is essentially the protobufs, and then the generator generates from that, and yours just happens to be...
+
+**Raphaël Simon:** Yeah... You see, if you write Swagger then it's completely different from your programming language. It's the same idea.
+
+**Brian Ketelsen:** Well, that leads me to the second thing that I noticed about Goa, which was the approachability of the DSL. I've seen many DSLs in the past... Being a former Ruby developer, everything we did in Ruby was a DSL in one way or another, so seeing a DSL in Goa that was approachable and understandable was really surprising for me. I had seen the test frameworks, which one is it... Ginkgo, Gomega...? One of those that uses a similar approach, and it still just didn't really click with me until I played with Goa, and I really enjoyed the readability factor of the DSL in Goa.
+
+**Raphaël Simon:** Thank you. Yeah, that took a while to get right. And actually you mentioned [Ginkgo and Gomega](https://onsi.github.io/ginkgo/) because they were definitely a big inspiration for the Goa DSL. I went through different iterations... In one iteration I was using literal data structures to define a DSL, and it was ugly. I mean, it was really ugly.
+
+I think it clicked once I saw the trick of basically having an anonymous function, being an argument; that's really the trick. Once you see that, once you understand that, then everything kind of falls together. Then it's easy to sort of embed those function calls and make it look like it's just a series of instructions, which is nice. But that took a while.
+
+**Brian Ketelsen:** So what has surprised you most about the explosion of Goa adoption?
+
+**Raphaël Simon:** I was very, very impressed by how the Go community and you, especially, really embraced Goa. It was more for sort of personal research, interesting projects, see what could happen... Also with the potential of maybe being used at RightScale but that was about it. And then I guess you stumbled on it and started tweeting about it.
+
+**Brian Ketelsen:** And I wrote a blog post.
+
+**Raphaël Simon:** Yeah, you put me into the Slack channel and it's been awesome. I mean, I think there is no way that Goa would be what it is today without that community, without all the input. That's just not code, it's the ideas, the requirements, the numerous bug fixes, I mean... That to me was like waking up in the morning and seeing a PR that fixes a bug I wrote. That's the best thing. I mean, there's no better way to start a day. So I've been very impressed, I'm very grateful and it's been awesome.
+
+**Brian Ketelsen:** So it's only appropriate that we talk about that blog post that I wrote, because on this show we have a habit at the end of every show of talking about the [Free Software Friday](https://open sourcefriday.com) movement that we're trying to portray here, and that was the blog post in... I wanna say it was in November of last year where I mentioned that I had stumbled across Goa and I thought it was just an amazing thing, and I was talking about ways that you could talk to open source programmers and thank them for the work that they do and tell them that you appreciate it. I think I actually even proposed to you, I'm not sure... Oh, I did, yeah. On 17th November, 2015, "I think I wanna marry the guy who wrote Goa." \[laughter\] So I have to apologize if that made you uncomfortable in any way...
+
+**Raphaël Simon:** \[16:04\] No, that made me laugh. That made me have to retrieve my lost Twitter password. \[laughter\] Yeah, I wasn't on Twitter at the time and it was a colleague of mine that saw that tweet and told me about it, and I had a good laugh. It's been great. I really appreciate all the support that you've been giving Goa, and I think again Goa wouldn't be what it is today without all of that support and all the people now participating into the development of it.
+
+**Erik St. Martin:** I know it was probably a few months ago, but you went to a refactoring to kind of support pluggable... To create kind of plugins for stuff, because I know Brian ended up going to and creating a plugin for ORM integration.
+
+**Raphaël Simon:** Yeah, I think Goa may have caused Brian to kind of rewrite the same thing seven times in a row, or something like that... \[laughter\] So sorry about that. But yeah, I mean, it was basically an exercise of trying to make it possible for plugins to be added to Goa at the same time that the big plugin that Brian was developing was being developed, right. So Brian wrote this amazing plugin called [Gorma](https://github.com/goadesign/gorma) which allows you to define models in DSL. Now you can not only define your API shapes, but you can also define the database models. From that Gorma generates code that will instantiate those models from request bodies and then create response bodies from the model, so it makes it very easy to have a full stack in a few minutes, so it's awesome.
+
+But yeah, I was working on trying to make plugins work in Goa in the same times that Brian was working on Gorma, so I must have brought him program Gorma maybe 200 times, or something like that.
+
+**Brian Ketelsen:** It was sure a fun process though, it's okay.
+
+**Raphaël Simon:** Yeah, and I think the end result is nice. I think anybody that now writes a plugin for Goa has to thank you. I think that should be the rule.
+
+**Brian Ketelsen:** So what's been the most surprising plugin that you've seen, or the most surprising contribution to Goa?
+
+**Raphaël Simon:** I think Gorma is definitely up there. Once you think about it, it's a use case that's really important, I just hadn't thought about it, and once you think, "Oh, yeah, obviously", the next thing you need to do after you get your request is to start it. Well, you're gonna need to talk to some database, and yeah, you could generate code to do that. So I think that has been very interesting, because I hadn't thought about it and it just makes a lot of sense and I think it's very useful.
+
+**Erik St. Martin:** So I guess it's kind of hard to go into detail about the actual DSL itself, because it is all audio based. I mean, we can draw stuff on our own individual whiteboards if we wanted to, \[laughter\] but somehow I don't think that's gonna help the listeners. One thing I would like to talk about though is not everybody is kind of familiar with code generation, so I guess one thought process that constantly comes across people when they first hear the idea is "How do you maintain generated code?" Like, if you were to modify it and you need to regenerate, you know, are you wiping over all the top of your stuff? I'd love to kind of hear you explain what the model is for maintaining your code that's been generated, and if I've got a new version of Goa and wanted to take advantage of some new features or plugins, what does that look like for the code that I had to manually write as part of that API?
+
+**Raphaël Simon:** \[19:57\] Right. So the main idea is you don't. You do not maintain generated code. Basically, you know, regenerated code is generated in its own package and it's cheap code. You don't have to maintain it, you don't have to test it, you don't have to really know the internals of it; you're welcome to look at them and hopefully it's understandable, but you don't have to. All you care about is what it provides to you and how it interfaces with your code.
+
+So one of the code generation principals behind Goa is that user code and generated code never mix. And there is a very clear interface, an explicit... I mean a Go interface - it's a very explicit interface within the two. There's not just one, there's multiple, but the idea is that you have interfaces that are clear between the generated code and the user code. And if you regenerate your code, you shouldn't care.
+
+I mean, basically the idea is if you change your design and you add - let's say you add a new field to a request payload, you regenerate your code, all that means is now your context subject has a new field and you can use it, and you don't have to worry about anything else.
+
+Obviously, there are cases where the interface may break. They may change between different tools, but in that case it should be clear, it should be you moving from 1.0 to 2.0, and you're doing that consciously. It shouldn't be something that is a side effect.
+
+So I've been very careful about that, because in the past I've had experience with CORBA, IDL, MIDL, and it was always really painful whenever the generated code mixed with user code. Because now what do you do? Do you test the whole thing? Do you now own the generated code? Do you need to test it, to maintain it? And then you're running into the issues of lifecycle when you change the source, then you need to change the code... Sometimes some MIDL generators would put markers and comments in your file, and then they would find those markers and change the coding between, and you're not supposed to change that.
+
+So I really wanted to try and avoid running into those issues, and so both the generated code goes into a front package, which you do not touch. Actually, you cannot touch it because the generator or the co-generator will wipe out the entire directory every time. So there is no way that your code is gonna mix with the generate code. And the interface is a Go interface, it's explicit and that's how both codes interact.
+
+**Carlisia Thompson:** So when you say "Don't worry about testing the code that was auto-generated", part of the code was the controllers. So how is your workflow? Do you then go manually write tests for integration, for functionality? I'm not a huge fan of testing controllers in specific, I'm more a fan of testing integration, but do you then go and write it manually?
+
+**Raphaël Simon:** So the controllers that the GoAgent generates, this is code that you own. So there are two kinds of code that GoAgent generates. One is the vast majority of the code; it's things that are living in front packages that you don't worry about. But then there is also this scaffolding code, which is kind of just a bootstrap code to help you get started. It's not something that you're gonna regenerate all the time, it's something that you do once and it helps you quickly compile your service and be able to test it and play with it right away. That code belongs to you. That code you test it and you maintain it like your code. And actually next time you're in GoAgent it won't overwrite those files, and those files live in the main package. So the controller lives in the main package and you test that, you own that. The low-level handlers that get generated by default in the package called App, those are the ones that I'm saying you don't have to maintain, you don't have to worry about.
+
+**Carlisia Thompson:** \[24:13\] Got it. And I wanted to say too, in prepping for these episodes I watched a talk that Brian Ketelsen gave in Tampa, and it's simply amazing. If you don't know Goa and have any interest at all, the talk is an hour fifteen, but it's so worth it because he shows the functionalities that Goa provides in Gorma and then he shows codes, and pretty much I watched the whole talk and I came away with a very good sense that I understood what Goa does.
+
+And I'll tell you, it was very simple to use. Another thing that I thought was, I come from a Rails background, and I saw a lot of similarities. To me it felt like this could very much be an alternative to Rails if I wanted to do backend app or an API app in Go, except that it didn't abstract away a lot of things. I saw right there what the call was doing, and it was very much under my control, as opposed to just calling abstractions that maybe I knew or maybe I didn't.
+
+**Raphaël Simon:** Yeah, there is definitely some similarities in the way that you have controllers and you have resources, so that definitely is similar. I think also one other thing that Goa is trying to do is stay simple. So one of the things that we've used quite a bit here and we've grown an application probably way too big for what Rails was supposed to be doing, and so we felt a lot of pain with some of the plugins and at some point I think we had more than a hundred gems we were using. So at this point it becomes almost impossible to understand the request flow throughout.
+
+So something I think Goa is trying to do is to keep things simple; kind of get the best of Go, the Go principles of doing simple tools that do simple things and can be composed together to achieve what you want, and try to get those ideas and mix them with at the same time the practicality of doing something where you don't have to rebuild everything every time.
+
+I think that's kind of the two goals that are a little bit opposed to each other, but it's a good tension and I think Goa is trying to strike the balance between the two.
+
+**Carlisia Thompson:** My impression was that it was very easy in the sense that when you jump into a Rails app, it's very easy to get going. So it was easy in that sense, but it was also simple and that's what I was trying to say... You know, in Rails I'm using a lot of abstractions that maybe I went into the Rails source code and looked at it and I know what it is, but probably I didn't. And with using Goa and Gorma, I see everything right there, I have direct control of what's going on and it's simple.
+
+**Raphaël Simon:** Yeah, that makes sense. I'm happy you say that. I mean, that was definitely a goal too, trying to simplify things and kind of hide a lot of the complexity of hooking up the model in the generated code, and then what you have to implement as the user should be fairly straightforward. Basically the data structures you have to deal with are the ones that you define in your design, so it should all be very expected and very simple to use.
+
+**Brian Ketelsen:** \[28:08\] Now, I have an anecdote about that. In the Goa Slack channel, in the Gopher Slack, we call Raphael the Godfather, and that's because of his extreme dedication to the simplicity of the DSL and the user experience. He will not let anything get by that complicates the process, and I really appreciate that.
+
+I think having that laser-sharp focus on user experience and developer experience is what makes Goa a great tool, versus many of the other code generators, some of which I've written, that suck. So that's important. You have to have the Godfather in every project.
+
+**Raphaël Simon:** \[laughs\] Yeah, I try to keep all the complexity below. You can look at it if you want, but you don't have to deal with it. I think it's a very interesting principle. Like in a big team, you get developers of every level that need to use your tool, and so I think you need to make it approachable, so anybody can take advantage of it and leverage it as best as possible.
+
+You shouldn't have to know how the tool works to take full advantage of it. I think it's the tool's job to make sure that you can use it in a way that's easy and all the complexity is hidden from you. And at the same time, if you are a more advanced user or you're curious and you wanna see how it works, it shouldn't be hidden either. What's underneath should also be fairly nice design, but you shouldn't have to be exposed to the whole thing from the get-go.
+
+**Erik St. Martin:** So another thing that's kind of risen in extreme popularity over the past couple of years is Swagger when doing API specifications, and as I understand it, Goa also generates all the Swagger specs so that you get the Swagger UI kind of for free for anything that you define in this DSL.
+
+**Raphaël Simon:** Yeah. I mean, Swagger was definitely a big inspiration for the abstractions in the design, so there is no coincidence that the Swagger generation is very complete in the sense that you can express anything that you can express in Swagger in the DSL. Actually, the first inspiration was JSON schema. I don't know if you're familiar with how Heroku documented APIs, but they used a different schema, this kind of recursive JSON schema to describe all of their APIs.
+
+And so that was kind of the initial inspiration for the abstractions in the design language, but then it so happened that Swagger is also using JSON schema for a lot of their representation of what they call the path object. And so that mapping was very easy to do, and it just was sort of natural. And I think it's great too because that means that people that already know Swagger are already used to thinking about the design of APIs will feel right at home, they will have to deal with the similar abstractions that they already know.
+
+And actually, I think an interesting project or add-on that could be done with Goa is a tool that would take some Swagger definitions and generate the Goa DSL, kind of go the other way round. So if you write the Goa DSL you get Swagger, but it would also be interesting if you had Swagger to be able to go to a Goa DSL, because then you will be able to take advantage of the GoAgent to generate those other things.
+
+**Erik St. Martin:** He's assigning that to you, Brian.
+
+**Brian Ketelsen:** Pardon me?
+
+**Erik St. Martin:** He's assigning it that to you. That's your task. \[laughter\]
+
+**Brian Ketelsen:** I was just going to say, if you started with a Swagger specification and you generated a Goa DSL and then the Goa DSL generated a Swagger specification, you could set that thing into an endless loop. And by the end of it, it would be Turing-complete.
+
+**Raphaël Simon:** \[32:02\] \[laughs\] Yes, it will actually be very interesting to see how the Swagger evolves over time or it degrades. \[laughter\]
+
+**Brian Ketelsen:** Or whether it takes over the world and starts launching nuclear warheads.
+
+**Carlisia Thompson:** I have a question for Raphael. The views aspect or feature of Goa, I thought it was super interesting. I remember working with a Rails app, an API that was serving cube data as rests for resources, and we had to do some filters that were complicated. Once I figured out a pattern, we just followed the pattern; it was sort of simple, but then I ended up running into problems because we were using the Swagger as a documentation tool - not necessarily to design the API, but just to document the API - so there was a mismatch there between what we were doing and between the Swagger specs, whatever the spec version was that we were using.
+
+Now, with query params and filtering features of an API, is that what the views does? Like if I have different filtering criteria, I can use different views to represent that, is that what it is?
+
+**Raphaël Simon:** Yeah, that's the idea. So the idea is that a single resource may be represented in different ways. You may have an index view for example that only has a few fields, and you may have a detailed view that has all the fields, and you may have another view that is specialized in some other way. So the idea is that you shouldn't have to kind of redefine a different media type every time. So you define your media type once, you list all the fields of the media type, and then you define views, different ways of representing that media type. And each view can define arbitrary fields that were defined in the media type. And then how you produce those views from the request is really up to you.
+
+If you decide that you want to use a query string parameter call view, and the name can be either index or expanded, then great. Do that, and in your controller, in your code, you basically build a response using the view that you wanted for that value of the query string. And that all gets also translated into the Swagger that gets generated as basically different responses for the action. So it's all documented and you get also the benefit of not having to redefine those different media types every time.
+
+**Carlisia Thompson:** Yeah, that sounds brilliant. And I bet it's a lot easier to document as well.
+
+**Raphaël Simon:** Yeah, it is. And I think people have a sort of instinctive understanding of it; it makes sense. If I want to index you, then great. It's the same packing resource, it's just different ways for representing it. So I don't think it's a very complicated abstraction, and it does add a lot to the DSL.
+
+**Brian Ketelsen:** Yeah, I completely agree with that.
+
+**Erik St. Martin:** What's that?
+
+**Brian Ketelsen:** I'm just saying I completely agree with that. I love the idea of views having the same resource represented slightly differently for a different use case. It doesn't mean you should have to write a ton of different code, you just ask for that resource with a specific view.
+
+**Raphaël Simon:** Yeah.
+
+**Erik St. Martin:** So I'd like to make sure we have kind of time to do a fireside chat... You know, talking about news and projects and stuff we've run across together. So before we move on off of Goa, I'd just kind of like to hear from you, what's next for Goa? What kind of functionality are you looking to add here in the near future?
+
+**Raphaël Simon:** \[36:04\] Yeah, so there are a couple of things. First of all I should say that Goa is not 1.0 yet, so I think the near future is going to be finishing 1.0. We are very close, and what I think will make sense is to finish up the security examples that we've started, because that's an area that can get a bit hairier than the other areas, so I think good examples around that makes lot of sense.
+
+So finishing those examples and making sure everybody's happy with those, and then I think at that point we'd be ready to phrase and kind of shift 1.0, whatever that means. But the idea is that then that is stable, so if you are waiting for Goa to be stable to use it, there you go; now you can start using it.
+
+And now for moving on for the next, 2.0, I think there's a couple of interesting areas I'm looking at right now. One is extending Goa beyond HTTP; in particular I've been looking at gRPC. I think it's an area that I've been asked a lot and it's also something we are looking at here at RightScale, so I'd like to see what we can do there. It's going to be interesting, because some of the abstractions don't match exactly the kind of HTTP rest abstractions, so we're going to have to come up with some interesting solutions there, but I think it makes sense.
+
+And another interesting space is making the DSL engine a bit more flexible. So today we've mentioned it's possible to write plugins, and plugins can define their own DSL and/or they can define their own output. But it's a bit more difficult if you want an output from one plugin to affect the output of another plugin, or a built-in generator. An example of that would be, what if you wanted to write a security plugin, and there would be some DSL that you can put in your API description that says, "Hey, if you need to call this action then this is the authorization middle way that you need to go through."
+
+If you wanted to do that today, it would be a bit difficult because you couldn't modify the output generated by the built-in generator for the low level HTTP server glue. I think that's another interesting dimension to look at in terms of trying to make Goa a bit more open and have more people being able to contribute more plugins to it. So this is also something I'm thinking about.
+
+**Erik St. Martin:** This is great. I guess if anybody wants to keep up with or investigate Goa, [goa.design](https://goa.design) is probably the best place. The GitHub link's there.
+
+**Raphaël Simon:** Yes, and the Slack Channel. I think there's a [GopherAcademy](https://gopheracademy.com), so [gophers.slack.com](https://gophers.slack.com) and there's a Goa channel there.
+
+**Erik St. Martin:** That's right. And you'll be actually speaking at [GopherCon](https://www.gophercon.com) this year and Brian will be speaking at Abstractions about Goa as well, if I'm correct?
+
+**Brian Ketelsen:** That's right. And we have a big announcement for people who might be interested in learning about Goa at either one of those conferences. I talked to the organizer of Abstractions and I talked with Erik, and we both agreed to do a discount code for both conferences, so you can get $50 off if you book at GopherCon or Abstractions if you use the code 'gotime', all lower case with no spacing. This will get you $50 off either conference if you want to go see Raphael talk at GopherCon or see me talk at Abstractions about Goa. [Abstractions.io](https://abstractions.io) is the website for Abstractions and [gophercon.com](https://www.gophercon.com) for GopherCon.
+
+**Erik St. Martin:** Alright, so let's do some fireside chat here - news and interesting projects. We'd love for you to participate - Raphael, jump in wherever and offer your own input or things that you've come across and you find interesting.
+
+**Raphaël Simon:** Great, sounds good.
+
+**Erik St. Martin:** Who wants to kick this thing off?
+
+**Carlisia Thompson:** \[39:57\] I'll start. I would like to mention the CLI tool that I found. The author's name is not very clear, but I'm going to say that his Repo is mkideal, and the project's called [CLI](https://github.com/mkideal/cli). I love it because the examples are super clear and there are tons of examples. I did a CLI app at some point in Go. If I had seen this it would have been so much easier for me to understand how to do it. He also has not only flags but commands; it seems very clean and neat, so that's my recommendation today.
+
+**Raphaël Simon:** How would you compare it with [Cobra](https://blog.gopheracademy.com/advent-2014/introducing-cobra/)? I've been using Cobra for Goa, but I'm curious?
+
+**Carlisia Thompson:** I thought it was easier to understand and follow. If I am going to use Cobra today - because I've used it before; the first time I used Cobra in Viper - I will have an easy time. But if it was my first time, this would have been so easy because the documentation is amazing. Kudos to the project maintainer.
+
+**Erik St. Martin:** I just quickly looked at this, but it seems like it has kind of integrations for other things. You can define a particular argument as a pit file and it kind of decodes that and gives you a pointer to the file so you can interact with it that way. So it kind of is an interesting approach with these decoders. I have to look into this a little more.
+
+**Carlisia Thompson:** Exactly. And you can define your flags as slice or map, and there are the features there.
+
+**Erik St. Martin:** That's interesting.
+
+**Brian Ketelsen:** So my addition for this week is the post by Scott Mansfield from Netflix about application data caching, and it is way too in depth and too long to discuss here, but there are some really interesting discussions about data storage and data structure, Go tools like the [Rend project](https://github.com/netflix/rend) which is available on GitHub open source. A very nice and technically in-depth article, just the sort of stuff that I love to wake up to with my coffee, and it even has some RocksDB in there for you Erik.
+
+**Erik St. Martin:** Yeah, I'd love me some RocksDB. Yeah, so I read that post here. It's actually really interesting... Rend is kind of wire-compatible with memcached. And basically what they implemented was this proxy almost in between their clients and memcached, and they implemented like an L1 and L2 cache so that memcached was the L1, but obviously they could swap that out, and then they were using RocksDB to communicate with their SSDs as kind of like an L2 cache.
+
+All of this was to reduce their financial costs monthly for their Amazon instances for high memory, because they were storing lots of user data in memory, so they'd have kind of like the hot data set in a given region, but they'd also have a cold data set, in case people failed over from another region and things like that. So it's really interesting how much they dropped off and I love the fact that they're using RocksDB, and there's a lot of people using that now. MongoRocks was out not too long ago, and one of our other favorites, CockroachDB - they're using RocksDB under the covers, unless they've changed by now. But I think they're still using it. And RocksDB actually comes out of Facebook.
+
+**Brian Ketelsen:** Yeah. I definitely just want to shout out to Scott and the team at Netflix for such a nice and thorough write-up. I know Scott's been dragging the people who will listen kicking and screaming into the Go world; even though they're a Java-heavy shop, they do have a lot to Go behind the scenes there, they just don't talk about it a lot.
+
+**Erik St. Martin:** \[44:04\] Yeah. And I remember seeing some of the performance metrics. It was something in the neighborhood of like two million requests per second, but I think that wasn't fully active because that wasn't wired up the backend. I know when it was all set and done, the whole system was something in the neighborhood of like 20 or 25 thousand inserts per second... But still, I mean, the amount of performance they were getting out of this Go proxy is awesome.
+
+We'll link to that in the show notes too, because that is an interesting read and especially if you're not familiar with RocksDB and some of those things, that's kind of fun by getting to learn how Log-Structured Merge-trees work. Cassandra uses the kind of same approach there.
+
+**Brian Ketelsen:** Yeah. So another project that I've been following for a long time, but really only recently has started to mature is [SHIELD](https://github.com/shieldproject/shield) from Stark & Wayne on GitHub. You guys may remember Dr. Nic from the Ruby world. He seems to have endorsed Go or embraced Go, and this tool SHIELD is almost your universal utility knife for backing things up. So you can write plugins to back up Redis; you can backup a database, you can backup a disk, you can backup anything is if you write a plugin for it.
+
+And when SHIELD first came out, I read the code because there was no description in GitHub and just tried to guess what it was going to do eventually and I couldn't figure it out for quite a few months, and now it's matured quite a bit, and it looks to be a really nice tool for backing up all the things.
+
+**Erik St. Martin:** Yeah. I briefly looked at that. I need to find a use case for it. But I like the idea that you can kind of wire up where it's pulling the data from and where it's pushing the data to. I need more time.
+
+**Brian Ketelsen:** Yeah, almost like the concept of [Heka](https://github.com/mozilla-services/heka) we were talking about last week. You know, this is a Heka for backups.
+
+**Erik St. Martin:** Yeah, that's actually a good comparison.
+
+**Brian Ketelsen:** Thanks for saying so. \[laughter\]
+
+**Erik St. Martin:** I have to make you feel better.
+
+**Brian Ketelsen:** After the code reviews I've been through this week, I'll take anything I can get. \[laughter\]
+
+**Erik St. Martin:** So another interesting project that I've seen was [zap from Uber](https://github.com/uber-go/zap), which was a structured logging framework that is supposed to have, I think, zero allocations. That was kind of interesting.
+
+**Brian Ketelsen:** You know, we're down here in the South so we can call that Y'ALL, yet another level blogger. \[laughter\]
+
+**Carlisia Thompson:** I really liked the structure part of that system. I remember when I worked, again, in the Rails app and we were using Splunk to keep track of our logs, and we had to agree upon a specific way to write our code so that it will be easy to find in the Splunk; we had to just like put certain keywords and the equal sign and then whatever variable we wanted to look at, and we had to rely upon everybody remembering to do that. So with this structure, it just makes life so much simpler for everybody, besides the fact that it seems to be very efficient and a lot of other features.
+
+**Erik St. Martin:** Alright, anybody have anything else they want to talk about before we kind of go on our merry way?
+
+**Brian Ketelsen:** No, it's been a pretty full show.
+
+**Erik St. Martin:** Or not so merry for Brian, who's gonna get peak down in his code reviews tomorrow...?
+
+**Brian Ketelsen:** I'm going back to my code reviews for today. \[laughter\] Don't tell Blake if he's listening.
+
+**Erik St. Martin:** So one of the things we like to do when we close the show is just kind of briefly go around and give thanks to an open source project kind of as you spoke to earlier, Raphael; to get kind of that feedback from the community sometimes makes your day, so we want to make sure that we're regularly reaching out and thanking people for the things that make our lives easier. You want to kick this off, Brian?
+
+**Brian Ketelsen:** \[48:02\] I'll kick it off today. One of my favorite open source tools ever is an NSQ from Bitly. I've used NSQ in dozens of projects and it has never ever disappointed me; it's blazing fast, it is 100% predictable and reliable, and it's just amazing how much you can do with NSQ in very little code. And I really appreciate the fact that they open sourced that, it's a great tool.
+
+**Carlisia Thompson:** What is it?
+
+**Brian Ketelsen:** NSQ. It's a distributed Queue that's incredibly fault-tolerant and really fast and it's written in Go, and it's written really smartly.
+
+**Erik St. Martin:** Yeah. Actually Matt Reiferson did a talk in GopherCon 2014 on it. I think the talk was titled ["Spray Some NSQ On It"](https://speakerdeck.com/snakes/spray-some-nsq-on-it) or something like that.
+
+**Brian Ketelsen:** That's right, yeah.
+
+**Erik St. Martin:** Yeah, that should be on GitHub, too.
+
+**Brian Ketelsen:** And that video is up on YouTube, yeah.
+
+**Erik St. Martin:** How about you Carlisia?
+
+**Carlisia Thompson:** I would like to mention today [iTerm2](https://www.iterm2.com), which I'm sure most people already use. If you don't, you definitely should check it out, because eventually you will. \[laughs\] It seems that everybody makes the transition from the normal terminal that comes with the Apple system to iTerm2. And especially the 2.9 beta version. I had to download that for some reason that I forgot; it's been a couple months and it's amazing.
+
+There are a bunch of new features that are very interesting, very useful. I'm just going to say I recommend that you leave... It pops up a tip of the day every day, right on the terminal. It's very non-intrusive; we can just hit skip and it will go away. Basically, leave that on and you're going to discover a treasure trove of cool features for your terminal. There, that's it.
+
+**Erik St. Martin:** Yeah. For when I am actually on my Mac recently, I have the little tips on there because it's been a while since I've explored features at it, so I'm letting it annoy me periodically to tell me things that I should be doing.
+
+**Brian Ketelsen:** They've added some really radical stuff to iTerm2. The latest betas are pretty crazy in terms of the toys that they have added. I'm not sure if I'll ever use them all, but they are impressive.
+
+**Erik St. Martin:** I get a little jealous because most of the time I work off of my Linux workstation so, you know... GNOME terminal is I think the current one I am using in i3, but it's not the same. Raphael, do you have a project you'd like to thank?
+
+**Raphaël Simon:** Yeah, actually we started using RethinkDB, and it has been very interesting. I stumbled on it kind of by chance and was reading the description and the feature set and it all sounded good, like it usually does. But then what really struck me is how well it fit with the use case that we were after, which was trying to generate events whenever some data was updated, and so RethinkDB has that built-in, this idea of subscription is built in. It's been a very interesting journey. It has changed quite a bit the way we're thinking about the design for those new services, and so I would definitely recommend people take a look at it if they haven't yet, because it does provide another dimension to how you can design your systems and take advantage of these subscriptions capabilities. So very, very glad that they open sourced that.
+
+\[51:39\] And something else I wanted mention - it's not a project, but I wanted to give a shout out to other companies that let their own employees develop open source projects, because it takes time, and we all going to have to make a living, and at the end of the day the companies that allow their employees to develop open source projects are really enablers and I think we need to thank them for that.
+
+And I'm thankful for RightScale obviously with Goa, but I was also thinking about JP Robinson at New York Times doing Gizmo... I mean, there are many, many examples of people that work in the industry and where their company actually pays them to develop open source projects. I think that's awesome.
+
+**Erik St. Martin:** And I actually get to cheat because we got to just talk about the Netflix post and RocksDB, and I love RocksDB, so I'm going to give a shout out to them. \[laughter\]
+
+**Brian Ketelsen:** That's cheating. That shouldn't even count. We're taking this one off of your scoreboard, Erik.
+
+**Erik St. Martin:** \[laughs\] But, I mean, it's awesome. If anybody hasn't played with it, they should. And even just investigating kind of how Log-Structured Merge-trees work is kind of fascinating. So I think with that, we are just about out of time.
+
+I definitely want to thank everybody for being on the show and especially, Raphael, for coming on and talking to us about generating all the things.
+
+**Raphaël Simon:** Thank you. It has been great. Thank you very much.
+
+**Erik St. Martin:** We have the Godfather of code generation on the show. \[laughter\]
+
+**Raphaël Simon:** This has been really great. Thank you for the opportunity, I really appreciate it.
+
+**Erik St. Martin:** And we'll have links to everything we've talked about in the show notes, or if you happen to be following us on Twitter @GoTimeFM, most of the stuff should be linked there, or the Slack Channel, the Gopher Slack or Goodtime FM, there as well. So I think that is about it and with that, I guess, we'll see everybody next week.
+
+**Brian Ketelsen:** Awesome, thanks everybody.
+
+**Carlisia Thompson:** Thank you, goodbye.
+
+**Raphaël Simon:** Bye.

SOLID Go Design_transcript.txt

@@ -0,0 +1,339 @@
+**Erik St. Martin:** We are back for another episode of GoTime. Today on the show we have myself, Erik St. Martin, Brian Ketelsen is also on the show today...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** And Carlisia Campos.
+
+**Carlisia Thompson:** Hi, everybody!
+
+**Erik St. Martin:** And our special guest today, although he needs very little introduction, is Dave Cheney. Say hello, Dave. Why don't you give everybody a brief introduction?
+
+**Dave Cheney:** Hello there! My name is David, I am a Go enthusiast from Sydney, Australia. I've been involved in Go for many years, and I love the opportunity to be involved with the language and get involved so early with something I'm so passionate about. Hello, everyone!
+
+**Brian Ketelsen:** It's kind of amusing having you introduce yourself, while one of the things we found at GopherCon just a month or so ago was that nearly everyone that we talked to learned Go from your blog. Out of the 1,500 people that were there, 1,499 of them listed your blog as one of the resources they used to use Go. So it is kind of embarrassing to introduce you, but we feel it's necessary.
+
+**Dave Cheney:** Yeah, it was great to meet so many people at GopherCon. It was really touching the way that everyone was like, "Oh, I love to read your blog!" It was really touching. Five years ago, I never started out to be an author, a blogger or a public speaker. Just like every good engineer, you think "Oh, I've run into this problem so many times! I can solve this by just writing it down once and then I can give people the URL." That's kind of how I got started.
+
+**Brian Ketelsen:** A question on that - did Go encourage you to find your voice, or did just becoming a better engineer encourage you to find that voice?
+
+**Dave Cheney:** It's kind of like the question, "Does the tail wag the dog, or does the dog wag the tail?" I joined Canonical about four, five years ago, and we were encouraged to communicate on IRC all the time, so it was a great opportunity to moonlight in the IRC channel for Go. At the time Go 1.0 was just barely out and there were so many questions people had, and they would come into the channel all the time and ask the same questions. As I said, I tried to solve this problem by just writing it down, and I'd give people URLs. Then around the same time... So Go had supported Arm - I knew this, and I found a really cheap Arm box in Australia. One of the magical things about Australia is that we don't have access to Raspberry Pi's and things like that; it's always hard to get equipment, so when I found this, I was like "Can I install Go on it?" I could, and that became the very first builder.
+
+I was so excited about it, I wanted to tell people "Hey, you can run Go on this kind of hacked up NAS." That was one of the first things I wrote on my blog. Then it just went from there.
+
+**Erik St. Martin:** In addition to all the blog writing, you've also contributed quite a bit to Go.
+
+**Dave Cheney:** Yes. As I said in my introduction, it was kind of like this opportunity to get involved at the ground floor. All you needed to be involved was spare time, and it's just snowballed since then. You know, that kind of "see a need, fill a need" kind of thing.
+
+**Brian Ketelsen:** \[04:01\] For years, you've hosted the unofficial builds for the Arm platforms on your website, and I think it was not too far in the past when Go started making the Build Dashboard and actually having builders that were hosted in-house. But I think for the longest time, all of us that used Arm boards with Go were downloading Go directly from you, which was awesome and we all appreciate it. Our Raspberry Pi's definitely are thankful for that.
+
+**Dave Cheney:** I really think Arm is really special. I know Intel rules most of the server world, but Arm has a really special place. It's so simple, it's such a beautifully clean instruction set, rather than the Intel mess. Just like I appreciate Go for being simple and minimal, I really appreciated Arm for being all the same things. The story for how to build an Arm distribution, and mainly a lot of the magic about Arm machines is they're usually pretty weak, especially if they're on 5.1. A lot didn't have the opportunity to build Go; cross-compiling used to be quite difficult, as we all know. That was just something I could do. I reached out to Andrew and said, as long as I'd put a big warning at the top I'd be happy to maintain those builds", and he was happy, too.
+
+In the last year, we've managed to get real builders using places like Scaleway. I think Scaleway hosts all the inter-builders. Now we have real builders in the dashboards, which means that the Go project can produce a real tarball for everyone to use, which is exactly what I wanted. It's graduated from being a side project to being something that's fully supported by the Go Team now
+
+**Erik St. Martin:** I think the blog post I'm waiting for the most is the "How does Dave Cheney make more time in a day?", because... \[laughter\] You have a day job, you contribute to Go, you contribute to proposals for language changes... Recently you've been traveling a lot, doing talks at a lot of Go conferences. How you make time for that is just astonishing.
+
+**Dave Cheney:** Yeah, it's a pretty full schedule. The magic of Australia is that it's a day or two on a plane any way you want to go. I don't know, I've always been very lucky. Canonical was extremely supportive of me, working on Go, and they even sponsored Arm and I to work on the first cut of the Arm 64 board. That was great, that my day job could become the thing that I love. And yeah, you just find time in the weekends, and after work, and you just integrate it into your life. I'm really lucky that I've been able to do that.
+
+**Brian Ketelsen:** Well, on behalf of all of the people across the world, we all really appreciate the effort that you put into proselytizing Go, teaching everybody and building community. I don't think the Go community would be the way it is now without you, so thank you.
+
+**Dave Cheney:** Thanks, Brian.
+
+**Carlisia Thompson:** Yeah, I thoroughly agree with that.
+
+**Erik St. Martin:** I have to add my name to the list of people who learned a ton from Dave's blog, especially in the early days. When Brian and I were starting out, in late 2011, early 2012, there wasn't a lot of content out there.
+
+**Dave Cheney:** I feel really lucky and privileged to be able to do that, because it was this base that I could fill up with words. There were some great things to say about Go. I was learning a lot about it, and I wanted to tell other people about it, and there was just an opportunity.
+
+\[07:55\] If you had met me, as I said, five or ten years ago, you wouldn't have picked me for any of these things. I don't know whether I've had to learn them or whether I've been lucky to learn to be a public speaker. I haven't done any public speaking since high-school. I thought when I graduated I can just throw away that bit of my brain, like "I'll never get to do public speaking or debating anymore", but I had to learn how to do that again. A writer? My father is very impressed by that. He was like, "Your writing has improved so much."
+
+As an engineer, leaving high-school, I thought "Non-fiction writing - who needs that? We just need code."
+
+**Brian Ketelsen:** \[laughs\] Well, I think we've spent 14 minutes now on Dave Cheney fanboyism, so why don't we slow down on the ass-kissing session for just a minute and talk about some of the really cool things that you've done lately. You gave a great talk at Golang UK last week about solid design. Why don't you tell us a little bit about that?
+
+**Dave Cheney:** The meat of that talk - the solid design principles - came out of a presentation I did a couple months ago in Perth to Dave Thomas' YOW! group of conferences. That talk was to a group of people who didn't really know Go; it was a mixed bag of technologists, most of whom were very passionate about functional programming. So I had an opportunity to take this talk and kind of redo it for a home team crowd, and I wanted to make it interesting for the audience, and say why should you care about these things, not just presenting an abstract I wanted to wrap it in a bigger request. If Go is going to be a language which companies invest in, they build products in and they use them in their infrastructure, they're going to be investing in them for 10-15-20 years.
+
+My bigger message was that Go programmers need to start thinking about how programs are designed, because the alternative is that we'll just become the JavaScript framework of the month, and possibly replaced by something else. But if we think about design and more importantly talk about design, develop a language to talk about the design of programs, rather than just moving from the next fuss - HTTP right to the next one - then Go has a chance to be a language that people want to use the programs that are written in 10-15 years.
+
+**Erik St. Martin:** So Dave definitely listened to this show, because Brian rants about the number of HTTP routers about every episode. \[laughter\]
+
+**Dave Cheney:** The other talk I gave at Golang UK was about how to write faster Go code, so I might be a little bit hypocritical in dumping on people who are writing HTTP routers, but the bigger picture is that the Go code that we write today has to be maintained, it has to be changeable; it can't just be something which solves today's need. It needs to be maintainable for the long term.
+
+Otherwise, maybe in five years people will be like, "Oh, this Go code... It's not maintainable. What are we gonna do?" and they'll rewrite it in something else and continue that search for the next thing. To be an investment that a company is gonna make for a decade or more. The maintenance of the program is far more important than just sticking the prototype together and seeing how fast it goes.
+
+**Carlisia Thompson:** \[11:38\] There is another aspect of thinking about design. For me, it does take effort; it does take effort in you learning what good design means. But once you start learning it, it makes coding easier. For example, when I started learning Go, I would think "Where do I put things?" and I see people asking that all over the place - "Where do I put things? Where do I put my models? Where do I put this? Where do I put that?" Well, if you take some time and think about how to design your interfaces, how to design your packages, how to organize everything, if you start thinking about dependencies - that question gets answered automatically, and you end up with good code.
+
+There are multiple layers and multiple reasons for you to think about design, I think.
+
+**Dave Cheney:** That's exactly right, and you touched on a really important thing - you just said "good code" there, but that's super subjective. What is good code? Well, I like it to look a certain way, I like to have long identifiers, I like to call my receiver this, rather than the single letter that we're used to, because that's how I used to do it. What I was interested in talking about in the UK is what if we had a different language to talk about design, that was not so subjective, like "I like this, I prefer it to be a certain way"? One that was more objective. And that's some of the ideas that Martin's solid principles talk about; they're not less opinionated, but they came from a point of saying, "I like this because it is easy to modify. I don't like this because there's a lot of coupling with the other types in the other packages. We can say it more objectively."
+
+The thing Martin says about the solid principles is that they're not rules, they're guidelines. You can say every now and then, "Look, I should be honest in all my dealings, I should be truthful with my friends", but sometimes you have to bend the rules, tell a little white lie, those kinds of things. When you talk about design principles, you can say things like "I don't like this because it's quite tightly coupled, but this seems like a reasonable trade-off to achieve our objective."
+
+It's interesting to talk about design using those kinds of words, rather than things like, "I don't like that. That code should be more beautiful", or "I don't like it, it should be shorter." These are not really actionable to have in a wider design context, because everyone's ideas are different. "How short is short? How beautiful is beautiful?" These become subjective and the subject of arguments.
+
+**Erik St. Martin:** Right. Some of those things that people point out are more from an aesthetic standpoint, and it's like art - what I appreciate is gonna always be different from what you appreciate, but I think we can both agree that two highly coupled components are hard to maintain. We can collectively agree on that. I think talking about this at this objective level makes a lot of sense, and it's one of the reasons why I loved Ruby a lot when I came into the Ruby world a few years ago, because these were the conversations that people were having all the time, or about the Law of Demeter, coupling and cohesion, and things like that.
+
+I really appreciated that people were talking about making clean abstractions and maintainful code, so I like the idea that we're starting to talk about that in the Go world, as well.
+
+**Dave Cheney:** Yes, absolutely. I think it's critical, because if companies are going to invest in the long-term -- and they have started. We have Docker, all the CoreOS products, all the HashiCorp products, Kubernetes - there's an investment. But to make that investment pay off in the future, it can't just be just smashing out code as fast as possible. There has to be some fundamental design so we can change the code in the future, as the requirements change.
+
+**Brian Ketelsen:** My question is, if there's a maturity model for Go as we evolve into a more popular language and a more well-adopted language, does that mean we have to go through some ugly growth phases, like Gang of Four patterns and Enterprise JavaBeans? What does our maturity model look like in Go?
+
+**Dave Cheney:** \[16:09\] Does anybody else want to jump in while I think?
+
+**Erik St. Martin:** Sure. I think that Gang of Four is probably a little too far. I don't think we want to get into that, because the language is specifically kind of designed to prevent that - this whole inheritance chain and things like that. But I think that there are some lessons to be learned. Most of those abstractions were built for good reasons. Abstracting away, creating clean interfaces and things like that, and I think that we can do that without having to have that many patterns.
+
+To Dave's point, there should be objective goals that we're trying to achieve, and not necessarily set in stone patterns; that would be my take on that.
+
+**Dave Cheney:** I did have a section in the talk which I cut because I didn't have time, but mainly because I had a lot of pushback on it. I start the talk by saying, "Who does code review? Why do you do code review?" Somebody yelled out, "To find bad code", and that's really the hook there. I continued with, "So the patterns book - does that tell you how to write good code?" My assertion was, "Perhaps not. Perhaps in the bigger context they're called patterns because you apply them like a sewing patterns, or like a recipe. When you have a particular problem, you could use a set of those solutions if they fit." But I think talking about design and principles - to take Martin's word - are higher-level notions of "What is the goal?" and not "What is the problem I'm solving now?" And if the goal is to make the code maintainable - and by maintainable I mean changeable in the future, a thing like a visitor pattern or an iterator pattern isn't gonna give you the vocabulary to talk about that. That's just a point solution.
+
+**Erik St. Martin:** Yeah, and I think it also limits the possibilities. If we always refer to "You need to use one of these patterns", I think that it also kind of closes off creativity, but I think that we can generically talk about things. These two components should not be coupled together.
+
+I always mix up the two books... There is another book called Clean Code by Bob Martin as well, and then there's The Pragmatic Programmer: From Journeyman to Master - both of those books I really like. They have a lot of unique ideas. They show you that if one type seems to know too much about another type, maybe you have the function in the wrong place, and things like that.
+
+We could talk about these at a very high level without having to go into, "Oh, this is a visitor pattern" or "This is a decorator pattern", or flywheel, or any of the other ones in the Gang of Four book.
+
+It's actually kind of interesting... I haven't had to think about the Gang of Four book in a number of years, since Java. And that's a good thing too, because I succinctly remember a piece of middleware that I swore somebody went through the book and found a use for every single pattern in the book. \[laughter\]
+
+**Dave Cheney:** So here's the weird thing about the patterns book. I guess it was written in the mid-to-late '80s, probably in the '90s... At the time, people - and I'm kind of gesticulating to the luminaries who thought that it would just be the first of many books; they thought there would be patterns in everything. Every year there would be Patterns - 2005, 2006, just an endless supply of them. But it actually turned out that the 30-odd of them that were in that book are pretty much all there are.
+
+\[19:52\] It's not because Demarco and his friends I think Gamma sat down and thought up 30 patterns, and then they were like, "Okay, we've gotta do a second edition of the book." They observed them in code that they were looking at. They kind of got it back to front - they looked at this wide body of code and tried to find commonalities, and from there they extrapolated a patterns book. But they could never find more patterns, because there are a finite number of them. They're kind of like a law of nature - you can't invent new laws of nature; they're just there.
+
+That really kind of set the patterns book as being the start of a way that we're gonna describe every piece of software design; it became this one point in time, of these couple dozen observations about software at that time, written in the '80s.
+
+One of the things about my talk - and I was very inspired to do it ironically in London, because Jim Warrick's talk from 2007 starts with talking about the Great Fire of London and saying then when they were going to rebuild London, they had all these proposals for how to rebuild London, and these questions... What he opened his talk with was, "Looking at all these different plans for how to rebuild London, how do you decide what's a good one? Looking at all the architects in this room, how do you decide which one you'd like? What is the right design to rebuild London?" And again, without language to describe what is good architectural design any more than what is good software design.
+
+**Erik St. Martin:** Yeah, that's interesting. We could say the same about algorithms too, right? There's a lot of clearly defined algorithms that have really good use cases, and we reach for that bag of well-defined algorithms based on need, but sometimes based on things we know about how things scale, and their performance, and how clean they are, we also are free to make our own choices, right?
+
+**Dave Cheney:** Yeah, to talk about algorithms - what is the meta language that we talk about algorithms, the big O notation, what is the time and complexity versus the space complexity? A linked list has better space complexity, but poor time complexity, and also in the current hardware it has even poorer time complexity, versus just the vector. So the metalanguage to talk about algorithms are these concepts of time complexity and space complexity; it's space versus time trade-off.
+
+**Erik St. Martin:** Unfortunately, that's a lot more measurable than these concepts we're talking about now, with how coupled is something - that's hard to measure.
+
+**Dave Cheney:** Yeah, yeah. But there's still probably an argument... You could compare a hashmap to just an array of items. For really big hashmaps and really big arrays of items, the lookup time is O(log N) versus O(n). But for really small ones, that N is really small, so it doesn't matter. These are the subtleties... If you're saying, "Well, we always have to use a hashmap, because hashmaps have faster lookups" is ignoring the fact of... Say HTTP had a map - is it ever gonna have five things in it? What's the overhead of setting up that hashmap, hashing all the items, versus just doing a straight linear search. HTTP headers only have five or six items in them, usually.
+
+So those are the kind of design decisions you can talk about with space and time, the big O notation. That was the thing that I wanted to get people in the Go community talking about - talk about design at a high level, rather than just posting on Reddit, "Hey, what's the fastest way of framework? What's the best HTTP?" I wanted to see people starting to talk at a higher level, start thinking about "What is the best way to design my application to make it maintainable in the future? Make it maintainable and reusable, composable."
+
+**Erik St. Martin:** \[24:06\] Yeah, I'd love to see more conversations along these lines, too. I've been developing Go for a number of years and I still struggle with package layout. At what point do I split things up into separate packages? When do I make sub-packages? How we have 'io' and then 'ioutil' and things like that. I'm still trying to abstract these patterns from common codebases that I see, and come up with my own rules of thumb. Having more conversations like this, more people talking about it I think is a really good thing, because I think a lot of people can learn from this.
+
+**Dave Cheney:** Yeah, the standard library is a double-edged sword. For authors like yourself, or anybody who wants to give some advice that won't change the next week, the standard library is really good, because it's gonna be the same for five or ten years. We can give this advice and know it won't be out of date soon. But the thing about the Go library is that while it's one of the most well reviewed Go code in the world and it's written by the best Go programmers at the time. It's also some of the oldest Go code and it has some inconsistencies. You can look at it and pretty much prove whatever side of the argument you want to make. You'll always find an example in there that supports whatever argument you wanna make.
+
+That's tricky, because what is one of the three things that we tell new Go programmers? Go do the tour, go read the language spec, go read the standard library. That's not as clear a guidance as I think we'd like.
+
+**Brian Ketelsen:** Well, some of the problems with the standard library is that pieces of that code were written before we knew what good Go code design look like. It evolved with design, and we - the Go community - didn't take the time to go back and change those things in the standard library, for various reasons. So I agree, it is interesting to see some of the variances in style, especially in the standard library, based on the age of the code.
+
+**Dave Cheney:** Yes, absolutely.
+
+**Erik St. Martin:** Yes, and how you talk about things changing and evolving was based on what we knew at that time. One of those things that you've been also doing talks about and advocating is error-handling. I think before we shift over into that, we should probably break really quick to do a shout out to our sponsors, and then we'll come over and start talking into error changes.
+
+**Dave Cheney:** Okay, cool.
+
+**Break:** \[\\00:26:43.01\]
+
+**Erik St. Martin:** We were talking about the standard library and evolving it based on new knowledge gain from years of writing code in what is the 1.0 spec. Some of the stuff that we're starting to see and one of the topics you're primarily advocating is the way error handling is done. It seems like some of the sentinel error values and just returning up the errors seemed to be good enough as the language was evolving, but I'd like to talk a bit more about your new approach. You did a talk at GopherCon about it, and you've got your own package to be used to help with error handling. I'd like to talk a bit about that.
+
+**Dave Cheney:** Sure. First of all, before I say anything, I need to be very clear that I stand a very small amount above the shoulders of many giants who've done a lot of work before. The errors package that I wrote is directly influenced by the one that we wrote at Canonical for Juju, which is based on Roger Peppe's work from earlier. There is a long lineage of this idea evolving, which is something that I also see in other areas in Go. Not to get too distracted - for example two and a bit years ago Rob Pike wrote about functional options. I thought this was such an amazing pattern that I went and talked about it at dotGo, mainly because I didn't think people gave Rob's post enough credit; I thought it was a brilliant idea and it just kind of flew under the radar.
+
+I got on stage and talked about it at dotGo. The idea keeps percolating, and the latest evolution of it is in gRPC - they used that heavily in the constructives for all the gRPC types, the formalization around the naming of options and the name they're gonna call it. What I see in the broader perspective is there's kind of an evolution of these ideas, which is how it should be.
+
+To talk about errors is kind of two stories that sit side by side. The first story is that I've written a lot of blog posts about how I think error handling should be done, and this is separate from stack traces and things like that. In fact, embarrassingly, I actually wrote the same blog post twice, about a month in-between. I even gave it the same title. When it showed up on Reddit, people thought it was a cross-post. The big picture there is that I'm trying to push forward heavily this idea that if there's an error return from your function in general - and there are always exceptions, especially when you're dealing with the network and retriable things - you should try to basically say, "This error happened I don't know anything about, anything about the details. I just need to go through my cleanup behavior and then give the error back to the caller." It makes the code and the design so much simpler and so much more decoupled to just say, "An error happened. I'm gonna clean up whatever I was doing in this function", and most times that's almost nothing, because we have nice, small functions that are well factored, and then you just give the error back to the caller. "I don't know what happened. I'm cleaning up and I'm gonna give the error back to the caller."
+
+I've talked about ideas of rather than checking the error matches a particular value, or the error is a particular type, you should instead try and think about it as, "Okay, if I need to know something about this error - is it a temporary error? Does it fit the temporary interface? (which you get from net dot com or you can define yourself)." That leads to much loosely-coupled way of error-handling. I don't know anything about where this error happened, I don't know whether it happened in my direct call or whether it happened hundreds of stacked frames down. Something happened, I'm gonna clean up and hand the error back to the top.
+
+\[32:06\] That's a way for designing Go programs that deal with errors in that fail-fast kind of way. At every stage you're not trying to, "Oh, something went wrong. I'm gonna look at that error and see if it matches a dozen of the kinds that I know about, and in those particular cases I'm gonna retry, or I'm gonna adjust some timer and then do it again." No, just blow up. Just blow up, give it back to the person above you, maybe they know how to do it. Hand the error back. Fail early, fail fast, because we know that's the way to write reliable software, this idea of crash-only software. If an error happens, just quit; something will restart you, try again. That's one part.
+
+**Erik St. Martin:** In the case of the is-temporary check - I know in your talk you kind of brought that up - do you advocate that if it's temporary people do some kind of exponential backoff with some backpressure to eventually fail out? Or are you advocating just always return and pass up the chain and handle it at the highest level possible?
+
+**Dave Cheney:** It's always a trade-off. I think in the places where your code does actually know it's dealing with a network -- this is to come back to the idea that you want to have modular design; the way that your modules interact with each other are interfaces, rather than concrete types. In the case that your code does know it's dealing with the network, you're actually writing an HTTP server or you're writing the SSH package, or something like that; something that will most of the time actually work out with the network. You have the simplest knowledge that when a particular call operation does fail, it could be because the DNS just flaked out, the network flapped or something like that.
+
+Often times when you're working in this binary package and you're passed a ReadWriter or a ReadWriteCloser you don't know where that came from - it could be a buffer, it could be a file on disk, it could be anything. It really depends on what is the goal of your package and to take that responsibility and just wrap up. You can image that the HTTP package knows a lot about the network. There's even things that we're trying to do in 1.8 to retry HTTP operations if we think that they're safe to do so. It's a GET request, it didn't have a body, there was a temporary error trying to make the connection. Maybe in that circumstance you can retry, but all those kind of caveats mean that you know a lot about the environment that that package is operating in.
+
+I think it general you don't know have that kind of visibility to how your package is working. Many times perhaps you shouldn't; perhaps you should try and treat them more like black boxes, because that makes them easier to just clip together. There are less implicit agreements between code; they have to be explicit, or they're just opaque.
+
+**Erik St. Martin:** I guess that makes sense... Because even if you think about it from the network concept - what are you doing? Some temporary error may have occurred, but you can't guarantee idempotency, right? You could retry, but that may cause some undesired effect on the other side because it half-completed, or something like that. Retrying is always hard; you really have to understand what the system is doing and potentially check state and make sure that something didn't get half-committed before retrying.
+
+**Dave Cheney:** \[35:46\] Exactly. In those situations, it shouldn't be so easy to just blindly put in a retry. You perhaps wanna think about how this operation failed. That means that you need to know very intimately about all the parts of the code downstream for you, which means a lot more coupling, you have a lot more knowledge of the components that you're building on top of. There are certainly cases to do that; I think they are less widespread than people think, and in general you want to try and compose your programs out of small pieces.
+
+To give an example, the SSH package, which built on top of networking public keys, SSH agents... The interfaces that those types implement are just the usual read/write closer. We worked really hard to make the con interface and the session interface look pretty much like a read/write closer or a similar thing that you get from os/exec. People don't expect os/exec phase to be retriable, so we don't really expose those either. That's all from the point of view of building packages that interoperate at a very high level. They don't know a lot about each other apart from the interfaces.
+
+There's a separate part of error handling, which is when error does happen, how do you tell the developer or the operations person -- what I was saying earlier, you just kind of wave your hands and say "I'm just gonna give the error back to the person above me, the code above me. It will figure out what to do."
+
+Eventually, you're gonna reach the top of your function or the main handler of your web server or whatever it is, and if that is gonna come to you, you're gonna have to figure out what happened. In that case, you want to get as much information about the error that happened. You want to encode as much information as you can; preferably, you want to get a stack trace or something to point you to where the error actually occurred. Because as a developer, I'm gonna get a bug report, and if it just says, "Failed to request io.EOF" - where did that come from?
+
+So the second part of error handling is using the fact that the error is a value, and we've just talked about it from the caller's point of view - just making it opaque, just making it, "An error happened" and you don't know anything more than that. Then we can use this fact and we can stick extra information into it. For a long time, the tradition has been to use fmt.Errorf, put in a little prefix and then print out the error. Then annotate the error all the way up, so you get this kind of string that's growing, with a little bit on the front every time.
+
+That's been a pattern we've seen in the standard library a lot, Donovan and Kernighan talk about it in their book... There's a lot of Go code written out there, "if err != nil { return fmt.Errorf} some description that says what happened, and then the text of the error. \[\\00:39:06.14\]
+
+And that's good, because at the top you get what Roger used to call 'breadcrumbs' of "This failed because this failed:because this failed:because this failed:because this failed", and you can kind of grep for those little individual strings and kind of manually construct a stack trace of where you were in that code.
+
+That's good, but it has problems that... There are cases -as few as they are and as many as I would prefer they weren't - in the standard library where you do actually want to check for a specific value. io.EOF is the super example of this. Any I/O reader must return io.EOF. It can't return ReadFile:io.EOF. It must return exactly that value of io.EOF. We're actually checking for quality there.
+
+\[40:06\] In certain cases you can't do this annotation, because taking io.EOF, printing its string out, pending to another string and then returning an entirely different value from fmt.Errorf gives you something which doesn't compare, and you can't strip off that prefix anymore, because you've forever damaged it. So if we're talking about using the error value to annotate extra information, some kind of message, a stack trace or something like that, it has to be undoable. And again, my work in this area is very small, and it's certainly not unique. There's a lot of work that I stand on, with this idea of "Okay, so if we have an error, let's give it a method that lets you get the underlying error."
+
+If we're stacking them one on top of another, let's have a method that we can undo the stacking, so that if we do need this behavior of saying, "Is this io.EOF?" or for example if you use "OS does not exist", that knows about a certain bunch of types from syscall from Windows; there's a few other ones that it knows specifically to check, and says "I know how to interpret these error types. I know how to look at them and say, is this actually caused by a file not found?" So you need to be able - whatever wrapping you do - to add context, add a stack frame, add a message, and you need to be able to undo that, because there are cases where you need to extract the error, because that's the way the code goes.
+
+**Erik St. Martin:** Right, and there is cases we've seen where people have masked the sentinel error values based on the type that they're returning in their error, too. Relying on those sentinel error values becomes problematic.
+
+The nice thing I like about this approach too is the other pattern we've seen people trying to solve these same problems with is tagged log, but that only helps in the log messages that are going out; that doesn't help the callers that the messages are being passed back up the stack, too.
+
+**Dave Cheney:** Oh, this comes into my other big rant, which is only handle the error once. Handle means basically I've inspected the error value; if error != nil, that's your inspection, I've looked at it. Then you get to make exactly one decision. That decision could be to log the message; you've written it out, so therefore the error is handled, you don't need to return it to the caller.
+
+Now, what were some cases you might log it... Say you're searching in a search path, you're looking for a particular file. It's not in your home directory, it's not in the shared directory, isn't in the system one. You're not gonna bail out on that first time around; if it's not in your home directory, you're gonna look in the shared location, then you're gonna look in the system location. So you check the error, and it might be the case that "Okay, it wasn't found there, but I have two more search paths to look", so the error is handled at that point.
+
+What I see a lot is at every level in the call stack, if error != nil, I'm gonna write out "Log - some error happened", and then return that error to the caller. That means however much you apply this pattern all the way in your code, you're gonna get 10 or 15 different log messages basically telling you the same thing "Error happened - Error happened, failed. Error happened - couldn't open file. Error happened - couldn't parse JSON." And then, right at the top of your handler or your main function, you're just gonna get the raw error, with no stack trace and no context. Logging kind of happens externally; it's written out to the STDOUT or it happens through some log shipping, and the actual program logic of handing that failure case operates in an entirely different universe. So not only you're generating a bunch of log messages, but the thing that you get back at the top of your program has not context, it has no hook to any of that log context that you're sending out to logging.
+
+\[44:11\] I strongly advocate, if there is an error, just return it to the caller, and the error's package with the wrap method gives you the ability for that little piece of log context that you're gonna caught in log.error if, just put that in the error itself (Errors.wrap) with that message text, and return that to the caller. So you get all those annotations which are previously sent out to the log file via this kind of side channel, and now available at the top. When you're gonna print out or analyze that error and log it into a file, or you quit the program because the error happened, you have all that context there for the operator or the developer to figure out what happened.
+
+**Carlisia Thompson:** I have a question about that. How does structure logging fit with this philosophy? I thought I would see the point of what you're saying, but the repeats, especially if you're not really crafting your logging message strings, how do you handle if you want to do structured logging? Do you use the dump of the levels that you accumulated into a value, and that's your log?
+
+**Dave Cheney:** This is probably the most opinionated thing I'm gonna say, but I don't see the point in structured logging. Not because I think it's not a useful thing, rather than just have a free text blob of text; this idea of key/value key/value is useful, but I think there are really two consumers of logs - there is the person running the program (usually the operator, because I come from an ops background). In that case, if a program tells me something, like this UNIX philosophy - if the program tells you something, then it was important, you should pay attention to it. The number of environments I've worked in where you can't look at the log messages without grepping out a bunch of rubbish, it's a big problem.
+
+So if the only things that you log are things that the user needs to take action on, then I don't see a lot of value in investing in a framework for describing keys and values for logs. To be very clear, this is my opinion; I don't want to push that onto anybody else. I know there's a lot of people who see a lot of value in structured logging, but for me looking through this window of like... If you're gonna log a line, it's actually something that I need to take action on, then arguably you should be logging very little, because if there's thousands of lines of output, something's gone terribly wrong. And if there's thousands of lines of output and nothing has gone wrong and your program is really chatty, then you've got a much more serious problem.
+
+The second persona is obviously the developer, and I keep them separate from the person running the program versus the person debugging the program. The developer wants all the logging and tracing on, so I think in that case your structured logging is something that you use in development, and maybe interpret that to be always print out the file, the line and the function that it was executing in, and maybe some timestamps and things like that - then yes, that is super useful. But I don't think the two use cases should be conflated.
+
+As the operator, I only want programs to output when there's something that I need to do. They shouldn't just tell me that they're still running, they shouldn't just tell me information like, "Couldn't dial the socket, but I'm retrying. It's okay, don't worry." That's not something I need to care about, you shouldn't tell me that. For the developer, yes, you want to turn on all those logging, so you can see the retry loop and say, "Well, it always retried three times before it does anything." But they're different personas. In that kind of worldview, structured logging doesn't seem as useful to me.
+
+**Erik St. Martin:** \[48:15\] We had a conversation with Scott Mansfield from Netflix too, and he was talking about how they don't really rely on logs so much as they do counters. They use metrics for everything; they would count the number of reconnect errors that are occurring and measure that over time, and they could see that there's a clear problem because the number of reconnect attempts is happening at a much higher frequency than usual, and that's when they start digging in.
+
+I think the other case where people like structured logging is in distributed application tracing. I can look for a tag that says a "request ID" and I can get all the logs associated with a given request. But to your point, when you get to large scales, it's really hard to manage all those logs anyway, so you kind of have to find different ways.
+
+I want to roll back a little bit where we talk about trying the best you can to return upstream. One case that I see a lot of people use logging for in those cases is when you're in kind of a select loop; you're pulling from a channel, something happened, you don't want to return because you're just a parallel workstring, you're running concurrently to the main thread, so you don't want to die out because then you stop processing all messages. I typically see a lot of logging take place in those types of methods, so that people aren't just kind of throwing away the fact that there was an error with some given thing.
+
+**Dave Cheney:** Yeah, so you've gotta consider the persona that you're in. Are you in the developer persona? "I want to observe the operation of this select loop. It's one of many that's going on concurrently; I believe that if I can get inside into how all these different intermeshing parts are moving, I'll be able to reconstruct the flow of events later on." That's the developer persona.
+
+The operator persona, if that was just dumping out information like, "I'm going back through the select loop again, "what event conditions fired?" that would make me furious. I've worked in environments in trading companies where we would produce gigabytes and gigabytes of logs per application - there were many applications running at the time - and all my day was just bzipping and un-bzipping these things and then grepping out a bunch of stuff that was not useful. I think the distributed tracing examples are really a good counterpoint to my points about structured logging, that actually yes, that request ID is something you wanna thread through, but is that something that needs to be printed out on the console, like "I'm handling this request?" or is it just something that goes into...?
+
+In terms of logging, there are definitely exceptions to this case. Ordered logs are probably a perfect example of where structured logging is useful. User ID, in-group ID, with permissions, set, did, operation. Because you do need, in logical systems and well-regulated ones, you do need ordered logs. But again, the ordered log is not something the operator sits tailing. It's not something you're gonna alert on, like an error happened in the order log. They are different personas.
+
+**Carlisia Thompson:** On the same subject, I wanted to ask your opinion because I see logging and instrumentation of metrics as serving different purposes. For example, I can start tracking how many times a certain request came true because I usually get 500,000 a day, and if I suddenly start getting 200,000 I wanna be alerted that something is going on, and I wanna see those metrics. What is your opinion on instrumenting your code that way, and getting metrics out of it?
+
+**Dave Cheney:** \[52:09\] Yeah, they're absolutely separate things. Logging is for the human, instrumentation is for the machines, for your monitoring, for your automated alerts, for your historysis, your automatic retry, your scaling up, your scaling down. If you're driving those processes off tailing a log file, you have a serious operational problem. They are separate and independent things.
+
+**Erik St. Martin:** Yeah, and I think logging too should be something that you should be able to back off of. I've worked on systems commonly where it's streamed over UDP; you don't want logging to slow down your application because there's some slowdown on the disk, or things start catastrophically failing because you run out of disk, and things like that.
+
+I guess it depends on how important your logs are. If you're doing something for a bank, you probably want every single message, it's probably of big importance to keep that for audit purposes. But in other cases, if your logging requests to your site, if you lose a minute and a half of logs because there was some slowdown there, it's just not the end of the world.
+
+**Dave Cheney:** Yeah, they're different use cases - the ordered log, the HTTP request log, if you have to keep them for analytics, fraud detection or something like that... And then there's the log of your actual application code that was -- every time it speaks to you, does it tell you "This is something you need to care about?" or is just telling you things and you're like "I see that all the time." My rule of thumb is if to work on an application you have to get out grep to filter out a bunch of stuff which is not important to you, the problem is that you're logging too much and that logging is of not enough value. If this is completely separate from the ordered log, which has to happen for every action - the HTTP, it has to happen for analytics and fraud purposes, or the metrics which are how you monitor the health of your system.
+
+**Erik St. Martin:** It's hard, because there's no cardinal rule, right? It's just like the other topics we've had here today... It's about looking at your programming, determining how important these things are to you. Are they a necessity to operate and maintain this application, or are they really just fluff that makes you feel comfortable that you could open a log and see that data if you wanted to. The number of times I've seen applications that are heavy on the logging side and nobody ever looks at the log - that's probably the better majority of the applications I've worked on. Most of the times, you're looking at your metrics dashboards and things like that. It's too hard to go grepping through logs, especially when you don't have a central logging place for these things.
+
+At high scale it also becomes its own problem, because that's another system that can fail, when you're doing your distributed logging out to one place, and you have to make the decisions, how worthwhile is that additional complexity to you, and the additional storage to store all these logs, or are you really trying to get a rough state of your application.
+
+**Carlisia Thompson:** In companies that handle that for you, they charge a lot of money. It's very expensive.
+
+**Dave Cheney:** Oh yeah.
+
+**Erik St. Martin:** Those companies love when you throw them just needless logs. \[laughter\] It's usually some kind of like a rate charge.
+
+**Dave Cheney:** There's a strong moral hazard in there for them to not help you become better. They'll just write you a better tool to handle larger volumes of logs; by all means, don't change, just keep going how you're going.
+
+**Erik St. Martin:** \[55:53\] I think the difficulty is that when you look at a line of code and you're thinking about, "If something were to go wrong here", you think about all the times that you're tried to debug an application and you didn't have enough information. I think people err on the side of providing too much information, just in case they need it. I mean, I guess there's other ways around it too, aside from logging all the time.
+
+Some people will build in ways where they can signal the application to change its verbosity for the logging levels; some people will do Canary builds with additional logging in them... There's just a variety of ways you can attack debugging a problem.
+
+The other issue becomes when you have errors - is it a systemic issue that continues to happen and plague the rest of the system, or is it just an anomaly? You're going to occasionally have bugs; it doesn't matter how much logging you put in there, you're probably never gonna figure out why that happened. If you can't reproduce it, it's always going to be hard to debug by just looking at the log messages that took place. The log messages are really only there to guide you in setting back up the conditions that were taking place when that error occurred.
+
+**Dave Cheney:** Exactly, and once that's happened, it's too late; the horse has bolted. To come back to errors - you've mentioned errors. Why I think Go is so successful for being a language for writing server software - and this is really where we're seeing it; it's branching out into other things as well, but its home territory is server software - is because of the way we do error handling. We don't have exceptions. Perhaps not everyone has grasped this, but every time you type... You might think, "Oh, geez... If error = nil, return nil. I have to type this all the time..." - that's missing the point. It's making you think about what happens if this operation failed, and you have to do that everywhere, all through Go code, because we don't have exceptions. And we don't have exceptions because to write reliable programs you have to think about the failure case first.
+
+Don't worry about the happy path, think about what happens when this fails. I think that is what is making Go really successful for writing server software, because you can't just write the code in this linear "Oh, everything's gonna work, and that throws cause on the function declaration is gonna take care of any problems." We see how the languages with exceptions go for reliability; you don't know if they're gonna explode at any point. And as kind of verbose as Go's error handling is, it makes us think about the "What happens if this fails?" literally at every function call, because any function call can fail. And if you don't want that function call to fail, don't return an error. Write it in such a way that it can't return an error by having extra pre-conditions, or accept the fact that any time you deal with the real world (the network, the disk), it could fail, and you need to handle that failure right then and there, rather than just waving a hand and saying "I/O exception will bubble up to someone who knows how to handle it." The best place to handle that failure is right there, in that function, right at the point that the error happens.
+
+**Carlisia Thompson:** And if people are really annoyed about checking, doing the if statement all the time to check the errors, they can use your errors package, right? I love the way you made it so you can just return the error, and if it's nil it's nil, and if not, the message is there, and that's it.
+
+**Dave Cheney:** Yeah.
+
+**Erik St. Martin:** \[59:47\] I know when I first got into the language, the kind of verbose error handling was kind of annoying too, because I came from languages that had exceptions, and then you start to realize it does make a lot more sense there. But I think it's just a change of viewpoint. It's a half glass empty, versus half full. We look at it and we're like, "Wow, this is annoying that I have to keep doing this", but it's much more exciting when we think about the fact that everybody else who's working on this project also has to do this, right? It's kind of like HOA regulations. \[laughter\] Kind of a pain in the butt, right? It's annoying, because you don't wanna have to follow the rules, but it makes everybody else follow the rules.
+
+**Brian Ketelsen:** I think another corollary to that is the idea of interfaces in Go. I was thinking through this today, and I think there's a good parallel between the way you think about interfaces in Go and the way you handle errors in Go, versus other languages. With Go interfaces, your modeling behavior and you don't have to think very hard about that inheritance chain and which abstract classes to create above them. I did a lot of Java and C\# and Ruby, and all of that object-oriented inheritance, there is a big cognitive load to that.
+
+Just using embedding and composition in Go feels so light and so much better, but it's hard for people who come from object-oriented languages to catch that feeling. Again, it's one of those things where it takes everybody some time to adjust to the new features that they're not used to, before they can embrace them.
+
+**Dave Cheney:** I agree, and this is really the open question that I had from my talk. Every episode of this podcast, every time you interview somebody, everyone at some point in the podcast says, "Oh geez, you should have seen my first code... I used so many channels and I did them wrong." Everyone knows that lesson now. Anyone who has become a successful Go developer is like, "Wow, far too many channels. I went overboard there." But "Don't use too many channels" is not actionable to a new Go developer. They're like, "What are you talking about? This is why I've learned this language. Apparently, concurrency is a really important thing; why shouldn't I use channels?"
+
+It becomes really subjective and not particularly useful to say, "Be careful, don't use too many channels." Where is the design language that says, "Where is a channel appropriate, where is it not?" Those kinds of things are missing in the general discourse of Go. Or if not missing, not emphasized. It's not things that we talk about. We focus on speed, or static compilation, or cross-compilation, or other things like that, which are equally good, but they're kind of missing the wood for the trees...
+
+Erik talked about it, the way that in the Ruby community there was this focus on design. People talked about the language design, always; those were the kinds of things that you would talk about at conferences. Where is that language, that discourse in Go? That's really the open question from my talk, I think.
+
+**Carlisia Thompson:** I'm very glad to say that I'm starting to see a major shift towards that conversation with you and Ben Johnson and Mat Ryer. Mat Ryer [wrote a blog post](https://medium.com/@matryer/line-of-sight-in-code-186dd7cdea88) about his talk at Golang UK, talking about "Check your errors first, and then do the happy path, just like you were saying. It just goes to that design concept of "Put a guard into your method".
+
+Going back to what you were saying about this conversation about design, when I started doing Go, when I was meeting people who were experts, I would ask "How did you learn?" and "Trial and error" would be the answer, and on and on again people would say "Trial and error." Now I see that people are thinking, "Well, let's not subject people to trial and error anymore."
+
+\[01:04:14.01\] Katrina's talk at GopherCon in Denver had a lot to do with this concept of "Let's pave the path for people to jump in and not go through the hassle of trial and error. Let's have educational material..." And now a lot of people are talking about design. I sense that there is a shift, and I think that it's very positive.
+
+**Dave Cheney:** Yeah, Katrina's talk was fantastic, and the thing that we should all in this podcast remember is that we are the success story, we are the ones that didn't quit, we are the ones that didn't get so lost, that didn't make such a mess that we couldn't figure it out and we just gave up. We are actually the ones that figured out how to write successful Go code. And Katrina's talk is really important, because as she said, as a beginner you don't have that... There's a phrase, "Hindsight is 20/20." We're all looking back at our experiences and saying, "Oh, it was hard to learn, but we got through somehow." Put yourself back into the mind of a beginner; you have no concept of right or wrong, you don't know when you're writing good code or bad code, you don't know when you're bringing knowledge from another language or you're just learning it from scratch, and it's this good or bad; am I having a hard time running this program because I'm fighting against the language or because I'm actually making a mistake?
+
+As a beginner, you have no context to judge yourself, to judge your progress like that. Katrina's talk was really important to remind us all of... We are the success story, we are the ones who persevered and learned the language, even through trial and error or just reading the right example at the right time, that put us on a successful path, but we shouldn't consider that.. With enough time anyone can do that, because a lot of people are unsuccessful and they give up halfway through.
+
+**Carlisia Thompson:** Yeah, good point.
+
+**Erik St. Martin:** I think we are actually about overtime, so I think we're gonna skip over talking about news and projects this episode, as much as we would love to go forever. Can we do like a 12-hour podcast? \[laughter\]
+
+**Brian Ketelsen:** With Dave I think we can, yeah.
+
+**Erik St. Martin:** So I think we can skip into \#FreeSoftwareFriday, and then we'll kind of close out the show. As always, Brian, do you want to kick this thing off?
+
+**Brian Ketelsen:** I do. I spent a whole lot of time playing with rsync this week. It's old school, UNIX tools, but I just can't like without rsync, so big shout out to the people who keep rsync fast and awesome and safe. I love rsync, thank you.
+
+**Dave Cheney:** I think that is Jeremy Allison - is that his name? The same people that make Samba make rsync. Maybe I'm remembering it completely wrong, but there is a strong correlation between the two, I think. Using rsync and SSH can pretty much move the world.
+
+**Brian Ketelsen:** Yeah, and I think I did this week. \[laughter\]
+
+**Dave Cheney:** Do you want me to go next? I have one.
+
+**Erik St. Martin:** Sure.
+
+**Carlisia Thompson:** Yes.
+
+**Dave Cheney:** Somebody gave a shout out to AG a couple of weeks ago on the podcast...
+
+**Erik St. Martin:** That was me.
+
+**Dave Cheney:** I have one better, because it's called pt - the Platinum Searcher, and it's written by a Japanese Gopher; I'll put the link in the show notes. Pt is way better than Ack, way better than AG... I use it every single day. I'm not a big one for editor integrations; I have a very Spartan environment, so for me my entire day is just pt, some piece of text, find the line, go in and edit it.
+
+**Carlisia Thompson:** \[01:08:06.06\] I am so looking forward to installing that. With this endorsement... I use Ack all the time; also not on my editor, just on the terminal, and this is sounding like a lot better, by the description. I'm just dying to try it.
+
+**Dave Cheney:** It has all the features of Ack and AG, of skipping over temporary files and .gits and things like that, but it's written in Go.
+
+**Erik St. Martin:** I'm trying to think of who it was, too... Somebody had just mentioned... I think it was Harald Ringvold maybe, in the GoTime FM Slack. Just before the show he pointed that out to me too, like "Have you seen this?" So I definitely need to install it. You said it's basically feature-compatible with the Silver Searcher?
+
+**Dave Cheney:** Pretty much... I mean, I don't know what the features are; I just use pt. My two requirements are pt and pt-l. Pt-l gives you the names, and you pipe them through Vim and edit your files. It's written by Monochromegane, a Japanese Gopher. I saw her presentation on this in 2014, I think, the first time I went to GoCon in Japan.
+
+**Erik St. Martin:** That's awesome. Plus, we can contribute when we find new usage. But I probably have a similar workflow to you. I basically AG a directory looking for what I'm looking for and then just open it in Vim. I don't do a lot of editor integrations and stuff like that; I'm just pretty comfortable with having my editor open and a shell.
+
+**Brian Ketelsen:** I just installed this and it's beautiful.
+
+**Erik St. Martin:** You're ahead of us. So how about you, Carlisia?
+
+**Carlisia Thompson:** Well, I recently got a job doing Go full-time, and I was working on a new project and going through the phase of defining and designing, and recently I got full-on coding. My shout out today - we've mentioned it before - is Sourcegraph. I can't not tell you how much faster I grep things. If I'm on GitHub, I don't want to download everything to my local machine and just search on my local machine; I could do that, but it's so much faster. I'm on GitHub looking at a library, I'm browsing through the code, and I have Sourcegraph guiding me through, just popping up the descriptions. If I want to go deeper, I just click on the link and I'm there. It's been AMAZING.
+
+I've learned a hundred times faster, just learning what I'm looking at and also learning Go at the same time, because of course, I see the patterns. Another shout out is Go it self - I love that. The Go code that I see on people's libraries, they look pretty much the same as the Go code that I'm writing. The consistency is amazing, and it makes life so much better.
+
+**Erik St. Martin:** Awesome. Mine this week is a little off, but I haven't been using a lot of new programming tools over the past couple weeks, and I don't think everybody wants to keep hearing old stuff, so I'm gonna shout out to Asciidoctor, which is asciidoctor.org. Typically, I'm a markdown person, but I haven't found a really good toolset for being able to do table of contents and things like that for markdown. Asciidoctor is similar to markdown. It uses AsciiDoc and then behind the scenes it can do DocBook, so it can generate PDFs with linkable table of contents; you can do little sidebars and annotations, it has source code highlighting, so it's really awesome for doing documentation, especially with code involved.
+
+**Brian Ketelsen:** \[01:11:57.12\] Nice.
+
+**Dave Cheney:** Yeah, I use it all the time. I actually write all my talks long form; I actually write everything I want to say, and I generally do before I then transpose it into Keynote or something like that. For one, I need to know how many words I've got, and Keynote won't tell you that. I tend to write up the whole thing long form, and I've taken to writing in AsciiDoc, just so that I can then turn it into HTML and send a link to people.
+
+For me, that's so much better than using a Google Doc, because to use a Google Doc you've gotta be online, whereas this is just a text file, and you can edit it wherever you are.
+
+**Carlisia Thompson:** Nice.
+
+**Erik St. Martin:** And we can just use Vim. A nice little guard file, updates the PDF alongside of it... And then I get to give a second shout out to Afrin, for preventing me from sniffling this whole show.
+
+**Carlisia Thompson:** \[laughs\] Is that open source?
+
+**Brian Ketelsen:** No, it's not open source, and you probably have to show ID at the counter of the pharmacy to get it these days.
+
+**Erik St. Martin:** The ingredients are listed on the back, so it's somewhat open source, right? \[laughter\] I guess the algorithm to combine them is not existent, but that's close.
+
+**Carlisia Thompson:** Yeah, that reminded me of Katrina's talk again... \[laughter\] You have the ingredients, but you don't know how to put it together.
+
+**Erik St. Martin:** \[laughs\] That correct mixture ratio... Alright, so as much as I would love to continue on, especially having Dave on the show, we've had a lot of interesting conversations and I think way more that could be had, I think we are way over time, so this will be a nice long episode. I definitely want to think everybody who's on the show today, everybody who's listening, everybody who will be listening to the show when we drop it live... Big shout out to our sponsor Backtrace.
+
+If you aren't subscribed already, you can subscribe at GoTime.FM. We should have an upcoming newsletter. We are @GoTimeFM on Twitter, and GoTime.fm/ping on GitHub if you wanna submit yourself or suggestions for guests for the show, or questions.
+
+I think that's it. With that said, everybody, goodbye.
+
+**Brian Ketelsen:** Thanks for getting up so early, Dave.
+
+**Dave Cheney:** Not a problem, thanks for having me.
+
+**Carlisia Thompson:** Thank you so much, David.

Sarah Adams on Test2Doc and Women Who Go_transcript.txt

@@ -0,0 +1,455 @@
+**Erik St. Martin:** It's Go Time! A weekly podcast where we discuss interesting topics around the Go programming language, the community and everything in between. If you currently write Go or aspire to, this is the show for you.
+
+Alright everybody, welcome back for another episode of Go Time. This is episode number five. Today we have Brian Ketelsen here, say hello Brian.
+
+**Brian Ketelsen:** I'm not here though, I'm in San Francisco this week. Hello!
+
+**Erik St. Martin:** That's very true, you're part here. You're not here anyway - this is all virtual studio.
+
+**Brian Ketelsen:** That's true.
+
+**Erik St. Martin:** We also have Carlisia here.
+
+**Carlisia Thompson:** I am also not there, I am in San Diego. \[laughter\] Hello everybody.
+
+**Erik St. Martin:** And today on the show we have a special guest with us, Sarah Adams, who most of you know as an engineer, speaker, and also the founder of Women Who Go.
+
+**Sarah Adams:** Hi!
+
+**Erik St. Martin:** How are you, Sarah?
+
+**Sarah Adams:** I'm listening to you from San Francisco.
+
+**Erik St. Martin:** So is everybody in California but me today?
+
+**Brian Ketelsen:** That's correct.
+
+**Sarah Adams:** Sounds like it.
+
+**Erik St. Martin:** I knew I was getting left out here.
+
+**Brian Ketelsen:** You have some serious FOMO going on, Erik. Fear of missing out.
+
+**Erik St. Martin:** But, see, I'll be having dinner before you guys, so I have less work when we're done.
+
+**Brian Ketelsen:** You know, the problem with being out here is that my kids start sending me text messages at three in the morning.
+
+**Sarah Adams:** Oh, no...
+
+**Erik St. Martin:** Yeah, that's always rough, to get synced up with the kids and family. You think three hours isn't that long, but it's a lifetime.
+
+**Brian Ketelsen:** It's a lot, it is.
+
+**Erik St. Martin:** Like, everybody's going to bed before you're having dinner, and everybody's having lunch when you're waking up.
+
+**Brian Ketelsen:** We've got a lot to talk about this week, I think we should dive in. There's a lot happening.
+
+**Erik St. Martin:** Yeah, so last week we talked a bit about the 1.7 stuff and some of the performance change improvements there, and over this past week Dave Cheney put together some visualizations of that which really kind of blew my mind, because I knew there was improvements, but we've cut more than half the difference between 1.4 and 1.6 out of the way, so...
+
+**Brian Ketelsen:** Yeah, we're halfway back to where we were, which is fabulous, because Go has really great compile times, and it's nice to see that coming back down to... Insanely great.
+
+**Erik St. Martin:** And I'm looking forward to seeing it less than 1.4, that'd be a great achievement. Imagine being even faster than 1.4 was.
+
+**Carlisia Thompson:** Is that even possible? Is that on the cards, though?
+
+**Brian Ketelsen:** Anything's possible with SSA. Have you seen the team working on that? The brain trust will make it happen, I have confidence.
+
+**Sarah Adams:** Who's working on it?
+
+**Erik St. Martin:** I'm trying to think of who's specifically working on that functionality... Do you remember, Brian, who the specific team was working on the SSA stuff?
+
+**Brian Ketelsen:** I don't know the whole list of team, no.
+
+**Erik St. Martin:** We'll look that up and then we'll put it in the show notes.
+
+**Brian Ketelsen:** So other big news this week, the context package is now going to be in standard library. This is huge, huge. I'm so excited about it.
+
+**Sarah Adams:** Yeah, I'm really excited.
+
+**Brian Ketelsen:** And the way that they've engineered it is really nice too, so that if you're using 1.7, it will use the one in standard library, and if you're not using 1.7, it will continue to use the one in the Net package. That's really awesome.
+
+**Erik St. Martin:** Yeah, that's fantastic. Because gRPC and all that stuff depends on the context package, and we've been using that for -- I don't even know how long that's been floating around. I'm really glad to see it kind of pulled in. Sarah, were you saying something about the context package?
+
+**Sarah Adams:** No, I'm just excited for it to be in the standard library, just a cool addition.
+
+**Erik St. Martin:** And hopefully a lot more people will start using it as part of their packages where they expose network requests and things like that, because that's really the power in it - having the context forwarded along, so that you can stop it anywhere in the process.
+
+**Brian Ketelsen:** Yeah, so all you library developers out there, if you're not putting context as the first parameter of your public functions, now is a great time to start doing that, please. I wanted to say please, I don't wanna sound too bossy. I can come across that way sometimes.
+
+**Carlisia Thompson:** And from the little experience that I have with Go, I see a lot of times when people use other network packages just so they can get the context, and I would even do that, because I don't wanna do that stuff by hand. But now that it's in the standard library, I wonder how it's going to impact the usage of the external libraries. Or if people are just gonna have to keep ahead, keep adding more features to make it more attractive for people to use them.
+
+**Erik St. Martin:** But is it really a competition, though? I think at the end of the day it's about writing good quality software, that's readable, and I think that by having external libraries that people really like - and we kind of get consensus on these patterns - I think it's okay to pull that stuff in. Because not everybody's gonna be aware of these things, despite how much visibility we think they have, or as people find stuff in the standard library - that's generally where people look first, so I think it's a hard debate. We're kind of pulling away users from some standard library, but I think that the library owners are probably glad to see it there. I think it will get more love in the standard library, too.
+
+**Brian Ketelsen:** It'll certainly be easier to use.
+
+**Sarah Adams:** Yeah, I wonder how the Gorilla toolkit is gonna change because of this, because they've implemented their own network context, I think. I haven't used it in a while...
+
+**Brian Ketelsen:** Yeah, Gorilla has its own context, and every other mux on the planet has its own context; I'm really excited about them not having their own contexts. I hope that they all converge to use the standard library context.
+
+**Erik St. Martin:** That's actually really interesting, I hadn't even considered that. I mean, I've used the Gorilla mux in the past couple of years, but I don't think I've used anything else from the Gorilla stuff in a while. So that will actually be really interesting to see how that's adapted to this.
+
+**Sarah Adams:** Yeah, and I think the Gorilla mux even imports its own Gorilla context, within the mux package. So it will be interesting to see if they go forward with the Go standard library context.
+
+**Erik St. Martin:** We should email them and ask.
+
+**Brian Ketelsen:** Open an issue on the GitHub repo.
+
+**Erik St. Martin:** Maybe one of their developers is one of the two listeners. \[laughter\] Alright, so one of the other projects that I've been using recently is vendor check. I noticed that they've got an update that now tells you your deprecated dependencies, which is awesome. So basically it goes through your vendor path; it's just a -u flag, and it will tell you all your unused \[cross-talk 00:07:55.09\]
+
+**Brian Ketelsen:** This is interesting, because we've talked about the blog post that this originated from in our last episode, the CloudFlare blog post about creating the simplest possible SSA tools. Vendor check was an extension of that, and it's nice that it's getting some very usable features; it will be good to get that vendor directory pruned as needed.
+
+**Carlisia Thompson:** It sounds to me almost like vendor check should be side by side with fmt.
+
+**Sarah Adams:** Yeah, and go imports.
+
+**Brian Ketelsen:** Yeah, it's definitely a must-have tool.
+
+**Erik St. Martin:** Yeah, and I think that the vendor stuff is probably early for that stuff to kind of get pulled in, at least adopted by the Go team, right? Because it's only been recently that there's been this agreement that maybe the Go tooling should handle vendoring more, so it will be interesting to see how much they think should be pulled in. But I imagine we'll start seeing tools like Vim-Go and all that jazz incorporating in this, in something like the meta tooling.
+
+**Carlisia Thompson:** Exactly.
+
+**Erik St. Martin:** Like, there's a Go meta-linter and stuff like that that runs all the suite of different tooling.
+
+**Carlisia Thompson:** I can totally see that happening, too.
+
+**Brian Ketelsen:** So on that note, on the idea of having vendor tooling being built into Go itself, I know that Andrew Gerrand was talking about sponsoring a talk or a panel discussion on the hack day at GopherCon on the 13th of July, for an hour or so, talking about packaging and vendoring. So if you're got strong opinions on that, you might wanna come to Denver in July and get together and talk to the Go team directly about package management and vendoring. That would be a great opportunity to have your voice heard.
+
+**Erik St. Martin:** And strong opinions in general. I know that they're wanting to do kind of a collaborative session with big Go users and kind of seeing what pain points are there and how people feel that the Go team can ease those pains, and make it easier to adopt and use Go.
+
+**Carlisia Thompson:** And on that topic, there is an issue opened on the Go repo where they just pull in everybody's opinion into one place - at least they put links to things, and there's probably something good to read through if you are going to go to this event and discuss, so we have all the information...
+
+**Brian Ketelsen:** It's a really long issue.
+
+**Carlisia Thompson:** Yeah, it's huge. But it's not the Go team endorsing any way or another; it's just gathering everybody's opinion in one place, and giving it as it is - "Okay, this is what people are saying. Let's just have it here, so we're not replicating this all over the place, so we have a starting point. We don't have to go back and talk about things that were already talked about." So it's all in there, very interesting.
+
+**Erik St. Martin:** I ought to pull that up when I have a weekend.
+
+**Brian Ketelsen:** It's longer than a weekend.
+
+**Erik St. Martin:** I can only imagine.
+
+**Carlisia Thompson:** Yeah. It's not light really, it's very thoughtful expressions of how things could be done technically. I'll find the link.
+
+**Erik St. Martin:** Awesome. So on a sad news side of things, did anybody see the email that Rob Miller sent out to the Heka mailing list?
+
+**Brian Ketelsen:** I did.
+
+**Carlisia Thompson:** No, what?
+
+**Brian Ketelsen:** Very, very sad.
+
+**Erik St. Martin:** Yeah. So Rob Miller works for Mozilla on a tool called Heka. How would you best describe Heka, Brian?
+
+**Brian Ketelsen:** Heka is a stream processing tool that you can use to take inputs and process them and munge them and do strange things with them and send them back out to other places. One of the most common use cases would be log aggregating and management; it's significantly more complicated than that, but that's probably the best use case for it - moving logs from here to there.
+
+**Erik St. Martin:** Yeah, it's basically like a pipeline, and there's different inputs you can swap out - collectors and emitters and things like that, so you can take inputs from various different types of systems, and you can output to various types of systems. There was a really interesting project, and he presented it at GopherCon 2014. By all accounts, it seems like people are using it, but I think he's been primarily the core maintainer of it, and they're using something else internally at Mozilla, and he hasn't had the time, and he's going to continue to have less time. So I think that that's probably going to be -- I don't know whether 'deprecated' is the right word for it...
+
+**Brian Ketelsen:** Discontinued Mozilla support perhaps, or Mozilla sponsorship.
+
+**Erik St. Martin:** ...and I think that they're open to somebody else taking over the project, but they don't have the time to help facilitate that takeover either, and I think he expressed some concerns about even the patterns it was designed under; the way they were using channels wasn't quite hitting the performance levels that they were wanting, and things like that. He kind of believed that there'd be some heavy refactoring. Maybe we can get him on the show and talk about it a little bit more in depth, what his thoughts are.
+
+**Brian Ketelsen:** That'd be a great idea. We'll link to the mail list announcement in our show notes. It's way too long to discuss here, but the main takeaway from the email that he sent out was that the refactoring required to make Heka perform significantly better than it does now, which is actually really solid performance. But to get to that next level it would require less use of channels, and that's probably a good show topic for us at some point, talking about the performance of channels under significant load, and when channels are great and when they aren't.
+
+**Carlisia Thompson:** That would be an amazing topic, I'm sure a lot of people can benefit. I can benefit from it.
+
+**Erik St. Martin:** So before we get into some discussions about all the things that Sarah is doing these days, we typically go through some interesting Go projects, because Brian is full of -- just this encyclopedia of projects. But before we go into that, we don't need Brian anymore. Have you guys seen the LibHunt thing that was going around?
+
+**Carlisia Thompson:** No.
+
+**Erik St. Martin:** There is now the Go LibHunt. It's go.libhunt.com, and you can basically browse around, categorize projects and libraries in Go, and then kind of rank them.
+
+**Brian Ketelsen:** You know, just because somebody lists a bunch of libraries in Go does not replace my curation, Erik. \[laughter\] The added value that I bring every week to the curation of cool projects is what's important here. You cannot replace me with a bash script.
+
+**Erik St. Martin:** We can try. \[laughter\]
+
+**Sarah Adams:** Brian, what's your process? How do you find the Go projects?
+
+**Brian Ketelsen:** Before I go to bed every night I look at the GoLang Reddit thing just to see if there's anything interesting there; I don't get a lot out of Reddit these days, but I have a special query on GitHub that I use to see recently updated or recently created Go projects, and I just scan through them, looking for things that sound exciting that I haven't seen before.
+
+**Erik St. Martin:** And that query can be yours for just three easy payments of 59,90. \[laughter\]
+
+**Brian Ketelsen:** Exactly. And actually I'd be happy to post that query in the show notes too, because there's nothing magic to it; it's just a really long GitHub query.
+
+**Sarah Adams:** I had an app - it wasn't called StumbleUpon, but it was something like that and it acts like StumbleUpon, where you can look through and you can filter. It's like a Go project library, but it looks through GitHub and helps you stumble upon Go projects that are relatively popular. It was pretty cool.
+
+**Brian Ketelsen:** That's nice. All of those queries are prone to error, because if GitHub's detection of the project type isn't accurate because maybe you don't have any Go files in the route - or whatever they use to detect the projects - they might be excluded.
+
+**Sarah Adams:** Is that common?
+
+**Brian Ketelsen:** It is. I've seen projects that don't list themselves as the primary language that they are just because whatever GitHub uses to detect that was thwarted by maybe their directory layout, or whatever.
+
+**Erik St. Martin:** I'm not sure how that detection works. I mean, what percentage of the codebase is in what... Because if you had, say, [Grafana](https://grafana.com/) that's a bunch of Go, but it's a whole lot of web stuff too, HTML, CSS and JavaScript too, so is there more of one than the other, then does that cause false positives .
+
+**Carlisia Thompson:** I have always wondered that too, if somebody knows, please...
+
+**Sarah Adams:** You can also specify when you're creating a repo what language the project is.
+
+**Carlisia Thompson:** Really?
+
+**Sarah Adams:** Well, I think it just helps you then generate the git-ignore.
+
+**Carlisia Thompson:** I've never seen that.
+
+**Brian Ketelsen:** Interesting.
+
+**Sarah Adams:** But I'm not sure if they keep that data...
+
+**Brian Ketelsen:** Yeah, I wonder if they store that as metadata. I've never done that specifically, so I don't know.
+
+**Erik St. Martin:** Like Sarah said, I think I've only used it once just to generate the git-ignore.
+
+**Brian Ketelsen:** So now that Erik has tried to replace me with a website... \[laughter\]
+
+**Erik St. Martin:** The pressure is on...
+
+**Brian Ketelsen:** Yeah, the next segment of our show is where we each talk about interesting Go projects that we perhaps stumbled upon in the past week. I'll start, since I'm bringing the most value here - I'm really angry with you Erik now, this isn't gonna fly... So the thing I found this week that I thought was really cool was a combination of one that I talked about previously, which is Minio, an S3 object storage clone that you can deploy on your own hardware or on the cloud somewhere, that gives you an S3-compatible object storage pool, and another project that is awesome, which is Kubernetes... So the Deis team - Deis is a platform as a service on top of Kubernetes - they created a Minio storage plugin for Kubernetes, so you can use Minio S3 storage for your Kubernetes cluster, and it's got some really tight integration with Kubernetes. It looks really awesome, so two great tastes that taste together again, which is Minio and Kubernets. That's at github.com/deis/minio
+
+**Erik St. Martin:** So I will go next. I saw this a while back, and I think it was really in its infancy, which is Lime Text, which is like a Sublime Text clone, but written in Go, and it's actually been coming along quite well. I was actually curious whether Carlisia had tried it, because I know you're a Sublime user, right Carlisia?
+
+**Carlisia Thompson:** No, I'm not.
+
+**Erik St. Martin:** Oh, I thought you were a Sublime user.
+
+**Sarah Adams:** I use Sublime.
+
+**Carlisia Thompson:** I used it, but I've stopped using it long ago.
+
+**Sarah Adams:** And I haven't heard of Lime.
+
+**Erik St. Martin:** Have you checked it out, Sarah?
+
+**Sarah Adams:** No, I haven't. I'm looking at it right now.
+
+**Erik St. Martin:** Yeah, so this is actually pretty interesting. I mean, you can't get me away from Vim, but I feel like if you could, it might be Sublime, and this makes it kind of enticing, because if I wanted to modify the editor, I could actually do it in Go.
+
+**Brian Ketelsen:** Well, it's interesting from another perspective, in that it's almost modeled on the Emacs and Neovim server and client model. So the Lime Text app has a backend, and then it can have multiple frontends. You could actually use a command line app to use Lime Text, or they've got a Qt-based editor for a graphical environment, but the backend stays the same. So that makes it unique I think, in terms of Go-based text editors. It certainly made it more interesting to me.
+
+**Carlisia Thompson:** I do wanna check it out. Yeah, I'm an Atom user - I use it with the Vim plugin, but this looks cool.
+
+**Erik St. Martin:** I don't know why I thought you used Sublime, but now I remember Atom, because you did bring up a new set of plugins for Atom. It wasn't in the last episode, but the one before.
+
+**Carlisia Thompson:** Yeah. All these editors look a lot the same in a lot of ways, so...
+
+**Erik St. Martin:** I can't keep up with all the new editors.
+
+**Carlisia Thompson:** Sarah, do you have a Go project you wanted to mention?
+
+**Erik St. Martin:** Feel free to say no.
+
+**Sarah Adams:** No, I didn't prepare anything.
+
+**Carlisia Thompson:** Yeah, so I'll go next. I found this HDR histogram, and it's not something I have used, but I can see myself using it. It keeps track of a simple count of basically incoming requests - a simple count of incoming requests that you have. You can specify what it is that you wanna look at over time.
+
+**Erik St. Martin:** So this is showing like a requests-per-second over time, or...?
+
+**Carlisia Thompson:** I think it's requests per seconds.
+
+**Brian Ketelsen:** I've used this package before, I think it's more generic than just requests per second. I think it's actually just a histogram package that you can use to collect metrics about any particular event, and then present them in a histogram. So a request per second is a great example of how you would use it if you were collecting metrics on a website.
+
+**Carlisia Thompson:** Yeah, exactly. It looks like that. It's configurable. They have a Go version of this, and the way I found about it and why it's relevant is because I saw a talk by Gil Tene on Strange Loop from last year, and he was talking about how network graphs usually show us the 95 percentile of the worst response times that you get. And he goes on to talk in detail about how meanless that is, and how much it hides the information that you really want to see, which is the actual count, the actual max. He also goes on to talk about the difference between service time and response time, and it's fascinating because - I don't know, I don't usually think about it in those terms, but it makes total sense. It's a fascinating talk, and if you want to monitor your stuff and what you're using is the usual commercial tools that are out there, maybe you should check this out. We will have links.
+
+**Brian Ketelsen:** Will you put that link in the show notes? That sounds like a great talk.
+
+**Carlisia Thompson:** Yes, I already did. There it is.
+
+**Brian Ketelsen:** Perfect.
+
+**Erik St. Martin:** So Sarah, one project that we would love to hear you talk about is your Test2Doc. That's really cool.
+
+**Sarah Adams:** Thanks. So I got this idea like a year and a half ago. I was maintaining a ReST API; I was working for a company called Sproutling, we were building a web baby monitor, so I was building a ReST API that had multiple clients. We had custom hardware, which was sort of a base station that was monitoring room temperature in the baby's room; we had an iOS app, which was the second client, and we had a web app, which was the third client.
+
+So we had multiple developer teams working on each of these, and since I was the only person responsible for the ReST API - well, not because of that, but I needed to have API documentation, of course. So I started using [Apiary](https://apiary.io/), because I liked the format. You can write it in markdown, and the API blueprint specification was open source, which is nice. For larger changes I kept adding an endpoint, or deleting an endpoint - those were easy to remember to update the documentation, but for smaller things like deleting an attribute, all the way down to deleting a column on a database table would trickle up to the endpoint change, which would mean the field was missing on the JSON response.
+
+Those smaller changes started to add up a lot, and so my documentation was often really inconsistent with the actual API. So I forked to a tool called [Dredd](http://dredd.org/en/latest/), which is meant for testing new documentation against your actual API. It was pretty good, but I had to periodically just run this and update all of the documentation. I started to get really frustrated, because my unit tests were all there; if only my fellow engineers could read my Go unit tests and the status documentation, that would have worked great. So I realized that all of the information that you need for API documentation is in the endpoint Hammer test, so I decided I was just gonna record the requests and responses as the test ran, and put them in a markdown file in the appropriate format, and then be able to generate all of my API documentation, host it, and have everything be automated, so I would never have to worry about out of date documentation and angry developers, people asking me questions and things like that. So that's sort of where that came from.
+
+**Brian Ketelsen:** So when you're writing your tests, how much differently do you write your tests to make the documents look appropriate? Do you have to...?
+
+**Sarah Adams:** Not at all.
+
+**Brian Ketelsen:** Not at all?
+
+**Sarah Adams:** Yeah, it's super simple. There's maybe six lines of code that you have to add. Essentially, if you have really good, really thorough unit tests, like testing for user passes nil, and user passes opposed with no request data, and all of that - all of those tests are captured, and so you can see in the documentation "When you pass nil, this happens". So the tests are really just like "If this is the request that the user sends, what should the appropriate response be?" And that's exactly what documentation is also.
+
+**Erik St. Martin:** That's really interesting. So how do you have that implemented? You're statically analyzing the tests?
+
+**Sarah Adams:** No... Actually this is what - I wrote this bit a while ago. But I think I used the HTTP tests.
+
+**Erik St. Martin:** They're like response-recorders, and stuff like that?
+
+**Sarah Adams:** Yeah, so I actually paused the test right before the actual test executes, and copy the request body from the request object itself and put that into a buffer somewhere, then execute the tests and copy the response data before we actually returned, and put that into the buffer as well. And then when the full test suite is finished, flush that buffer to a file, in the appropriate format. And there are some other intricacies, like pulling out requests, URL variables... In the documentation, for example if you're testing "Get widgets with ID1" and then "Get widgets with ID2", those would naturally be two separate URLs; they're trying to figure out how to match those two together, and notice that that the one in two are actually variables. So there's some intricacies with that, same with query parameters.
+
+**Erik St. Martin:** Does this support header logic, too?
+
+**Sarah Adams:** Yeah, all your headers are logged also to the same buffer, and they're in the appropriate format for the API blueprint.
+
+**Erik St. Martin:** That's really awesome, I kind of wanna play with this.
+
+**Sarah Adams:** Yeah, it is awesome, I love it. I use it at work.
+
+**Erik St. Martin:** And is there a way to augment the documentation, so things that aren't necessarily captured by monitoring the requests and responses, things that you might wanna take notes on, like what appropriate values are, or things like that?
+
+**Sarah Adams:** Yeah, so for each package, an .apib is spit out, and what you actually need to do is have sort of a -- I call it a template, but it's really just the description of your API and sort of high-level things like that. Those go at the top of the .apib file. Once all of your tests have run, you'll get back one .apib file per package, so you need to combine them. During that step, you can actually insert... For my current company we have a list of all of our errors and error codes at the top of our documentation file, so that's generated right before we append all the .apib files. So yeah, it's totally flexible.
+
+**Carlisia Thompson:** That's cool.
+
+**Erik St. Martin:** So what's the process for this? You just run this tool after you're done, so that you're kind of committing this documentation?
+
+**Sarah Adams:** Yeah, I have it built into our CI flow. You push out some code on a feature branch, and when it's ready to land into the development branch, or whatever you use - master... You land that in, and then we have a special hook that says, "Oh, if I'm on the master branch, I need to run the combined .apib file script", and push that up to -- well, how I have it is I push that up to a separate branch, a docs branch on a repo, and then have Apiary actually read that file to show the parsed, beautiful API documentation.
+
+**Brian Ketelsen:** Nice.
+
+**Carlisia Thompson:** I just thought about making this - another tool... Make a diff between the pushes, so you can see like a change log version, that would be really cool.
+
+**Sarah Adams:** Yeah, that would be cool. And there are a lot of things that I wanna add to this. A couple people have requested Swagger support; I think that's probably more common that Apiary for API documentation.
+
+**Erik St. Martin:** Swagger has really blown up lately.
+
+**Sarah Adams:** Yeah. The interesting thing about Swagger though is they seem to want you to generate your sort of hammer skeletons. I'm not really sure how that fits into this sort of test-generates-docs flow, because really what they want you to do is have a spec generate the code... It's sort of cyclical. I'm not sure how that's gonna work, I haven't played with it yet. We'll see.
+
+**Erik St. Martin:** Yeah, they kind of fit in different parts of the workflow, right?
+
+**Sarah Adams:** Yeah, exactly.
+
+**Erik St. Martin:** It's that Swagger kind of... You build to the specification and then it spits out code, and it knows that it meets it, whereas this tool kind of comes in after the fact and kind of gets insight into how your API works.
+
+**Sarah Adams:** Exactly, it's a different workflow.
+
+**Carlisia Thompson:** Here's the perfect workflow: you do your specs, you run it, you spit out the Swagger docs, you run the Swagger docs and that then generates your codes.
+
+**Erik St. Martin:** But I think this is interesting though, because people love Swagger, but everybody likes building their APIs in different ways, and we see that prevalent in all the number of frameworks out there for building APIs right now. But yours, it doesn't have any ties into those specific... You can write in whatever you wanted to and have similar documentation to Swagger, and I think that's an awesome idea.
+
+**Sarah Adams:** Thanks!
+
+**Carlisia Thompson:** Yeah. The one issue I can see with trying to make it fit in with Swagger is that Swagger has a very... Well, it has a specification, so it's strict in that way, and if you design something that is not supported - not necessarily, it wouldn't be ReSTful, but it's not supported by that spec version that you're working with, then it just doesn't work.
+
+**Sarah Adams:** Well, API Blueprint has a pretty strict spec also. You just have to match the data, you have to really evaluate the spec and match the data, fit it into the spec.
+
+**Carlisia Thompson:** Yeah, so you have to have some prior knowledge of what the spec is for the tool you're working with.
+
+**Sarah Adams:** Sure.
+
+**Erik St. Martin:** Alright, so I think we've got about ten minutes left, and I definitely don't want to close the show out without getting a chance to speak with you about your Women Who Go initiatives.
+
+**Sarah Adams:** Oh, awesome.
+
+**Erik St. Martin:** Could you tell us a little bit about that, and kind of how things are going there?
+
+**Sarah Adams:** Yeah, sure. We're actually growing really fast at the moment. I'm sort of blown away, it's really exciting. We just launched a chapter in Tokyo, so that's really cool. I could talk about why I started it, or how I started it...
+
+**Erik St. Martin:** Yeah, talk a little bit about what it is and how it got started, and what your goals are.
+
+**Sarah Adams:** Sure. So I really wanted to create a safe space for women to enter the Go ecosystem. I started the group about a year ago, and I had been going to Go SF meetups since mid-2013, when they were still really small, like 30-50 people, or something. And I was often the only woman, very consistently, so I started to get a little frustrated. But the meetups were so excellent that it worked out okay.
+
+Then I got accepted to talk at GopherCon early 2014, and I was actually listening to a Changelog podcast about GopherCon, and I think it was Brian who... I can't actually remember - someone asked a question like, "How can we help people get more involved in the Go community?", or something like that. And Brian suggested that you start a Go group in your community, and I sort of took that as my community being my women, and I wanted to get more women involved in Go, so I started Women Who Go.
+
+We had our first event about a year ago. We just talked about the difficulties of being a woman in tech and a woman in the Go community, and how can we start trying to fix these issues. And I've had a meetup about every month for a year, and I think our largest event has been the Bill Kennedy workshop - we had 70 women attend and want to learn Go, which was really powerful.
+
+The main goal of the group is just to provide a safe environment for women to learn more about Go, to explore, and hopefully the idea is that then they go to Go SF events or GopherCon, once they feel a little more safe. I think it's been working pretty well.
+
+As far as our ten chapters around the world, women actually will message me or somehow find me on Twitter, and they'd be like "I see what you're doing and it's really cool. I wanna start a group in Denver" or wherever, and I just help them get started, and they really run with it. The number of women that have been really excited about starting groups like this has been really spectacular.
+
+**Brian Ketelsen:** That is so awesome to hear. I'm just all verklempt over here, so keep talking. You said you have ten chapters now, right?
+
+**Sarah Adams:** Yes, we do. We've got five in the U.S., we've got one in Bangalore, one in London, one in Tokyo... If you go to WomenWhoGo.org you can see our list of chapters, and there are also resources if you wanna get involved, but you don't need to identify as a woman. We've got Berlin, Bangalore, Tokyo, Mexico City and London, and then in the U.S. we've got Boston, Boulder, New York City, San Diego and San Francisco.
+
+**Brian Ketelsen:** Is there information on WomenWhoGo.org for people who might be interested in starting their own chapter?
+
+**Sarah Adams:** Not explicitly, but people have found the hello@womenwhogo.org email address there and that's usually how they contact me.
+
+**Brian Ketelsen:** Perfect.
+
+**Sarah Adams:** So I suppose I could on the say on the site, "If you wanna start a chapter..."
+
+**Erik St. Martin:** I think it's great when things kind of grow bigger than you can keep track of anymore.
+
+**Sarah Adams:** It's amazing, especially when it's such a cool cause, trying to get more women into Go.
+
+**Erik St. Martin:** This is probably the first community that I've been a part of that at least visibly had these big women-only -- I'm not saying women-only, but advocating more women get into the community. There probably exist, but it definitely didn't feel as prevalent as it is here. I've been watching Twitter and seeing the new Women Who Go chapters and stuff like that, and it's like wow, I can't even keep up with how many there are anymore. I think that's fantastic.
+
+**Sarah Adams:** I know, it's awesome. There are a few meetups that I've been to, like Pythonistas and Women Who Code has a Ruby Tuesdays for women, but I haven't come across any other women's group specific to a programming language that is spread across multiple chapters.
+
+**Erik St. Martin:** Yeah, I've seen Ladies Who Linux, that's gotten bigger, and there's an Infosec one too, but for the life of me, I can't remember the name of it.
+
+**Carlisia Thompson:** There is also PyLadies.
+
+**Erik St. Martin:** Oh yeah, PyLadies...
+
+**Brian Ketelsen:** PyLadies, Rails Girls...
+
+**Sarah Adams:** True, yeah, so there's a ton...
+
+**Brian Ketelsen:** But it feels stronger in the Go community, and I love that. I love the push to have that inclusivity and that feeling of safety, so anybody can come in and learn without worrying about external factors. That's very nice, so be proud of what you've done, this is really cool. Like you were saying earlier, when you have that feeling where it's growing so big it's hard to keep track of - Erik and I get that same thing at GopherCon when somebody in Brazil sends us an email and says "Hey, we wanna do a GopherCon in Brazil." "Yes, please. Go do that." It's awesome.
+
+**Sarah Adams:** Yeah, that's exactly it.
+
+**Erik St. Martin:** Anything that gets more people involved is always a good thing.
+
+**Sarah Adams:** Yeah, I agree.
+
+**Erik St. Martin:** More conferences, more meetups, more blogs, more podcasts...
+
+**Carlisia Thompson:** I think there's also a good opportunity to break some misconceptions - there are additional opportunities to break misconceptions here. There are so many misconceptions that women cannot program, or even we ourselves say "Maybe I cannot program" or "Maybe I can program but I cannot be a great programmer", and there is a sense that Go is a low-level language; it's not as low level as C, but it can be used for low-level systems development. And there is an additional misconception that women cannot do systems-level programming. I don't know if you agree that this exists, but I have seen it. So with Go, we can help break this myth.
+
+**Erik St. Martin:** Yeah, I think in STEM in general there's a lot of that, being critical of other genders and their ability to do the job, and I think it's just naive.
+
+**Carlisia Thompson:** Yeah, but it exists, so...
+
+**Sarah Adams:** That's one of the things I love about the Go community so much - when those things pop up, people seem to be sort of all over it, like "That's really not okay." And I love how much time and energy that people like Andrew Gerrand and Jason Buberel have put into the code of conduct. Our code of conduct thread went on for months, because people were so passionate about trying to make sure that Go was so inclusive and that everyone felt safe in the Go community, and I really thank them for that.
+
+**Erik St. Martin:** Yeah, I really applaud that effort as well. I think that that was a fantastic thing that happened. And in general too, right? I know Carlisia and I have had conversations about this before - everybody be nice to each other, what's hard about that? That was one of the things I loved about this community when I came into it, because I don't have a masters degree or PhD in CompSci, I'm not a highly academic programmer, but there were these PhD people all chatting up in mailing lists and stuff and perfectly happy to help and answer questions, and just their love of the language, they wanted to share that with people. I think that we should do that, whoever it is that's trying to join our community, we should be as welcoming as possible.
+
+**Carlisia Thompson:** Exactly.
+
+**Sarah Adams:** Yeah, and I think since we started being really inclusive and being aware of that when we were so small - I really think that it's gonna help us as we grow, to maintain that sense of inclusivity and safety, as opposed to other languages who are sort of trying to tack it on... After they've grown a lot, it's a lot harder, or it seems a lot harder.
+
+**Brian Ketelsen:** So for the women who are listening to the podcast or listening live, if they go to WomenWhoGo.org they can see a list of chapters. Will that give them the ability to find when the next meetings are?
+
+**Sarah Adams:** Yes, exactly. There is a list of all of the Meetup pages, or in Tokyo's case the Connpass. There's a Twitter account for each chapter, and some of them have Facebooks, and they're on Slacks. There are links for all of those on the WomenWhoGo.org site.
+
+**Erik St. Martin:** And you said for people interested in potentially starting their own chapters, the best thing to do is to email you at hello@womenwhogo.org.
+
+**Sarah Adams:** Exactly.
+
+**Erik St. Martin:** Awesome.
+
+**Brian Ketelsen:** Great topic.
+
+**Erik St. Martin:** Yeah. And on that note, I think that we are just about out of time for this episode, so unfortunately we get to say our goodbyes. But before we do that, we typically do the whole \#FreeSoftwareFriday where each of us just kind of briefly mentions a project that we are kind of grateful for, just to give support to the project and its contributors, or some of these things that we use every single day... Because sometimes a thank you is just good to give back, even if you can't contribute code. With that being said, who wants to kick this thing off?
+
+**Brian Ketelsen:** I'll start it off. My \#FreeSoftwareFriday shout out this week is to the thousand plus people who have contributed to Docker. I still love Docker as a build tool and a deploy tool. Docker is a lot of fun and it has made the easy things easier and some of the hard things more accessible, and caused me to lose a little bit of hair every once in a while, but I love Docker. So thank you, Docker people.
+
+**Sarah Adams:** I'm gonna shout out to the folks at Apiary, writing the Apiary Blueprint spec. It's really awesome, and you guys have been very accommodating about my documentation change requests.
+
+**Erik St. Martin:** That's awesome. Carlisia?
+
+**Carlisia Thompson:** I have two today. I will real quick give a shout out to remotemeetup.golangbridge.org, it's the Go Remote Meetup initiative that a few people are coming around to. It's what the name says - if you want to give a talk online and reach people who are not in your physical community, hop on there, we'll schedule a talk - I'm part of it too, so I'm saying 'we'. This is dear to my heart, I love it, especially because I'm not in a big tech center. San Diego is pretty good, but it's not Boston or San Francisco. So I'm looking forward to this, and people who want to see these talks, presentations, demos, tutorials and hopefully programming sessions - I have people here in San Diego who want to do that - just subscribe and you'll get notified. We have some stuff there already, and more coming.
+
+The other one that I've been meaning to say for the longest time is the Sourcegraph Chrome Extension. Install it on your computer and then go to GitHub and when you look at code, it's gonna be magic. You just hover your mouse over functions and constants and you get all sort of extra information that you don't have to hop to other places to see. There is a mini-tutorial video that they have, and we will include that on the show notes. It's pretty cool.
+
+**Erik St. Martin:** And we actually have Beyang, one of the co-founders of Sourcegraph, lined up for an episode. So that will be coming up as well.
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** For me this week - and hopefully I pronounce this correctly, because I don't think I've heard anybody say it - it's Rofi, which is a kind of an application launcher and window switcher for Linux, and I use that while I'm in i3 to open up new programs instead of dmenu.
+
+**Brian Ketelsen:** +1.
+
+**Erik St. Martin:** What's that?
+
+**Brian Ketelsen:** +1, Rofi's awesome.
+
+**Erik St. Martin:** Yeah, and recently they had a new release that brought a lot more features and made it look a lot prettier, so I've been having a blast with it. With that said, I wanna thank everybody, I wanna thank the panel - Brian and Carlisia - and I certainly wanna thank Sarah for coming on the show. I wanna thank everybody who's listening now and everybody who will be listening when these podcasts drop. Definitely share the show with your fellow Go programmers. Best way to subscribe would be to go to GoTime.fm and we will also have a weekly email newsletter coming out - you can do that. Or on Twitter as well, @GoTimeFM. With that said, thanks everybody, and we'll see you next week.
+
+**Carlisia Thompson:** I'm glad to be here.
+
+**Brian Ketelsen:** Thank you.
+
+**Carlisia Thompson:** Thank you, Sarah.
+
+**Sarah Adams:** Thanks.
+
+**Carlisia Thompson:** Bye.
+
+**Brian Ketelsen:** Thank you, Sarah.
+
+**Sarah Adams:** Thank you.

Scott Mansfield on Go at Netflix_transcript.txt

@@ -0,0 +1,467 @@
+**Erik St. Martin:** Alright everybody, welcome back for another episode of GoTime. Today we have a special guest with us, but first we'll go through who the typical hosts are. I'm Erik St. Martin, we also have Brian Ketelsen, which does not sound like Brian Ketelsen today, but I assure you it is the real Brian Ketelsen. Say hello, Brian.
+
+**Brian Ketelsen:** Today the part of Brian will be played by somebody with a very scratchy voice.
+
+**Erik St. Martin:** \[laughs\] We also have Carlisia Thompson...
+
+**Carlisia Thompson:** Glad to be here, hello.
+
+**Erik St. Martin:** And our special guest today is Scott Mansfield who we've talked about a couple times on the show, about Rend and a couple of other posts we've read. Welcome to the show, Scott.
+
+**Scott Mansfield:** Hello, everybody.
+
+**Erik St. Martin:** So you decided to heckle last show, so I guess the punishment is you have to be on the show now. \[laughter\]
+
+**Scott Mansfield:** Yeah... Like I said, I need to learn to keep my mouth shut sometimes.
+
+**Erik St. Martin:** So Scott, you work on some products at Netflix using Go. Do you wanna give everybody a little background?
+
+**Scott Mansfield:** Sure. So the project is called Rend, and it's a memcached proxy and server that's written in Go. It was an interesting choice of language, because Netflix is pretty much an all-Java shop, and we needed something that was more performant, more productive and less - not bloated, but doesn't have any baggage in terms of platform libraries and other things that every other Java app here pulls in.
+
+We also wanted to have some sort of performance, because the service that I work on is actually called EVCache. That's a distributed, charted memcached. And we're very latency-sensitive, so having an 80-ms GC in Java would be great for a lot of people, but for us that would be horrendous, so we picked Go.
+
+**Brian Ketelsen:** That's interesting, if you don't mind me interrupting. A lot of people are still very twitchy about Go's garbage collection. Can you elaborate a little bit more on why Go's garbage collection worked out for you when Java's couldn't?
+
+**Scott Mansfield:** There's a variety of reasons. Partially, the Go memory model itself is simpler and has less indirection, which allows the garbage collections to be faster, but really it was sort of a "Let's just create the program in Go and we'll see how it works." It didn't really start out as a work project; it ended up being a personal project that I was working on before, and really whenever I started to load test it, it actually turned out to be quite fast. And the garbage collections themselves haven't... They happen all the time, but we don't really notice because they're only a couple hundred microseconds, but not too bad.
+
+**Erik St. Martin:** So is this the first project within Netflix to adopt Go, or is there other ones?
+
+**Scott Mansfield:** I actually don't know when the other ones started, there's a bunch here. I don't know if you guys are familiar with the Chaos Monkey system.
+
+**Carlisia Thompson:** Yeah, yeah.
+
+**Scott Mansfield:** \[03:58\] So there is actually a new version of the Chaos Monkey coming out. It's not open source yet, but the whole backend of the Chaos Monkey has been rewritten in Go, and it's actually in production right now, striking fear into everybody's hearts here. I actually spoke to the developer before this to get some reasoning, and partly it was because Go itself is so easy to learn that he's not worried about people coming in and working on his code later. The old codebase was actually such a mess that people were afraid of changing it, so now he's rewritten it in Go.
+
+**Erik St. Martin:** That's awesome, because until now I love everything Go does, and now it's wreaking chaos on my system right? \[laughter\] It is now both evil and good.
+
+**Carlisia Thompson:** I wanted to ask you, with the project, the Rend library being so in need of performance... Did you apply specific techniques, did you apply any design concepts, did you use specific libraries to make it as performant as possible? Or did you just apply good Go idioms and it came out performing well and that was it?
+
+**Scott Mansfield:** Interesting enough, there's... Well, I'm trying to parse the whole question, there's a lot of pieces there. Sometimes the good Go idioms can be less performant than if you tried doing something lower level, such as ownership of data with the goroutine and then sending messages back and forth for the channels may not be quite as performant as doing some sort of AtomicInteger, like increment stuff. So actually on that point, Rend actually has no external dependencies. It's strictly standard lib Go, and that was partially because I'm afraid of picking a vendoring tool whenever it's still up in the air, but also because I could really... Like, I could solve our problems better by having a custom solution.
+
+One of the things that's actually a good example is our metrics library, because there's all kinds of metrics libraries out there where you have a counter struct and then you go and increment it and it still does atomic increments in the background, but it really didn't fit our use case quite as much.
+
+**Carlisia Thompson:** Is your metrics library also in Go?
+
+**Scott Mansfield:** Yeah, the whole thing... It's all in the same repository.
+
+**Carlisia Thompson:** Because I was thinking to ask you as well, I'm not sure if it applies what I wanna ask anyway... If you're using a Prometheus to collect metrics and log information.
+
+**Scott Mansfield:** Yeah, so our deployment is actually quite interesting. On the same server we're running Rend, memcached, our L2 disk-backed solution called Mnemonic which reuses part of the Rend code, and a Java-based Sidecar process that's actually the hook into the rest of the ecosystem. So in Netflix we have a system called "Atlas" that does our metrics collection, and the client for that is in our Prana sidecar. So for us, we actually have the sidecar process pull Rend to pull metrics out every once in a while, instead of Rend actually pushing metrics anywhere.
+
+**Erik St. Martin:** And now, the mnemonic part of it was the RocksDB portion of Rend, right?
+
+**Scott Mansfield:** Yeah.
+
+**Erik St. Martin:** We should probably back up a little bit too, because we discussed it a little bit in another show, but we might wanna kind of talk about what Rend is, and the components of that and what you're using it for, to kind of give a better understanding of what it does and why performance was so critical.
+
+**Scott Mansfield:** \[08:02\] Okay, yeah. So earlier, as I mentioned, I work on EVCache, which is a distributed charted memcached. It's the second or third highest volume system that we have here. It's a cache that fronts pretty much everything - I mean, not everything-everything, but quite a lot. It's in all three of our Amazon regions; we hit thirty million operations per second globally earlier this year, so when we're talking about trying to save a couple microseconds or something here or there, it's because it happens a couple trillion times a day. So when we put something in front of memcached, we really didn't wanna slow it down so much; that's why I was so sensitive to having something like 80-ms GCs. Our clients actually normally see roughly one millisecond response time from us, and half of that is network latency.
+
+**Erik St. Martin:** Wow.
+
+**Scott Mansfield:** So the purpose of Rend, actually... So for us, Netflix as a whole has changed into a N+1 architecture globally. What that means is any member can be served from any region that we have. We operate in three AWS regions, and as the caching layer for the company, we actually do global data replication and it's partly to support this N+1 architecture.
+
+It's really expensive though, when you have all of this data that's stored multiple times in RAM when it's really only read in one region. So the purpose of this overall project that we called Moneta was to store some of that cold data on disk, and allow the hot data to still be served from RAM as fast as it could be, but the cold data would be in much cheaper storage.
+
+As a part of that now, Rend is the on-box memcached proxy that does... It's a wire-compatible memcached proxy; our client didn't change at all, it still uses the same Java memcached client that we were using before. That's actually sort of the secret sauce of the EVCache product, and it speaks to Rend.
+
+**Erik St. Martin:** That's one of the things I found most interesting, that you kind of got this layer 1, layer 2 built-in, except it was wire-compatible, so you didn't really have to rewrite anything to use a new caching layer, you just talked to it as if it was a memcached.
+
+**Scott Mansfield:** Yeah, so our upgrades are pretty much just doing another deployment, and we get instantly more efficient storage.
+
+**Erik St. Martin:** Do you have anything special between the two layers? Did you implement Bloom filters or anything like that to save seeking the data off-disk if it doesn't exist there, the cold data? Or is it almost guaranteed to exist when you're looking for it in memcached, in your particular use case?
+
+**Scott Mansfield:** Not necessarily true. When you do things like [Chaos Kong](https://netflixtechblog.com/chaos-engineering-upgraded-878d341f15fa) where we evacuate a single region and split it between the other regions, you might have a huge number of misses in L1 very quickly. I didn't actually work on the RocksDB part, my teammate \[unintelligible 00:11:23.03\] did a lot of work to make that very efficient. The part that he's reusing is just the protocol parsing, the server loop piece of Rend, but the backend storage is all him, and there's a variety of different ways he's made the storage efficient enough to be able to handle misses like that.
+
+**Erik St. Martin:** \[11:43\] Yeah, RocksDB has been a favorite of mine for a long time. I'm kind of jealous you guys got to build something really cool with it. So walk us through the performance of that. You spoke to having to kind of go against the idioms to get the type of performance that you are, the one-millisecond latency on that. Is there a lot of those that you had to go by? Do you have kind of like a running list of things like that, of reproducible patterns that get to perform some operation in a more performant way than is currently idiomatic?
+
+**Scott Mansfield:** Part of it was the design itself is less... I'm trying to think of the proper words here. Most people might immediately think like, "Okay, send messages back and forth so that you could do requests", but for us, we have a connection coming in as a connection going out, so we have these sort of vertical slices and it's a very strictly connected, like one connection in to one connection out, and that allows us to have both isolation, but also a little bit easier time programming.
+
+There's not too many places where I've bucked the trend; I've just tried to avoid over-abstraction. So for the metrics library, for example, counters are AtomicIntegers, and it's a pretty straightforward thing that you would think to do.
+
+**Erik St. Martin:** Right. And there's been a couple of instances that we were talking about the other week, Heka... He believed that they had overused channels too, and that they could have got much better performance had they just stuck to using mutexes and AtomicIntegers and things like that instead of all the channels that got used.
+
+**Scott Mansfield:** Yeah.
+
+**Erik St. Martin:** So I think naturally we wanna use all this stuff because it's cool and it's new, and the languages that we came from didn't have them, and I totally abuse - I should go to jail for my abuse of channels when I first came into Go. I wanted to use them for everything.
+
+**Scott Mansfield:** I think that's a pretty common pattern, though. Everybody comes in and, "Oh look, concurrency, parallelism. Channels everywhere", and then we calm down.
+
+**Carlisia Thompson:** That happened to me, to use channels and ask for some advice about my code, and people were like "Just use a mutex here." So I would say for people who are starting out, learn how to use a mutex so that you can then make a choice if that's what you need, versus channels. A lot of times that's enough, and this performs a lot better.
+
+**Scott Mansfield:** I also think it's important to remember that nothing is magic, so for a channel there is a fast path - think buffered channel, not the one where you need a handshake where there's no buffer. But for a buffered channel there's no magic. You have pretty smart code at the front whenever you're trying to insert something, but if you end up competing for that, it's a lot. That's the way it works. You can't have anything else there. So it's not like you're going to magically be faster by having this channel for concurrency. It has to have some sort of management of that concurrent behavior internally.
+
+**Erik St. Martin:** Yeah, and I know some of this stuff, too. This is one of the things I was guilty of early on, I was using channels for state. When I should really be using a mutex, I would create these goroutines that select on channels, and that's where the updates took place to state, and that seemed like the pattern, because go ahead channels, why would you want mutexes? And this was in the early days, but I still see people coming to the language and doing that. I don't know what the best way to offer advice for that is... Whether there's "When to use channels, when not to use channels."
+
+**Brian Ketelsen:** I think I have a pretty good idea. If you're at Netflix scale, then all of the rules don't apply. But if you're not at Netflix scale, use whatever you want I think we've probably spent too much time focusing on tiny microperformance benchmarks, when 90% of our latency comes from the network and the disk and the database. We should worry about those things instead.
+
+**Carlisia Thompson:** \[16:11\] My impression though is that mutex and channels, they are not interchangeable. I mean, you can use channels in the way that you would... If all you needed was a mutex, you could force a design with channels in your code, but they're not really the same thing. I could be wrong.
+
+**Erik St. Martin:** No, they're not. They're not at all. The only way it ends up working that way is because you end up having one goroutine that is the thing always updating state. It's almost used that way, but I think the pattern kind of came from - I think there were some projects early on that had that pattern, and then a lot of people kind of copied it and followed suit. I can't even remember what library I picked that pattern up on, and then I kept doing it. And there were other big name Go programmers doing the same thing, too. I think we finally realized to slap our own hands, like "Why!? Why are we doing this?" The code's much more complex, it's harder to reason about... And it's actually less performant.
+
+**Carlisia Thompson:** And while on the subject, I just wanna mention this real quick: if you do figure out that a mutex is not gonna do it for you and you do need to use channels, if you haven't, it's worthwhile to watch a Rob Pike video on Concurrency Design In Go. I think that's what the name is... I'll put the link on the show notes. It's beautiful. It's not something that you watch and you're like, "Oh, I learned everything", but you'll get a sense of the different ways you can design for concurrency. It's gorgeous, it was my favorite video ever for Go. Have you guys seen that?
+
+**Erik St. Martin:** Yeah, yeah.
+
+**Carlisia Thompson:** Of course.
+
+**Erik St. Martin:** So for Rend, is that pretty much done? Are you actively maintaining it or are you adding new features?
+
+**Scott Mansfield:** Well, at this point it's mostly done. It's got a couple new things I'm adding to it, mostly to support new memcached commands, because we're supporting each one very explicitly; sometimes I have to go in and edit code to add support for things like append() or prepend(), or things like that. It's in a pretty stable state at this point, actually. It's being used in production for us already, so I would call that stable.
+
+**Erik St. Martin:** Now, are you gonna continue to support changes so that it stays wire compatible with memcached, or you're just kind of staying at the current version? Does it support all the commands that memcached offers?
+
+**Scott Mansfield:** It doesn't really support everything that memcached offers, and there's no plan to be completely a hundred percent wire compatible, because there's some things that we just simply don't use. Our EVCache Java client that we vend to people does not expose everything, so we don't worry about supporting everything.
+
+**Erik St. Martin:** Okay.
+
+**Scott Mansfield:** It's a very pragmatic approach, because it's meant to solve Netflix problems, and it's open source in the hope that it will help somebody else solve their problems as well.
+
+**Erik St. Martin:** I don't think that there's a need to be 100% either. There's a big project that came out of YouTube called Vitess which is wire compatible with MySQL, but kind of makes MySQL distributed, and they don't support all SQL in there as well, just kind of the core things that they use.
+
+**Brian Ketelsen:** And that's okay, definitely if it solves their problem. I agree.
+
+**Erik St. Martin:** And if it does not solve your problem... Pull requests accepted.
+
+**Brian Ketelsen:** \[20:01\] Or forks.
+
+**Erik St. Martin:** Right, or forks. Kind of on a different track here - was it yesterday, or the day before? - I came across another one of your blog posts, which I actually love, which was called How To Block Forever In Go. That was kind of like a list of all the different ways... Are these just things you came across, where people would create deadlocks in code?
+
+**Scott Mansfield:** Not strictly. I think it's still in the Rend code, I have been making a new wait group and then adding one and trying to wait on it so it could block forever in my main and of course, I thought that was a little bit absurd. So a while ago we were talking in the Gopher Slack about this, and I mentioned ways to block forever, and then other people started piling in and adding suggestions and other things, and I thought it was kind of funny, because there was just... I don't know how many are listed here...?
+
+**Erik St. Martin:** It was probably ten or more... There was quite a few, and I actually have one that's missing.
+
+**Scott Mansfield:** Yeah, that's the great thing about it. I learned the proper way to do it, which is the runtime.go exit I think, in the main, which allows you to exit out of your main but allow every other goroutine that you've started to keep running. So that's the proper way to do it, and I didn't know that. It's one of the wonderful things about putting something out there - people will come correct you, but that means you actually get to learn the right way to do it.
+
+**Erik St. Martin:** So wait, what was it? You said runtime.exit?
+
+**Scott Mansfield:** It's called go-exit, I believe...
+
+**Erik St. Martin:** Yeah, something along those lines, I can't remember now. It's one of those things, you have to be there ready to type it, and then it comes to your mind. Well, nowadays you don't even have to do that, because of the editor plugins...
+
+**Brian Ketelsen:** Yeah, VimGo...
+
+**Erik St. Martin:** The one that I remember not being on the list is a nil channel will also block forever. So if you try to send or receive on a nil channel, it will block forever.
+
+**Scott Mansfield:** I need to add that now. I feel like it's not complete.
+
+**Erik St. Martin:** \[laughs\] I think it should just be like a never ending list that evolves.
+
+**Brian Ketelsen:** Yeah, that's the power of the internet. You can go back and edit it, and nobody will ever know.
+
+**Erik St. Martin:** Yeah, and for everybody who's listening who has not seen this post, we'll link to it in the show notes, but it's basically this running list of different things you can do that would end up making your program deadlock; or the goroutine or the application itself just blocks forever. It was a fun read, because I'm going through there and like 90% of them I've seen or done mistakenly. And one of them that I saw was the double lock. That one was fun because, although I've never done it that way where you lock twice in a row, I have locked in a function and then called another function that locked the same mutex, and basically made it wait forever.
+
+**Brian Ketelsen:** I did that this week. Yep... Oops!
+
+**Erik St. Martin:** And I feel like some of the static analysis tools that are out there could be evolved to look for some of these patterns. I mean, some of them are Runtime-specific, right? You can't know that the channel is gonna stay empty forever, but others like the double locking I feel like you should be able to catch some of those, I guess. I don't know. Shamefully I have not written a static analysis tool, so...
+
+**Brian Ketelsen:** It should be easy.
+
+**Erik St. Martin:** Right? For anybody who writes static analysis tools... Hey, it's no different than the business delivering requirements, right? It's just a button. How hard could it be? Just add the button.
+
+**Scott Mansfield:** Just slap some regex on it and you're good to go.
+
+**Erik St. Martin:** \[23:57\] Right? Regex solves all the problems. Alright, so anybody have anything else you wanna talk about? Netflix, or the usage of Go there? What else are you working on, Scott? Do you have anything else going on in the open source community that we can steal?
+
+**Scott Mansfield:** Netflix does, certainly, for sure. I actually had this list of Go projects written down, but it's not necessarily perfect for this... I mean, there's a bunch of things - I've linked them all actually to you guys already - that are all open source and are related to Go use here. But myself personally, no, I've pretty much been stuck working on Rend this whole time.
+
+**Erik St. Martin:** Such is the life of a developer... Okay, so I have to look for that link, but we'll make sure that's in the show notes too, for anybody that's interested in all the kind of projects that are coming out of Netflix and that are open source, and even outside of Go. Netflix has been releasing a lot of cool stuff.
+
+**Brian Ketelsen:** Forever. Netflix in my mind is one of the pioneers of the "Open sourcing our tools so that you can use them" group. We're not at the Free Software Friday yet, but you gotta throw down for Netflix, because they've been helping everybody else build awesome environments for a long time.
+
+**Erik St. Martin:** Yeah. I mean, long before it was as trendy as it is now. And you have to give credit too, because we're Go developers and it's one of the primary things we all love, but we were other language developers too, right? It's almost impossible to solely develop in one language these days, and there's plenty of other projects that Netflix and other companies have released that are Java, and all that jazz, that we've gotten some good use out of over the years.
+
+Speaking of projects and news, do you guys wanna have a random roundtable about things going on in the community, and projects we're interested in and playing with?
+
+**Brian Ketelsen:** I'm ready.
+
+**Erik St. Martin:** You're ready?
+
+**Brian Ketelsen:** I'm ready.
+
+**Erik St. Martin:** Your voice is clearing up there, Brian. Are you feeling better?
+
+**Brian Ketelsen:** I muted my microphone and coughed quite a bit, it helped a lot. So one of the big things that happened this week was GoKit was tagged at 0.1.0, and I think that's a really big milestone for GoKit. It was kind of an arbitrary tag... When I talked to Peter about it, he said there wasn't anything gigantic that made it into a 1 tag. But they've got thousands of users, and they're drawing this line in the sand and saying, "Hey, this is a point where we're stable and worthy of a release milestone." The Go Kit packages are really nice because they're useable outside of GoKit microservices, the logging package is amazing; I really like their logging package a lot. And they've got lots of little packages that are easy to use outside of the entire GoKit ecosystem. So if you haven't looked at GoKit yet, please do. Lots of good stuff there, and they've got a great, vibrant community that helps push that GoKit code forward.
+
+**Erik St. Martin:** So is this more of marking as stable API, where the API won't change much?
+
+**Brian Ketelsen:** I don't think there's any significant guarantee of API stability in this release, but it's just kind of a...
+
+**Erik St. Martin:** A confidence tag?
+
+**Brian Ketelsen:** Exactly, it's a milestone.
+
+**Erik St. Martin:** Yeah. GoKit's been doing some great things, and I use their log package, too. I'm quite fond of it, it's one of my favorites.
+
+**Brian Ketelsen:** Yeah, it's a good logging package.
+
+**Carlisia Thompson:** And one FYI, Peter was on the Changelog podcast, and in that episode he goes over the components of the package, and he talks about stability and moving towards a stable release. It's a very good show.
+
+**Erik St. Martin:** Scott, what are you doing for logging? Because you said you don't use any external dependencies. Did you write your own logging package or are you just using the standard library?
+
+**Scott Mansfield:** \[27:57\] Generally you just stay quiet when everything's okay, but we rely a lot on metrics because in AWS you can have instances just up and disappear. We run somewhere between eleven and twelve thousand instances, so we're not gonna worry about the logs from one instance, most of the time. If we do log, it's when some things are really completely wrong and we're going to close the connection, or something like that, and therefore I don't really worry so much about it. We just use the log package.
+
+**Erik St. Martin:** So this is more just kind of to be able to triage errors you're seeing in your metrics of system performance and latencies and things like that, then you kind of go after the fact to triage? So you don't really use this much of the tagged logging and stuff like that that other people use?
+
+**Scott Mansfield:** No, certainly not. We just... Every time that I have an error that's a very specific situation, I just put a metric and if that counter goes anywhere above zero, then we know specifically what went wrong.
+
+**Erik St. Martin:** That's true too, right? Because ultimately that's what a lot of people do anyway, right? They tag their errors of certain types and then they try to query and get counts of them and all that stuff. So you're just kind of skipping the bloat of having all those logs sitting around and just keep the thing that matters to you, the count.
+
+**Brian Ketelsen:** Does that mean that you have watches on those metrics, to trigger events or notifications?
+
+**Scott Mansfield:** Yeah, so if there's anything that we know would be catastrophic, we could work on having alerts and other things on loads. I feel like an AtomicInteger increment and reading it once a minute is far more lightweight than writing out a whole big JSON block.
+
+**Erik St. Martin:** But JSON is so slimmed down in comparison to XML.
+
+**Brian Ketelsen:** And human-readable, too.
+
+**Erik St. Martin:** Right?
+
+**Brian Ketelsen:** So, we've turned our podcast into SREs at Netflix. We're gonna have to change our branding, but I think you're getting a lot of good, valuable information out there, guys.
+
+**Erik St. Martin:** Yeah. I always find it interesting too to talk to different people who work at scale, because anytime you get into distributed systems, and especially the size that Netflix is, you can't be concerned about a single machine anymore; it's impossible to do that. So I always find it interesting to see what people's approach is to make sense of the massive amounts of data, and metrics, and logs, and all that jazz. And it especially became interesting when you said you use no outside dependencies.
+
+Alright, so moving on. What else have we got?
+
+**Brian Ketelsen:** I wanna say too about our perennial, favorite projects here at GoTime, our Vim Go and Hugo, they both leveled up this week with some updates. I haven't read the Hugo announcement yet, so I don't know what's new there. Vim Go had some interesting changes for implementing interfaces - is that what you were telling me, Erik?
+
+**Erik St. Martin:** Yeah... I don't even know how you would pronounce this command... go fmt - I would never expect it could be pronounced, until I heard someone say it. So I don't know how you would pronounce the command, but Go implementer... But it's cool, because it basically stubs out your type with all the functions, so that it will implement said interface, which is really cool.
+
+**Brian Ketelsen:** Nice.
+
+**Erik St. Martin:** I haven't used it yet, but it sounds like something I would use.
+
+**Brian Ketelsen:** Yeah, me too. So how about you, Erik, did you come across any interesting projects or news this week that you wanted to share?
+
+**Erik St. Martin:** I saw Francesc's Go Tooling In Action video, which I thought was really cool. Did anybody watch that?
+
+**Brian Ketelsen:** Oh, that is a great video, yes.
+
+**Erik St. Martin:** Scott, did you get a chance to see that?
+
+**Scott Mansfield:** \[32:00\] I have not yet.
+
+**Erik St. Martin:** It was very cool... I always like watching people work too, and he kind of walks through some of the tools that he uses and how to use them. I even saw him to the new fancy Torch graphs that Uber supplied, which I have to say is a much easier way to visually see pprof graphs.
+
+**Brian Ketelsen:** Yeah, they're pretty.
+
+**Erik St. Martin:** Have you played with that one yet, Scott?
+
+**Scott Mansfield:** The Go Torch projects?
+
+**Erik St. Martin:** Yeah, the Go Torch projects.
+
+**Scott Mansfield:** Well, the guy who invented flame graphs actually works here on our SRE team.
+
+**Erik St. Martin:** Oh, nice.
+
+**Scott Mansfield:** ...so it's a pretty well-ingrained use for Java apps here. People use it all the time, and only recently have I actually started using Go Torch. I've been stuck in the stone ages apparently, using the web graph output from the pprof tool.
+
+**Erik St. Martin:** You're not the only one, I do the SVG thing, too.
+
+**Brian Ketelsen:** Scott, I think that's the closest we've ever come to a mic drop on GoTime, thank you for that. \[laughter\] Yeah, we invented those - thanks, Erik.
+
+**Scott Mansfield:** Not we, Brendan Gregg. All credit goes to him. He's really, really great at what he does.
+
+**Erik St. Martin:** Yeah, he's like the godfather of performance. I've got his book on my desk here, which I still haven't made it all the way through. What happens with getting older and having less time? I just... I don't get it. Somebody invent more time. Could you write that in Go, please? \[laughter\] Scott, did you have any projects you wanted to talk about?
+
+**Scott Mansfield:** I kind of keep my head in the sand... I've been working on some features that we need for Rend to be deployed, and we had all kinds of things going on recently, so unfortunately no. I also have a - God, she's eight months old now - eight-month-old daughter, so all my free time is pretty much spent with her.
+
+**Brian Ketelsen:** That's a big external dependency right there.
+
+**Erik St. Martin:** Yeah. My - I guess she's 20 months now - 20-month old daughter woke up just before we got on the call for this show. That's twice now. She times it perfectly, I think she knows.
+
+**Carlisia Thompson:** Of course she knows.
+
+**Erik St. Martin:** She's like, "I wanna be on the mic, too." \[laughter\]
+
+**Brian Ketelsen:** She likes attention.
+
+**Carlisia Thompson:** She's a future podcaster.
+
+**Erik St. Martin:** I'll get her on the show when she can talk.
+
+**Carlisia Thompson:** I have a project I wanted to mention. Yet Another Web Framework (YAWF).
+
+**Erik St. Martin:** So is that actually the name of the project, or is that what you've labeled it?
+
+**Carlisia Thompson:** No, that's an acronym I just came up with. But the name of the project is Iris.
+
+**Erik St. Martin:** I don't think I've seen Iris... So what's the spirit of it? Is it like closer to a Revel, is it closer to a Martini, or a Negroni?
+
+**Carlisia Thompson:** Yes, so HttpRouter... He actually has a graph here that he benchmarked - I'm assuming it's a he - the Iris package with HttpRouter, GorillaMux, Gin, Beego, Martini, the standard lib package and other ones that I've never heard of. And he claims that it's twenty times faster. I learned of it from \[unintelligible 00:35:36.16\] when he did one of the remote Go meetups and he said that he uses it and he loves it.
+
+I haven't used it, but anything that says "I'm 20 times faster" calls my attention.
+
+**Erik St. Martin:** So what's your feeling on this, Brian? What was it, episode two, that you made the comment about router performance...?
+
+**Brian Ketelsen:** \[35:58\] Can we please stop making more routers for Go? Please! \[laughter\] We have some, they're great, and that's not really where your code is gonna improve in terms of latency, so stop. Thank you.
+
+**Carlisia Thompson:** I heard the episode and I saw that, and I had to mention it.
+
+**Brian Ketelsen:** You're just trolling me, Carlisia. That's not nice. \[laughter\]
+
+**Carlisia Thompson:** I have to try to get my way, somehow. \[laughter\]
+
+**Erik St. Martin:** I haven't even looked at it, I'll have to pull it up. Recently I haven't really been... I'm kind of in the Scott camp here where it comes to the frameworks... Recently I've just been writing my own stuff. Maybe I'm not building anything big enough, I feel like I need a framework for the repetitive nature of it, but...
+
+**Brian Ketelsen:** Or maybe you just don't wanna take on another external dependency that you have to babysit.
+
+**Erik St. Martin:** That's quite a possibility, as well.
+
+**Brian Ketelsen:** Which is gonna make it harder and harder for us to find interesting Go projects if we're never using any.
+
+**Erik St. Martin:** That's very true, too. I should probably make a point out of playing with new projects. It's hard, though. You get kind of trapped in your own little world, building stuff... So what was the other thing that I wanted to talk about...? Oh, the survey.
+
+**Brian Ketelsen:** That's right.
+
+**Erik St. Martin:** \[unintelligible 00:37:15.10\] the survey? There was a survey that went out... Who sent that out?
+
+**Carlisia Thompson:** It was Ed's.
+
+**Brian Ketelsen:** Ed Muller, from Heroku.
+
+**Erik St. Martin:** That's right. He sent out a survey, trying to gauge people's usage of Go and the way they use it, the libraries they use, the vendoring tools they use... Maybe so we can agree on one. Scott, can you use one? \[laughter\] Have you tried any, Scott?
+
+**Scott Mansfield:** I was forced to use Godeps to deploy something on Pivotal Web Services. I think I had one dependency in, I just put it right in the vendor folder. It would not actually compile and run my code without a Godeps file.
+
+**Brian Ketelsen:** Wow...
+
+**Erik St. Martin:** This is kind of like how I forced Brian to use Node one time.
+
+**Scott Mansfield:** Do you still have PTSD from that?
+
+**Brian Ketelsen:** Yeah, didn't we talk about this last week?
+
+**Erik St. Martin:** I still can't remember what it was - I think it was a JSON Lint thing, or some kind of tool like that I had him install, and I didn't realize it was Node, and I'll never live it down.
+
+**Brian Ketelsen:** No, I actually sent him an email and said, "Report to my office. You're fired." \[laughter\]
+
+**Erik St. Martin:** So Govendor I like. I've been using that one recently. And that seems to be kind of almost the same thing, it just uses the vendor folder that already exists, and it kind of stuffs stuff in there. I kind of like that one. I don't hate it, I should say that. But I think you're right, we're still trying to get consensus as a community over what to use there.
+
+**Scott Mansfield:** People have actually been frustrated, for example, with the AWS SDK for Go. They don't use any sort of vendoring tool, and they just have every dependency in their vendor folder. People are upset with them and they keep opening issues, but I think their position is very pragmatic, saying "There's no clear winner. We're not gonna pick one, because somebody is not gonna have that tool."
+
+**Erik St. Martin:** Yeah, and that's kind of what I like about the Govendor thing, because it doesn't really do much aside from stuff your dependencies in the vendor folder. At least from my understanding. I haven't seen any kind of manifest or anything like that. I've only recently started using it, but it seems to be that's all it does, stuff it into the vendor directory for you and do the go gets for you and stuff like that. I kind of like that approach. I'm still waiting for consensus on what to use.
+
+\[39:53\] One of the things with the vendoring I still haven't figured out is - and maybe somebody here can solve that for me - there's kind of the whole "You don't vendor dependencies in the library, only in the command", or do I have that flipped? Have you guys heard that, where people are advocating not to vendor dependencies for libraries?
+
+**Scott Mansfield:** Yes, you actually had it right. It's mostly for just... People who are writing libraries shouldn't force a dependency, because otherwise you end up running into diamond dependencies very quickly.
+
+**Erik St. Martin:** Yeah, in a lot of libraries I think it makes sense, but there's others that are so big that they kind of force a version. I guess maybe they should make at least recommendations. There should be something maybe in the documentation that says "This library is known to work with these particular versions", or something like that, or there's at least a minimum requirement. But dependency management is not an easy thing, right?
+
+**Brian Ketelsen:** I think we all need Maven for Go, and that's where we're going to evolve to.
+
+**Erik St. Martin:** Oh my god...
+
+**Brian Ketelsen:** I don't think there's a middle ground. This is probably an episode of its own, but I really don't think there's a middle ground. And trust me, I don't like Maven either, but how can you only do part of dependency management? How can you only do half of that? I think we have to do it all, and everybody has to do it all, or nobody gets anything. But that's just my opinion.
+
+**Erik St. Martin:** And if only people could scream at you right now, Brian.
+
+**Brian Ketelsen:** They are, and that's okay.
+
+**Erik St. Martin:** ...through the airwaves.
+
+**Brian Ketelsen:** It's alright. I think we talked about this a little bit last week - humility on the internet. I am perfectly happy to be wrong every day and have people tell me that, because I learn from it. So I'm accepting the fact that I'm wrong now, too.
+
+**Scott Mansfield:** I would like to point out that the authors of different tools are actually talking to each other now, which is great. They are starting to try to find a middle ground or some kind of consensus on like what a lock file should be, or what kind of dependency resolution you should do... So there is movement on that front, but it still seems like a long way off.
+
+**Erik St. Martin:** Yeah, that's actually a good observation. I kind of noticed that, too. In the earlier days of people talking dependency management, it was "We don't need it", and then it was like, "Okay, maybe we need it a little bit", and then there was like five tools, and then there were ten tools, and there was arguments. But you're right, I think that there's been a lot more kind of consensus. I think that the Go team has kind of stepped in too, and realized that maybe they need to kind of help facilitate this a little bit too, even if they don't implement the tool, they gave us the vendor directory, which I think made the tools less intrusive. We didn't have to do the whole Go path mangling that was required for some of the tools earlier on.
+
+So yeah, I'm interested to see how it comes along and how long that takes.
+
+**Scott Mansfield:** And actually a lot of the discussion is happening in Slack, there's a vendor channel that people are talking in, so if you wanna follow along, you can see the discussions happening, and of course, voice your own opinion if you feel the need, Brian.
+
+**Brian Ketelsen:** Just keep it civil. That's a touchy subject for Go developers, and our Gopher Slack has a very specific code of conduct. If you're gonna touch something as deep as vendoring, just remember to be adult.
+
+**Erik St. Martin:** I think that this show has become "Learn a new Slack channel every week."
+
+**Brian Ketelsen:** \[laughs\]
+
+**Erik St. Martin:** Because every week somebody mentions a new channel, and like "Wow, I didn't know that existed."
+
+**Carlisia Thompson:** \[43:50\] And something about channels on Gopher Slack for people who are listening... Hop onto the GoTime FM channel, because we can all multitask here, we are very good at that and you wouldn't believe this. We have Adam tweeting for us, and we are all on the channel also typing, our guests are typing, and we're talking and doing all the things at the same time. So join us...
+
+**Erik St. Martin:** And if you hackle us enough like Scott did, we might drag your butt on the show. \[laughter\]
+
+**Carlisia Thompson:** Exactly.
+
+**Brian Ketelsen:** As punishment. Now, is that concurrency or parallelism, Carlisia?
+
+**Carlisia Thompson:** It's concurrency, for sure.
+
+**Brian Ketelsen:** Okay.
+
+**Carlisia Thompson:** Yeah. \[laughs\] Good question.
+
+**Brian Ketelsen:** On that note, one of the things that I wanted to bring up this week is the season three of Beyond Code, which featured GopherCon 2015. That's launching this Saturday, and it's going to be in the show notes for this call. Beyond Code Season 3 has interviews from lots of the people that went to GopherCon and it's really awesome. I just saw some of the previews and really enjoyed asking interesting questions of the people in the Go community. So if you get a chance, check that out. It's really cool. Adam and his team did a fantastic job putting that together for us.
+
+**Erik St. Martin:** And both Carlisia and Brian are on there.
+
+**Carlisia Thompson:** Yeah. \[laughter\] Completely by chance. And I also want to mention that it was very late at night, they were way on the back of the bar - this was at one of the after-parties; there were so many, I can't even remember. It was huge, they were way at the back... So just by the time I got to the end of the bar, I already had I don't know how many beers, so that is that. And everybody who was with me was drinking, and two other people who were with me are also on the movie... And I don't know how we all managed to just talk clearly, I can't believe it. I felt like I was ambushed.
+
+**Erik St. Martin:** This is real. This is people. It's beyond code. Beyond code is the bar.
+
+**Carlisia Thompson:** It is the real deal. But Adam was so great... The power of making people feel comfortable behind the camera - amazing. They're gonna be at GopherCon again. I highly recommend it, just do it. It's fun.
+
+**Brian Ketelsen:** It was like looking at a time capsule. That was me a year ago, talking about Go, and talking about things... It was fun to watch.
+
+**Erik St. Martin:** You made the comment in that - I think it's in the intro video we'll link to... I'm sure Adam, if he hasn't sent it now, is sending it on the Twitter... So you made the comment, something like "Everything interesting in the computing world is either written in Go or soon will be." How do you feel about that observation one year later?
+
+**Brian Ketelsen:** It's true. If you think about the things that are really shaking up our industry right now, there's a shortlist, and on them are containers; the entire container industry is driven by Go, whether it's Docker or Kubernetes - all of those pieces are written in Go. A plethora of tools that are coming out now for us are powered by Go or written in Go; Go on the backend, somewhere. So it's really neat to see that really start to come true.
+
+**Scott Mansfield:** I find this interesting, that it directly contradicts Atwood's Law, which is "Any application that can be written in JavaScript will eventually be written in JavaScript." \[laughter\]
+
+**Brian Ketelsen:** I think that's actually also true, because I'm pretty sure there's already a JavaScript container engine.
+
+**Erik St. Martin:** \[47:51\] Right. I was gonna say, when we get off this call I'm gonna have to Google 'containers in JavaScript'. If it's not written in JavaScript, there is probably at least bindings.
+
+**Brian Ketelsen:** Yeah, I'm sure there is. I realize it's a bold statement, but I think it's less hyperbole than it sounds. There's a lot of really interesting stuff happening in Go, and a lot of the great things happening in computing right now have Go in the middle of them somewhere.
+
+**Erik St. Martin:** I think you're right, and we see more and more coming. I mean, look, we have Scott on the show, and by next year he's gonna have - I don't know, at least ten more teams inside Netflix using Go. Right, Scott?
+
+**Scott Mansfield:** Sure, I just need to convince them to move away from our big old Java platform.
+
+**Erik St. Martin:** And changing the wheels on a moving bus is never difficult, ever.
+
+**Brian Ketelsen:** But look at the GopherCon sponsor list, as an example. There are companies on there that you wouldn't even have thought touched Go a year or two ago. There's some real surprises in there, it's really awesome to see it.
+
+**Erik St. Martin:** Alright... So I think we're actually running overtime a little bit. Typically, each show we do kind of like a \#FreeSoftwareFriday, where each of us lists a project, thanking them for making our lives easier. Who wants to kick this thing off?
+
+**Brian Ketelsen:** I will. I stumbled across Jessie Frazelle's dotfiles about six months ago, and I realized - I think it was yesterday, perhaps - that instead of doing a Google search or hitting Wikipedia or something like that, I really just needed to look in her dotfiles anytime I had a question about how to do something. So I can't recommend those dotfiles strongly enough for you... They're on GitHub at jfrazelle/dotfiles. Everything in the world you need to do is in there. There's some amazing stuff that you can learn from just cloning those dotfiles.
+
+**Erik St. Martin:** So these were just your same defaults by Jessie?
+
+**Brian Ketelsen:** Oh, it's so much more than same defaults by Jessie. This is unicorns and rainbows in your shell. It's everything.
+
+**Erik St. Martin:** I know we looked for them for a couple of configurations, I can't remember what they were for. She had linked them to us on Twitter a while back. I think it was for using Mutt.
+
+**Brian Ketelsen:** I put in the show notes "Zero to Awesome in one git clone." I stand by it.
+
+**Erik St. Martin:** That's awesome.
+
+**Carlisia Thompson:** I'll go next... I'll follow Brian's lead and not mention a software per se, because I couldn't come up with one today. I will mention this open source book that I've been going through, it's called Network Programming With Go. So much of Go is used for systems programming and networking, and I've been trying to learn more about it. This book is great because it's thorough in terms of breadth, but each subsection, you can just go on the internet and find videos and spend two hours or more learning about it. It brings everything together. It goes over everything there is, at least that seems to me to be the case. It has a lot of examples of using Go in the standard library to do some of that work. The guys is a professor, his name is Jan Newmarch. It's a pity \[unintelligible 00:51:35.22\]. So that's my recommendation today.
+
+**Erik St. Martin:** Nice. And Scott, how about you? Do you have anybody you wanna thank?
+
+**Scott Mansfield:** Well, I think I'm gonna take the cheap way out and just say Go.
+
+**Erik St. Martin:** That's not cheap.
+
+**Scott Mansfield:** \[51:51\] Honestly though, the standard library being open source has allowed me to have a much deeper understanding of what actually happens when I say, for example, 'bufio' without 'write', or something like that. It matters a lot for us. Being able to just very quickly go from docs to source code and follow the path allows me to really understand what's going on.
+
+**Erik St. Martin:** Yeah, and I don't think we consider that cheating. I think it's the one thing that makes all of our lives easier, all the time.
+
+To everybody's point, we use only a couple of tools every day, so I think we've gotta start stepping outside the box. For me - and I know I'm gonna pronounce this wrong, because I don't think I've ever heard anybody pronounce it, but it's actually a project called Radare, or Radare2, rather. It's not something I use every day, but it's something I play with. They call it a reverse engineering framework, but really it's kind of a disassembler and debugger. It kind of does some of the same stuff GDB does and all that jazz; it serves kind of the same role that IDA Pro does, but it's completely open source, and there's Go bindings for it, which is awesome. So you can actually script the disassembly and searching and patching of code using Go. I've only tinkered with it a little bit, but it's something that I'm looking forward to playing with more. It has ASCII control flow graphs of the assembly, and all kinds of fun stuff. I'd like to see what I can do about pairing it with Delve, one day, when I have infinite amounts of time.
+
+**Brian Ketelsen:** Tomorrow?
+
+**Erik St. Martin:** Later today, you know... Alright so with that said, I think we are probably well over time at this point. I wanna thank everybody for being on the show, I wanna thank everybody for listening. Everybody who is chatting with us in the GoTimeFM channel on Slack. We are on iTunes too, so now everybody can share us through iTtunes or just go to GoTimeFM. We do have a github.com/GoTimeFM/ping if you want to suggest people to be on this show or for us to ask questions, or... What else?
+
+**Brian Ketelsen:** Somebody needs to turn down the bass on Erik's voice.
+
+**Erik St. Martin:** Yeah, I'm terrible about that. And I think that's it. Twitter: @GoTimeFm on Twitter, as well. With that said, goodbye everybody.
+
+**Brian Ketelsen:** Thanks for being on, Scott.
+
+**Scott Mansfield:** Sure thing.
+
+**Carlisia Thompson:** This was fun, thanks Scott.

State of Go Survey and Go at Heroku_transcript.txt

@@ -0,0 +1,531 @@
+**Erik St. Martin:** Alright everybody... \[laughter\] I'm still laughing. \[laughs\] I actually had to pull away from the mic on that one. Alright, welcome back, it's episode ten. As always on the call myself, Erik St. Martin, we have Brian Ketelsen...
+
+**Brian Ketelsen:** Hello!
+
+**Erik St. Martin:** ... and Carlisia Campos.
+
+**Carlisia Thompson:** Glad to be here.
+
+**Erik St. Martin:** ... and today with us we have a special guest, Ed Muller from Heroku, who will be talking about all things Go at Heroku and some dependency management and any other random topics we decide to come up with. How are you doing, Ed?
+
+**Ed Muller:** Howdy!
+
+**Erik St. Martin:** Thanks for coming on, it's kind of exciting.
+
+**Ed Muller:** Thanks for having me.
+
+**Erik St. Martin:** What I want to talk about first is you recently sent out a survey - which I hope everybody's taken - getting information about people's Go usage. Do you wanna talk to us a little bit about that and the purpose you're looking for from that? And hopefully we can get more people to take it.
+
+**Ed Muller:** Yeah, so I started asking people in various Slack channels, "Hey, what can you tell me about Go users in different ways?" and Damian Grisky, the gentleman who does all the Go implementations of all the various different types of algorithms, he had linked me to the State of Rust Survey and said "Something like this might be pretty cool." I started looking at that and I was like, "You know what, I can't answer most of these questions for Go. I have my own intuitions, but I just can't answer these questions, so why don't I just do the same thing?"
+
+**Erik St. Martin:** How were the responses from that, Ben? Have you been getting a lot of feedback from that?
+
+**Ed Muller:** So far there's almost 2,400 responses, but I know there's more than 2,400 Gophers in the world.
+
+**Erik St. Martin:** I'm willing to bet that there probably are.
+
+**Carlisia Thompson:** 2,401, I took it today. \[laughter\]
+
+**Erik St. Martin:** I have to admit, I didn't complete it all the way through. I was really trying to analyze the page where it started asking what would I change, what would I want, and I feel like I've been around too long, I'm too used to it, so I was trying to sit back and think about that constructively, and I never went back to it. So there would be 2,402, but...
+
+**Ed Muller:** Go back to it, do it again...
+
+**Brian Ketelsen:** I took it and I answered all the questions honestly, and then at the end it said, "And do you want to leave your name?" and I was like, "Oh man, I answered all these questions honestly." Alright, so I figure at GopherCon I'm gonna get a beatdown from somebody.
+
+**Erik St. Martin:** So you put my name instead of yours is what you're saying?
+
+**Brian Ketelsen:** No, I put my real name in, but I did mention that dependency management was a pain point that we need to resolve as a community immediately.
+
+**Ed Muller:** Yeah, we do. So I maintain the Go Buildpack at Heroku and I have the wonderful honor of having to implement all sorts of different detections based on whether people are using things like GB or Glide or Govendor or Godeps, and that also excludes things like GVT and all sorts of other stuff... Where the other buildpacks are just like, "Hey, you're a Node, use npm. You're on Ruby, use Bundler etc."
+
+**Brian Ketelsen:** That's gotta be a lot of fun.
+
+**Carlisia Thompson:** \[03:57\] So what are the dependency packages that you support at Heroku?
+
+**Ed Muller:** The managers that we support are Godep; I'm also the current maintainer of that. Govendor, GB, and - it's not released yet, but if you use the master branch of the Buildpack, Glide support. And I think I've come up with a way to manage our last version, but I need to spend some time and write a bunch of code and then test it before committing to it.
+
+**Carlisia Thompson:** Do you have stats that you can share for how many projects use one or the other?
+
+**Ed Muller:** The vast majority of them use Godep. There are though users of Govendor and then GB; so as rankings, the vast majority is just Godep and then Govendor and GB. Part of that is just historical, because before the vendor experiment, if you wanted to do dependency management you basically used Godep.
+
+**Erik St. Martin:** Yeah, that was what I was gonna lead into as well - the question becomes how much of that is historical, because many of the other ones are new kids on the block in comparison. Godep has been around much longer than Govendor and GB. And is Glide the newest one?
+
+**Brian Ketelsen:** Glide's not the newest one by a long shot. There's probably been 30 edits since Glide came out.
+
+**Ed Muller:** Yeah, I occasionally have conversations with authors of new ones, and I'm like "Great, it looks like you solved the 80%. Now here is the rest of the 80% problems that you're gonna run into. Have fun!"
+
+**Brian Ketelsen:** Good luck with that...
+
+**Erik St. Martin:** It's hard, because I feel like there's no perfect solution, right? It's like there's things I love about each of these tools and there's things I can't stand either. I think I have to end up with the one that I dislike the least.
+
+**Carlisia Thompson:** Does anybody have any insights as to the states of resolution on this issue? Is vendoring something that's going to be solved soon, or it's not on the plate? I haven't been following, but it's important enough...
+
+**Ed Muller:** Well, there is a channel in Slack where myself, Daniel Theophanes, who's the author behind Govendor, some people from Glide kind of discussing some stuff and it's free for anybody to join. I haven't participated too much in it recently, but I know they are working towards some metadata standards. Daniel also was the backer of Vendor.json, which really wasn't adopted beyond his tool, though.
+
+**Carlisia Thompson:** Is anybody from the Go Language Team in there?
+
+**Ed Muller:** Not that I'm aware of. My understanding - and it hasn't changed, really - is that the Go Team was like "Here's Vendor. We're gonna let the ecosystem solve the hard part of the problem."
+
+**Brian Ketelsen:** Yeah, I think a good addendum to that though is the fact that the Go Team is listening very carefully to the issues that people are having in the real world. Andrew Gerrand has asked that we do a discussion at GopherCon on the Hack Day, so there's gonna be a room where people can come in and talk about issues with Go, and they fully expect people to be talking about dependency management at a little roundtable discussion.
+
+I know that they acknowledge that the vendor directory isn't a full solution. I think they would like us as a community to come together and help them make a plan or come together and offer a solution; perhaps one with code would be even better. But yeah, they are listening.
+
+**Erik St. Martin:** \[08:06\] I think it's a valid point too, because how much time do we want the Go Team invested in working on vendors stuff, instead of things like compile times and performance and things like that? Especially when we're still kind of eeling around blindly. There hasn't been consensus on "This is exactly the approach", so it's difficult. And I think every community has gone through this whole thing with "What do we do about vendoring?", or bundling, or whatever they happen to call it in their particular community.
+
+**Brian Ketelsen:** I have a strong opinion. Would you like me to share it?
+
+**Erik St. Martin:** Sure.
+
+**Ed Muller:** Yes, please.
+
+**Brian Ketelsen:** Look, Brian has a strong opinion again.
+
+**Erik St. Martin:** We need a better reason for you to get beat down at GopherCon.
+
+**Brian Ketelsen:** \[laughs\] All of the new languages that have come out recently - I'm talking about Nim, Rust, Crystal... What's the one I really like...?
+
+**Erik St. Martin:** Pony?
+
+**Brian Ketelsen:** Pony, thank you. All of the new languages that I've look at recently have this problem solved from the gate, and Go does not. And it's very frustrating to see these baby languages with much smaller adoption rates than Go have this problem completely solved. Now, I'm not saying that their solutions are perfect, but they're far better than what we have and they're built into the ecosystem already.
+
+Dependency management is a big deal, and repeatable builds is a big deal. I feel like we've been hung out to dry on it, and I think the community needs to come together and not create 30 solutions; I think the community needs to create one good solution, or Google needs to create that solution, or at least foster that solution.
+
+**Carlisia Thompson:** I was thinking the same thing, along those lines. The Go Language Team is part of the community, and it's sort of odd that there's a group of people working on a solution without any input or feedback from the Language Team. Are they aware that this is happening, or...?
+
+**Erik St. Martin:** Well, there's been a discussion with the Go Team surrounding vendoring, but I think that they were... I think that their opinion/standpoint has been that it's not part of the language itself, it's part of the ecosystem. I think that's why they've stayed mostly out of it, but I think that there was obvious pain points, that Go path munging for most of these tools, and I think that's why they wanted to step in and try to provide support there.
+
+I think that the Go Team is probably overwhelmed with stuff, and this is probably the least of their worries, which sounds bad to say. Maybe I'll get the beatdown from Brian for saying that. \[laughter\]
+
+**Brian Ketelsen:** No, I don't disagree. I think they have a million things to do. I just think that as a community we need to come together and solve this sooner rather than later, before it really starts to dampen the adoption that Go is getting now. Because I think Go has great traction, and it will only get better when we can prove to the rest of the world that we understand repeatable builds and dependency management.
+
+**Erik St. Martin:** Agreed. I think as a community we need to... I think we're just to used to everybody pointing the fingers towards the Go Team like they need to solve it. I think that's not the whole nature of the open source community either.
+
+**Brian Ketelsen:** No, and we all recognize that the Go Team is a small group of people in Google that are generally working for Google's best interests, but graciously sharing the Go programming language with the rest of us, and nobody faults them - at least I hope nobody faults them for taking care of Google first. That's not what I'm saying, by any stretch. I just think it's something that, as a group, the community needs to solve really soon.
+
+**Ed Muller:** \[12:12\] I can't really put words in the Go Team's mouth... I think I understand some of their motivations. I also think they don't run into some of the same problems internally using Go that other companies do, that don't have the Go Team down the hall, or in the lunch cafeteria, or things like that.
+
+But one thing I would say is if you are somebody who is frustrated by vendor, please don't make your own tool; we have enough of them. Find another tool.
+
+**Erik St. Martin:** +1...
+
+**Ed Muller:** Read that codebase. Submit PRs. Fix problems. It doesn't have to be Godep. Godep is far, far, far from perfect. But pick one of them and back a horse. Don't worry if you're not right in the end; I don't know if there's a right or wrong... But yeah, please don't make your own.
+
+**Carlisia Thompson:** Ed, I don't remember if you said the name of the channel where this conversation is happening...
+
+**Ed Muller:** It's called \#vendor in Gopher Slack.
+
+**Erik St. Martin:** So you were talking about how the 20% is still left unsolved. What do you see as some of those issues that still need to be figured out?
+
+**Ed Muller:** I think the biggest thing that a lot of the tools punt down the road, Godep included, is actual upgrade... Like, actually helping the user upgrade their deps and manage versions. A lot of them don't tackle dependencies for libraries per se. The old adage - if there can be an old adage - in Go is, "A library should not vendor their dependencies", it should be up to the users of those libraries to do that. But that's hard when you get to testing, compatibility and things like that; we don't have a really good culture in Go of releasing software. It's like, "Well, you have an API and it's on master." That's the historical context, anyway.
+
+So there's not a lot of people - although it is gaining traction recently - for SemVer tags for different releases. That was one of the things I really wanted to ask in the survey, for instance.
+
+**Erik St. Martin:** So when you talk about semantic version, you're kind of talking in the spirit of, say, Bundler for Ruby, where you define your dependencies plus a specific version, or at least a major-minor release, or something along those lines?
+
+**Ed Muller:** I'm of the opinion that for libraries you absolutely need to specify some constraints on versions, especially over time. For your application, I am less interested in specifying specific versions and looking for the lock, because that's the only way to get truly repeatable builds. Also, I don't understand people who don't wanna check in vendor. I mean, I get it, but the person who did ops for many years is like, "But what happens when GitHub is down?"
+
+**Brian Ketelsen:** Exactly.
+
+**Ed Muller:** Or being DDoSed.
+
+**Erik St. Martin:** And some of the other stuff too is that I feel some of that stuff comes as part of the code review. When you get into bigger environments, there's no reason you shouldn't be auditing these libraries before using them, before you put them on your production systems where they have access to your data; you should know what that library does and you should know what changed when you pull in a new version. So as part of my code review, when I submit my new feature and I pulled in a new library or I upgraded it, you should be able to see a code review, or you should be able to see what changed, and to be able to speculate what kind of problems that may cause. I never got that not checking in vendor thing.
+
+**Ed Muller:** \[16:14\] Yeah, totally. Actually, it's been a topic of discussion with my other Heroki this week, a lot of which don't... Heroku is a big company at this point by startup standards, and we're part of an even bigger company, so there are people who do lots of Node and Python, Ruby... Pick a language, we have it somewhere, or an enthusiast for that language at Heroku. And it's interesting, because I got to talk to a bunch of Node people and they've actually heard rumblings in certain circles of Node where people are starting to decide, "Well, maybe we wanna check in vendor", which I was kind of like floored by.
+
+**Erik St. Martin:** Yeah, I'm not too familiar with the Node ecosystem. Is it typical for the way they package their stuff to not check in vendor?
+
+**Ed Muller:** That's my understanding. You run an npm install... Again, my knowledge of Node itself is probably about your level as well.
+
+**Erik St. Martin:** So in this whole left-pad thing - it probably helped with the check-in vendor thing.
+
+**Ed Muller:** That's a gentleman who removed all of his...
+
+**Erik St. Martin:** Yeah...
+
+**Ed Muller:** I think that's part of what helped motivate that.
+
+**Erik St. Martin:** Everything sounds good when everything's working, when the golden path works. It's beautiful.
+
+**Ed Muller:** Yeah, it's great. I mean... Other complaints I get for not checking in vendors are like, "Oh, it makes your gifs messy" and I'm like, "But those are your dependencies. They're running with your code, they are part of your code." I think it was Brian who said, "I wanna see those too during your code review. I'm gonna take a look at what's in there. I'm gonna ask you why did you upgrade that?"
+
+**Erik St. Martin:** And even for failures, right? Something changed and you don't understand why you're noticing a new failure in production. All you did was upgrade say one library and make one other minor change, right? You don't know what changed in the library to understand why now you're getting socket connection errors and stuff like that, right? You start looking for a hardware problem because you're like, "This library has always worked... What's going on with the system configuration?" or something like that, and you come to find out it's one line of code that changed in the library and you didn't notice that slight change in semantic version, like a patch version that broke something.
+
+**Brian Ketelsen:** Well, another core issue is that just the idea of semantic versioning isn't defined for Go, and I think it was Dave Cheney maybe a year ago who wanted to start off this whole process by saying, "Maybe the first thing that we need to do is define what's a minor patch in a Go library, what's a minor version bump, what's a major version bump in a Go library, what's the definition? An API break and change, a bug fix...?" and he didn't get a lot of traction; he got a lot of argument, but not a lot of traction. I think we've got some fundamental issues to talk about before we can even get to the depth of solving the problem. Most Go packages that I've seen aren't tagged with versions of any sort, much less semantic versions. We have a long way to go.
+
+**Ed Muller:** I'd like to introduce a data point in here from the survey. Of 2,221 responses, the question of "Do you tag releases using SemVer tags?", 41% say yes, and 58% say no.
+
+**Erik St. Martin:** So most people aren't versioning their libraries.
+
+**Ed Muller:** The vast majority aren't.
+
+**Carlisia Thompson:** \[19:53\] But let me see if I understand. Right now is there anything that we can do with those versionings? Because if it's no, I see the point of people not using it, and I think that more people would do it if there was a function for it.
+
+**Ed Muller:** It is a little bit of a chicken and the egg, because if the tools don't have the tags to use, then you're not necessarily gonna spend time working on those feature sets, and vice versa, if you don't have tools that use some of them, theoretically why should I bother? Which is another thing I'd like to point out about SemVer - this is something that I struggled with at first until I really realized that SemVer is a social contract, it's not a technology contract, realistically. Despite your best intention, a 1.2.1 to 1.2.2 - you can totally accidentally slip an API change in there, or make a horrible, breaking change. So there's nothing in SemVer that prevents you from doing that, but you've basically agreed through this contract to say "I'm not going to intentionally make any API breaking or functionality breaking changes between these minor revs.
+
+**Erik St. Martin:** It's similar to the Go 1 promise - it's social. They've agreed not to change the API.
+
+**Brian Ketelsen:** Well, it's social with teeth, though. There is a script that runs in all.bash that guarantees that there aren't any breaking changes to that Go 1 contract. So nothing's gonna get committed to master or tip without passing that test. I can't remember which of the new languages I saw recently, but there was one of them - I couldn't tell you which, because I like looking at languages - that very specifically had a tool that tested API contracts in your packages before it allowed you to commit, to tell you whether you had breaking changes in APIs, to help you and guide you towards better versioning. And that's something that we can absolutely support with all of the fantastic introspection tools we have in Go.
+
+**Ed Muller:** Yeah, my pie in the sky, perfect tool would use introspection to determine whether something is at least API compatible or not with the version you have, and then when it detects the change can say, "Here's my last known tagged version .matches. What are you using right now? Do you wanna continue upgrading or not? Here, make a choice." No tool does that though yet, but hopefully one day.
+
+**Erik St. Martin:** We've got Scott in the GoTime FM channel here getting all Inception on us. He said, "Your dependency management tool is another dependency." So what do we use to manage that dependency? \[laughter\]
+
+**Brian Ketelsen:** Who guards the custodians? What's the land key custodian? Who watches the watchers?
+
+**Erik St. Martin:** Right. Another question we had in Slack is "Why did these other languages get vendoring out of the gate right, and how?" I don't know if any of us have answers to that. I think it's similar to kind of Go started out of the gate with concurrency in mind, right? It's just that kind of nature where you approach the problem from a given perspective, right?
+
+**Brian Ketelsen:** \[23:48\] Well, I think especially the smaller languages and the more recent ones all feel the pain that we as an industry have been kind of growing into over the last couple years and wisely knew out of the gate if they didn't have a solution to this there would be an issue, and maybe some of them have even learned from Go specifically. I think Go didn't have one at the beginning because Google uses a monorepo. They don't need one. And this was a tool for Google.
+
+**Ed Muller:** Yeah, if you can make a Go path... I mean, if you're gonna check in an entire Go workspace, then you just check out your stuff and commit them; you don't need it. What's there is there, and what's used is used, and it's tracked.
+
+**Erik St. Martin:** Alright, I think we're about halfway through the episode. I'm sure we probably don't wanna talk dependency management the whole thing - we probably could, theoretically, but do we want to?
+
+**Brian Ketelsen:** My blood pressure's going up. This is not good.
+
+**Erik St. Martin:** I do wanna hear about Go Heroku though, if you don't mind chatting with us about that for a few... Both in support for Go and Heroku's own internal usage of Go.
+
+**Ed Muller:** So, support of Go - Go has been unofficially supported for a very long time. Keith Rarick, a former engineer, wrote the Buildpack, wrote Godep initially, at least partially, so that he could run his Go code on Heroku. That Buildpack eventually became what we have now.
+
+Last year I was given an opportunity inside to help make Go a formally supported language. What that means is if you file a support ticket and you have a Go application, myself and others can help you with that application, other than going "That's not a supported language. Have you read the docs? Is it something with the platform?" Support can then help you. But if it's a supported language, we can go a bit deeper and actually take a look at your application and make better recommendations about what's either wrong or right, or things like that. Along with that comes documentation in dev center, paying for my salary, things like that. That's been really cool.
+
+**Erik St. Martin:** Do you have a lot of Go customers?
+
+**Ed Muller:** It's actually the smallest percentage language of overall revenue or even active users, but it is growing faster than most, except for Node.
+
+**Erik St. Martin:** That's interesting.
+
+**Brian Ketelsen:** Do you think that's based on Heroku's position in the market? It seems like Heroku's biggest customer-facing feature is writing websites or delivering websites, as opposed to deeper service-type things. And websites really aren't the biggest strength of Go.
+
+**Ed Muller:** No, they're not. Most of our Go customers are writing API services; that's the code they deploy. They don't write a website, or the Go version of a Rails app, or anything like that. They also are commonly doing it in conjunction with other Heroku apps that are written in Ruby or something else, and they needed to get performance in some portion of the app. A worker, an API backend, things like that. High concurrency, low latency.
+
+**Erik St. Martin:** Okay, so customers are kind of moving more polyglot, where they're kind of augmenting their Rails apps with more Go apps, more than it is customers deploying sole Go apps.
+
+**Ed Muller:** As a general rule yes, but not exclusively.
+
+**Erik St. Martin:** \[27:59\] That's interesting. Sorry, I cut you off when you were going off onto the internal usage of... I was just kind of curious about the growth of Go customers.
+
+**Ed Muller:** It's been good, it's been steady. My job is partially to help continue that growth, not only just in Heroku, but also just - well, making sure that Heroku's a good place to run Go apps. So if anybody here is listening to this and you would like to use Heroku for deploying a Go app but you don't, for some reason, please let me know. Because I want you to. I think Heroku's a great place to run applications. That's why I work here.
+
+**Brian Ketelsen:** I'm happy to give Heroku a glowing recommendation. We run a big web app plus API at Heroku at my day job, and it is just fantastic support, great service, everything works wonderfully, and it's so nice to be able to use that Heroku CLI tool to get logs immediately, roll back, deploys are a dream. So go use Heroku, there's no reason not to.
+
+**Ed Muller:** That's a great review.
+
+**Brian Ketelsen:** 100% Go. I'm here for you, man.
+
+**Ed Muller:** Cool. Inside of Heroku... Large portions of the platform have actually been somewhat rewritten in Go. For instance, if you git push Heroku Master, the Git server behind that is written in Go, the thing that actually executes your slug-building. So that's what you see when you see language detected Go and then the compilation process - that's been recently rewritten as a Go process.
+
+All logs from dynos are moved to the log router, which is still written in Erlang, but that process that actually handles the batching and delivery, that's Go. Portions of our new private spaces offering, which is basically Heroku in a VPC - not your VPC that you bring to us, but a VPC that we create for you on Amazon; large portions of that are written in Go. We have some API work being done in Go. All system metrics are extracted off of instances using a Go tool. I've been instrumental in some of those, and not so much in others.
+
+If you're a fan of our dashboard metrics, that's Go. The backend for that is all Go, the front end is obviously Node and other frontend technologies.
+
+**Carlisia Thompson:** Do you have more...? Continue please, I don't wanna interrupt.
+
+**Ed Muller:** No, I was trying to think of what else... I feel like I'm missing some important parts, but...
+
+**Erik St. Martin:** That's all? \[laughter\]
+
+**Carlisia Thompson:** What I wanted to ask is are these rewrites, or majority rewrites, or majority new things...?
+
+**Ed Muller:** It's a mix; I'd probably say 60/40 rewrites, because for instance git push Heroku Master, that was a combination I think of some Twisted evented code at some point. If you're not familiar with Twisted, it's a Python thing, plus some other stuff.
+
+The slug builder portion was Ruby; all of API was just Ruby at one point. System metrics, I think we used Collecti at one point. The log processes, that's new; the metrics stuff, that's new. Some of the stuff they're doing in APIs, not necessarily rewrite, but new functionality that they're kind of slotting in unbeknownst to users. So it's a little bit of both.
+
+**Carlisia Thompson:** \[32:15\] I have a sense that the whole internet is being rewritten in Go.
+
+**Ed Muller:** If it were up to me, +1... \[laughter\] But as I said though, Heroku is a place - we call ourselves Heroki, so if I've said that already, you understand what I am talking about. You'll find somebody at Heroku who likes any language that's probably out there right now.
+
+**Erik St. Martin:** Challenge accepted.
+
+**Ed Muller:** Heroku has a champion for it. We have contributors to Crystal who work here.
+
+**Brian Ketelsen:** Crystal looks pretty awesome, by the way. We need to have an episode just on all these new languages, because I love them.
+
+**Ed Muller:** Yeah, there's some interesting things about a lot of these. Crystal I've probably looked at more than anything, but that's mainly because I was a Ruby person for a number years. But yeah, some of these other languages are looking pretty good, too.
+
+**Brian Ketelsen:** While we're talking about Go at Heroku, we can't forget Doozer.
+
+**Erik St. Martin:** That's right.
+
+**Ed Muller:** Yeah... So that was actually never used in production at Heroku.
+
+**Brian Ketelsen:** It was used in production elsewhere. \[laughter\]
+
+**Ed Muller:** Yes it was.
+
+**Carlisia Thompson:** What are you talking about?
+
+**Brian Ketelsen:** Doozer. Doozer was a spiritual predecessor to etcd, for example, or Zookeeper. It was a Go implementation of a distributed coordination system.
+
+**Erik St. Martin:** ...and with an implementation of Paxos distributed consensus protocol. That was one of the first distributed consensus systems Brian and I started using in the Go space. This is before etcd and Consul and all that good stuff.
+
+**Ed Muller:** I believe it's before Go One was even out.
+
+**Erik St. Martin:** Yeah, it was pretty early on. And I learned some of my Go idioms and anti-patterns from that codebase, too.
+
+**Ed Muller:** What's one anti-pattern that you learned from that codebase?
+
+**Erik St. Martin:** I believe that was one of the ones that was using channels for state.
+
+**Brian Ketelsen:** Yeah, and Doozer specifically - if I remember - had one great, big, giant select in the main processing loop, and that was definitely a big anti-pattern, too.
+
+**Erik St. Martin:** I could be wrong, but that seems like one of the earlier projects that I played with and started digging around looking for patterns. I could be wrong about that one, but I think that that's the one that I'm thinking of, Brian; it's that big select. It could be a completely different codebase, too. This was years ago now. So is Doozer still around?
+
+**Brian Ketelsen:** Doozer's still around. I'm a maintainer still.
+
+**Erik St. Martin:** Is anybody using it, though?
+
+**Brian Ketelsen:** I don't know about that.
+
+**Ed Muller:** Wasn't Adobe using it at some point for something?
+
+**Erik St. Martin:** There was a couple people that were using it back then. I can't think of who they were now, but yeah...
+
+**Brian Ketelsen:** I think Bit.ly even used it for a while, but I don't know if they still are. Good question.
+
+**Erik St. Martin:** I still can't believe that somebody took it... Who did the Paxos implementation? Because I don't know whether I have the courage to do something like that.
+
+**Brian Ketelsen:** It was Blake and Keith, I think.
+
+**Ed Muller:** Yeah, I think it was Blake Mizerany and Keith Rarick.
+
+**Erik St. Martin:** I don't even have the courage to try and implement Paxos.
+
+**Brian Ketelsen:** It's awesome. I learned so much from that codebase. That was definitely the biggest project I had ever seen in Go at the time, and even though Keith and Blake today still say that there are things that they would do differently, there are things that might not be idiomatic, the vast majority of it was really great Go code, and I learned a ton. I'm very grateful that it existed.
+
+**Erik St. Martin:** \[36:04\] I mean, let's be fair, too. That was 2011-2012, so a lot of people use channels for a lot of things. I think we're all still figuring it out as a community what the patterns were.
+
+**Brian Ketelsen:** How can you declare idiomatic if it's only been around for a little bit?
+
+**Erik St. Martin:** Right. So we can call things idiomatic or anti-patterns now, but we're referring in the past, when they weren't necessarily then, so... Yeah, that was probably one of the biggest and most complex projects that I had seen back then. It was inspiring, we used it for a lot of stuff.
+
+**Brian Ketelsen:** We did, and had a lot of fun with it, too. So we've covered the survey, we've covered... Oh, there is one question I had for you. I heard a rumor that the Heroku CLI tool isn't all Go anymore, that there's some hybrid, maybe Node in there. Is that correct?
+
+**Ed Muller:** The Heroku CLI is really 98% Node. Let me rephrase that. The target is for it to be about 98% Node. Right now the CLI is an amalgam of Go, Node and legacy Ruby. The Ruby bits are effectively being phased out for what is basically a Go bootstrapper that can easily be upgraded, that manages the Node parts. And I apologize to the primary maintainer of that if I've got any of that wrong, but that's my understanding of it.
+
+**Brian Ketelsen:** Interesting.
+
+**Ed Muller:** There is something called HK that we had done, it's probably still on our repo. It's not maintained anymore, but that is a implementation of the CLI. That is purely in Go. While I myself personally would have loved if either HK or a rewrite of the CLI were done in Go (purely GO), I still think it was a good decision probably from the popularity aspect and accessibility aspect to do the Node stuff.
+
+**Brian Ketelsen:** Well, realistically, if it's solving the business problem there's no point in changing it just for the sake of changing it.
+
+**Ed Muller:** Well, so Node runs much better cross-platform than Ruby does, and hence the deprecation of the legacy Ruby in portions of the CLI, and the necessity to rewrite those portions in something, and Node was chosen.
+
+**Brian Ketelsen:** Fair enough.
+
+**Erik St. Martin:** Damian is actually in the GoTime FM channel and he pointed out ActiveState was using Doozer.
+
+**Brian Ketelsen:** We can count on Damian, he's like a walking Wikipedia.
+
+**Erik St. Martin:** He is.
+
+**Brian Ketelsen:** Shout out, Damian. Everytime we have a question, Damian has the answer. And when he's sleeping, there's no answers in the GO world.
+
+**Ed Muller:** Sometimes I feel that way, too. \[laughter\]
+
+**Erik St. Martin:** And Reddit. They get all his news from Damian. \[laughter\]
+
+**Brian Ketelsen:** He's probably the biggest contributor on the Golang Reddit.
+
+**Ed Muller:** It wasn't me that submitted this State of Go survey to Reddit. I'm pretty sure it was Damian.
+
+**Erik St. Martin:** It happens. It's the same thing with all the GopherCon announcements. We whisper it somewhere in the universe, and Damian is like "I got this!"
+
+**Brian Ketelsen:** I got this! That's pretty awesome.
+
+**Erik St. Martin:** Alright, so do we wanna talk news and any interesting projects any of us have come across?
+
+**Brian Ketelsen:** I've got a huge one. I just found it yesterday - I think they just released it yesterday, the SourceGraph Editor. Has anybody seen that?
+
+**Erik St. Martin:** That looked cool.
+
+**Brian Ketelsen:** Oh my gosh! Now, I'm not recommending it for full, real-time, all the time use, but let me explain what it is and I'll tell you why it's awesome first. It's a plugin for Atom or Vim, one or the other editors...
+
+**Erik St. Martin:** Sub...
+
+**Ed Muller:** \[40:07\] Sublime. You're right, thank you. A plugin for Sublime and Vim that allows you to... Well, it opens a browser window and then navigates to the definition of the symbol that you're typing, as you're typing it. So if you start to type fmt.prin, it pops up fmt.printline and gives you the definition of it, plus five or six curated examples of it from open source projects. So it gives you this really awesome real-time second-screen information about the code that you're writing, with examples plus the regular go doc for it. It's real-time, it's just the tiniest bit slow. As you're typing, at least in Vim, it slows down Vim a little bit and it gets a little distracting, because that browser window is constantly flashing with different functions as you're changing positions to look at new symbols. But it's amazing. The technology behind it must be impressive, and I was blown away when I played with it. I haven't turned it off yet, I've been running it for a day, and I can honestly say that's a really useful tool.
+
+**Erik St. Martin:** So two things with that, right? One is Vim probably, because Vim's not so great at async yet, so it's probably having to do stuff synced with your typing, which is hard. But the second part is it's rave programming. Rave programming, Brian. Just embrace it. \[laughter\] Flashing screen...
+
+**Carlisia Thompson:** I wanna say we're gonna have Beyang on the show in three weeks from now.
+
+**Brian Ketelsen:** Oh, that's awesome. We'll have a lot to talk about there, because it's a really impressive tool. So that was the biggest news I saw this week, that tool. If you haven't checked it out, it's at sourcegraph.com/tools/editor. You can see the screencast that they've got embedded in that page. If that doesn't sell you on at least trying it, I'd be surprised.
+
+**Erik St. Martin:** Yeah, and I believe everything there is written in Go. At the very least almost all of it is written in Go, all of their products. They have an open source library too, for doing language detection and analysis on code in a generic way, too. That's really cool.
+
+**Brian Ketelsen:** Their whole team is very prolific in open source, too. It's a company founded in Go roots, that lives and thrives in the community, so a shout out to our friends at Sourcegraph. You guys rock!
+
+**Erik St. Martin:** And they blogged for us. Remember the live blog?
+
+**Brian Ketelsen:** Yeah, that's right.
+
+**Carlisia Thompson:** And they host a meetup in San Francisco. I don't know how often it is, but I went to one, it was pretty great. There were people from LinkedIn there speaking, and other people on the panel. It was pretty awesome.
+
+**Erik St. Martin:** I'm seeing the trail in GoTime FM. \[laughter\] You guys are distracting me.
+
+**Carlisia Thompson:** No, that was pretty amazing. I said his name and he popped into the channel.
+
+**Erik St. Martin:** I think Adam invited him in there.
+
+**Brian Ketelsen:** Beetlejuice, Beetlejuice, Beetlejuice!
+
+**Erik St. Martin:** So two things: first, there was this project somebody showed that's in IM GUI, like immediate mode user interface, which is basically like OpenGL with windows inside of it, and it's called EweyGewey. I love the name of it, too. But it's like the alpha of the alpha right now, but I thought it looked cool, especially thinking kind of like the embedded space, having GUI on embedded devices. So I'm gonna keep watching that to see how that comes along.
+
+\[44:01\] And then that spawned this discussion about cross-platform GUI type approaches in Go, and there was a bunch of stuff. I kind of mentioned CEF, which is the Chrome Embedded Framework, and somebody said no to please encourage people to contribute to this project called Gob. With Gob they're attempting to write a full web browser in Go, which is really cool. I don't have the time to contribute, so everybody else contribute so that we can have a full web browser written in Go.
+
+**Brian Ketelsen:** Interesting. What are they using for the user interface components?
+
+**Erik St. Martin:** I'm not sure, I didn't dig into it too much.
+
+**Brian Ketelsen:** Oh, Shiny. They're using the Experimental Shiny repo.
+
+**Erik St. Martin:** That's right, that's right, I did see that. I lied. 3 AM, 2 AM... Whatever time it was.
+
+**Brian Ketelsen:** As the days get closer to GopherCon, the sleep wanes and we become less and less coherent.
+
+**Carlisia Thompson:** Alright, my turn. My project today is Gogs. It's a self-hosted Git service. I think it's very cool because if you want to host your own Git service - of course, that's what it is for - it seems pretty solid. I love that it has tons of documentation; I always love to mention projects that are well-documented. And also the issue list is very well labeled. There is a variety of categories, and it seems they could use a lot of help. But I also thought it was interesting because I think it's a good codebase to dive in and learn from. The concept of a server or a service is very easy... I mean, we were talking about domain knowledge, right? I think it's something that we can come in with the little bits of domain knowledge and understand the bits and pieces.
+
+**Erik St. Martin:** Yeah, Gogs popped up maybe two years ago, something like that...?
+
+**Brian Ketelsen:** A year and a half, two years ago, yeah.
+
+**Erik St. Martin:** Yeah, it had a few features and it was really interesting. And it was like overnight. It started replicating almost all the features from Git. Or GitHub, rather.
+
+**Brian Ketelsen:** Yeah, so we had Gogs in production for our main code repository... What was that, two years ago, Erik? And it had zero complaints. It's a fantastic service, really simple to install and rock solid. No complaints at all, especially if you consider that it's a tiny codebase but they replicate the 80% of features from GitHub that you really need, but it's behind your own firewall. Very nice.
+
+**Carlisia Thompson:** Yeah, and Git service - GitHub or GitLab - is something that we use every day, so it will be interesting to look at how that can be implemented in Go. I found it interesting to dig around.
+
+**Erik St. Martin:** I think we lost Ed. Are you still there?
+
+**Ed Muller:** Yes, I am. Sorry, I turned on Mute for a second, I was trying to find something.
+
+**Erik St. Martin:** No worries at all. We thought you were as tired as we were.
+
+**Brian Ketelsen:** We had somebody in the GoTime FM channel in Slack, and I'm gonna butcher his name, I feel terrible, but it's Florin Patan - he mentioned the go get button Chrome extension. I actually installed that two weeks ago when he announced it originally, so that's another good one to shout out; we'll have to add that to our show notes. When you're on a GitHub repository, you can just push the little Gopher icon and it copies the go get URL into your buffer and you can just hit Paste in your command line and you'll have that go get command ready for you to do a go get. It's a tiny little tool, it's really handy; I use it constantly now since I've installed it. So a big shout.
+
+**Ed Muller:** \[48:03\] I'd like to shout out, it I may, to Heroku's open source Go project, some of which I've contributed to. If you take a look at our open source Go repositories on GitHub you'll see a bunch of stuff, and a lot of engineers who work there are also contributors to various things, and Go itself.
+
+**Erik St. Martin:** Yeah, Heroku has had a lot of involvement in the Go open source community for a number of years. It's one of the reasons why we're so happy to have you on the show.
+
+**Brian Ketelsen:** Yeah, it is. It's awesome.
+
+**Ed Muller:** You should just try to get Keith and those guys at some point, too. I'm honored to be on the show, but... man, did they have a big impact early on.
+
+**Carlisia Thompson:** And talking about involvement from Heroku, I wanted to also mention that Heroku is a big supporter of GoBridge, financially and otherwise, and Ed is as well. You have taught a GoBridge workshop in San Francisco, we're very grateful for that, so thank you.
+
+**Ed Muller:** Thanks for organizing GoBridge. I think it's an amazing organization, and I was more than happy to contribute my time.
+
+**Carlisia Thompson:** Thanks.
+
+**Brian Ketelsen:** That's a big GoTime FM hug right there.
+
+**Carlisia Thompson:** Yes, totally.
+
+**Brian Ketelsen:** Maybe we need to add a section at the end of the show. After \#FreeSoftwareFriday we add GoTime FM Hugs, I don't know... Let's toss that around a little bit; put it in the show notes, we'll think about it. \[laughter\]
+
+**Erik St. Martin:** And speaking of \#FreeSoftwareFriday - and I think we're about out of time too, so I think we're tracking good... At the end of every show we try to do a \#FreeSoftwareFriday where we give shout outs to more projects - because we've just been giving out shout outs - to projects we've been using, currently or in the past, that have made our lives easy. So who wants to go first?
+
+**Brian Ketelsen:** I'll start.. I found a tool three or four days ago from Dmitri Shuralyov...
+
+**Erik St. Martin:** Also known as shurcooL...
+
+**Brian Ketelsen:** Yeah, known as shurcooL, with a capital L.
+
+**Erik St. Martin:** That's the hard part, right? You know everybody by their handle. Florin, I know him as dlsniper. Anyway, continue...
+
+**Brian Ketelsen:** Yeah, it's okay. This tool is called git-branches, and it's just a tiny little command line tool that tells you the status of the branches of your Git repo - how far you are behind or ahead of master, and all of the different statuses of the remote branches, too. Really nifty tool, I've used it constantly since I've installed it. It's rare for me that those tiny little command line helpers stay in muscle memory beyond a day, and this one has. It's useful.
+
+**Carlisia Thompson:** Alright, so the project I want to mention today is Pachyderm. It was mentioned on the show that we're going to release later today, with Daniel Whitenack. He talked about Go and data science. This project is open source; I haven't used it, but I checked it out and again, it's another project that's super well documented. He has also very organized and very well labeled issues, and they also have issues for newbies, so it seems like a great project for people who want to start contributing to open source and to Go. It's very fascinating, and this is something that's fascinating me about Go, what's going on in the industry right now: basically it seems like it's a modern alternative to Hadoop, and just how people are reinventing solutions... So it's an alternative to Hadoop, but it's not an implementation of Hadoop in Go. They're using containers, they are using Go, and they're taking advantage of these contemporary technologies to reinvent the solutions in a much better way.
+
+Again, I haven't used it; this is from reading and from just general knowledge, but I think it's very, very interesting.
+
+**Ed Muller:** \[52:09\] I'm going to totally have to play with this.
+
+**Brian Ketelsen:** Yeah, I did play with it, but long ago, when it was much earlier, and it's a really nifty tool because it allows you to pipe the outputs of your containers. Each of the steps in your data pipeline is just a container that accepts input and sends output, so you get that Hadoop-like flow, but with containers with Docker. It's sleek. It really is nice.
+
+**Erik St. Martin:** It's been quite some time since I think I've played with it too, so it's probably about time for a refresh.
+
+**Ed Muller:** It sounds like they've basically - if that's the way it works, they've basically implemented something I've been noodling around in my head, using standard-in/standard-out type stuff between processes, and then just take care of the mechanism for moving that data around and orchestrating it.
+
+**Erik St. Martin:** So they just saved you a whole lot of development time.
+
+**Ed Muller:** Thank god.
+
+**Erik St. Martin:** \[laughs\] Did you have somebody you wanted to give a shout out to as well?
+
+**Ed Muller:** Yeah, I'm gonna actually give a shout out to - and I can't believe I'm gonna do this... The '90s me is gonna kick my ass, but Visual Studio Code, which is something from Microsoft. I really never thought that a GUI editor would get me out of using Vim, but it has, and I really like its Go support, as well. So a shout out to both Microsoft and Luke Hoban, who writes the Go plugin. He works at Microsoft as well. So that's my primary editor for code now anyway.
+
+**Brian Ketelsen:** Yeah, we've talked about Visual Studio Code a couple times, it is a really strong environment for Go development and the Go plugin is tight, including debugging with Delve on all three major platforms built-in.
+
+**Erik St. Martin:** Yeah, that's one of the things that makes me wanna play with it a lot, the Delve support. Like you said, I think it's a strong contender. I think there's a lot of people using Visual Studio in the Go world.
+
+**Ed Muller:** Well, it also does some stuff that the Sourcegraph editor does, right? As I'm typing fmt.print, it's showing me the signature. And I can even go to the definite - because that's on the standard library, I can actually jump to where that's defined and look at the source code right there.
+
+**Erik St. Martin:** Have you used Vim Go with Vim?
+
+**Ed Muller:** When I used Vim, so probably it was eight months ago that I last used Vim Go, which I understand you can do some of the similar things.
+
+**Erik St. Martin:** Yeah, it's got a lot of that stuff now, where you can jump to the definition and all that jazz.
+
+**Brian Ketelsen:** Visual Studio Code is significantly prettier, though. Tool tips with function definitions when you hover over a function call... I'm not gonna lie, it's sexy.
+
+**Carlisia Thompson:** And there's that Go Doc Tool that I talked about I think in the second episode, or I forgot which episode. That does the same thing. It will jump to the code source...
+
+**Ed Muller:** Are you talking Pythia?
+
+**Carlisia Thompson:** No, it's called Go Doc.
+
+**Erik St. Martin:** Oh yeah, I know what you're talking about now, too. I can't remember... Yeah, you did mention it in a prior episode.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Now we're gonna have to go through show notes to find what it is.
+
+**Brian Ketelsen:** The name was something like Go Doc Tool, though. It was not a memorable name, it was kind of a generic name, so I think you're right. Something like Go Doc Tool.
+
+**Carlisia Thompson:** \[55:48\] Yes. And I wanted to say, we have such deeply rooted perceptions, rights? When Ed put the link to Visual Studio Code on the document, I had to actually go and check if it was open source, because I was gonna say "Ed, this is not open source." I didn't know... So today I learned it's open source, and I couldn't believe it.
+
+**Ed Muller:** Yes, if you write in TypeScript, you can contribute.
+
+**Brian Ketelsen:** Well, there's another show that we could probably do, entirely on Microsoft turning the ship around.
+
+**Erik St. Martin:** Yeah, that's what I was gonna say - Microsoft today is not the same '90s Microsoft.
+
+**Brian Ketelsen:** Because they're crushing it. If you're listening, Microsoft, you're turning the ship around and we appreciate it.
+
+**Erik St. Martin:** So for me, I'm gonna cheat, because we've been talking data science and all that jazz, and I'm kind of currently using it - Apache Kafka, which is a distributed message queue and publish-subscribe system, which I'm sure many of us are already familiar with. It's saved our lives more than once, I'm sure Brian can agree.
+
+**Brian Ketelsen:** Kafka's awesome!
+
+**Erik St. Martin:** Especially when you have to do multiple databases, using it is kind of like your distributed commit log, and then having your other databases populate from there. So much win. And I think that's it. Anybody...? Good?
+
+**Brian Ketelsen:** Good.
+
+**Erik St. Martin:** Alright. I think that we're right about on time to close this thing out. I wanna thank everybody for coming on the show, and I especially wanna thank Ed for coming on the show, and Heroku, for all that they do with the Go world. I know you guys support the GoBridge efforts, I know you guys are sponsoring GopherCon, you've been contributing to the open source space for Go for a very long time, so we wanna thank you for that. We wanna thank all the listeners, both live and who will be listening to this shortly. Next week we are out, both Carlisia and Brian have to travel for some reason. Like, they have lives, or something. \[laughter\]
+
+**Brian Ketelsen:** No, this is a big deal. We're gonna be at the Women Who Go first birthday party in San Francisco.
+
+**Erik St. Martin:** Oh, that's right, that's right. Alright, I can't give you too much slack for that then.
+
+**Carlisia Thompson:** And I wanna mention that it's open to everybody, so if you are in San Francisco sign up on the Meetup page. I'll post the link on the Slack, and maybe Adam can tweet it. It's open to everybody, men and women, and anybody... Non-binary people, everybody. Just show up. Some really cool people are gonna be there, I'm just saying.
+
+**Brian Ketelsen:** I'm excited to go. Women Who Go is a great group, and I'm happy to go help them celebrate their first birthday.
+
+**Ed Muller:** Maybe I can get a cheap flight down.
+
+**Carlisia Thompson:** Please! Go!
+
+**Erik St. Martin:** So we're out next week, but the following week we will be back and we will have Jessie Frazelle on the call. Or show. I keep calling it a call, it's a show. So we'll have her on the show when we get back, and then after that we have I think Beyang Liu?
+
+**Carlisia Thompson:** Yes.
+
+**Erik St. Martin:** So almost in line with us talking about the new Sourcegraph tool today. Yeah, so if you haven't subscribed already, GoTime FM is the easiest way to do that. We are now on both Google Play Store and iTunes, I believe. More episodes will be dropping if you're listening to this live right now. I think episode four drops today, and then five and six over the next couple of days. We're slowly getting caught up. We are on Twitter @GoTimeFM, we are GoTimeFM in Slack if you want to be on for the live stuff, and I think that's it. Yeah, GitHub - github.com/GoTimeFM/ping for suggestions for speakers or comments about the show and all that stuff. Thanks again, Ed, for coming on the show. It's been great having you on the call.
+
+**Ed Muller:** Thanks for having me, it's been great being here.
+
+**Erik St. Martin:** Alright, everybody.
+
+**Ed Muller:** Thanks Ed, great show.
+
+**Carlisia Thompson:** This was fun. Bye, everybody.
+
+**Ed Muller:** Bye-bye, everyone.

Teaching and Learning Go_transcript.txt

@@ -0,0 +1,339 @@
+**Brian Ketelsen:** Okay, we're back. Today we have guest Todd McLeod joining us, and we'll be talking about a lot of exciting events in the Go community. Why don't we start off with you introducing yourself, Todd? Tell us who you are and what you've been doing in the Go community?
+
+**Todd McLeod:** Yeah, great. I'm really glad to be here, I'm super excited to share my experience with Go and some of the things I've learned about Go. I'm a tenured faculty at Fresno City College in CIT and I'm also adjunct faculty at California State University Fresno in Computer Science, which is a bit of surprise... I didn't know that this was where my career was gonna end up, because I studied economics and I studied business, I got my MBA, and then I was hired by the college to teach accounting, started for them in 2000, and I had a real knack for computers. So in 2001 they moved me over into the tech side, doing some basic computer stuff, HTML, CSS, ColdFusion, and then slowly I just kind of evolved into more and more coding.
+
+I really love to code, I like the creative process behind it. I feel like I have an artist's soul, and being able to create things, bringing together the left mind and the right mind, the engineering, the science... The precision of programming, but also being able to build something - I love that.
+In 2013 my job duties had shifted at the university and the college in 2005, and I was put in charge of online education, and I basically started this institute to teach all of the college university professors in Central California how to teach online, because I'd been teaching online since 1997; I really embraced the web early. So from 2005 to 2013 I did no programming. I was in the programming game, and then I was out of it - cold out of it. My job is an entirely different description.
+
+That kind of wound down in 2013 and they were like, "Well, do you wanna jump back into coding?" I was like "Yeah, okay... So what server-side language should I use now?" and "Do people still use Dreamweaver?" \[laughter\] and my colleague just shook her head... She was like, "Oh, god... You've got a lot to learn!"
+
+I started looking around at different server-side languages, like "Hey, what JSP, ASP...? Dang, we can't use ColdFusion? I knew that one! PHP... Right? Or do we wanna go with Ruby, or Node, or Python...?" and then I had a student who I'd trained back in the early 2000s who'd become an awesome JavaScript engineer - Aaron Roberson, shout out to... Shout out to Nike - he's up at Nike now, one of their engineers. And Aaron's like, "Dude, you gotta check out Go." I was like "Go? What's Go?" He's like, "Go is like the zen perfection of programming." I'm like, "Okay, I'm interested. Tell me more about Go" and he's like, "It was built by the masters..." I'm like, "What do you mean?" He's like, "Google built Go. They hired the heaviest hitters in the industry and they put some of the greatest minds to work." I'm like, "Who? Who are the greatest minds?" "Rob Pike, Robert Griesemer, Ken Thomson..." The same people who created the C programming language, UNIX, UTF-8, they created the language because all the languages in the world weren't making Google happy, and so Google said, "Let's build a new language."
+
+\[04:09\] So they hired these guys who helped create C, helped create UNIX, helped create UTF-8 and they created this new language, Go. "You gotta check that out. It's built to do what Google does."
+
+So when I heard that, I was like, "Okay, you totally got my interest." The credentials sold me alone, so I just started really having to level my skill set up. It was just like late nights, late nights, late nights, 2013... Is this too much? Do you guys want me to keep rambling?
+
+**Brian Ketelsen:** No, ramble on!
+
+**Todd McLeod:** This is my intro, right? 2013, late nights, Pluralsight, Lynda.com, Udacity... I went through this crazy course on Udacity - Introduction to Computer Science. It's one of the hardest courses I've ever taken in my life. It started out, the first couple of videos were on YouTube, and there was like 65,000 views on the first modules of videos; when I got to module seven I was getting into videos that were like 12 views, 13 views... It's like 65,000 people started this course, and we're down to 12 people who've made it this far. And at the end of the course in Python we rebuilt the algorithm that Larry Page used to create Google; the basic crawler to index everything, and parse all the HTML.
+
+So it was a crazy intense course, taught myself Python online, taught myself Java, and then started picking up Go. Got some grant money, put some programs together...
+
+In 2014 December, that's when I started learning Go, and then in 2015, literally two-and-a-half weeks later I was teaching it at the university the first time through. It was kind of a laboratory project where all of the students and myself are trying to figure out "How do we do web dev with this language?" Then in 2015 in the summer, awesome experience - this incredible grant. Strong Workforce development grant, gave us $100,000 - crazy amount of money - to put together a boot camp to train people how to do web dev. So we took that hundred thousand dollars and I hired all of the people that I wanted to learn from. We flew them in, and for four weeks Caleb Doxsey kicked my butt. I have so much appreciation for him, because he was a merciless teacher. He took no mercy and he just plowed ahead and he gave me more material than I could assimilate, and he really gave an incredible foundation for myself and everybody in our region who was interested in web dev, how to do web dev with Go.
+
+Caleb really broke some incredible trail, and then we took all that which we learned from Caleb and we've just been teaching it at California State University Fresno and Fresno City College, and it's been an incredible experience just to be involved. I love the language. I love the fact -- to me it's a programmer's language. This isn't a Mickey Mouse language, this is for people who really know how to program, and you have to understand what's going on at all levels. If you're doing web dev with Go, you have to know the HTTP protocol, you have to know RFC 7230 and IETF. You have to know that every bunch of text is going back between the client and the server, it's formatted in a certain way. And you've got your start line, and then you have your headers, and then you have your body; you have to know the syntax of the status line and the request line, and be able to parse that and put together your own ServeMux. What is a ServeMux? First time I heard ServeMux mux I thought, "Man, are we talking about a dog here? What's a ServeMux?" But that's basically just another name for server, router...
+
+\[07:56\] Once you understand all that, using the net package, you can start to put together your own server and do all of your own routing without even having to rely upon what's available to you in the net/http package. But when you can do that, you understand the net/http package.
+
+I think Go is amazing. For web dev it's my first choice. I love it because of the performance. Another interesting anecdote - just to finish the ramble - is when I first started learning Go there weren't a lot of materials out there for web dev, but Go was really big quickly in China, because Go scales incredibly; Go does what Google does. So one of the books that I started reading was a book written -- I think the guy's name was \[unintelligible 00:08:38.01\]. He wrote that book in Chinese and then it got translated to English, so I was trying to learn Go web dev in a book that was basically Chinglish. I don't know if you know Chinglish, you can google it.
+
+It's been a fun experience, at times exhausting... Last night I was up 'till -- I mean, I saw Bill Kennedy tweet at like 3:30 my time, so he was just getting up, 6:30 East Coast time, and I was like, "Alright, Bill, talk to you in a couple hours..." I don't know, I've got a bit of that obsessive, intense, passionate focus. Like the artist soul - I get into something, I just love to get into it.
+
+I'm putting together this training now to do web dev with Go, taking everything that Caleb taught all of us, and everything we've learned through teaching it. I think we've done seven sections now at the university and college, so everything we've learned teaching at the university and college to graduate students in computer science, who get it really quick and are super fast, super sharp and wanna know even more, to first-year community college students who for whatever reason didn't make it into the four-year university and are just getting going with academia and studying and all that.
+
+Refining what we learned from Caleb and having taught it in these different environments, we've put together this really good, approachable - and that's the key word, approachable - code pathway for learning web dev with Go. Because I think for a language to be successful - and I really want Go to be successful because I don't wanna have to go learn another language - you have to make it practical. Like, "Hey, this has to get something done, it has to be really applicable" and if you study it as a student you can go out and you can get a job, but it also has to be approachable.
+I think one of the next big things that I'd love to see for the language is like a Tony Gaddis style book; Tony Gaddis is a famous programming textbook author in academia, who's done some really popular books on Java, C and stuff like that. So I'd love to see a Tony Gaddis style book, because I think another one of the things is when you start teaching it at the college and the university people learn that, and then they go out in the workplace and they wanna use it.
+
+It's really hard when you're already in the industry and you've got your day job, to then work all day, and if you're passionate you wanna just keep working around the clock at whatever you're doing... It's really hard to like, "Hey, I know Ruby, and I could get this knocked out in six weeks on Ruby, or I could take a year-and-a-half, or nine months and learn this new language and try to do it in that. Ugh, let's just get it to market." So it's hard to switch once you're out.
+
+I think the language could really use a big foothold in academia, and I'm happy to be able to help with that. I'm happy to help bring it along and enjoy it. I also like the venture of cutting trails... So that's a little bit of my story, or a lot of my story. \[laughs\] Nice having all of you guys here, thanks for listening, we'll see you next week. \[laughter\] Did I take up a whole hour?
+
+**Carlisia Thompson:** Good job, Todd. With that said, bye everybody. \[laughs\]
+
+**Brian Ketelsen:** Yeah, but why don't we take a moment to introduce the rest of our show? \[laughs\] This is Brian Ketelsen, I'm sitting in for Erik St. Martin today, who's in an airport listening live... Hi, Erik, we miss you! And we've got Bill Kennedy in today...
+
+**Bill Kennedy:** \[12:04\] Hey, everybody!
+
+**Brian Ketelsen:** And Carlisia Pinto is joining us, as usual... And we're all excited to be here.
+
+**Todd McLeod:** You know, funny story - and I love having Bill on the conversation with us, because I was like, "I've gotta learn Go! I've been charged by my community to help shepherd young minds into programming, and I don't have a solid enough grasp on this language", so I went up and I took Bill's training. At the time it was called Hardcore Go - now it's Ultimate Go. I took Bill's training and I told Bill what was going on, and Bill just cracked up. He was like, "Wow, this is the craziest story I've ever heard!" But Bill was great, so I'm really excited to have you on the call here, Bill. I really appreciate Bill's training - great training... And how much Bill has helped me out to educate me, so that I can then go educate other people. He's been a really wonderful mentor and helping teach me and helping grow the community. Cool to have you here, Bill!
+
+**Bill Kennedy:** Yeah man, and I've got a lot of good questions for you... Because we're all trying to teach people right now at different levels, and you're getting people who have not even programmed before, right? Or by the time they're in one of your classes they've got some programming background...?
+
+**Todd McLeod:** No, a lot of people have never coded before. I put one course out there on Udemy and I tried to make that as approachable as possible. And truth be told, that's when I was learning the language, so I'd learned some new stuff; my background is econ and business, and some of the nuances of programming that ColdFusion had completely abstracted away, I'm like, "Oh, okay... So how do we do recursion?" That was stuff I'd been learning in the entire 2013 on, so I just wanted to teach everybody what I'd been through. That's my Udemy course. It's very approachable, and a lot of people first time in there.
+
+I think Go is a great first language, because it teaches programming fundamentals exceptionally. You have to know how to program to use it, and it also has a lot of room to grow. So it's not like some Mickey Mouse thing - Mickey Mouse is wonderful, but it's just a saying; my son loves Mickey Mouse... But it's not like some Mickey Mouse language where you're gonna hit a wall and you can't do anymore with it, or you're not actually learning what's happening. It's more low-level, so...
+
+**Bill Kennedy:** I love those Udemy videos that you've been doing. I catch them every once in a while, and what's amazing to me - and I'm really interested how you got into this - you'll talk and teach, and then suddenly you just start writing everything that you're doing, and you're jumping around, and then you're writing more... I'm always curious what happens to all these incredible notes that you're putting together.
+
+**Todd McLeod:** Oh, writing? What kind of writing? What do you mean?
+
+**Bill Kennedy:** You'll say something, and...
+
+**Todd McLeod:** In the video?
+
+**Bill Kennedy:** Yeah, in the videos. You're like writing a whole document; by the time you're done with the video, you've got like three pages of notes written down. I've seen that in a few videos, it's really interesting. **Todd McLeod:** That's the thing, man... I'm not quite sure where I'm doing that, but I'm glad it's cool and I'm glad you like it. I have a big writer in me. For a long time my hobby in the evenings before I had kids was just to write fiction, so... I've written like 40 novels; that blows me away.
+
+**Carlisia Thompson:** Let me translate to you - in a minute I'm gonna talk about that also, but let me translate to you where Bill is getting at - what Bill is getting at is are you writing a book about Go? That's what he wants to ask you.
+
+**Todd McLeod:** Oh, am I writing a book about Go?
+
+**Carlisia Thompson:** With all those notes...?
+
+**Todd McLeod:** I'm not. I'm not writing a book about Go. I love being able to connect with people. I kind of view it as -- anthropologically we've learned from each other in person; that's the vast amount of our history through evolution as humans. We learned talking to each other, so in my trainings I really love trying to... So much gets conveyed non-verbally. You can hear my voice, but if you can also see me, I think that that conveys a lot.
+
+\[16:14\] I just really love that medium of teaching where it's online, it's a course, you can see what I'm showing you on the screen, you get the nuances of my voice, I could school you a little bit and give you direction and tell you to do this exercise (Go do it! Go do it now! Just pause the video, do the exercise!) It's fun; personality comes through, you can see me...I really try to do that with all my courses.
+
+A lot of courses are just sort of a very narrated, reading a script, voiceover presentation or screencast. You can learn things from those, but it lacks that life and that vitality. I think that's again where that sort of artistic soul of mine comes in, where I love to create and think about the aesthetics of it, and what's the final product, what's the feel of it gonna be, and how do you convey something and have a good time and enjoy it, and also build all that into it?
+
+So I'm not writing a book right now, but check this out! When I do a course, like me last course on HTML and CSS -- because when I was teaching it and when I got back into it, I couldn't find any materials that taught it the way I thought it should be taught, and there's a lot of things that would... Like, "Let's jump really quickly into bootstrapping." It's like, "No, you should really understand the fundamentals of HTML and CSS before you jump into bootstrap." I know bootstrap gives you fast, quick results, but that comes at a price and is gonna catch up with you later.
+
+My last course that I created HTML and CSS, the outline (the outline!) for that course is 300 pages. So I'm not writing a book, but my courses are very thorough. Each lecture I'm documenting what I say, and what the points should be that you get from that lecture, so students can go back and Ctrl+F through it to find that one subject. Or they could skim it and see, "Oh, do I need to watch this video?"
+I just try to get people the tools they need to learn. That's my craft being an educator, how do I do it as well as possible and create the most beautiful and useful pieces of education material; like an architect might want - I want a beautiful and useful building... That kind of a deal, you know?
+
+**Brian Ketelsen:** That's awesome. We need to take our first sponsor break.
+
+**Break:** \[18:48\]
+
+**Carlisia Thompson:** Todd, you said that you don't like the idea of bootstrapping because you quickly reach a point where you don't know what you are doing because you don't have the foundation... Or maybe I'm interpreting more than what you said here, but I think that also has to do with what you said about Go being a real language. But I want to hear from you what you mean when you say that Go is a real language. What does that mean to you?
+
+**Todd McLeod:** Yeah, I really believe in minimalism and stripping things down and keeping everything as light as possible. Every line of code, you should know what it's doing and you should not have any extraneous code. If it's there and you're not using it, why is it there?
+
+That's actually one of the design practices, idioms of Go - you can't have a variable if you're not gonna use it; that's an error, right? And I love that about Go. It's similar for me in everything I approach, like in my house - I don't wanna have stuff around if I'm not using it. Pass it on, donate it, let somebody else use it.
+
+With HTML and CSS, I'm not a fan of frameworks and libraries. Yeah, they get a lot of things done for you quickly, and if you understand the fundamentals of HTML, CSS, JavaScript enough to be able to go in and know what they're doing, and tweak them and adjust them when you need to do that - fantastic, use them all day, because it's a tool and there's a place where you can apply it. But if you just learn bootstrap, if you just learn jQuery, and if you do that at the expense of learning HTML and CSS, or at the expense of learning JavaScript, then I think you've really missed - I strongly, firmly believe you've really missed - a super important layer in your educational foundation to be competent and skilled developing applications on the web.
+
+So if you look at metrics, and I'm really into building websites now, and we're putting together a website ourselves, which I'm very excited about, and performance is so key, it's such a key metric... When you look at studies on performance, like Amazon lowers their time by one hundred milliseconds and sales go up 1%, it's like, "Wow, people are super sensitive." Performance is really key, so the average size of a web page today - 2,200-2,400 kb, right? And the site we're building right now is 400-600 kb each page. So we're like one tenth, one-sixth the size of average sites. How do we do that? We don't have any jQuery, we don't have bootstrap, and when we want to put an image onto the page, we're not using Font Awesome. Because if you download Font Awesome, that's 100 kb. That's one twenty-fourth of your size budget for that page if you're trying to hit normal sizes today.
+Instead, we extract SVGs, run them through Illustrator, get that SVG and then stick that code in. That costs us maybe 7 kb, or 5 kb on that page for those images.
+
+\[23:56\] So just keeping things lean, and having complete control over your codebase, and a thorough understanding of your codebase - to me, that's what it means to be a craftsperson. This is very much a craft; it's the craft of building software. And just as somebody like a woodworker, they would know all the tools in the wood shop, and they would know the different characteristics of the different materials they work with. And when you first come into a craftsperson's workspace - like a woodworker's workspace - you might be like, "Holy cow, there's a lot to know about this craft! There's like a hundred different lays, or all these different little chisels and files, and where would you use each one and why, and which material would you choose for which situation...", but after time you become that craftsperson and you have that intimate knowledge of all of your tools and all of your materials, and you can really start to build beautiful, well-built, performant applications.
+
+So that's my approach - just to do things well. When I looked at server-side languages, different languages approach things in different ways, but Go seemed to me to be the one that was the most zen - coming back to that word, zen - and the one that is the most fundamental. You're working down at a low level and you understand everything that's going on. You're actually getting that request and parsing that text and you can build your own ServeMux if you want. A lot of that is abstracted away for you if you use the net/http package in the standard library. But you could grapple it, you could wrap your head around it and you could see what's happening there.
+
+I don't know if that answered your question, Carlisia, but being a programmer's language - and I don't have the depth of experience with Ruby, I never did any Ruby, but from what I've heard of Ruby, it's like there's a lot of magic. Also, from what I saw at Python and Django, it's like "Hey, put in a couple of lines of code, and KAPOW! in 15 minutes we have an entire CRUD application", and it's like, "Yeah, but what happened there?" How much ability do you have to customize it? Whereas if you learn web dev with Go, then you need to understand that the internet engineering task force are the people who put together the recommendations for how the internet and the web should be deployed and built, and they have these requests for comments, and there's been a variety of requests for comments in this entire history of how the web's been built, the 7230s up in there - those are the current ones - and then here are the specs, this is what happens... And then you could take that text that's coming in and you could work with it, pull out the pieces, pull out the method, pull out the route, and you make decisions based upon that, do a little conditional logic... That's what I mean about the programmer's language.
+
+Sometimes I say "Go suffers no fools!" Kind of like the Pirate Ride at Disneyland... \[laughter\] Deeeeead meeen teeell nooo taaaales! Goooo suuuuffers nooo fooools! Because I'll hit these walls where I'm like, "I have no idea what is happening there", and Go has humbled me so many times. It brought me to my knees with hours spent contemplating the simplest things. In retrospect, I look at them and I'm like "Okay, I get that now, I understand it. It's simple now", but at the time I'm like "What the heck is happening there with StripPrefix? How do I get StripPrefix to work and serve my files?" Hours spent on that...
+
+So it doesn't suffer fools. I mean, it's got \[unintelligible 00:27:42.12\] it's got a slice to bite. I mean, it gets down to all of your data structures and everything, and ... I just gotta ramble a little bit more about Go - this is one of the things I love about Go: innovation. Technology is about innovation, and for me - that's my perspective, but that's the heart and cornerstone of what programming technology is about.
+
+\[28:10\] A lot of people, as I've met people learning the language, they're like "How come it doesn't have generics? This isn't OOP... Where is the inheritance?" \[laughs\] I'm like, "You're a programmer! You create things that innovate. You need to innovate, too", and I feel like that's what they did with Go.
+
+They looked at, "Hey, this is how programming's evolved - spaghetti code, procedural, structured OOP"... They looked at research, like Tony Hoare's CSP, and then they said, "Let's integrate all that and do this new thing." When I first started to learn Go, people were like "Go's all about types. It's all about types." I'm like, "I don't understand that yet." But now I'm like, "Oh, it's totally all about types!" You create your own types. I can create my own type "hotdog" if I want, and the underlying type can be an int, and then I gotta attach a method to that. And interfaces...
+
+I feel like Go innovated and took programming and tried to bring it to the next level. Whatever name you might put on that, but from spaghetti to procedural structured OOP to the next evolution of coding. So it's a programmer's language and it suffers no fools, because you gotta know what's going on, and to really use it you have to understand a lot of the most important concepts of programming.
+
+**Carlisia Thompson:** I love the description that you gave. You threw a lot of concepts in there, and there's a lot we could unpack from what you said, but I think at the base of what you said, you're equating a real language with craftsmanship, and I agree with that. I think a lot of languages have so many options that you can throw at your code, and you spend a lot of time making decisions about things that at the end of the day are not really what's going to make your craft. And with Go, because it's so minimalistic and so simple, you start moving out of that and making a different type of decisions, but at the same time you are always thinking about tradeoffs.
+
+**Bill Kennedy:** Todd, you're day in and day out in the classroom with people at all skill levels, and one of the things where at least GoBridge is really focused on going into next year is how do we take people who have never programmed before and want to program and get them learning programming with Go? There's lots of challenges there, and I thought it would be awesome if you can help anybody who's listening who's really interested in doing training. What are some really positive things that we can do, and maybe the things that you've learned not to do when it comes to teaching Go, especially beginners?
+
+**Todd McLeod:** I love the adage of teaching that "the expert makes everything easy." Somebody who's super skilled with the language can, if they also have the ability to teach, and that's true with any subject. They could then convey difficult things simplistically. I feel like I'm just starting to hit stride with teaching the language, and being able to take all these concepts and in an hour I could lay out some really cool things for people...
+
+You know, the first thing that came to mind, Bill, is I did a presentation here at a little tech event we had in Fresno, and gave everybody an introduction in the language and I made a video about that on YouTube. We could put that video in the show links. If there's people out there who are interested in Go, you're wanting to start to learn go, you could check out that video on my YouTube channel, and in 45 minutes it lays out how you declare your variables, different ways to use the variables... It lays out all the basics, gets you up to declaring types, structs, aggregate data type that holds different types of data together in one data type, and methods, and interfaces, and polymorphism... That's all in like 40 minutes.
+
+\[32:23\] In terms of teaching people, like "Okay, GoBridge - we wanna reach out to people, disadvantaged populations also, and people who've had no experience with computers or maybe didn't grow up with a lot of access to computers...", I think that the next thing that comes to mind is reach them when they're young, if you can. There's research out there that shows there's a break point psychologically at age 13, and then again at age 25. After those break points it becomes harder and harder to learn a language, and that's just any language.
+
+**Bill Kennedy:** Let me interrupt you real quick, because this is kind of what I'm looking for. Natalie, who lives in Berlin, has been giving classes to beginner-beginners. One of the things that she's noticed - and these are the kind of things that we as people who wanna educate won't learn until we get into the classroom... One of the things she's noticed which I thought was fascinating is that people who are just starting out programming will not ask questions. She's got to almost directly ask that person, "Ask me a question, ask me a question!" before they will. Are you finding those types of things? How are you dealing with those? How can somebody who wants to get into this space, what are they gonna experience and how have you gotten around those types of issues?
+
+**Todd McLeod:** I think that that's a really key point to teaching anything, but a lot of people have difficulty asking questions. That, I think, is something that teachers need to be informed about - you really need to encourage your students, "Hey, ask questions!" That's your job as a student. If you knew everything, you'd be the teacher; but you don't, so you're the student. Once you know everything, you could be the teacher if you wanna be, and the way you learn everything is asking questions.
+
+I remember when I was in grad school I would ask questions, I would ask questions, I would ask questions, and professors would be like, "Okay, come see me in the office hour, because you're the only one with questions." Then, after class, people would be like, "Thank you so much for asking those questions, I don't get it either." I'm like, "Why weren't you asking questions then?"
+So it is hard for people to ask questions, and I think just bringing that human element and connecting with your students and creating that atmosphere where they feel comfortable, and where it's fine to not get it... There's a saying that I came up with one time, "The more I admit I don't know, the higher I go. The higher I go, the harder it becomes to admit I don't know." I don't know if it's an ego thing... It's a tough thing, but encouraging students to ask questions is a good one.
+
+**Brian Ketelsen:** I think that there is definitely a social factor in people not wanting to admit that there are things that they don't know, and I think it changes in different cultures, too. It's a lot stronger in the American culture from what I've seen, and there are definitely other cultures where people have a different approach to what they know and what they don't know.
+
+**Carlisia Thompson:** You know what, I'm going to risk and say it might be a universal thing, because I grew up in Brazil and my elementary, all the way up to high-school was done in Brazil. Like Todd, I was the one asking the questions all the time, sometimes up to the point of being a pain in the butt, and 90% of the class wasn't asking questions. It was always like this; I lived in different cities, it was always like this. So it might be normal... most people won't ask questions.
+
+**Todd McLeod:** \[36:06\] Alright, enough theory. Let's model it. Let's all start admitting what we don't know. \[laughter\] Right now.
+
+**Brian Ketelsen:** Well, I can tell you one way to figure out what you don't know - by using Backtrace, our second sponsor.
+
+**Break:** \[36:18\]
+
+**Carlisia Thompson:** Talking about beginners and teaching, I have a question for Todd that's more generic. I would like to know your opinion about whether kids should learn how to program early on? I will volunteer my opinion - I say usually kids should not be spending time programming early on. Maybe when they are early teens they could start learning, because I think kids should invest time in learning especially how to write. There is so much reasoning and logic that goes into writing, and programming is so much about reasoning and logic, and writing is so important for so many aspects of our lives, that I think you have to make time for programming and you have to cut time from somewhere.
+
+I'd much rather have kids spending extra time in writing, rather than programming. When they get to a point where they can assimilate things at a faster rate, which will be when they are older, they can pick up programming really quickly. People think that they need to get kids into programming early because it takes so long to learn programming - I don't agree with that. I think when you're ready, you learn fast. So what's your opinion on that? When your students come into your class, do they have a background in programming, do they start early? Do you see there is a difference? Who is better prepared to learn as far as you can tell?
+
+**Todd McLeod:** The students that I've seen that started programming really young, they did that because they had a passion for it. I haven't seen any tiger parents who are like, "I'm gonna make my kid program. He's gonna be the next \[unintelligible 00:39:02.05\] of programming." I haven't seen that in our community, but the kids who got into it because they were just passionate about it, if they got into it young, they are amazing. They speak that language like it's their native tongue.
+
+I think it's fantastic if kids could program before 13. I also think if we're gonna force certain subjects on students (reading, writing, arithmetic) I think coding needs to be in there. That needs to be your bread and butter. That's the new math, that's the way we do calculations for engineering tasks. Like yeah, you need to know some basics - multiplication, division, subtraction, addition, but beyond that you should just be coding, I think.
+
+**Brian Ketelsen:** \[39:48\] I'd rather see official logic, first. I'd rather have a formal training in real logic than programming first. I think programming is an extension to math and logic, so a good background in math and then logic and then programming would help programmers. I think one of the things that I stumbled with -- I was one of those kids that was programming at ten, and I didn't understand all of the concepts, so I fumbled through them. Had I had maybe more formal training in logic earlier, it might have been easier.
+
+**Todd McLeod:** Oh, cool.
+
+**Bill Kennedy:** When I think about teaching beginners, I'm always focused on what is that visual aspect to it? Because I feel if there isn't a visual aspect it's really hard, because everything's just abstracted. So how do you bring a visual aspect that is reasonable to that beginner programmer, so they can really see what they're doing, outside of writing to STDOUT?
+
+**Todd McLeod:** Yeah.
+
+**Brian Ketelsen:** This is kind of off-topic, but it just reminded me... I traded in my Mac on a Surface Book a month ago, and I've been on the road for an entire month with the Surface Book training, and it's been awesome, I really love it. But one of the things that really stood out for me as an exceptional reason to do this is that in the middle of the class when somebody asks me, "How does Kubernetes' networking work?" I stop what I'm doing, I open up the sketchbook and I draw on the screen a diagram of Kubernetes' network. The first time I did it, the entire class stood up with their cell phones and took a picture of the projector.
+
+**Todd McLeod:** That's awesome.
+
+**Brian Ketelsen:** I was blown away. I didn't realize just how much the ability to draw live on the screen would make a big difference. It's just a totally random thought, but it's part of that whole visual thing.
+
+**Todd McLeod:** Yeah, I like that.
+
+**Bill Kennedy:** And Todd, you know I live on the whiteboard in the classroom.
+
+**Todd McLeod:** Yeah.
+
+**Bill Kennedy:** Do you use a whiteboard in your classroom at all? How do you do that visual piece when you're in your classroom?
+
+**Todd McLeod:** Yeah, totally, I use a whiteboard. It depends upon what I'm trying to convey, but it's another tool at my disposal, so when the situation calls for it, I like the whiteboard. Also, I've just started for my online courses - instead of trying to photoshop something out and make a diagram, I just get a blank white piece of page, some colored pens, take a picture of it with my cell phone - good enough. I like that sketched out quality, it's nice. So it's kind of similar to you, Brian, where you're just sketching it out on your screen.
+
+**Brian Ketelsen:** Yeah, I find it really helps. I ended up doing it in every class this last month.
+
+**Carlisia Thompson:** And talking about your online courses, the Udemy course on Go that you have - first of all, I wanna say for everybody to hear, I have seen so many people comment on Slack, on Twitter that they learned Go by doing the Udemy course that you have, and that they loved it.
+
+**Todd McLeod:** That's cool.
+
+**Carlisia Thompson:** It's over and over and over again. I haven't taken the course yet, but it's definitely on my to-do list. Now, I wanted to ask you why do you think people rave about your course so much?
+
+**Todd McLeod:** I don't know, maybe because I'm a goofball. \[laughs\] For me it's kind of like just hanging out here with you guys. It's fun, I like talking, and I like sharing. For me, I approach it as... I hate the ivory tower of academia, and I hate that pretention and ostentation (or however you say that word). I like approachable, and I think we're all in this together; I know some things, so let me share them with you, and I know that all of you can and have -- Bill and Brian, I've learned from you guys... We all learn from each other. I just approach it in that way, and that's how I approach my classes. It's like, "Hey, let's have a good time and enjoy ourselves and figure this stuff out."
+
+\[44:00\] I think also it's the fact that I've been doing it since (gosh, man...) 1997. That's almost two decades. If you look at Malcolm Gladwell's theory of outliers, it takes 10,000 hours, or 4 hours a day for ten years to become an expert at something, and I definitely know that the way I teach today is really different than the way I taught when I started out. I think it's a skill, like anything, knowing how to present material and how to do oratory oration, public speaking in a way that's captivating and compelling. Pacing, changing the volume - which I've just done here to demonstrate it - and then speeding it up... All of that, as humans, we are designed to notice that which changes. If you can keep stimulating people, they keep paying attention. You do that in a variety of different little techniques that I don't even think about anymore, unless I stop and start talking about them.
+
+So I think that all has something to do with it.
+
+**Bill Kennedy:** Todd, I can also give you an answer to this because over the last three months -- in fact two days ago at the Vancouver Meetup somebody was glowing talking about your course and the videos. I'm seeing this more and more, and it's always this ridiculously positive, glowing experience. I ask people what they're getting out of the video, and I think it also kind of lends into some things that Natalie was sharing with me too with her experience. I think that when you're on that video teaching people, people are not threatened like you're this authority. You're able to give people that idea that you are with them, in the same boat, and you're gonna make mistakes, and you're gonna learn with them on this video, and I think it just completely relaxes people.
+In Natalie's experience, she's told me, in the classroom when she's made mistakes, it has sometimes really helped the entire class open up a little bit more because it's like, "She's not perfect, and neither are we." I think that's a huge aspect to your videos and how you approach teaching.
+
+**Todd McLeod:** Oh, nice.
+
+**Carlisia Thompson:** And we should mention that Todd's giving a coupon code for a discount for his Udemy course. The code is "gotime", so for listeners - you can definitely use that
+
+**Todd McLeod:** Yeah, and I also really believe in pay it forward, help the world... I only got to where I am because tons of people helped me out along the way. I think 'gotime' gives you access to my courses for $10, so if you can't afford that because you're in a third-world country where 10 USD is a month's wage or something, or you're just a student and you're eating Top Ramen, just send me a note on Twitter and I'll give you free access. Don't even think twice about it; I love to do that, I love to help people out, and it's awesome for me just to see... I truly believe education is one of the noblest of endeavors, and as somebody improves themselves, they're improving the world. Like Gandhi said, "Be the change." If you are that change, if you are making change in your life, if you're educating yourself, you are making the world a better place. And then once you have risen up, once you've lifted yourself up, you're now in a position to lift other people up.
+
+I'm a full believer in doing what I can to help others, and if you can't afford it just send me a note and I'll give you free access.
+
+**Brian Ketelsen:** We love that attitude. Bill and Erik and I feel the same way about the book that we wrote, and when people ask, we're always glad to help them have it without cost.
+
+**Carlisia Thompson:** I think Bill Kennedy gets paid every time he sends somebody a book, because he's always trying to push the book for free to people. \[laughter\]
+
+**Todd McLeod:** \[47:59\] Yeah, he gave my entire class his book. You know, that generous spirit always comes back. You can never have too many friends.
+
+**Bill Kennedy:** Actually, the royalties to the book, Brian, that goes back to Gopher Academy every year for the scholarship fund, right?
+
+**Brian Ketelsen:** Yeah, we split the royalties for the book between GoBridge and Gopher Academy, so none of us are making any money off the book anyway. \[laughs\] They help support the scholarship fund for GopherCon, they help support all of the GoBridge activities...
+
+**Todd McLeod:** Sounds great.
+
+**Brian Ketelsen:** So let's move to interesting Go news and projects. I'd like to start this off with something that's interesting but not perhaps awesome - the Reddit Golang Subreddit kerfuffle this week.
+
+**Carlisia Thompson:** Oh my god...
+
+**Brian Ketelsen:** ...started with the CEO of Reddit deleting things and editing posts, which I find absolutely an abomination. You should never ever change user's content. It's horrible, and I reacted very poorly by saying that Reddit was a "wretched hive of scum and villainy", the Ben Kenobi quote. A lot of people took that poorly... I would like to publicly apologize for mischaracterizing all of Reddit for just the tiny percentage of the world that's really a wretched hive of scum and villany. Most of the people on Reddit are really awesome, especially the Go Reddit, so this is my public apology for my gross overstatement of the issues on Reddit.
+
+**Carlisia Thompson:** I wanna say something about that - I saw so many well thought out and kind comments on that thread. People saying, "Let's have temperament. Let's really think this through. Do we really wanna delete Subreddit?" They had a really nice conversation, it was lovely to see.
+
+**Brian Ketelsen:** So on to more interesting news... Go 1.8 Beta 1 released today, raise your hand if you installed it. I already did. Can you see my hand?
+
+**Todd McLeod:** I'm installing it tonight.
+
+**Brian Ketelsen:** It is awesome. By awesome, I mean it didn't break anything, and the compiles are a little faster, and the code seems a little bit faster. Overall, awesome.
+
+**Bill Kennedy:** Cool! I'm kind of excited about two pieces of this update. The new profiling that you can get out of a tracing tool, and I'm really interested to see how the plugin stuff ends up working and being adopted, because some of that is a little -- we can get in a lot of trouble with a plugin, but it's also really interesting.
+
+**Brian Ketelsen:** I'm afraid of the plugins, honestly. One of the things I loved about Go was that it was static and there was no question at runtime what was going to be happening with your app. The whole idea of dynamically loading other code just opens a whole can of fear for me. I'm sure I'll get over it eventually...
+
+**Carlisia Thompson:** I wonder if you could block that from happening. Could you lock a code and say, "Hey, nothing external is going to plug into my code and run."
+
+**Brian Ketelsen:** You have to actually write code to dynamically load other plugins, so it's not gonna happen automatically or by mistake. It's not something that can happen implicitly, you have to explicitly make it happen. But it scares me a little bit, I'll be honest.
+
+I am very excited about all of the changes in the http package, graceful shutdowns, context everywhere, and the DB SQL package - holy cow! Almost every function in DB SQL now has an equivalent that takes a context as the first parameter, so we get awesome cancellations all throughout the database package...
+
+I don't even know what kind of speed they're taking over at the garbage collection team, but they must be living next to a math lab because all they do is make that damn garbage collector faster and faster and faster and faster. Kudos to them for working so hard to make garbage collection awesome.
+
+**Bill Kennedy:** \[52:05\] Brian, I'm sure you had the same thought I did reading through the 1.8 notes. All I thought about was, "Oh my god, we have a lot of work to do to update materials for teaching."
+
+**Brian Ketelsen:** Right? Yeah, so much! There's so many big changes, and the thing about the Go 1 compatibility guarantee is that that code that you wrote for Go 1 is still gonna work in 1.8. I love that. But I was actually thinking exactly the same thing this morning, or last night when I was reading those release notes - "God, I've got a lot of material to update."
+
+**Bill Kennedy:** Yeah, and context, because it's being used as much as it is, I think now becomes a really important topic for all of us to start teaching and teaching effectively, and making sure people aren't abusing the context as a generic bag of values and teaching cancellation properly.
+
+**Brian Ketelsen:** Yeah, I teach context now in day two or my three-day class. I bring it right in. I almost have to, it's so big in Go now.
+
+**Todd McLeod:** Yeah, I wanna come sit in on your guys' classes again, get a fresh take on all the material you're teaching. I like learning from you.
+
+**Carlisia Thompson:** Really looking forward to taking Brian's online class about... Is it web development the name of the class, Brian?
+
+**Brian Ketelsen:** Which one?
+
+**Carlisia Thompson:** The one that you're doing online.
+
+**Brian Ketelsen:** Well, which one? I'm doing a lot online. I've got one at the end of the month, Go for not-beginners... What's it called? Go Beyond The Basics. But it's not necessarily web.
+
+**Carlisia Thompson:** Yeah, that one. That's the one.
+
+**Brian Ketelsen:** You'd better hurry up and sign up, too. Last I heard, out of the 300 seats in that there were only 20 left, and it just opened yesterday.
+
+**Carlisia Thompson:** I need to find somebody to pay for me. \[laughter\]
+
+**Brian Ketelsen:** Well, I'm doing it again in January and February, so there'll be time to take it again.
+
+**Carlisia Thompson:** Yeah, I'm sure. I'll definitely take it.
+
+**Bill Kennedy:** Is that one of the classes through O'Reilly?
+
+**Brian Ketelsen:** That's an O'Reilly webinar. I don't know how their new pricing scheme works, but I think it's open for anybody who's a Safari Online member, or something like that. Some really ridiculously lower pricing for Safari people.
+
+**Carlisia Thompson:** Oh, I think I signed up for that and haven't canceled at work. \[laughs\]
+
+**Brian Ketelsen:** Yeah, check it out, because I think it makes a big difference.
+
+**Carlisia Thompson:** I'll check it out. Thanks for letting me know.
+
+**Brian Ketelsen:** And let's see... Oh, oh, oh! This one could not be more exciting. You know, when I get excited about Go packages, holy cow! Travis Jeffery - or Jeffery Travis, I'm not sure which, because they both sound like first names - is writing a Kafka implementation in Go, and I wish I had a dollar for every time I said, "I wish somebody would just rewrite Kafka in Go." Now, somebody's doing it. It's called jocko, it's at github.com/travisjeffery/jocko. It's nearly implemented; I think there's just a few bits left, and when I was talking to him on Twitter he said that the bits that were left were really just a weekend of work. I don't know what quality level it's at - I haven't tried it yet - but I'm so excited.
+
+It's completely client-compatible with Kafka, and there's nothing that makes me more excited than having Kafka without having to put a JVM on a machine somewhere. Crazy excited about Kafka rewritten in Go. Jocko is the name of that.
+
+**Bill Kennedy:** Are you using Kafka in anything that you're building now, or is it just...?
+
+**Brian Ketelsen:** I use Kafka everywhere I can. I probably said this on the show before, I think it's probably the most underrated technology of the last ten years. It's such an amazing tool for data storage and streaming... It's like Git, but for your data. It's amazing.
+
+**Todd McLeod:** Hm! Yeah, I'm gonna model that not knowing right here for all the other students out there. I experienced this at times when I listened to GoTime, but it's like, "Oh yeah, what is Kafka? I've never heard of it, never been exposed to it." So it's like GitHub, but for data.
+
+**Brian Ketelsen:** \[56:04\] Well, that's a poor way to say it, maybe I should have said it better. Kafka is a... Gosh, it's so difficult to describe. It's a distributed data store that processes streams that allows you to get to your data at different points in time. We use Kafka frequently as the source of truth for our data, and then other systems, like the databases, the queues and whatever, read from Kafka. That propagates the data throughout the system. So Kafka is the source of truth, and everything else reads from Kafka.
+
+Distributed log - thank you, Erik St. Martin for jumping in and telling me it's a distributed log. So it kind of allows you to have any client be able to come in that can say, "Start me at zero and give me all of the changes in the data." It's an amazing system... If you haven't played with Kafka yet, go check out the documentation. There's a steep conceptual curve to Kafka, so you need to dedicate some time to read it. But once I did that, I just could not love technology more than I love Kafka.
+
+**Bill Kennedy:** Hey guys, I'm in the middle of a training in Vancouver at Hootsuite and I gotta get out of here, but I really appreciate you letting me be on the show today. Todd, it was awesome to talk to you. Brian, Carlisia, we'll talk soon. Thank you guys again for letting me be a host today.
+
+**Carlisia Thompson:** Thanks a bunch, Bill.
+
+**Todd McLeod:** Yeah, good visiting, Bill.
+
+**Brian Ketelsen:** Take care, and tell the people at Hootsuite I don't hold it against them that they picked you instead of me. \[laughter\]
+
+**Todd McLeod:** I'm not even on the radar. \[laughter\]
+
+**Brian Ketelsen:** Take care! Alright, so let's move on to \#FreeSoftwareFriday, one of my favorite segments. Every week we try to give a shout out to an open source maintainer or a group that makes a project that you love. Sometimes not everybody has one, sometimes we have more than one, but today I'll start off with the surprise of the year, maybe the surprise of the decade... I'm gonna shout out to Microsoft, and Rich Turner and the whole team at the Windows Subsystem for Linux group, for replacing three computers on my desktop with just one.
+
+I am so excited about Windows Subsystem for Linux; I now run a Surface Book and Linux right on top of it. I don't need my Mac and my Linux and my Windows machine anymore to get all of the different jobs that I need to do. I don't even have a Mac anymore, so thank you to everybody at the WSL team for finally making 2016 the year of Linux on a desktop.
+
+**Carlisia Thompson:** You don't have a Mac? That's blasphemy.
+
+**Brian Ketelsen:** No, it's not. It's awesome. I gotta tell you, it's amazing.
+
+**Carlisia Thompson:** Oh my god!
+
+**Brian Ketelsen:** There's a handful of things that I miss from my Mac, but I've got Linux, and it's right there, and it's real Linux, and it works.
+
+**Todd McLeod:** Nice.
+
+**Carlisia Thompson:** I mean, I get it if you didn't have the Mac before and you just had Linux, but you had a Mac all this time and you just got rid of it.
+
+**Brian Ketelsen:** Yeah, I've written a couple blog posts about this. We probably don't have time on this show to go into why I switched, but absolutely I'm happy.
+
+**Carlisia Thompson:** Alright, give me the links. \[laughter\] Anyway... I'm gonna break the rule today and I'm not gonna give a shout out to software, I'm going to instead give a shout out to all the Go Meetup organizers. It so happened last night that I was with Erik here in San Diego because he was here for work. And I met up with him and also \[unintelligible 00:59:39.06\] who is the other Go Meetup organizer here in San Diego with me, and also Alex... But anyways, we were talking about meetups, and you know, it's such hard work; I talked to other organizers as well - it's such hard work, and it takes so much grit and really a desire to grow the community and help the community stay together.
+
+\[01:00:02.03\] I have a huge appreciation and I wanna give a shout out to everybody. Along the same lines, also I wanna say that I'm gonna be in the Boston area for Christmas, Go Patriots! And I would love to get together with the Meetup organizers there. I'm also gonna be in San Francisco in January and I'm hoping that the San Francisco Meetup is gonna happen on the week that I'm there. Meetups are awesome.
+
+**Todd McLeod:** Yeah, and I just would also like to chime in that if there's anything I could do for any of those meetups or any of the different groups around the world, if you wanna have me as a guest speaker and you're close to Fresno, or you just wanna videoconference me in to talk about Go or any of that stuff, feel free to reach out to me, Todd McLeod. Twitter is probably the easiest way to reach me, @todd\_mcleod. That link will be in the show notes, too.
+
+\#FreeSoftwareFriday - reflecting upon this, what free software do I use for which I'm appreciative, and when I started to reflect upon that question, I kind of just had this sense of amazement, because there's so much free software which I use, and I haven't really thought about it before. I had that amazement and gratitude, like "Oh my gosh, look at what humans have created!" There's so much which is out there. So many different things came to mind for me, but the big ones which often times go unnoticed and we just sort of take them for granted - I mentioned the IETF and the RFCs, and the entire web... \[laughs\] GoDoc.org - who made GoDoc.org? It has both the standard library and third-party packages. I use that every day. I love GoDoc.org.
+
+Or just the different packages that you can find in there that people have coded up. \[unintelligible 01:02:02.25\], Satori, Julien Schmidt - all of them in the last week. So I just have that sense of appreciation for the amount of free sharing and giving which goes on in the world, and just taking that moment to recognize it. So thank you, Brian, for coming up with that idea for \#FreeSoftwareFriday, because it was a really cool experience just to sort of step back and pause and be like, "Holy cow!" Yeah, there are a lot of people who are doing a lot of good, and just doing things to contribute to the greater commons of the world.
+
+**Brian Ketelsen:** Yeah, and by the way, GoDoc was Gary Byrd and he donated it to the Go Team two years ago, give or take, and we all use GoDoc so often, so thank you to him specifically.
+
+**Todd McLeod:** Yeah.
+
+**Brian Ketelsen:** So on that note, I'd like to thank everybody... Todd, thanks for coming in, Carlisia and Bill who's already departed, but thanks for stepping in for us today, Bill. Thanks to everybody who's listening out there, thanks to our dedicated Slack team in the GoTimeFM channel on the Gopher Slack, we couldn't have this much fun without you guys. Thank you to both Minio and Backtrace for being amazing companies and sponsors for us.
+
+We encourage you to share this show with all of your friends, and especially if they like Go or if you're trying to kind of nudge them towards Go - we might be able to help with that. An easy way to subscribe is to head to GoTime.fm and you can subscribe to our weekly email, which should be coming shortly. You can follow us on Twitter on @GoTimeFM, and if you have something that you wanna discuss on the show, or a guest you think we might want to bring on, head to github.com/gotimefm/ping.
+
+On that note, thanks everybody. We really appreciate this show, it was a fun one!
+
+**Todd McLeod:** Yeah, great fun, thank you!
+
+**Carlisia Thompson:** Bye!

The Go Compiler and Go 1.8_transcript.txt

@@ -0,0 +1,521 @@
+**Erik St. Martin:** It is episode \#27 of GoTime. Today on the show we have myself, Erik St. Martin, we have Carlisia Pinto...
+
+**Carlisia Thompson:** Hi there.
+
+**Erik St. Martin:** Brian Ketelsen is out today, and filling in for him today is Bill Kennedy. Say hello, Bill...
+
+**Bill Kennedy:** Hi, everybody.
+
+**Erik St. Martin:** And our special guest today actually taught us all how to make a lot of profit using maps at GopherCon. I'm still waiting for my check, but on the show today is Keith Randall from the Go team.
+
+**Keith Randall:** Hello, everybody.
+
+**Erik St. Martin:** Do you wanna give everybody a rundown - who you are, what you do specifically on the Go team?
+
+**Keith Randall:** Sure. I work on Go runtime internals and compilers. I work on making Go faster, all behind the scenes. You don't sort of see anything I do in APIs or anything like that, but every release we make things a little bit faster and a little bit less memory, and all-around better.
+
+**Erik St. Martin:** That's awesome. So you specifically work on the compiler and runtime?
+
+**Keith Randall:** Correct. I sort of started out working on Go, working on runtime things like maps, scheduler, some of the type conversion stuff and so on. More recently I've been working on compiler internals, making generated code better, smaller, that sort of thing.
+
+**Erik St. Martin:** That's awesome. Have you played a big role in SSA stuff that happened over the last couple of releases?
+
+**Keith Randall:** Yeah, so I started the SSA backend project, proposed it, got people on board with it and sort of was the tech lead for it. I wrote the first prototype and then got a bunch of other people both from inside Google and outside to help work on it. It was released in 1.7 for amd64. For this upcoming release, 1.8, it's gonna be available on all of the other architectures: arm, MIPS, PowerPC and so on. I think maybe even there's a SPARC one coming, I'm not sure whether that's gonna make 1.8.
+
+**Erik St. Martin:** Oh, nice.
+
+**Keith Randall:** Yeah, and the performance we get on x86, it was something like 20% better. It very much depends on the application, but we're getting on average about 20% better, mostly because the x86 chips are really good at executing bad code, so you really have to do a good job of making better code before you can see the performance improvements. We're getting something more like 40% better on ARM chips, which are not as good as hiding the old bad code. I think it turned out pretty well overall.
+
+**Erik St. Martin:** Yeah, and ARM needs the love even more, because ARM typically doesn't have the clock rate that an x86 chip does.
+
+**Keith Randall:** Right, absolutely.
+
+**Erik St. Martin:** Those performance improvements help a lot.
+
+**Keith Randall:** And the performance improvements help save power, too. That's also a big thing.
+
+**Erik St. Martin:** Yeah, that's true as well. We should probably circle back a little bit to when we talked about SSA and maybe give a brief explanation of what SSA is and why that benefits us to have the compiler leverage SSA.
+
+**Keith Randall:** Okay. I guess at first it'd help to describe what the old compiler was like. The old compiler used to take the abstract syntax tree of a Go program and would generate code sort of node-by-node on that syntax tree. If there was a plus, it would load both arguments into registers, do the plus and then store the result somewhere.
+
+\[04:02\] It would do that one at a time on the nodes of the syntax tree, with no look ahead, very little look behind... The code it generated wasn't very good, because there were a lot of moves you didn't need, there were a lot of operations that if you did that same add twice, it would execute that add twice instead of reusing the result.
+
+So SSA instead takes the abstract syntax tree and builds a control flow graph, and a value graph. And then we can do all sorts of optimizations on that graph, like common self-expression elimination, we can do bounds check elimination, we can do better scheduling, dead code elimination, all that sort of stuff - all of which benefit the generated code and make it better than what was generated previously straight from the abstract syntax tree.
+
+SSA compilers have been around for a while. I know I've worked on one 15 years ago, so it's a pretty mature compiler technology. GCC uses it, LLVM uses it... It's a pretty common compiler technology. This is not sort of a researchy thing; SSA is known to be a good way to generate code for compilers. We need to get Go up to speed so that we can compete with the other languages.
+
+**Bill Kennedy:** I've got a quick question, because I've always tried to visualize these things that are going on... So this piece is happening inside of the compiler; is this helping to generate that intermediate assembly? Is that kind of where this is? Where in the toolchain between the compiler, the assembler and the linker is all this sitting?
+
+**Keith Randall:** Fair enough. So when you start with Go code, there is a parser that basically takes that Go code and makes an internal in-memory representation of the abstract syntax tree. From there, SSA takes that abstract syntax tree and generates assembly code, that is actually sort of an in-memory representation of the assembly code. It's sort of semi already assembled, and then that gets passed to the linker and the code generator from there. Basically, the input is an abstract syntax tree and the output is an in-memory representation of assembly.
+
+**Erik St. Martin:** Okay, so this would actually be an IR... Bill and I were actually kind of having this debate before the show - the difference between an intermediate representation and an intermediate language. And the best I could come up with is that an intermediate language is actually produced code, whereas IR is typically in-memory data structure, but I could be completely wrong there, too.
+
+**Keith Randall:** Yeah, I don't think I've ever heard the term "intermediate code"...
+
+**Erik St. Martin:** Or intermediate language.
+
+**Keith Randall:** Yeah, or intermediate language... I don't know. It's a good question. So LLVM has something which maybe I would call an intermediate language; it's an actual textual representation of the IR.
+
+**Erik St. Martin:** Yeah, that was my interpretation of the difference between the two. I've always heard IR, and then Bill said IL this morning and I was like, "Hm..."
+
+**Bill Kennedy:** I think I got that from the .NET side of things over there... They have a whole intermediate language over there between what the C\# compiler is producing, if I remember...
+
+**Keith Randall:** Yeah, I believe it's like Java, they have some sort of bytecode thing, right?
+
+**Bill Kennedy:** Yeah. The SSA is really interesting, I was just always curious if it came before or after the assembler, or somewhere in between.
+
+**Keith Randall:** Yeah, so there's no assembler when that Go compiler runs; there's no assembler used.
+
+**Bill Kennedy:** Oh, okay.
+
+**Keith Randall:** The thing that's generated from the compiler is already essentially equivalent to what the assembler produces when it parses assembly.
+
+**Erik St. Martin:** Oh, interesting. So basically there's only a linker after that, right? There's no intermediate assembly stage.
+
+**Keith Randall:** Correct.
+
+**Erik St. Martin:** I think Rob Pike did a talk about that at GopherCon, where he was talking about the fact that there's a shared layer, there is an assembler, and there is the compiler, but there's like an object or some kind of library that's used between the two.
+
+**Keith Randall:** Right.
+
+**Erik St. Martin:** \[08:02\] It was a while ago that I saw the video. I didn't get to watch the talk while I was there, but I remember vaguely that there was no assembly stage in the compile process.
+
+**Keith Randall:** Right, we go directly from the compiler output... It generates something called the obj library; it generates basically one structure for every assembly instruction that tells you what the register inputs and the register outputs are. And then actual instruction selection, like encoding the bytes of the instruction, is done by that obj library. The compiler itself doesn't emit bytes; it emits these data structures one per assembly instruction.
+
+**Erik St. Martin:** Oh yeah, so it doesn't... Because in a typical approach the compiler would emit assembly instructions, and then those would then get turned into the actual machine code by the assembler. So you're saying that that obj library converts the IR directly into the machine instructions by using kind of internal data structures.
+
+**Keith Randall:** Exactly, yeah. So our assembler is really just the parser. It doesn't assemble in that sense. The obj library, which is part of the linker (sort of) is the thing that actually does instruction selection from the internal representation.
+
+**Erik St. Martin:** Interesting. I need to start playing with compiler internals. \[laughter\] It's a little below where I usually work, but it's really interesting. So looking at the changes -- and I know that a lot of the work that you guys have been doing has been making it easier to port to new architectures on the backend as far as the assembly and stuff goes, now what about the compiler backend itself? In theory, is it reusable, kind of like JRuby and Scala are built kind of on top of Java bytecode?
+
+**Keith Randall:** The new SSA backend is very easy to port. There's just a machine description file that has all the opcodes you wanna use, and a bunch of read/write rules that tell you how to get from machine independent IR to a machine-dependent IR.
+
+As far as the compiler itself, whether you can embed a compiler in some other program, it's not directly reusable, although it's certainly more reusable than the old compiler, and that's the direction we're heading - to get to the point where we could - if we wanted to - make the compiler a library.
+
+**Erik St. Martin:** I don't think I have a direct use case for that, but it's just interesting to kind of see these different languages build on top of things that other languages have done, and kind of leverage that stuff where there's shared resources, so if somebody wanted to make their own spinoff of Go that has some wanted feature, that not necessarily is gonna be brought into Go proper just yet because of the Go 1 compatibility guarantee or something - maybe they could do like a spinoff that has it in there, but leverage all the same compiler logic.
+
+**Keith Randall:** Yeah, that would be nice.
+
+**Bill Kennedy:** I was curious, we constantly talk about how fast the compiler is and how we're trying to bring it back down to that when it was written in C, but optimization's also really important, so how do you guys strike a balance about how much optimization the compilers do, as opposed to how much time that would take?
+
+**Keith Randall:** It's a good question. There is a tradeoff there, and at some point we're gonna have to say no - and we have said no - to optimizations that just would take too long otherwise... Like alias analysis; we haven't done any yet, and we're sort of scared to go down that route because it can be very expensive.
+
+\[11:42\] The original goal of the SSA compiler was we wanna make the compiler generate code that's better enough that the compiler gets no slower because we compile the compiler with the compiler. So we sort of wanna buy back all the extra time we're spending by making the compiler faster, and we didn't quite get there for x86; SSA added something like 30% or 40% to the running time of the compiler, what made the compiler 20% faster. So we sort of lost out on 10%-20%. But on ARM it totally works out; we get 40% back by compiling the compiler with the SSA backend, and then we spend 40% extra time, so the compiler is actually no slower with SSA backend than it used to be on ARM.
+
+**Erik St. Martin:** I always love how meta that is. \[laughter\]
+
+**Keith Randall:** It is very meta. It's hard to describe.
+
+**Bill Kennedy:** Are there optimizations that - I guess once all this SSA stuff is done - you'd like to see maybe going forward?
+
+**Keith Randall:** Sure. We got some of the major ones, like common self-expression, which are very important. There are ones that we could do that sort of are more domain specific. We could certainly improve our generation of floating-point code, for example. We could do a better job at bounds check elimination. We could do some simple alias analysis that would get rid of some variables that would otherwise have to be stored on the stack - we could put them in registers.
+
+There's things like that, but at some point we're gonna reach diminishing returns; it's not worth the extra effort of coding, it's not worth the extra runtime with the compiler to do those sorts of things. Then at some point we're gonna have to declare that we're done, or at least we're done unless someone comes up with new ideas.
+
+**Erik St. Martin:** There's always "more better."
+
+**Keith Randall:** That's true, yeah.
+
+**Erik St. Martin:** I think there's the fear that there's an end, but it's just like any goal in life - by the time you get anywhere close, you've drawn the line out further, right? There'll be something else that comes up and you're like, "We need to do that!"
+
+**Keith Randall:** That's true. And there's always people filing bugs, saying "Hey, my program is not as fast as I think it should be. You guys should fix this." I have a stack of them that I have to look at. So yeah, there will always be complaints; it's just a question of, you know, there's limited manpower and there's limited compiler running time, so you have to be judicious about what you attack.
+
+**Erik St. Martin:** Yeah, I guess that's the tradeoff, too. It's the same thing with the language. The whole thought process behind the language is how do we provide everybody what they need without providing them too much, and it's the same thing with the compiler. How do you do everything you need to do but without having slow build times.
+
+**Keith Randall:** Right.
+
+**Erik St. Martin:** Every time I have to compile a C or C++ app I wanna email all of you and thank you. \[laughter\] You forget, and then there's one day you have to work on something and build it and you're like, "Oh, this is so bad."
+
+**Keith Randall:** Yeah, I had to download LLVM at one point and build it and it took like two hours. Like, how is this possible? I mean, I'm sure there's some incremental thing which you could do better if you're a developer, but from scratch it took like two hours to build.
+
+**Erik St. Martin:** I remember doing this on processors less than a gigahertz. I remember upgrading GNOME or KDE back in the day, you'd let it run over night.
+
+**Keith Randall:** Yeah, I don't wanna go back to those days.
+
+**Erik St. Martin:** And the 56k modems... I don't wanna go back.
+
+**Keith Randall:** Our house at home just got upgraded from a 2 MBits connection to a 6MBits connection, as we live in the boonies and we're too far from the central office for anything good. But just the jump from 2 MBits to 6 MBits has been awesome.
+
+**Erik St. Martin:** It's like life-changing.
+
+**Keith Randall:** It is. Now more than one person can watch a video at a time in our house, so we're not hitting each other over the head whenever anyone else is doing anything that's ruining our videos.
+
+**Erik St. Martin:** It's not fighting over "Who can use the bathroom to brush their teeth first", it's "Who gets to watch their movie."
+
+**Keith Randall:** Yeah, exactly.
+
+**Erik St. Martin:** Like, "You watch cable, I get Netflix today!" So what's next for the compiler, what's exciting? What do you have planned for the next couple releases?
+
+**Keith Randall:** \[15:58\] Let's see... One of the big things that's coming - or will, if it works out - is we're gonna change the calling convention. Right now when you call a function everything gets passed on the stack in memory, and everything gets returned on the stack. That's pretty inefficient, but it makes things like walking the stack and finding all these GC routes and things like that very easy. So we're looking at passing values and registers and returning values and registers instead.
+
+It's sort of a big project. It's not terribly hard coding-wise to get the compiler to generate that code, but it has a lot of implications for the runtime and it has a lot of implications for... Like, everyone who's ever written assembly would have to change their assembly, so we're sort of looking at how we roll such a thing out to make it so that everyone doesn't have to rewrite all their stuff all at once. But we think it could buy another 10%-20% in runtime, so that's one big thing.
+
+**Erik St. Martin:** How much assembly would you say exists in the Go standard library and runtime?
+
+**Keith Randall:** The standard library might have 10,000 lines of assembly...
+
+**Erik St. Martin:** Wow.
+
+**Keith Randall:** It's not huge, but there's a lot of stuff for all the... BigInt has a lot of assembly, all of crypto stuff there's a lot of assembly, and then you could put assembly in your Go project, so there's probably all kinds of stuff on GitHub that we don't even know about that has assembly. That's the stuff I'm worried about. We can fix the runtime and the math and whatever else ourselves, but the problem is someone out there has random assembly that they're using in their project and you don't have control over when they change that assembly, and so on.
+
+We're currently thinking about how we might roll such a thing out if it ends up working out.
+
+**Erik St. Martin:** Yeah, that almost feels like it's gonna have to be some sort of phased approach where there's like at least a release or two to kind of give people time to convert.
+
+**Keith Randall:** Yeah, and we were thinking about... You know, the current assembly, when we switch to a new calling convention, we can then generate stubs for all the old calling convention things, and then you can sort of opt in to get the new calling convention and we'll remove the stub as you change your code. Something like that may have to happen.
+
+**Erik St. Martin:** Right.
+
+**Bill Kennedy:** Do you work on any of the escape analysis stuff for the compiler too?
+
+**Keith Randall:** I've touched escape analysis, yeah. I am not a major contributor to it. David Chase did a lot of the most recent stuff.
+
+**Bill Kennedy:** Okay. There is a document that Dmitry put out a little over a year ago on some of the escape analysis flaws and I was curious how much of this has been worked on over that year, and if there's any update to what's left.
+
+**Keith Randall:** I don't know, that's a good question. I know that it's another one of those never-ending rat holes you can go down, trying to get every last case that people care about. I don't think anyone's been working on it seriously for the past year. Maybe fixing obvious bugs and things, but there's been no concerted effort to cover the remaining gotchas and so on.
+
+**Erik St. Martin:** I have a question for you. We actually have a C++ app that requires real-time thread support. Over this past week we were kind of joking about, "Would that be something we could ever rewrite in Go?" Basically it takes MPTS streams - multiplexes, multiple MPEG video streams together, and to keep the timeline (because it's a linear video) it requires real-time threading. So this was actually kind of like a thought experiment, and I was thinking to myself, you could in theory use syscalls to set a thread to real-time priority and lock OS thread to keep the goroutine running in that thread. But I'm wondering what other implications might need to be accounted for inside the runtime, in order to get actual red priority support.
+
+**Keith Randall:** Yeah, it's a good question. I think it should just work. If you take a goroutine, lock it to a thread and tell the OS "Give that thread high priority", that should just work. You'll get pauses when GC starts and stops, but those have been getting quite low recently, and I can't think of any other reason why you wouldn't get all the cycle time that the OS is gonna give you. Yeah, so that should work.
+
+\[20:06\] As long as your program is single-threaded, once you try to use multiple goroutines to do that, I'm less confident it would work out of the box.
+
+**Erik St. Martin:** Yeah, this would be multiple threads with different priority, because you basically have some threads going out to fetch new segments of video and audio, and then you kind of have your real-time thread responsible for keeping your timeline and multiplexing the package together and dropping them, and accounting for network jitter and stuff like that. So yeah, it would definitely be multi-threaded.
+
+I might have to whip up a silly example of something like that to see whether I could get it to work and whether it falls flat. Before it wasn't even a consideration because of the garbage collection time, but now it's nice to see that we're kind of in a point where that's not the most complex part of it. It's really the fact that goroutines by nature aren't really their own threads... Which is to most people's advantage, but in this case it's much harder.
+
+**Keith Randall:** Right. Yeah, goroutines don't exist as objects to the users, so you can't set priorities and things like that on goroutines. That's sort of a deliberate design decision, that they're anonymous, so you can't do things like wait for goroutines to die and things like that.
+
+**Erik St. Martin:** Right.
+
+**Keith Randall:** It makes the runtime all that simpler, but it makes things like real-time a bit more difficult.
+
+**Erik St. Martin:** But in those use cases, I'll take it. You can use Go for almost anything, except for a couple of these odd use cases that not many people have to worry about.
+
+**Keith Randall:** Yeah, exactly.
+
+**Erik St. Martin:** Alright, so we're gonna take a quick sponsor break, and then we will jump back on with Keith.
+
+**Break:** \[21:47\]
+
+**Erik St. Martin:** Alright, we are back. Carlisia, I know you had some questions for Keith.
+
+**Carlisia Thompson:** Yeah, I was curious to know if you do any side projects when you're not working on compilers, or if you do a different sort of compiler work when you're not at work?
+
+**Keith Randall:** Like when I'm home, hacking by myself?
+
+**Carlisia Thompson:** Yeah.
+
+**Keith Randall:** Yeah, I sort of hack on random stuff. I wrote a pretty good integer factorization library, which you can grab on my GitHub account. It can factor 50-digit integers. I'm a math geek and a performance geek, so I like to sort of hack on stuff like that.
+
+**Carlisia Thompson:** Very cool. I'm gonna check that out.
+
+**Bill Kennedy:** Are there are other languages that you work in, other than C -- like, have you looked at Rust at all? What do you think about their philosophies around integrity and around the runtime there?
+
+**Keith Randall:** Yeah, I like the idea of Rust, that you keep track of exactly what pointers mean and what they're allowed to do and when they disappear, and things like that. I'm not a big fan of the fact that there's eight different kinds of pointers, or whatever the number is nowadays. Because that adds a lot of cognitive load to the user to figure out which ones he's supposed to use where.
+
+I haven't actually written anything in Rust, so take my comments with a grain of salt. Maybe it's easier than I think it is. But I like the fact that in Go everything's naturally -- you're used to it coming from C or from Java, or whatever... There's no fancy new semantics to learn.
+
+**Bill Kennedy:** \[24:05\] One of the questions that seems to come up more and more - and I think it's because I'm seeing more programmers that are coming from functional programming languages, is they get afraid about pointers and they start asking me, "What is the advantage of having the pointers over not having to deal with them?" What kind of answers can I give them? Do you have any opinions around that?
+
+**Keith Randall:** It's fundamentally a question of efficiency, and to the extent that a compiler can realize that you're doing something functional and can pass pointers around under the hood, so you don't have to do big copies - that's great. The SSA thing would totally be impossible to write in a functional language, because everything's linked to everything else via pointers, and the side effects matter. If I wanna delete an instruction from an instruction stream, I need to sort of update all the people who use that instruction, I need to update all the arguments of that instruction... So there's a lot of side-effect things that have to go on in order to make the compiler work, and work efficiently, that I don't have to iterate through all the instructions to find a single use of an instruction, for example.
+
+So I agree that the semantics of a functional language are much easier to understand, and make for a nicer programming language. In languages that scale, it's hard to make functional programs efficient in all cases, whereas given a pointer, it's much easier to sort of design your thing to make whatever algorithm you're doing efficient.
+
+**Bill Kennedy:** That's cool. I'm also curious if you played with Delve at all, and what kind of support are you seeing maybe in the future to help the development of that tool?
+
+**Keith Randall:** Yeah, I love Delve. We are in contact with Derek all the time... We're making this change to the compiler that's gonna change the layout of registers or layout of memory locations - does Delve still work if we do this? So we had a good contact with him, and I love Delve. I use it not all that much when I'm developing Go, but when I'm doing hobby projects I use Delve all the time.
+
+**Erik St. Martin:** That's awesome, so you actually collaborate and reach out proactively and let him know that there's going to be these potentially breaking changes to kind of give him the headstart?
+
+**Keith Randall:** Yeah, exactly.
+
+**Erik St. Martin:** That's great.
+
+**Keith Randall:** Go had a very bad story for debuggers for a long time, and it was slowly bumping up our list of "This is something we have to tackle, this is something we have to tackle", and then Derek tackled it for us, it was great.
+
+**Erik St. Martin:** One of those, "See a need, fill a need."
+
+**Keith Randall:** Exactly.
+
+**Erik St. Martin:** I was actually really surprised when it came out. To your point, I kind of thought that that was ways down the road as far as the Go team, that there was still a lot of work to be done on the language and the compilers themselves, and I recognize that there needed to be a debugger, it just wasn't the priority now, and then Derek pretty much came out and was like, "I got one!"
+
+**Keith Randall:** Yeah, exactly. It was pretty sweet.
+
+**Erik St. Martin:** Yeah. So speaking of cool projects, do you guys wanna get into interesting projects and news, and we'll just kind of talk about stuff that's going on right now?
+
+**Carlisia Thompson:** Yeah, let's do that.
+
+**Keith Randall:** Okay.
+
+**Erik St. Martin:** So the biggest of which is Go 1.8 beta, which was recently released, and for anybody who hasn't tested their code against it, they should, because it drops in February, if I recall...?
+
+**Keith Randall:** Yeah, February 1st, or January 31st, something like that.
+
+**Erik St. Martin:** And Brad Fitzpatrick gave everybody a warning that he's got time to fix bugs now, but later not so much. So file the bug reports now. Is there anything you're particularly excited about in this release?
+
+**Keith Randall:** The big thing is the SSA stuff, for all the other architectures besides x86. That's sort of been my focus. What else is cool in this release...? It's a good question.
+
+**Erik St. Martin:** I know everybody was raving about the 10 to 100 microsecond GC pauses...
+
+**Keith Randall:** Right.
+
+**Erik St. Martin:** \[28:01\] I think it was guaranteed to be under a hundred microseconds, but they were seeing ten-ish most of the time, if I recall what that was.
+
+**Keith Randall:** Yeah, the pauses we got rid of... There's a bunch of stuff that you have to do when you stop the world. When you do a GC, you stop the world, you sort of set some bits, then you have to do some stuff and then you have to start the world up again. And the stuff you need to do, we've been shrinking and shrinking and shrinking, and now it's down to just sets and bits in various places... And start again; you don't even need to scan a single goroutine stack before you can start the world again. So it's getting quite a bit better. Sub-microsecond for almost everybody, and well a sub-microsecond for lots of people.
+
+**Erik St. Martin:** And then I know this release also saw some improvements with the overhead and calling out to Cgo.
+
+**Keith Randall:** Right.
+
+**Erik St. Martin:** I don't remember what they were... I wanna say it was like cut in half, or something like that; a big concern for people using cgo was the expense of calling out to C, so most of the time the code got written in C, and then there were these logical breakpoints where flow of execution kind of got handed over to C, it did its thing, came back, rather than the more iterative tight loop type calls into C.
+
+**Keith Randall:** Right, and a lot of people we'll serve are stuck with legacy stuff in C, and you've gotta use it... Yeah, so I think the big improvements were in defer. We've put some defer records on the stack instead of allocating them from the heap, and that sort of helps a lot when you have to do -- you basically have to do a defer every time you go into C; in case something panics, you need to defer there to recover. I think that was the big thing, but in general it got a lot of love in this release. Ian looked at it quite a bit to get the overheads down as much as we can.
+
+**Erik St. Martin:** Speaking of which, defer itself was improved. Was that kind of where this was gained? The overhead was kind of saved there because it leverages defer and then defer itself had performance improvements?
+
+**Keith Randall:** Yeah. That was the main reason behind the optimizations to defer, it was for the C path.
+
+**Erik St. Martin:** We actually have a listener in the GoTime FM channel, Chris Heinz, who's asking a question for you. He's asking what the status of inlining \[unintelligible 00:30:11.05\] functions is, because currently you can only inline functions if all the functions they call can also be inlined.
+
+**Keith Randall:** Right. Yeah, so actually we have an intern who's going to be working on that. He's started already, I believe, although I haven't seen \[unintelligible 00:30:25.01\] but it's actively being worked on. The tricky part is getting all the stack traces right when you start doing that, so that's what he's working on.
+
+**Erik St. Martin:** Yeah, and that's actually what he's mentioning here, he said "Part of the problem is that we wanna preserve stack traces, and inline functions will not show up in stack traces."
+
+**Keith Randall:** Right. We're working on it so inline functions will show up in stack traces. It will no longer be a one-to-one mapping between the PC you have and the function that you are in, because some PCs will be in two or three functions nested, so we sort of have to record all that information to be able to have runtime callers return that to you in a sensible way.
+
+**Erik St. Martin:** Some other stuff... I saw the race detector detects concurrent map use. I actually didn't realize that that wasn't detected before...
+
+**Keith Randall:** Actually the race detector always detected that. However, we implemented something additional in 1.6, which is that the runtime itself, even when the race detector is not being used, the runtime itself will detect concurrent map use and panic -- or not panic, it would actually just crash the program. But it wasn't complete. It handled some cases and not others, and we improved that in this release to make sure that we handled as many cases as we could possibly handle.
+
+Basically, it detects if you have a reader and a writer at the same time for a map, and it will crash the program because in that situation programs would nondeterministically occasionally crash anyway, and then you'd have no idea why they crashed because they crashed some later time, in some unrelated code, and it was sort of a very confusing situation to be in, whereas now the map detects that you're doing that kind of thing and it crashes immediately, so you can hopefully find and fix the problem before you release some code to production.
+
+**Erik St. Martin:** \[32:15\] I think the other stuff that I saw was around plugins, some stuff for the HTTP server, some more context stuff... Plugins seem cool. I mean, as far as readability, I think there's some concern there because you have to do some type assertion when you read from it. So it starts to look a little crazy, but the fact that we have plugins is kind of cool, and I'm not really sure how else to do that without doing the type assertions.
+
+**Keith Randall:** Yeah, it's a difficult problem, and it re-rears all the problems you have with Java distribution - now you have to distribute your plugins somehow along with your binary... But for use cases where you need it, it's really useful and you can sort of wrap all that type case stuff into a library on the client side, so you don't have to see it except for the person who's actually doing the wrapping.
+
+**Erik St. Martin:** Oh, that's interesting. It's just kind of like a wrapper library that does the type assertions.
+
+**Keith Randall:** Right. So that's sort of how we expect it would be used - you have a plugin for, I don't know, some Photoshop transformation, and it takes an image and returns an image or something; you just have a wrapper on the client side of that library that casts the argument to the interface to pass it and cast the thing back to an image when you get it returned. In that way, the client doesn't need to deal with that.
+
+**Bill Kennedy:** The plugins - I haven't even look at it yet... Are you able to reload plugins at runtime, or is it when the app comes up, those are the plugins that you'd have to restart?
+
+**Keith Randall:** You can load plugins at runtime, whenever you want. You just call whatever the routine is - I don't even remember its name. I don't know about reloading. I think once something's loaded, you're stuck with it.
+
+**Bill Kennedy:** Yeah, I'm a little concerned that people are gonna start abusing -- well, I guess you can abuse anything, right? But start breaking that up... The one area I guess always comes up with the static binary as opposed to having this as security, like "Oh my god, we just found a security flaw and we wanna fix that, and now I gotta rebuild every binary I have to do that, as opposed to just deploying maybe the new plugin." This is like the classic argument I'm constantly hearing about. Maybe the negative side of Go, always just building that single binary for deployment.
+
+**Keith Randall:** Yeah, it's tough for distributions like Ubuntu or whatever... They really want to have shared libraries so that when there's a bug in a Crypto library they can just push the Crypto library and not every Go binary in the world that uses Crypto. Yeah, so I certainly understand the argument.
+
+**Erik St. Martin:** I think it's about time for our second sponsor break, and then we can kind of get into some other cool stuff that's going on and interesting projects we've run across this past week.
+
+**Break:** \[35:05\]
+
+**Erik St. Martin:** Alright. Carlisia, wanna talk to us about some stuff you've seen?
+
+**Carlisia Thompson:** Yeah, I wanted to mention that GothamGo videos have started to pop up on YouTube. There are three now - Russ Cox, Cassandra Salisbury and Aditya Mukerjee, and hopefully the rest will be coming soon.
+
+**Erik St. Martin:** That one... What was that - reimplementing Git in Go, or something like that. I haven't watched it yet, but I saw it listed.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Were you at GothamGo, Keith?
+
+**Keith Randall:** No, I wasn't.
+
+**Bill Kennedy:** I was there... Yeah, they built an entire package in Go so you wouldn't have to use the C libraries anymore. It looks really interesting.
+
+**Erik St. Martin:** What were the other two, Carlisia?
+
+**Carlisia Thompson:** The other two were Dissection of Gophers by Cassandra Salisbury, and Codebase Refactoring with Russ Cox, and the Cloning Git one was the one by Aditya Mukerjee. We also started having the Advent series, the blog post series on the Gopher Academy blog. Those are really cool. We have one that's about timers, and a really good one about contributing to Go. That got the blessing from Brad. \[laughter\] There are a bunch of really good ones. It's a longer list.
+
+For people who don't know, every December Gopher Academy does this, and every day a new blog post will go out. Anybody can volunteer to submit a post, so next year, people, stay tuned and just hop in and ask around where you can put your name down for a post.
+
+**Erik St. Martin:** There might be space left, too. Damian Gryski is maintaining the list of who's on what days, so there may actually still be openings this year.
+
+**Carlisia Thompson:** That is a good point. I know for sure there are openings for backups.
+
+**Erik St. Martin:** Oh, yes. And there was a talk at GopherCon this year too, Michael Matloob I think it was... He did a talk about contributing too, which was really awesome.
+
+**Carlisia Thompson:** That is true. Contributing to Go, you mean...
+
+**Erik St. Martin:** Yes. Speaking of which, do you get a lot of contributions for the compiler itself, Keith? Or are people mostly contributing to the standard library?
+
+**Keith Randall:** We get a lot of people contributing to the compiler, certainly. It's sort of one of the most active portions of the development that's currently happening on Go, at least in the standard library and the runtime and so on. We get a lot of outside contributions, which is kind of nice, because we only have so many people inside of Google who have time to work on this stuff, and to the extent that we can get outside contributions, it's great.
+
+We had a lot of help from Josh Snyder and various other folks early on in the SSA development which really kept us on track and kept us on schedule. Otherwise, I only work half-time, so we only had one and a half people working on it inside of Google.
+
+**Erik St. Martin:** Oh, so you were the only one for most of it working on the compiler?
+
+**Keith Randall:** Myself and David Chase worked on it in the early days from inside of Google, and then there were a bunch of people from outside who worked on it as well.
+
+**Erik St. Martin:** So here's a question - for somebody who may have minimal or no compiler knowledge, how approachable is it for somebody to jump in and start trying to learn and contribute to the compiler? Is it something you kind of need a lot of knowledge about before, or is it fairly approachable for people to get in and fix bugs?
+
+**Keith Randall:** It needs some domain expertise. It's not the easiest thing to jump in and touch. We made porting as easy as possible, so you don't actually need to write any Go code to port the compiler to a new architecture, or at least it's all tables and stuff, it's not stuff that executes all the time. But if you wanted to add, say a new compiler optimization phase or something, it requires a fair amount of knowledge if you know - what SSA is, what transformations you can do on it, what you can't...
+
+\[39:59\] It's not the easiest thing to jump in and do, but the people who jumped in and worked on stuff on a compiler, I think they all had some compiler knowledge, but they were by no means experts. I would say it's sort of a middle-of-the-road thing if you wanna jump in; you should probably have taken Compiler 101 in college, but you probably don't need anything higher than that.
+
+**Erik St. Martin:** Do you have a recommended book or something, that somebody interested -- not necessarily like designing your own compiler, but just for anybody who might want a better understanding of how compilers work.
+
+**Keith Randall:** Well, there's always the Dragon Book - I forget who wrote it... But it's a standard compiler book. My advisor, Charles Leiserson has a great book on graph algorithms; a compiler is basically a big bag of graph algorithms. It's all depth-first search traversal, breadth-first search traversal connected components, all that kind of stuff. So yeah, any good algorithms book would also be a good starting point.
+
+**Erik St. Martin:** Excellent. Carlisia, what else do we have?
+
+**Carlisia Thompson:** We have... Oh, by the way, I wanted to give a shout out to Damian Gryski because he's been running the December series of blog posts for Gopher Academy, and he's doing a great job; it's so much work... He has to get after people who promised to deliver a post and don't show up on time... I don't know how I know that, but it's a lot of work and if it wasn't for him maybe we wouldn't have it. Those are really excellent posts.
+
+Also, he's on Slack and he said that there are no openings right now, but there are backup openings. Whoever submits a backup and doesn't get published as backup in December, will get published in January for sure. So please ping him or us and we'll direct you if you're interested for this December.
+
+Other things - there's the GoLab conference in Italy, somewhere near Florence. I'd love to go, but I can't. If you can go, it's on the 20th and 21st January. There's still time to book it.
+
+What else... I ran into this because I was doing some research this week - another thing that I wanted to mention is Dominik Honnef. He has a blog post listing all -- not all the tools, but at least most of the tools in the Go toolchain, and it's very neat. He also explains and gives examples of how to use some of the most complex or not as popular tools. That was really cool to run into.
+
+**Erik St. Martin:** Cool. Yeah, it looks like it shows not just the things that are part of the Go tool itself, but also some of the other tools that have kind of come out around it, like Benchcmp (BenchCompare) and the bench visualization, where it creates the SVG output of the comparing to benchmarks, and things like that. That's cool.
+
+**Carlisia Thompson:** Yeah. And the last thing on the list here is that there is a proposal for the top mod on the Golang Reddit to be Damian Gryski, and I personally think it's great. Basically, what's happening is there's the Golang channel which hasn't been very well moderated, by everybody's account, and because of the Google presence there, people started thinking it was an official channel from the Golang team, and it never was meant to be. So now people are saying, "Whoever's the current mod, that person will step out and choose somebody new who can really moderate and choose new moderators", and the proposal... I think -- who was the person who did the proposal? Was it Russ?
+
+**Erik St. Martin:** I think it was Russ, yeah.
+
+**Carlisia Thompson:** \[43:49\] Russ, yes. He's proposing that Damian Gryski is the person. So if you have an opinion, hop on there and speak up because that's probably going to change very quickly.
+
+**Erik St. Martin:** Is there a way to vote, or is it just unless there's no downvotes...? How does that work
+
+**Bill Kennedy:** Yeah, I don't think anybody has downvoted that at all, so I'm sure it's just gonna happen, and it should.
+
+**Erik St. Martin:** It should.
+
+**Bill Kennedy:** Quickly.
+
+**Carlisia Thompson:** Yeah. And it's going to be better for the community to have real and consistent moderation there.
+
+**Bill Kennedy:** Yeah, I walked away earlier this year from Reddit. It was such poison to me that I didn't even -- if I've looked at it even five times this year, that's a lot. Knowing Damian's going to be the top moderator, I'll definitely come back and start looking at it again.
+
+**Carlisia Thompson:** Yeah. It's good, because Reddit is actually very good. There are some interesting posts... I mean, the posts that are popping there, we see them everywhere, but there are some interesting discussions. Every once in a while it runs amok, but it's pretty good otherwise.
+
+**Erik St. Martin:** Keith, how do you keep up with what's going on in the community? Are you mostly heads down, or do you kind of watch for projects that are coming out that interest you?
+
+**Keith Randall:** I basically read Go Nuts, and that's about as much community involvement as I can take. \[laughter\] I sort of watch the project closely and I watch Go Nuts, and that's sort of where I get my information about what's going on in the community from.
+
+**Erik St. Martin:** I think I'm in too many of them, and then I end up not keeping up with any of them. But it works out, because I think everybody else curates it, so I only hear about the good stuff.
+
+**Bill Kennedy:** Keith, what office do you work out of, and where are you based out of?
+
+**Keith Randall:** I'm in Mountain View at the main Google campus.
+
+**Bill Kennedy:** Gotcha.
+
+**Erik St. Martin:** Yeah, it seems like there's a couple different places... I heard that the New York office actually has more people working on the Go team than Mountain View does.
+
+**Keith Randall:** That may be true now, yeah. It's about equal. I think we have 12-13 people here, and there's a similar number in New York, and then a couple people in Boston.
+
+**Bill Kennedy:** And Brad's in Seattle now, right?
+
+**Keith Randall:** Yeah, Brad's in Seattle. We have one guy in Switzerland and one guy in Pittsburgh. There's a couple other scattered people.
+
+**Erik St. Martin:** And these are the people who are actually Google employees that are full-time; that's not including all the people who work for other companies who are basically being paid to work on Go.
+
+**Keith Randall:** Exactly. Yeah, that's only the Google employees.
+
+**Erik St. Martin:** I love that that's a thing now, too. You can work for a company that basically just sponsors you to work on a project that means something to them, right?
+
+**Keith Randall:** Yeah, and that's open source. That's not something that there's directly a competitive advantage thing with; they just wanna make the ecosystem better, and that's great.
+
+**Erik St. Martin:** Yeah, we're seeing it a lot with Kubernetes now, too. There's a lot of big companies that just basically have engineers on their staff that are full-time working on Kubernetes, and being paid by Intel or Red Hat or various other companies that are contributing back.
+
+**Bill Kennedy:** Erik, you got paid basically to fix a bug in Kubernetes too, right? Because Comcast needed it...
+
+**Erik St. Martin:** In Docker, yeah.
+
+**Bill Kennedy:** Oh, in Docker.
+
+**Erik St. Martin:** I wouldn't necessarily call it a bug...
+
+**Bill Kennedy:** An enhancement.
+
+**Erik St. Martin:** Basically the real-time thread support, we had an issue with running a real-time priority process in Docker, and that was really the way group scheduling works. Basically Docker creates a new C group, C group gets zero real-time runtime, the process inside the container cannot upgrade its priority... So basically, I was just kind of patching Docker to allow people to supply a real-time runtime at container creation.
+
+**Keith Randall:** Right.
+
+**Erik St. Martin:** But yeah, to Bill's point, it's kind of cool that they're like, "Why don't you fix it?" It's like, "Well, that works..."
+
+**Keith Randall:** \[47:51\] Yeah, exactly. It's a great thing about open source stuff - the things that people care about, they can fix themselves, they don't have to wait for someone on high to fix it for them.
+
+**Erik St. Martin:** Yeah, I prefer PRs over bug reports, too. I try to encourage that, because I think people should all try to approach the solution, because sometimes a solution si better than no solution.
+
+A lot of people will refrain from contributing, and this kind of goes back to Michael's talk and the posts on the Advent series, with the contributing - a lot of people won't contribute out of fear that it's not a good enough solution to be taken in by some big name project, and they won't contribute at all, and then these types of things will just kind of linger forever, because it's not a huge priority to the people actually working on that. But it may be a big priority to you, and sometimes a good enough solution is good enough to be brought in just to solve the problem for people, and it can be refactored later into something that is more performant.
+
+I'm sure there's specific language features that nobody's gonna pull in some gnarly code for, but for most people's bug fixes... They're usually fairly trivial, and they're not gonna introduce a lot of problems for the rest of the codebase.
+
+**Keith Randall:** Yeah, and even if they're not perfect patches and they have problems, they often spur dialogue or spur someone to think harder about the problem, and end up pointing the way to a solution if not being the solution themselves.
+
+**Erik St. Martin:** So does anybody have any other interesting news or projects they wanna talk about, or do we wanna move into \#FreeSoftwareFriday?
+
+**Carlisia Thompson:** I don't.
+
+**Erik St. Martin:** I've been traveling a lot this week, so I've been kind of \[unintelligible 00:49:30.27\] How about you, Bill?
+
+**Bill Kennedy:** On my Twitter feed I think Daniel Whitenack, who gave that talk on Data Science at GopherCon, he has at least two or three packages a week around data science that he's publishing. Gonum is the big one right now; that repo, github.com/gonum has got a ton of stuff in it.
+
+Daniel shared this week another repo called go-hep, which is High-Energy Physics community stuff. It's amazing to see the communities that are coming in, that I guess were kind of exclusively Python at some point; now, going full throttle into Go. That's really exciting.
+
+**Carlisia Thompson:** Allow me to correct you, Bill, just a little bit. It's not a repo, it's a whole organization, and it's got a bunch of projects, very interesting.
+
+**Bill Kennedy:** Yeah, that's what I meant. Thank you.
+
+**Erik St. Martin:** That is a whole industry I know nothing about, physics. But yeah, it's so awesome to see all of this stuff come in. There's a lot more data science stuff, there's a lot more math stuff being done in Go, and that's awesome. And InfoSec stuff too, I've been seeing a lot more of that to start being written in Go.
+
+**Bill Kennedy:** Another thing that was interesting is my business partner, Ed Gonzalez, he got stuck this week on the floating point stuff, trying to compare two floating points that should have been identical but were different because of binary decimals; he found a package from ShopSpring called Decimal, which he's starting to look at to help fix all that floating point decimal numbers in Go for the work he's doing. That was really interesting, too.
+
+**Erik St. Martin:** Oh, interesting. And how about you, Carlisia?
+
+**Carlisia Thompson:** I ran into a project - I have not used it before, but it looks really cool. It was here in this document, but it was also in this Brazilian newsletter about Go called The Week In Go. It is the JSON Incremental Digger (JID). Basically, you install it with Homebrew and you can navigate a JSON file on the command line. You can say, for example, "Node 0" and you get just that one node, and there are a bunch of things you can do. I thought it was really interesting.
+
+**Erik St. Martin:** \[52:03\] Yeah, that's really cool. Have you seen this, Keith? You basically can give it JSON, and then you can kind of use JavaScript notation to traverse and dig down into the JSON file, and it has autocomplete of the properties, too.
+
+**Keith Randall:** Interesting, I haven't seen it.
+
+**Erik St. Martin:** Drop the link in the Slack channel too, for anybody who's in there. It's super cool to be able to do that.
+
+**Keith Randall:** Yeah, especially when you JSON gets large and it's really hard to... They tend to format as giant blobs that are hard to parse because they're all nested, and so on. It'd be nice to have a way to see just the parse you care about.
+
+**Carlisia Thompson:** Yeah, that's exactly what I thought. If you have a very long JSON, you can start up like, "Give me the counts" for whatever place in the tree or adds, and just get an idea of how many items there are.
+
+**Erik St. Martin:** Yeah, some of the JSON gets really repetitive, and then you're trying to write these crazy regular expressions just so you can find the thing that you need in this giant JSON output.
+
+Did you have a project you wanted to give a shout out to, Keith?
+
+**Keith Randall:** Yeah, we already talked about it actually, Delve. It's my favorite debugger now. I use it all the time on my personal projects. It's hard to use when I'm developing the compiler, because often it crashes before you've got something that you can put into a debugger. But I use it all the time on third-party stuff. Yeah, it's great. It's better than GDB is for C, which is not great praise, but that's all I care about.
+
+**Erik St. Martin:** People have been using GDB for C for ages now, so I consider that praise.
+
+**Keith Randall:** Well, I'm just saying that it's a low bar, to be better than GDB is for C. \[laughter\]
+
+**Erik St. Martin:** I've spent a lot of time this past week in meetings and on planes, so I haven't been writing a lot of code, standard Linux stuff. The last weekend... I'm kind of working on like a home meat probe thing for my smoker, because the wireless ones that I have stink. So I'm gonna give a shout out to the whole Arduino and Maker community, because it's ridiculously easy to just go on to some of these sites like Adafruit or Sparkfun and order parts, and somebody else has already written drivers for sensors and things like that; I don't have to write any of them. I was able to whip together something in just a few hours, rather than having to spend a ton of time writing I2C (I Two C) protocols and stuff like that. Or "I squared C". Naming is hard. Every time I think I know how people pronounce stuff, I'm totally wrong. Like, forever I thought it was "I Two C", and then it turns out it's actually "I Squared C."
+
+**Keith Randall:** I always called it I Two C.
+
+**Erik St. Martin:** See? And Rob Pike commonly throws off Goose and Gorch... It's like, every year I hear him do a talk or something and there's a new way to pronounce them, and I'm like, "Huh! I didn't know that's how you were supposed to pronounce it."
+
+**Carlisia Thompson:** And now that you mentioned that, I feel compelled to mentioned that this week Brian Ketelsen dropped a blog post on the December series of the Gopher Academy posts, and it talks about the barbecue thingy that you guys did.
+
+**Erik St. Martin:** Yeah, so initially... That's running on a Raspberry Pi, so they're kind of two separate parts that are going to be merged. So that's actually Go running on a Raspberry Pi, that's the PID controller, and I always forget the actual acronym. It's like proportional-integral-derivation, or something... It basically takes a set temperature and the current temperature and calculates an error value and determines whether or not the blower needs to turn on to provide oxygen to the fire to make it heat up. It's to keep a stable temp in the fire box of the smoker for long cooks, and that's all done in Go.
+
+\[56:01\] I'm currently working on the meat probe side of things, and then we're gonna try to merge the two into the ultimate Go and C and custom hardware little grill device, so that we can plot out on Prometheus and all this stuff, you know, temperatures in the grill and things like that. Who knows what we're gonna do with the data, but it will serve our purpose and it will do better than the stuff we bought, so... And that's provided time; that's the hardest thing, having time for these little side projects.
+
+So did anybody else have anything they wanna talk about, or do we wanna wrap this thing up?
+
+**Bill Kennedy:** I think we're ready to wrap it up.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** Alright, so I wanna thank everybody on the show, especially thank you to Keith for taking time to come speak with us, and a huge thank you for all the work that you do on the compiler for the language we love.
+
+A huge shout out to our sponsors for this episode, who are StackImpact and Backtrace. Without them, we wouldn't be able to do this show. A huge shout out to all the listeners, both listening live and who will listen to the recorded version of this. Definitely share the show with fellow Go programmers.
+
+You can subscribe by going to GoTime.fm. We're also @GoTimeFM on Twitter. If you wanna be on the show or have questions for upcoming guests, hit us up on github.com/GoTimeFM/ping. And I think that's it. I always feel like I'm forgetting something, because there's always so much to go through.
+
+Next episode will be with Thorsten Ball, and we're gonna be talking about building an interpreter in Go, which is highly related to this, and then we're gonna do basically a two-week break over the holiday, and we will be back in January. So with that, goodbye everybody!
+
+**Keith Randall:** Bye!
+
+**Carlisia Thompson:** Bye, thank you!
+
+**Bill Kennedy:** Bye!

The Go Standard Library_transcript.txt

@@ -0,0 +1,563 @@
+**Erik St. Martin:** We are back for episode \#15 of GoTime. On the show today we have myself, Erik St. Martin, Brian Ketelsen is also here…
+
+**Brian Ketelsen:** Hello.
+
+**Erik St. Martin:** And Carlisia Campos…
+
+**Carlisia Thompson:** Hi.
+
+**Erik St. Martin:** And then our special guest today is pretty well known in the industry, and has quite a number of interesting projects and articles that have been out. Please welcome Ben Johnson.
+
+**Ben Johnson:** Hey there. Thanks for having me.
+
+**Brian Ketelsen:** I'm crazy excited about this, Erik. I've gotta tell you.
+
+**Erik St. Martin:** I know, me too. I mean…
+
+**Brian Ketelsen:** Ben is a staple in the Go community, the smartest man alive. Probably the nicest — maybe him and Matt Holt are probably in a tie for the nicest guys alive. So this is going to be an epic show.
+
+**Erik St. Martin:** Well, I mean…
+
+**Brian Ketelsen:** Seriously.
+
+**Erik St. Martin:** One of the things that I remember — this was a number of years ago, but it was like, "I'm going to implement Raft." \[laughter\]
+
+**Ben Johnson:** That wasn't necessarily a good idea, though.
+
+**Erik St. Martin:** I mean, the learning lesson of it, right?
+
+**Ben Johnson:** It was definitely a learning experience.
+
+**Erik St. Martin:** Brian will tell you, I have the addiction to databases, too.
+
+**Ben Johnson:** They're fun. They're really fun.
+
+**Erik St. Martin:** So I think first — it's more newer content... One of the first things I want to talk about is your new series of posts, your walkthroughs.
+
+**Ben Johnson:** Oh, sure.
+
+**Brian Ketelsen:** Holy crap. Wow.
+
+**Erik St. Martin:** Yeah.
+
+**Ben Johnson:** It's been a really cool experience. I thought I would go through and explain some stuff. I use the standard library quite a bit. A lot of people gave me a hard time because I tend to not use their private libraries (maybe when I should), in lieu of the standard library. So I thought I would probably know most of it, but I learned a lot through the experience, too. Because little details about case folding in Unicode, all these little things you wouldn't expect, even from the first two introductory... You know, the IO, and the bytes, and the strings packages, which seemed like the most simple ones, obviously.
+
+**Erik St. Martin:** I think that's the interesting thing about producing content, right? So if you prepare a talk, or an article, or write books or do instructional videos, you'll always want to make sure you don't misspeak, so you end up doing a lot more research, even on topics you think you already know well, and it forces you to learn new things.
+
+**Ben Johnson:** Yeah, and I feel like it kind of lets you know what you don't know about the subject. Yeah, it can help you grow.
+
+**Brian Ketelsen:** I really love the level of depth in these articles. It's fantastic. I don't think I've read better blog posts. I can't talk today \[laughter\]. We need to start this whole episode over with better lips.
+
+So I really love the depth of knowledge in these. It's not written at such a level that it makes me feel like an idiot, it's just the tone and the technical detail is perfect. I really enjoy these series.
+
+**Ben Johnson:** Oh, thank you.
+
+**Erik St. Martin:** We'll link to all of these in the show notes, but we'll start dropping them in the GoTimeFM channel on Slack for anybody who's listening now, and wants to look through these posts if they haven't seen them already.
+
+**Carlisia Thompson:** And this is so timeless. It's going to be useful for probably forever. We just need to do a good job resurfacing these posts once in a while.
+
+**Ben Johnson:** The nice thing about the standard library stuff is that it doesn't really change. They'll fix bugs and make it faster, but you don't have to go back and revamp it. Well, maybe version 2.0, if that ever comes up for Go.
+
+**Brian Ketelsen:** Never.
+
+**Ben Johnson:** Yup, I agree.
+
+**Erik St. Martin:** \[03:55\] I think we need more content going through the standard library like that, and showing use cases. Because you can browse through Go Docs, and stuff like that, and look on the Go website, and look through these things, but that doesn't necessarily show you… We talked about Sourcegraph tool, right? When you start to use something, being able to see example use cases of these things. One example is I think Bill Kennedy had posted something about reading byte streams, and stuff like that - and this was just a couple days ago - and you've also got your post that was recent about using all the io readers and writers and TeeReaders and MultiWriters and stuff like that. It kind of drives that stuff home, right? It starts making people aware of these functions and packages that you might not have already been aware of.
+
+**Ben Johnson:** Yeah, for sure. You look at these packages and you see that the layout is alphabetical order, which is great if you know what you're looking for. It's been fun to break them down and understand… There's subcategories in these packages and what those look like. I think that helps to make it more relatable.
+
+**Brian Ketelsen:** I like the sub-context that comes out - not directly, but indirectly I walk away reinforcing the idea of very small interfaces in Go. I know that in a practical way, a lot of us think of interfaces as a big thing. "I've got an interface to save my user to the database." But that's not really the idiomatic Go interface. The idiomatic Go interface is an io.Writer. It's a tiny thing, it does one thing. Walking through these blog posts, in the background, hammered that home for me.
+
+**Erik St. Martin:** Yeah, especially the Standard Package Layout post. I was looking through that, and each approach was the negative sides to it. I could think of packages and projects that I've seen that have used it a lot. And you're like, "Yeah…" I've had some of the circular dependency issues, and stuff like that based on doing Rails-style layouts and things.
+
+**Ben Johnson:** I try to think of that as well. The Go standard library, it always makes so much sense; all the names, and the packages... It's just so well laid out. I think that was a big inspiration, too. What did they get right, and how do we apply it to more specific application development? I think they are different worlds, but there's a lot you can borrow from both, you know?
+
+**Erik St. Martin:** I think we need a service. Library Organization as a Service. Here's my project, \[laughs\] you tell me how to lay it out.
+
+**Carlisia Thompson:** That's exactly the name of the conference talk that I think should be derived from the Standard Package Layout blog post. Packages as a Service \[laughter\].
+
+**Brian Ketelsen:** Nice!
+
+**Ben Johnson:** Should be like a package layout factory.
+
+**Erik St. Martin:** "Send your project to Ben and have him send you back what the layout should be…"
+
+**Brian Ketelsen:** That's fabulous; $50 and he'll reorganize all of your packages for you.
+
+**Erik St. Martin:** Look at him undercutting your price already. \[laughter\]
+
+**Brian Ketelsen:** Well, Ben's a superhero, it's only going to take him 10 minutes. That's a pretty good markup.
+
+**Erik St. Martin:** That's true. If he could do one every 10 minutes, that would be a good hourly rate. \[laughter\]
+
+**Ben Johnson:** I've gotten a handful of people so far on the Slack channel just pinging me, asking me questions about the design stuff, which has been nice. You just give some people some quick feedback. It's nice to do that early on, because you know, projects go on for years, and getting that first piece can make everything else so much easier.
+
+**Erik St. Martin:** It gets really hard, right? There's the common expression 'it's hard to change the wheels on a moving bus.' Especially the bigger projects, you start going down this road, and you're kind of trapped in it. It takes too much effort to change out the organization, and abstract things out the proper way. It becomes a massive effort. Getting off on the right foot is good.
+
+**Carlisia Thompson:** \[08:00\] I really liked when I saw... Ben gave a lightning talk at GopherCon and I was there, and I went, "Okay! This is what I'm talking about! I need to learn how to do this." Because a lot of the Go projects that I've seen, a lot of them have a model package, and I just cringe. I don't know why I cringe; I started to understand why now, after going through this learning.
+
+Then I look at the models, and they have model information, and they have database implementation information altogether, and I don't like that \[laughs\]. So I really, really like the way that Ben lays everything out, and separates everything. Recently, I laid out a project from scratch. I'm not super experienced with Go, but I thought about it for a long time, because I feel that I need to have things organized, and if I don't know where to put them, I don't know what it is that I'm doing, and I need to figure it out. It's just part of the process for me.
+
+**Brian Ketelsen:** That leads me to an interesting question that I always struggle within Go packages. How big is a package? How big should a package be? Where are the boundaries for your packages? I always make too many packages; I don't know whether that's Ruby or Java in my background coming out, but I always make too many, and then regret it instantly.
+
+**Ben Johnson:** I think I've gone back and forth. I used to very much be on the mono package, like "Just put everything in there. It's a pain to try to separate out everything." I've gone the opposite end, too. I don't think that code size, the number of lines, is necessarily a good proxy for it. Sometimes you can have a huge package, and it feels fine. Other times, it's rough. I don't know. Separating by dependencies has worked for me so far. It works out to a midsized project, probably. If you have a really huge project, you might need to start breaking some stuff down further. I've been everywhere on that spectrum.
+
+**Brian Ketelsen:** That was kind of the anti-case I was thinking of. When you think of a large Go project, like Docker or Kubernetes, I wouldn't even know where to begin to start making those boundaries; it's so complex. When you think about dependencies… Good Lord, what are the dependencies in Kubernetes? I don't know. Maybe that's just too deep for me to think about right now.
+
+**Erik St. Martin:** But I think you can go back to the basics a little bit too, right? Two common books that I remember recommending to people over the years is Robert Martin's Clean Code, and he wrote another one, too; and The Pragmatic Programmer: From Journeyman to Master. Both of them advocate… You want things that aren't highly coupled together, for one, but your packages should be cohesive, right? Everything within the package should make sense. They should all be operating on the same data. If two packages seem to want to know too much about each other, then really you probably have your code in the wrong place, right?
+
+**Ben Johnson:** Yeah, that's a good point.
+
+**Brian Ketelsen:** That's what Nathan Youngman says on our Slack channel, "A package for a single idea" is something he heard from a talk a little bit ago. And that's good advice if you can well define what an idea is. If an idea is something not very broadly defined, that might work.
+
+**Erik St. Martin:** So talk to us about the motivation behind this series of posts. Is this something you're going to continue doing? And this is kind of like a side step from some of the things that you've been talking about, right? The first two GopherCons; the first one was writing high-performance databases, the second one was static code analysis, and now it's kind of like a shift into getting back to the basics, like project organization and library usage.
+
+**Ben Johnson:** \[12:02\] I think that I go from low level to high-level, and back again. I think that this structuring of projects and these high level concepts, they're kind of where I am now. I've been doing a lot more at the application level, and trying to figure out how that looks for Go applications. One thing that's always bothered me is when people say you can't write websites and web applications in Go, that it's an API thing, but it's not. You can't really build real web apps with it. I think there's now that sense of how you structure projects. I want to find a better way to do that. Part of it has been from doing stuff with Bolt. In my opinion, at least in our industry, we have containers, we have Kubernetes - which are great tools if you're at that scale, and you need super high uptime and crazy requirements, but I think for probably 90% of the applications out there, you could probably run on a single server fine and handle hundreds of thousands of requests per second, which is probably most people's load using something like Bolt, or some other key/value database. I'm trying to figure out how to simplify the stack and get away from traditional SQL databases, and things like that.
+
+**Erik St. Martin:** There is a lot of the whole 'fear of missing out' thing. All these new technologies come out and you want to feel that you need to use it.
+
+**Ben Johnson:** Yeah, totally.
+
+**Erik St. Martin:** Otherwise you feel like you're obsolete, you're not sticking with modern times. But as you said, the majority of people's systems just don't need to scale. Everybody doesn't have Kubernetes-level problems. If you have just three nodes that you're managing, I'd argue that you probably don't need Kubernetes for that. It's pretty simple to do with Puppet and Ansible, and things like this. They come with their own problems, too. I love Kubernetes, I really do, but it comes with its own set of unique problems and constraints. More things you need to manage, and setup and configure, and all these things. It's a lot of cognitive load for something you may not need, you're just using it for the sake of being able to say that you use it.
+
+**Ben Johnson:** I totally agree.
+
+**Carlisia Thompson:** Going back to something that Ben said… Ben, what do you think or tell people when they say, "Well, Go is not really for web apps; I don't know if it's even for API." Do you hear people say that?
+
+**Ben Johnson:** I think it does well with APIs. I think… I did a talk over at GopherCon for the kickoff party that was around... A lot of the industry is moving, we're not doing… Well, two things that Go's not really good at is templating and SQL databases. I mean, it's not great. You can use it, but it's not great. And the premise was a lot of people are moving away from SQL databases, key/value stores, or NoSQL databases, so that's less of a problem. And then using things like React on the frontend, that's making it so we are interacting with APIs and we don't have to have this templating side. I think the industry shift is actually moving more towards that Go is better for.
+
+**Carlisia Thompson:** Yeah, and even Amber - I learned that actually just yesterday, that they have something that generates JSON API's pack, and if you have a schema for that, I think they auto-generate code. Somebody was saying it's super easy, and we can do that with an API in Go, of course. Now, I have to follow up on something else you said now. Why is Go not good to use with SQL? I've never heard that before.
+
+**Ben Johnson:** If you use something like… I came from Rails before Go; that was my most recent language I was doing before Go.
+
+**Erik St. Martin:** You're in good company. We're all ex-Ruby on Rails people.
+
+**Ben Johnson:** \[16:07\] When you're doing simple web apps that don't need a lot of performance, Rails is pretty great. You just throw some migrations up there, and you just start typing, and you get all kinds of stuff for free. You're never really interacting with SQL at that low level. Go has some ORM tools; I haven't used any for quite a while. I'm not a huge fan of SQL databases. I used to be an Oracle DBA for years when I first started out, so I think SQL databases are really cool for certain applications, but the more I get into it, there's just this insanity of how we're sticking data in and out, and converting it, and doing this relational object impedance thing where the things that we do in our applications don't fit in the SQL Database.
+
+You have to break it out, and then we recreate, rebuild it back again. Going through the whole idea of setting these strings over to a database, they have to get parsed, and they get optimized, they get saved in a query cache, and then they get planned, and all this stuff... There's so many crazy steps involved in using SQL… It's an everyday thing now, but if you really dive into it, and think about it, it's kind of nuts what we have to do to stick data into SQL databases, instead of say… I can say an object database, but even just -- like in the instance of Bolt. Serializing objects into bytes and saving those is relatively well understood, and an easy thing to do. I'm surprised that our industry hasn't done that more, going for these very simple tools.
+
+**Erik St. Martin:** So I need to find the YouTube talk that I saw, and I may be misspeaking about what he worked on, but I believe that he worked on DB2, or something along those lines. And he was doing a talk, basically, about the things he knows for certain, which is history repeats itself, and he was bringing up that whole shift towards key/value stores. Everybody's on the hype of key/value stores, and he's like, "That's what databases were when they first came out…"
+
+**Brian Ketelsen:** Yeah, in the '60s.
+
+**Erik St. Martin:** Yeah, it was built into the mainframe application, everything. That's just what it did. And they had these maintenance windows when they would update, and then they needed to try to avoid that as the internet came to be and these systems needed to be online more, they couldn't withstand being down. At first they were bank systems, and it was okay for them to be offline after hours.
+
+So SQL came to light because SQL was sellable to business people. You could teach the basics of SQL to a business person fairly quickly, before you get into complex joins and indexes, and all that stuff. But if somebody wanted to query spreadsheet-ish data, they could do that, and that was the shift there. He was talking about distributed databases, and he's like, "Yeah, we had those too, except they were called federated." \[laugh\] And this is history repeating itself. Now that we need performance, we're going back the other direction, but it's just the new old stuff, right?
+
+**Ben Johnson:** Yeah, for sure. If you look at SQL databases.... SQL is just an abstraction layer, underneath the running whatever kind of engine underneath, which is essentially just a key/value store from a Row ID2, some byte-encoded row that's in there. That's interesting just to look at all the little layers.
+
+**Erik St. Martin:** And the difficulty there with performance becomes because of that layer of abstraction, it has to seek so much data of off disk to bring it up into the layer that starts doing the filtering. I know my SQL especially over-fetches data. At least that's done on the machine level, it's not all being passed back?
+
+**Ben Johnson:** Yeah.
+
+**Erik St. Martin:** \[20:00\] I like the approach that we're starting to think about things differently. I like the idea of column-oriented databases, things like... Cassandra was a big one I kind of liked. You could have these really wide rows, and you could scan along them, and read in just as much of that as you wanted, and it kind of takes a new way of thinking about the problem. But these things are highly interesting, and most people aren't doing a lot of complex stuff with data, too. They can't just write they own little key/value logic over the top of.
+
+**Carlisia Thompson:** I have to say that if you have used a NoSQL database and have experience and you can make tradeoff calculations, it's great. But if you don't have that much experience, and you want to know, "Okay, I have this data model, should I be looking at a NoSQL style or architecture?" It's really hard to figure that out, because you search on the internet - where else would you go? And there are all kinds of opinions in each and every way, and you just can't make up a decision. Without going through the experience, it's really hard to learn how to decide, okay, can I safely go in this direction? No, maybe I missed something; if you know how somebody decides to do, okay, I can safely go with NoSQL here, and I'll be fine down the road.
+
+**Erik St. Martin:** I think NoSQL is also an abstraction. So underneath, NoSQL is interacting with a
+
+key/value store, too. So it's just trying to use some sort of probabilistic algorithm where it needs to go to find the data. I think that's an abstraction, too.
+
+Choosing databases is hard, you really have to look at your data model and your access patterns. If you're looking stuff up by key a lot, having the overhead of a SQL Database just doesn't make sense. But there's also speed of development. Everything's a tradeoff. If you're doing a lot of stuff that's doing aggregates, you're trying to do averages and counts and all this stuff, this is going to cause you to have to seek a lot of data and read through it, and perform those calculations yourself. If you're comfortable with the tradeoff of time for development for performance, that may make sense. But if you're trying to get a prototype out, it may not make the best sense. And I'd love to hear your take on it too, Ben.
+
+**Ben Johnson:** Yeah, yeah. I think the difference of NoSQL versus SQL... I think the NoSQL isn't necessarily key/value, it's really more… There's been a lot of databases that try to optimize for a certain domain, I guess, and that tends to be where they shine. If you have a database around time series data, you could really optimize big things with time series, if you have a database specific for that, or if you have a search database. This certain kind of domains that are more specific than the generic SQL. I think that that tends to be where it shines. As far as the aggregates… Yeah, if you're trying to get a prototype out and you know SQL really well; I would totally go for SQL, without a doubt. It's probably not worth learning a new language or system to make something quick and simple.
+
+The things that I like specifically about key/value is that there's a lot of features that you think of that tend to be more around SQL databases, where it's like, "Oh, you have a schema!" A schema and a key/value store can be just a serialization library. ProtoBufs is actually a good serialization library, and they give you things like versioning, just really quick encoding and decoding, and you layer that on top of a key/value store, and you're starting to build your own database. It's simple, but that's a good thing.
+
+\[24:10\] Another thing, when you think about SQL and the SQL language - and I've done SQL for years, and I still find it to be really frustrating when you get down to more complex queries. Your query language when you're actually using a key/value store ends up being Go, which is awesome, because you can do anything you want in Go. So if you need to scan a table, or scan a set of keys and values, you can make an index inside of a key/value store... You can do all those things, and it's really just Go code underneath that's processing it. So you can do a lot to optimize. You no longer have these ideas like query planning. Your query planning is done before compile time, and you're writing the code to actually do the query.
+
+**Erik St. Martin:** There's little misses too, with people, with even indexing. The number of people that are surprised to find out that a single query only uses one index. You think it's the index-2 fields, and they're searching on both fields that somehow it does some sort of merge of those indexes and it makes things faster, and it's going to pick the best one and it could be wrong.
+
+**Ben Johnson:** Oh, yeah. Depending on how you order the fields of the index, they may or may not use it based on statistics, and the statistics can change over time, which can change your query plan. There's a lot of unknowns, and again, crazy stuff that happens inside of a SQL databases that I think we've become accustomed to, that I think are much simpler once you move to a simpler store.
+
+**Erik St. Martin:** The hard part about the shift becomes when you're not a 100% sure what you're going to do with your data. It becomes very easy to open up a CLI app, or your favorite GUI app for a SQL Database, and just poke around with the data, and start trying queries, and discover what it is that you're trying to do, and then implement that in the code side. It becomes harder to do that, but I think the biggest difficulty from the development standpoint — and Brian can agree too, because we've looked at a multitude of databases — it becomes the operational aspects.
+
+So I can agree that a key/value store is fantastic for my use case, but it becomes hard, because how do I manage backups and restores, and things like that? There needs to be operational pieces of it too if you're going to stand it up in production. Along with the overhead of building your own code to interact with the key/value store, you now need to build your own tooling for managing the database, and fixing corrupted files, and all the stuff that goes along with it.
+
+**Ben Johnson:** Yeah, I totally agree with that. I think there's a lot of education side too that's missing. If you're going to start off in that world, it's just not much there to fall back on and to learn from. I hope that improves. I'm definitely going to be writing some blog posts on that, too.
+
+**Carlisia Thompson:** That's a call-to-action for you too, Brian \[laughter\].
+
+**Brian Ketelsen:** Exactly. So I have a question for you, Ben. This is a kind of out-there question. Usually when you have a project, you get a feel for how people are using it. What is the craziest thing you've seen done with BoltDB?
+
+**Ben Johnson:** I would definitely say… This is easy, I can answer this right away. At the GopherCon, I was talking to Marty Schoch—I don't know if that's how you pronounce his last name. He does Bleve—which I thought was always called BLEEVE. But Bleve si the full-text search in Go.
+
+**Brian Ketelsen:** Yup.
+
+**Ben Johnson:** He actually wrote an LSM tree with Bolt; like, there were multiple Bolts that were merged together at runtime. As far as key/value stores go, they tend to be either LSM trees, which are kind of like these LevelDB or RocksDB. They end up having these different levels of data storage, and they get merged at query time, and they get compacted and all kinds of stuff. They tend to be much more complicated, and there's B+ trees - like Bolt - which tend to be very simple databases. He actually used the B+ tree Bolt's to actually build up an LSM tree that would merge in. I thought that was nuts.
+
+**Brian Ketelsen:** \[28:17\] So how does that work? Is each level a Bolt database?
+
+**Ben Johnson:** Yeah.
+
+**Brian Ketelsen:** Wow.
+
+**Ben Johnson:** Just cool, yeah. He made it work. He actually got a performance improvement for… I think it was write performance he was doing. I don't remember the details, but he has a lightning talk. It was great.
+
+**Erik St. Martin:** Well, LSM trees are very efficient on writes. That's why you see stuff like RocksDB. They're very highly optimized for the right speed.
+
+**Ben Johnson:** Sure, sure.
+
+**Brian Ketelsen:** I'm interested... Did he implement the Bloom filters, and stuff like that to determine…?
+
+**Ben Johnson:** I don't know if he got that far. That would be pretty cool.
+
+**Erik St. Martin:** Yeah, I want to see that. If you have a link to that, I would be very interested in that, because that type of stuff really interests me, and… We would have a whole week of episodes on how B trees work, and LSM trees, and all that stuff, but…
+
+When we say LSM, for anybody who's not aware, log-structured merge-tree, and it's just kind of that access pattern, how it builds levels as it stores, and as Ben said, kind of merges them back together. Cassandra is also another big user of LSM trees.
+
+**Ben Johnson:** Yeah, and they work great for a lot of use cases. They tend to be much more complex, especially operationally, but they get much better write speed, on something like a B+ tree typically, for random writes. You do stuff in things like range scans, you need to go over an ordered set of keys... They're typically much slower, because they have to jump around at the different levels, but really good... It's just tradeoffs, that's all it is.
+
+**Erik St. Martin:** So now the largest user of Bolt is InfluxDB, right?
+
+**Ben Johnson:** No. Influx ended up… They have their own format for time series, that's more efficient. The Bolt piece is more of a stop gap. There are a lot of pieces going on as far as distribution of the data, query language, and all that. We moved off of Bolt as actual main storage. We have something called TSM-1 now.
+
+**Erik St. Martin:** Okay. Okay, I remember it having swappable backends to begin with. I think you guys decided that it was too much overhead to support all of them.
+
+**Ben Johnson:** At the time there weren't many people, so it was way too much overhead. There were some issues with some of the other libraries we were using, more from an operational standpoint, not so much from the performance standpoint. As far as the largest user, which I'm not sure… Actually, I don't know how much this public around a certain company is using it; I did find out that there's one company that uses it... I think they have a three or four terabyte-Bolt database. I posted that on the Gophers Slack inside the Bolt Channel. I said, "Hey, this is crazy, someone is using a three-four terabyte-Bolt database" and there were a bunch of people that chimed in, and they were like, "Oh, yeah, I got that, too!" They're using these substantial-sized databases and it's working well for them.
+
+**Brian Ketelsen:** Wow. So how does one operate, how does an operator manage a large BoltDB database that big? How do you take backups of that file? What are the operational concerns when it comes to using BoltDB?
+
+**Ben Johnson:** It is a B+ tree, so as it gets larger, depending on how you structure your buckets inside, the accesses will get, I think login slower. Don't quote me on that. One of those O(n), big O notations. So it will start getting a little slower over time. As far as operationally, Bolt, the actual transaction itself implements io.Writer too, so you can actually send a Writer to it, in order to write out the whole database for you. I like hooking it up to HTTP; so if I just want to do a cURL command, I can just pull down the database. Obviously not a public endpoint, but it makes it really easy just to take snapshots.
+
+**Brian Ketelsen:** \[32:10\] Oh, nice.
+
+**Ben Johnson:** Yeah. Fully serializable, ACID, all that jazz.
+
+**Brian Ketelsen:** That's beautiful.
+
+**Ben Johnson:** And again, that's another tradeoff, too. If you're using an LSM tree, it's much more difficult to snapshot the whole database, because you have multiple files as well other operational issues there. It's not a good or bad, it's again, tradeoffs.
+
+**Erik St. Martin:** I think with almost every tech decision, you have to look at your problems base and determine which decisions gives you the best amount of benefit for the least amount of drawbacks, right?
+
+**Ben Johnson:** Yeah, totally.
+
+**Erik St. Martin:** I think that's kind of the whole thing, how we were talking about the appeal of things like Rails. If you're a company that's bootstrapping yourself, and trying to get a product to market, get a proof of concept out - there's huge appeal in how fast you can deploy a proof of concept website in Rails.
+
+**Ben Johnson:** Oh, sure. Yeah.
+
+**Erik St. Martin:** Especially if the majority of it is CRUD-based operations. I mean, you can throw together a decent site in a weekend, just hammering it out.
+
+**Ben Johnson:** It's pretty much what hackathons are, or the startup weekends - it's just like quick Rails apps in a day or two. You can really get some great stuff, some concepts going.
+
+**Erik St. Martin:** What were those called, the Rails events, Brian? They held a couple locally here, too, where they kind of did it across the country, and people got together. They formed teams and built stuff. It wasn't a hackathon, they called it something else…
+
+**Carlisia Thompson:** I know what you're talking about, it was at Gopher Gala. I did it once... Rails Rumble.
+
+**Erik St. Martin:** Rails Rumble. That's what I'm talking about. There were some cool things that came out of that that I really wish had gone somewhere. And some of them were completely humorous. Like, who came up with this idea?
+
+It actually reminds me too, because there's a new database I saw come out too called noms, and it reminds me of a Rails Rumble project that was here local in Tampa that was called the Omnominator \[laughs\].
+
+**Brian Ketelsen:** Omnominator, that's right. I remember that.
+
+**Erik St. Martin:** I can't remember exactly what it did, but it was something along the lines of finding a local restaurant, but I loved the name \[laughs\].
+
+**Brian Ketelsen:** Yeah, like a food truck search engine, or something silly like that.
+
+**Erik St. Martin:** For the life of me, I can't remember... I haven't seen a Rails Rumble; I haven't been completely connected to the Rails world in a while, either.
+
+**Brian Ketelsen:** No comment.
+
+**Erik St. Martin:** So Adam Stacoviak from Changelog just posted a link to it. The site is not up, but the GitHub still exists for Omnominator.
+
+**Carlisia Thompson:** I want to make sure we get Ben to answer the question that Erik asked.
+
+**Erik St. Martin:** Answer the question, Ben! \[laughter\]
+
+**Carlisia Thompson:** Now that you've written a couple of really thorough blog posts on doing the walkthrough with Go Standard libraries, are you up to doing more of it?
+
+**Ben Johnson:** Oh, yeah. I have 27 more posts lined up, that I'm working on.
+
+**Carlisia Thompson:** Wow.
+
+**Ben Johnson:** I'm trying to start on the lowest level of the stack, which is why I did IO and bytes first, because I really don't depend on much Unicode stuff. But I kind of want to move up into the encoding ones, and things that lay on top of that, and so on and so forth.
+
+**Erik St. Martin:** Nice.
+
+**Ben Johnson:** Yeah. The next one that's coming is the encoding package. Most people have never actually looked at the encoding package because there's only four interfaces, but I started breaking it out, and going to do some overviews of the other packages inside of there, and what encoding means, and it should work out pretty well.
+
+**Erik St. Martin:** \[35:48\] I think working with bytes and streams in the IO package is a really good place to start. Especially if people come from dynamic languages, they're highly used to just working with strings, so they're going to favor those a lot and create a lot of copies, and they're going to buffer a lot of stuff into memory when they don't need to, and they can kind of be copied across these… Pairing together these reader and writer interfaces. I think it's a fantastic place to start and to get people thinking about problems in a new way rather than read in all this data from some place, hold it in memory, and then write it out somewhere else.
+
+**Ben Johnson:** Yeah. Yeah, thanks.
+
+**Erik St. Martin:** I'd like to see you answer to Bill's challenge. It wasn't really a challenge, but he was looking for a better way to… Basically replacing a string in a stream, in a continuous stream. I started on a solution for it, but I just haven't had the time to put into doing it.
+
+**Ben Johnson:** Replacing a stream? What was the example?
+
+**Erik St. Martin:** He had a piece of code that he had put up on Play, the playground, and it was basically just taking bytes, and when it saw bytes in the stream, it would do it. I was trying to do a continuous stream, so basically no matter how many bytes were read in, it could figure out and buffer just enough bytes per second, to see whether the next character matched if it only got a partial read.
+
+**Ben Johnson:** Oh, sure. Yeah.
+
+**Erik St. Martin:** Because that's a common mistake people get when they're using readers and things like that, to think that they're reading all the content in one read; it could come up short for whatever reason. So that was basically what I was trying to implement a solution for, to kind of demonstrate if you're looking for the word 'omnom' \[laughs\].
+
+**Ben Johnson:** I look for that all the time.
+
+**Erik St. Martin:** Yeah, you could get the 'o' and the 'm' at the end of your first read and the rest is in the next, so that you can't just look at the buffer that came out of that. You're gonna have to look at the stream and build a little state machine internally as the bytes go by to figure out whether you found what it is.
+
+**Ben Johnson:** I was going to say state machine is probably a good way to go.
+
+**Erik St. Martin:** I started on an approach, I just didn't have the time to finish it. I think it would be an interesting thing to finish because it demonstrates a lot of the points from both your Bytes Walkthrough and the IO Package.
+
+**Ben Johnson:** Oh sure, yeah.
+
+**Brian Ketelsen:** What was nice about that specifically is that it kind of turned into VimGolf where we started with an implementation, and then somebody improved it, and then somebody else improved it, and then somebody really improved it. That's how I learned. That's wonderful. I love seeing the evolution of performance, knowing that the first way worked just fine. Often that's where a lot of us stop because that's all we need, but when those cases come along when you really need that last bit of performance, it's fun to see how to get there.
+
+**Erik St. Martin:** So the interesting thing about that problem was I was like, "Oh, this is going to be easy; I'll build a little state machine." What prevented me from finishing it is there's several little edge cases that come as a part of it, like when you get the partial read. You need to buffer for a second because you can't stream it out the other side yet, because you don't know whether you need to do the replacement yet. You have the first two letters; this could be the word but it might not be. You need a small buffer, but only in that instance. You don't want to buffer when you know you're reading characters that you couldn't possibly be part of the stream that you're trying to replace. So there's just overhead in doing the buffering.
+
+I was trying to build the most efficient version I could, and then I kept ending up in these edge cases where based on the number of bytes that ended up being read, it'd be like sometimes it worked, and I'm like, "Why?!" Programming is hard.
+
+**Brian Ketelsen:** It is.
+
+**Ben Johnson:** Computers are hard.
+
+**Erik St. Martin:** I think we got 10 or 15 minutes left; did you guys want to talk about anything else going on in the community or any interesting projects? I know I mentioned the noms database, I don't know if you've got a chance to look at that.
+
+**Ben Johnson:** \[40:04\] No, I haven't yet. Is that the one based on Git?
+
+**Erik St. Martin:** Yeah, that's exactly the one.
+
+**Ben Johnson:** Okay, no, I haven't taken a look yet.
+
+**Erik St. Martin:** So I haven't played with it, but I thought it was pretty interesting because one of the things that appealed to me was… It has the content addressable, which is becoming popular too, in storage, and the append-only, so you only get versioning. But one of the things why I really want to play with the idea is I love the decentralized nature of it. This is especially true because we can build client-sized applications in Go. We're still working on GUI, right? But you can still build client-side applications, so I love the decentralized nature of it. You could be working on something, and it could merge with work that somebody else has done.
+
+**Brian Ketelsen:** That gives me nightmares, thinking about the database rebase \[laughter\]. I am not rebasing my database.
+
+**Erik St. Martin:** So that becomes the question, right? I have not played with it. Don't take that as me advocating that you should go out and try and use this for that. But it did trigger that idea that I'd like to play with it, and see how well that works.
+
+**Brian Ketelsen:** I'm curious to take a look at it. I didn't have time to read the readme before we talked, but the tradeoffs that they've chosen are interesting, because in databases everything is a tradeoff. You have to choose. So what's the use case that they're trying to solve?
+
+**Ben Johnson:** Yeah, I was thinking that too, I wonder what their use case was.
+
+**Erik St. Martin:** They have a Slack, a mailing list, and a Twitter. We should ask them.
+
+**Brian Ketelsen:** Yup. Well, they do, they've got it all. They even have a cute logo.
+
+**Ben Johnson:** Typically, we mention these things, and then somebody who works on it, or knows a person who works on it just happens to be in the Slack channel, and we're being fed information real-time \[laughs\].
+
+**Brian Ketelsen:** It's not happening today. Why are the noms people not in GoTime FM Slack? Somebody fix this.
+
+**Carlisia Thompson:** Talking about cute logos, the project I want to mention today also has to do with database and it totally won me just for the website, because the website and the logo is also cute and well put together. It's simple and clean. So if you want to sell something to me, you know how to do it \[laughter\].
+
+**Erik St. Martin:** Give it a cute logo?
+
+**Carlisia Thompson:** If it's cute and color-coded, there we go. I'm sold.
+
+**Erik St. Martin:** I have this blade of grass, but it comes with a very cool logo. \[laughter\]
+
+**Carlisia Thompson:** Exactly.
+
+**Brian Ketelsen:** Sold!
+
+**Carlisia Thompson:** I'm easy like that. So this is not an ORM, this is a productive data access layer for Go. I'm finding this so funny because I think in every other language, a package like this will say, "We are an ORM. We are the best ORM", no matter how full-featured it was. But with Go, it was like, "No, no, no. We're not an ORM! We're not an ORM. \[laughs\]
+
+**Brian Ketelsen:** It's a dirty word in Go.
+
+**Carlisia Thompson:** It's a totally dirty word, right? So much. I chuckle every time.
+
+So I was looking at not ORMs and ORMs recently, and I found this today - it was actually in the Go newsletter, and I think I'm going to use it. It's not full-featured, it's not doing a lot of things that makes me scared. Being very new to Go, I don't think I can recognize enough to make decisions; my package is doing way too many things, I back off. That's my measurements right now. But I want to have a little functionality. I have an API that's going to have filters and parameters, and I want to just drop them into variables, put them inside the function, and voila. I don't want to be writing out SQL and doing a bunch of things by hand. I think I'll gain a little velocity, so I think I'm going to use this.
+
+**Brian Ketelsen:** \[44:20\] That's where people in the programming world always differ. There's a category of people that want to write their SQL perfectly tuned by hand, execute it, and then map those back into structures, and use them for whatever they need to. There's another category of people that doesn't want to think about the database in any way, shape, or form. And there's very little in the middle.
+
+**Carlisia Thompson:** Yeah.
+
+**Erik St. Martin:** So I'm actually somewhere in the middle.
+
+**Brian Ketelsen:** Oh, you just had to be contrary.
+
+**Carlisia Thompson:** With this, you can totally just send SQL. So I like that because I anticipated that I would need to do that. If it didn't have that feature, I wouldn't use it. But I think all of these libraries will have that, I would imagine. So you get something... You get both things.
+
+**Erik St. Martin:** Some of my pain points with doing straight SQL is… Anybody who's tried using the standard database SQL package can attest to this - scanning individual things gets painful. Especially when you're changing the SQL, you didn't get your type right, and all these things. That can cause a lot of pain, so I like the idea of things that make it easy to map my data and query back into my type.
+
+But there's also the other side of it. We talked about Rails. I love how easy Rails is to do these things, but there's two sides of that equation. It's not saying that I don't believe in that, because I really do; that fast prototyping is awesome. But there's two issues I end up having occasionally with it. One, when you have a complex query. Typically, you're fooling around with it, writing actual SQL, trying to make sure you get your dataset right. And then you're translating it into Active Record-type format, and then you need to change it, and you try to shift it back the other way.
+
+There's this translation process, but for the most part if you get familiar with Active Record, that's not a big thing. But for new people, there's also the fact that things like major ORMs can be leaky abstractions. They're perfect abstractions when everything is going well, but if you don't understand the SQL that's being run under the covers, that can really affect your performance. You get into N+1 query, N+1 issues, and stuff like that. It gets hard; where is the perfect balance? I don't know if I have the answer for that. I feel like I'm somewhere in-between.
+
+**Carlisia Thompson:** Yeah. There is the performance issue that if you're not aware what's going behind the scenes, you can get into trouble. That might also be the issue where you want to do something a little bit different, and now what? But you can always fall back to SQL, I guess.
+
+**Erik St. Martin:** It sounded like, from your standpoint, Ben, that you like the ORM side of things; you think that's a point where we could be better at, that would grow Go usage? Adoption, rather.
+
+**Ben Johnson:** I wouldn't even necessarily say that. I think when you get into ORMs, unless you're generating the code… A lot of ORMs use a lot of interfaces, and you lose the type-safety, and you just get a lot of issues on that side. I think there's some fundamental issues from mapping objects to relational ideas that you just can't get around. Personally, I think you get around a lot of it if you use a local key/value store, but again, that's not for everybody. You get away from N+1 queries; they don't exist because you don't have to do fetches to a remote server. You don't have SQL injection, because you don't have SQL. I think it's a different mindset.
+
+\[48:07\] So I wouldn't say ORMs are the way to go. Personally, I would avoid SQL, if you can. But that's my own personal opinion.
+
+**Erik St. Martin:** All key/value store, all the way.
+
+**Ben Johnson:** All the way.
+
+**Brian Ketelsen:** If you were going to avoid SQL, how would you build a system that had to have more than one active copy of the database? Is it possible to do something like that with Bolt?
+
+**Ben Johnson:** More than one active copy... Like distributing it in a cluster?
+
+**Brian Ketelsen:** Yeah.
+
+**Ben Johnson:** I think you can do things around. I think you have the same tradeoffs, whether it's Bolt or some other database where if you need to scale things horizontally, typically you need to shard your data. If you have a lot of coordination inside a distributed system, even a database, there's going to be locks and all kinds of tradeoffs there. So I'd say you could certainly shard out your data using Bolt. One thing Bolt is missing that I'm working on is doing an async transaction log, so you can actually connect one application instance to another, and have it be a…
+
+**Brian Ketelsen:** Like a standby?
+
+**Ben Johnson:** Yeah, a standby. That's one alternative.
+
+**Brian Ketelsen:** So does BoltDB offer any sort of replication log now? Synchronous or asynchronous?
+
+**Ben Johnson:** Not currently, but that is something I want to include in there.
+
+**Brian Ketelsen:** Nice.
+
+**Ben Johnson:** Because I think that would solve probably 95% of these cases out there, with a database and a standby that you can fall over to. That's why a lot of people run with Postgres, that uses async logs by default, I believe.
+
+**Erik St. Martin:** Right. So I think we're starting to close down on time, and I want to make sure we have time to go through Free Software Friday, but there's one other project you've been working on that I want to take the time to mention and that's the Secret Lives of Data.
+
+**Ben Johnson:** Right, sure. So it's a project that has been active, although I haven't produced anything for quite some time. I did this visualization of Raft (Raft is a distributed consensus protocol). What that means is if you have a cluster of nodes and they need to agree on some data, basically a transaction log, you need to agree on all these things in the log, even in the case of failover or your network gets split - how does that actually work? It was made by Diego Ongaro out of Stanford, along with John Ousterhout — I don't know if I'm saying his name right \[laughter\]. I totally butchered that, I'm sorry.
+
+But yeah, they've tried to make a simpler Paxos, if you want to think of it like that. Like a multi-Paxos. But the problem is when you read the paper, probably several times, if you're not in that world of distributed systems, distributed consensus, a lot of these concepts just don't make any sense. I used to do a lot of data visualization in a past life, and I really enjoyed D3 visualization, so I thought I'd try to apply that to Raft and distributed computing systems. So that's what the Secret Lives of Data is, this visualization of how Raft works.
+
+**Erik St. Martin:** I love it, because it makes the topics a lot more approachable. For a lot of people who don't work in this space, you say 'distributed consensus' and their eyes immediately roll over, right? This is something that's completely unapproachable, it's only for Ph.D. candidates at MIT, Berkeley, or whatever. So I've seen the Paxos white paper, and then you see Raft; I remember seeing that. The PDF is 11 or 12 pages or something, that explains Raft, and I was like, "Wow this makes things much more approachable", and then I saw the Secret Lives of Data. I was like, "Well, this makes it even easier to just kind of…" It may not be enough to implement, but it's enough for people to understand how distributed consensus works, and things like that, and some of the problems along with it. And I saw on the GitHub that you had planned to talk about how Kafka works?
+
+**Ben Johnson:** \[52:06\] Yeah, that was my next one I was going to do. As far as seeing things… I feel like we have a lot of fancy words in our industry that typically mean really simple concepts, and I think when you can just see a concept... A lot of times it only takes five minutes to just visualize a concept, and be like "Oh, I totally understand how Kafka works, or distributed consensus." They're scary words, but it's really simple concepts underneath.
+
+**Brian Ketelsen:** Log-structured merge?
+
+**Ben Johnson:** Log-structured merge-tree. It sounds like a nightmare, but it's not. It's not overly complex when you get into it. The implementation is, but the actual idea of it is not.
+
+As far as Kafka, I started working on that, and I've tried a lot of different methods for trying to visualize that. I wanted to try to do more for blog posts where it had visualization within it, but it didn't quite fit. I wanted to move to where I was generating out of video, because whenever you put up any kind of content on the internet, there's a whole bunch of people that tell you it sucks. One problem that people said about Secret Lives of Data was that it just moved too slow. So I was trying to figure out whether to do video around that, and then give some kind of narration at the same time, some kind of caption, or something in there, just so it would move at a better pace.
+
+**Erik St. Martin:** I think part of it, too... If it didn't move faster, you could make it more interactive, which would force people to be slower, like if they were supplying the data that went across, or something like that. But I think that's the hard part with teaching anybody anything - if you move faster, for some people it's going to be too fast. If you go slower for some people, it's going to be too slow for others. And that middle ground is insanely harder to reach. It's something that Brian and I have struggled with. Anybody who's tried to teach anything to anybody, trying to find that middle ground, I think that you're going to end up leaving people off on one side or the other, and it's really hard, and it breaks your heart trying to figure out a way to get everybody.
+
+**Ben Johnson:** Yeah, I totally agree.
+
+**Erik St. Martin:** Maybe you could have an automated play thing, where you don't have to click play, it just automatically transitions at a set interval, and you could put a slider for speeding it up or slowing it down or something like that.
+
+**Ben Johnson:** Yeah, that's true. Also the other part of it is it was just insanely hard to make, because I actually had to implement - because I was doing it all the time; it wasn't a set amount of time - I actually had to build the Raft implementation in JavaScript, that actually runs behind the scenes. I'm trying to find a much more simpler way to visualize.
+
+**Erik St. Martin:** \[laughs\] I see... I didn't think about that. You actually implemented Raft in JavaScript.
+
+**Ben Johnson:** Yeah, it was terrible. It was a bad idea \[laughter\].
+
+**Erik St. Martin:** Brian is giving you evil eyes from behind the microphone; I know it \[laughter\]. I know he's thinking, "Somebody's going to use this for evil."
+
+**Brian Ketelsen:** Yeah, it's going to be done. Never release that code, Ben.
+
+**Ben Johnson:** Oh, no, no.
+
+**Brian Ketelsen:** Never!
+
+**Ben Johnson:** Ever.
+
+**Erik St. Martin:** So I know we're running short on time, I think we might actually be a couple minutes over. But one thing we like to do with each show is Free Software Friday, where all of us will go across the board and list off some open source projects that are currently or have made our lives easier in the past, just because as we've spoken with other open source maintainers, most of the time, you only see the hate. You don't really see the love, so we want to continue to spread love for projects that are making our lives easier.
+
+So with that, Brian, do you want to go first?
+
+**Brian Ketelsen:** \[55:48\] Yeah, I'll kick it off with Minikube; github.com/kubernetes/minikube. K-U-B-E. It's a really fast and easy way to get you going on a Kubernetes cluster on your local laptop, which is awesome if you don't want to run 17 VMs to have a cluster. Very nice, simple, lightweight, easy way to get going.
+
+**Carlisia Thompson:** I can go next. First, let me mention that library I was talking about, it's upper.io/database.
+
+**Brian Ketelsen:** Oh, the database library earlier?
+
+**Carlisia Thompson:** Yeah. The not-ORM library. Before I forget too, I want to mention that Ben did a remote meetup event and he showed how to use BoltDB. That was pretty awesome.
+
+**Erik St. Martin:** Oh, cool, was that recorded?
+
+**Carlisia Thompson:** It is, yes. So if you go to remotemeetup.golangbridge.org, you will have the past events, and you'll find his event there. It was very good, I saw that one.
+
+**Erik St. Martin:** Oh, awesome.
+
+**Carlisia Thompson:** The free software I want to mention today is called Stow, it's part of the… I don't know how to pronounce this…
+
+**Erik St. Martin:** GNU.
+
+**Carlisia Thompson:** GNU, yes. I found this out through looking through Brian's and Erik's Dot files. I don't understand how I've been a programmer this long and I didn't know about this.
+
+**Erik St. Martin:** It's actually used under the covers for a lot of stuff to manage new versions of libraries.
+
+**Carlisia Thompson:** I thought it only did symlinks?
+
+**Erik St. Martin:** It does do symlinks, so it can basically symlink the default version of, say, a dynamic library or static library, to the most recent version of it that may exist somewhere else. But it's used for several things like that.
+
+**Carlisia Thompson:** Interesting.
+
+**Brian Ketelsen:** But it's very useful for DOT files.
+
+**Erik St. Martin:** Yeah. I cheated for DOT files \[laugh\].
+
+**Carlisia Thompson:** I see, I see. That's why the description here was a bit off from what I was expecting. But yeah, to manage DOT files… Wow, it's so easy. It's so easy to use! Can't believe I didn't know about it. Not I use it to manage my symlinks.
+
+**Erik St. Martin:** Yeah, so the cool thing about it is you can basically layer symlinks. The way I set it up in my DOT files is I have a DOT file GitHub repository, and all of my configuration files are stored in this DOT files directory, but then they're managed… The path structures based on the way it would be in my home directory, and then I can just do Stow and give it one directory, like Git. Then it symlinks all my Git DOT files to my home directory back to my DOT files' directory. Then I can just keep adding files, and keep telling it to reStow for those symlinks. If the directories already exist in your home directory, it symlinks individual files. If the directory doesn't exist, it symlinks the whole directory. It's kind of cool, because if you have Linux and Mac and all these things, you can kind of tell it to symlink just the things that on that box, rather than getting all of your DOT files, all or nothing.
+
+**Brian Ketelsen:** Yeah, it's winning.
+
+**Carlisia Thompson:** My biggest problem with symlinking manually was to remember how to un-symlink things. With Stow there's a delete command, and it's so easy.
+
+**Erik St. Martin:** Yeah. To un-Stow it?
+
+**Carlisia Thompson:** Yes, or un-Stow; I don't know, I don't know remember. I only did it once. I set it up super quickly and it worked, and I never had to look at it again. That's why I thought it was so great.
+
+**Brian Ketelsen:** Stow/d, I think.
+
+**Erik St. Martin:** Yes.
+
+**Brian Ketelsen:** Awesome.
+
+**Erik St. Martin:** So we have another lover of Stow.
+
+**Brian Ketelsen:** Yay!
+
+**Carlisia Thompson:** Yes, thank you. You did a great job explaining how it works, Erik. Thank you.
+
+**Erik St. Martin:** I set up that readme a long time ago. At the time, I think Brian was wanting to steal some DOT files, and a couple of other people we worked with, so I wrote up a thing because I was having to go to people's desks and help them, so it was just easier that way.
+
+So Ben, do you have a project you want to thank?
+
+**Ben Johnson:** \[01:00:01.13\] I don't have a project, mine is more like a maintainer. Kelsey Hightower, I just think he does… I know he's the Kubernetes guy, and sadly, I actually don't use Kubernetes, but I think he does a fantastic job being an evangelist for that. But really I think he's done so much in the community, and a lot of stuff he's done personally has meant a lot to me, so I just want to say thanks to him. I hope he keeps up everything he's doing and supporting the community, and everybody in it. Also, he had a fantastic intro at GopherCon this year. I thought he did an excellent job.
+
+**BRIAN KETELSEN:** Amen.
+
+**Ben Johnson:** So when the videos come out, please go watch that.
+
+**Erik St. Martin:** I've heard. Kelsey is a person. Kelsey Hightower is a person as well as his contributions in both articles and sample code; I think we all can admire and aspire to live up to that. Just a great guy all-around.
+
+**Brian Ketelsen:** I want to be like Kelsey.
+
+**Erik St. Martin:** Me too. Can I be like Kelsey when I grow up?
+
+**Brian Ketelsen:** It's going to take a lot of work.
+
+**Erik St. Martin:** So for my project, I'm actually going to sidestep development in Go projects.
+
+**Brian Ketelsen:** What?
+
+**Erik St. Martin:** Yeah, I'm going to do it. So as a hobby thing, I'm also - in addition to being addicted to databases, I'm addicted to information security. There's a distro a lot of people use, which is called Kali Linux, which is kind of based on Debian. But I'm an Arch user all the way around, so shortly before GopherCon I stumbled upon this, and it's a project called ArchStrike (archstrike.org). It's basically an Arch repository with all the InfoSec tools you might expect in Kali Linux, which is really cool. Now I get to stay in Arch, and not have to have a Kali VM running somewhere. I'm not sure how many other people in the Go world are InfoSec people, but I imagine they're there.
+
+**Brian Ketelsen:** Both of them are very excited right now \[laughter\].
+
+**Erik St. Martin:** You have to be a Go person listening to this podcast who also likes InfoSec and ArchStrike. And Arch Linux.
+
+**Carlisia Thompson:** And none of them are in the Slack right now. I'm sorry \[laughter\].
+
+**Erik St. Martin:** I think we made it all the way through our Free Software Friday. Before we start to close out the show, I do want to point out that the Changelog has another new podcast that's out that's called Request for Commits, and they're speaking with people about open source sustainability, and the human side of code. Business licensing, how projects are supported financially... That is changelog.com/rfc. Definitely check that out if you like our podcast, and the Changelog podcast - because who doesn't like the Changelog podcast?
+
+**Brian Ketelsen:** Right?
+
+**Erik St. Martin:** There's going to be one guy. I know there is.
+
+**Brian Ketelsen:** There's always one guy. Like the one guy on the GopherCon survey that thought Renee's talk was unsatisfactory. Seriously, a talk on the Gopher onset? You're out. Don't come back. We don't need you.
+
+**Carlisia Thompson:** Wow, her talk was awesome, I thought.
+
+**Erik St. Martin:** I think it was a nice mind-break. You forget how overwhelming all that content being jammed into you for two days straight can be. I think it was fun, and I think it was a nice step away from brain overload.
+
+**Brian Ketelsen:** It was awesome.
+
+**Erik St. Martin:** Did anybody else have anything else they want to mention before we close out the show?
+
+**Brian Ketelsen:** \[01:03:33.20\] There's gotta be something I forgot. Oh, you know how much I love to generate things in DSLs. The Quilt project I found yesterday; github.com/NetSys/quilt. Pretty cool way to generate container orchestration for your container deployments. It's a little bit outside of the realm of just straight Go programming, but it very much fits in my "generate all the things" mantra, which is a replacement for Docker Swarm, Kubernetes, or Mesos. And it uses a declarative DSL to describe your deployment, and then you just run it. It's kind of cool.
+
+**Erik St. Martin:** Well that's interesting, I haven't seen that yet.
+
+**Brian Ketelsen:** I find all the cool stuff.
+
+**Erik St. Martin:** Alright, I think we are out of time. I just want to thank everybody for being on the show. Thanks to Brian, Carlisia, and Ben, especially Ben for coming on the show, and talking, I think mostly databases. But this has been a great show. Thank you to all the listeners, both live, and who will be listening. If you aren't subscribed, you can go to gotime.fm, follow us on Twitter, we're at twitter.com/gotimefm. And we have a GitHub, which is github.com/gotimefm/ping, if you want to suggest speakers, or ask to be on, or have questions you might want us to ask speakers. And I think that's it, everybody. Thanks again.
+
+**Brian Ketelsen:** Thanks, Ben!
+
+**Carlisia Thompson:** Thank you!
+
+**Ben Johnson:** Thanks for having me.