<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dan Bentley on Medium]]></title>
        <description><![CDATA[Stories by Dan Bentley on Medium]]></description>
        <link>https://medium.com/@dbentley?source=rss-d3a2fbd2b0ab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*D3xDQ1jzTTBc_lNhc5G93Q.jpeg</url>
            <title>Stories by Dan Bentley on Medium</title>
            <link>https://medium.com/@dbentley?source=rss-d3a2fbd2b0ab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 06:03:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dbentley/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Microservice Devs: Put Down the Particle Accelerator]]></title>
            <link>https://medium.com/windmill-engineering/microservice-devs-put-down-the-particle-accelerator-1d0c17708ebe?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d0c17708ebe</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[tilt]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Thu, 05 Sep 2019 00:00:00 GMT</pubDate>
            <atom:updated>2019-09-06T16:23:01.687Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IFZONLJLhkmkE7iT.jpg" /><figcaption>More Science than is strictly necessary for daily work</figcaption></figure><h3>The Right Tool for the Right Job</h3><p>Build tools don’t work for microservices. We need a new kind of tool: the Microservice Development Engine (MDE). For decades, apps grew by building bigger binaries. So tools got better by getting faster at building big binaries. Now apps grow by adding more binaries (“microservice”), and each binary is smaller. Building each binary is easier, but requires more wrangling across binaries.</p><p>Google, Facebook and others invested Engineer-Millenia in making build tools that build huge binaries quickly, such as <a href="https://bazel.build/">Bazel</a> and <a href="https://buck.build/">Buck</a>. These became big science projects delivering amazing technical achievements, comparable to building a two-mile long particle accelerator.</p><p>(Particle accelerators show up a few times in this post, so some background: atomic physics experiments smash atoms together to see what happens. The first particle accelerator had a 4-inch diameter and cost $25. Over time, physicists got more demanding. Today’s best particle accelerator is <a href="https://en.wikipedia.org/wiki/CERN">CERN</a>: a 17 mile tunnel straddling the France-Switzerland border that cost $4.75 Billion to build.)</p><p>For most chemists, a $15 chemistry set helps more than a multi-billion dollar particle accelerator. If you want to develop microservices, a tool built for that will be better than a build tool like Bazel.</p><p>What does a Microservice Development Engine look like? It looks more like the build tools of 40 years ago: handling incremental updates to free you to focus on your app, not your build.</p><h3>Why We Use Build Tools</h3><p>Stu Feldman created the first build tool, <a href="https://en.wikipedia.org/wiki/Make_(software)">Make</a>, to replace a script like build.sh because he kept making a mistake: he&#39;d <a href="https://www.princeton.edu/~hos/mike/transcripts/feldman.htm">debug the wrong code</a>. After changing a file, he&#39;d run a program only to realize it didn&#39;t even contain his change. Compiling the whole program was so slow that he&#39;d avoid doing it by compiling just the file he&#39;d changed. This trick is fast but dangerous: forget to compile a file and you end up with the wrong program. Make gave developers the best of both worlds: as fast as compiling just what you&#39;d changed; as correct as a complete build.</p><p>Build tools free you from having to remember what to do after you hit save. Just run “make” (or “ant”, “yarn”, “bazel”, etc.) and you’re set. Today’s build tools share this goal, and improve on Make:</p><ul><li>Unit-testing as a first-class feature (like go test)</li><li>Dependency management and releases (like npm update or mvn publish)</li><li>Parallel cloud builds (like Bazel’s RBE)</li><li>Automatic rebuild after hitting save (like <a href="https://webpack.js.org/">Webpack</a>, <a href="https://jestjs.io/">Jest</a>, or IDEs)</li></ul><p>Build tools make projects more inclusive. You can contribute on day 1 without having to go to a bootcamp to learn all the dependencies of the codebase. New team members can have an impact without having to go to a build boot camp.</p><h3>Build Tools Focus on Files</h3><p>Build tool optimizations are based on a model: they’re pure functions from input files to output files. This view makes caching and parallelism easy. Need to compile a file? Check if you’ve already compiled it, and if so, just return that output. Need to compile 100 files? Send each to a different worker in the datacenter. This model even fits unit testing: it’s just generating a file that’s the output of running the test binary. Getting this correct and fast takes lots of effort, but it’s worth it given the productivity gains.</p><p>Build tools are particle accelerators. They’re both large engineering projects that combine small pieces into progressively larger results. Compiling a C++ file with headers is like smashing protons and neutrons to create a Carbon atom. Linking many libraries to create a binary results in an Iron atom. Container images are even larger, like a Uranium atom. Want to combine files? Nothing’s better.</p><p>But what about when you your operation doesn’t involve a file? If you need to run a server, what’s the file that’s output? How do you represent seeding a running database as a file operation? If your build failed because GitHub was down while it tried to download a dependency, how do you evict that entry from the cache? “Make everything as simple as possible, but no simpler.” Files are too simple for microservice dev.</p><h3>Development Today Needs New Tools</h3><p>For decades, the ways apps changed fit into make’s model: projects got bigger, and thus build tools got faster. The move to microservices is different: it’s a change in quality, not quantity.</p><p>Microservices means your app isn’t just one binary; your app (the experience your users care about) is the sum total of lots of individual binaries. Linking happens not at build-time but at run-time, over HTTP. Each individual build is smaller and faster. Starting the app is now more involved, as you have to connect all the components together in some way. You aren’t delivering an atom; you’re assembling a molecule.</p><p>The new layer of working with molecules introduces new workflows. For example, kubectl log lets you get the independent stdout/stderr for each resource as it&#39;s running. Build tools don&#39;t automate this because it doesn&#39;t fit with their model, so it&#39;s up to the developer to make sure they&#39;re looking at the right log. It&#39;s easy to forget to check every nook and cranny, so developers end up missing an error and continue on a wild goose chase.</p><p>An example of a missing tool in this new level: when I was at Google, I loved that our <a href="https://cacm.acm.org/magazines/2016/7/204032-why-google-stores-billions-of-lines-of-code-in-a-single-repository/fulltext">monorepo</a> meant I could build and test any project with one command. It was cool that even though I never worked on GMail, I could refactor it easily. But if I wanted to actually change GMail, I’d have to go dig up a team-specific Wiki page or shell script that described how to start up the constituent pieces, spread across terminal tabs. Running your full app should be as easy as building a monolith.</p><h3>Microservice Development Engine: the Chemistry Set</h3><p>Microservice development requires a new kind of tool: a Microservice Development Engine, or MDE. An MDE targets the same goal that first drove build tools: freeing you from remembering what to do after you hit save. New teammates should be able to ship code without learning the entire stack. We can’t be sure exactly what an MDE will look like, but the history of build tools lets us make informed guesses.</p><p>Make offered a faster and more consistent experience than the build.sh it replaced. It was able to do better because the engine could understand the structure of the Makefile (as opposed to the imperative flow of a script). MDEs will need a declarative description of how to build and deploy your microservice app. Because distributed systems involve the state of running services, you&#39;ll need a richer language to describe dependencies beyond the file-level data that build tools encode.</p><p>This description of your app’s molecule will include how to build each component microservice’s atom. Crafting a great experience at the molecular level won’t leave much time to work on lower levels. The same way MDEs shouldn’t write their own network stacks, a good MDE will let you use whatever build tool you already use.</p><p>MDEs will be reactive to provide the best of both IDEs and Kubernetes. Like IDEs, MDEs will watch your filesystem to upate when you save. Like Kubernetes they’ll watch your cluster to respond to unexpected events. The same way Kubernetes frees you from restarting a process, MDEs free you from remembering to do a build or refresh a log.</p><h3>Early MDEs</h3><p>One popular declarative description of how to build and deploy your microservice app is Docker Compose. <a href="https://docs.docker.com/compose/">Docker Compose</a> is a proto-MDE: it can build and start, but won’t react as you edit with incremental updates. To be clear: we love Docker Compose! It’s incredibly popular, a testament to the value it delivers, and users can hack in updates via mount points. Other proto-MDEs work outside containers, like <a href="https://github.com/ddollar/foreman">foreman</a>, the cleverly-named go-implementetation <a href="https://github.com/mattn/goreman">goreman</a>, and <a href="https://github.com/cortesi/modd">modd</a> offer similar functionality outside containers.</p><p>I work building <a href="https://tilt.dev/">Tilt</a>, a Kubernetes-focused MDE. If you use Kubernetes in production, you need Tilt in development. There are other MDE projects, like <a href="https://skaffold.dev/">Skaffold</a>, <a href="https://tekton.dev/">Tekton</a> (sort of an MDE), <a href="https://garden.io/">Garden</a>, <a href="https://okteto.com/">Okteto</a>, or <a href="https://kelda.io/">Kelda</a>.</p><p>I’m especially proud of a few Tilt features that really exemplify what MDEs can be, how they can offer a better experience, and how Tilt’s going to grow:</p><ul><li>The <a href="https://docs.tilt.dev/tutorial.html">Tiltfile</a> is an ergonomic way to define how to assemble the molecule of your app, from the simple (our <a href="https://docs.tilt.dev/tutorial.html">tutorial</a> highlights getting started with just Dockerfiles and Kubernetes YAML) or complex (calling out to an existing YAML generator like Helm or a custom script using ).</li><li><a href="https://docs.tilt.dev/custom_build.html">custom_build</a> lets you call out to an existing build tool. (A community member was able to integrate their Bazel builds without requiring any changes to Tilt)</li><li>Tilt’s localhost Web UI is a Heads-Up Display that gives you context across your app so you see problems faster, without having to play 20 questions with Kubectl</li><li><a href="https://blog.tilt.dev/2019/04/02/fast-kubernetes-development-with-live-update.html">Live Update</a> lets you skip image builds altogether: it updates running containers with new code, even for compiled languages.</li></ul><h3>MDEs: the Right Tool for the Job</h3><p>An MDE is going to supercharge your development in the times when you want to see and understand what’s happening across your app. Tilt’s still just a fraction of what it will be; if you want to help us realize this vision and have it for your inner loop, try Tilt and tell us what you think.</p><p><em>Originally published at </em><a href="https://blog.tilt.dev/2019/09/05/put-down-particle-accelerator.html"><em>https://blog.tilt.dev</em></a><em> on September 5, 2019.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d0c17708ebe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/microservice-devs-put-down-the-particle-accelerator-1d0c17708ebe">Microservice Devs: Put Down the Particle Accelerator</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fast Kubernetes Development with Live Update]]></title>
            <link>https://medium.com/windmill-engineering/fast-kubernetes-development-with-live-update-7b2395490d68?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b2395490d68</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[tilt]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Wed, 01 May 2019 15:59:39 GMT</pubDate>
            <atom:updated>2019-05-07T21:24:15.058Z</atom:updated>
            <content:encoded><![CDATA[<h3>Speed Up Your Kubernetes Development with Live Update</h3><p>Would you like to update your code on Kubernetes without waiting for a Docker build each time you change a file?</p><p>The new <strong>Live Update</strong> feature of Tilt does just that. It’s live in <a href="https://github.com/windmilleng/tilt/releases">Tilt v0.8</a>. This post walks through setting up Live Update and using Tilt to speed up your Kubernetes iteration loop to just seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/1*YZ7hJnHYw2dRyTdwntqJWg.jpeg" /><figcaption>Soon, your iteration loop will feel like this.</figcaption></figure><p>Live Update supports more projects than most sync tools because in addition to syncing files, it can run commands — which lets you call compilers, code generators, and more. (In particular, this means that Go projects can finally see the benefit of Go’s fast compiler even when running on Kubernetes.)</p><p>We’ll be using <a href="https://github.com/windmilleng/live_update/">this example repo</a> to demonstrate how to get up and running with Live Update. Feel free to pull it down, <a href="https://docs.tilt.dev/install.html">install Tilt</a>, and follow along.</p><h4>Phase 0: Tilt-ify your Deployment</h4><p>Live Update builds on top of Tilt’s ability to build, push, and apply images to Kubernetes. In this example, we’ll be iterating on a single Kubernetes Deployment. Let’s start with a simplified version of the Tiltfile for a Python project:</p><pre>k8s_yaml(&#39;hello.yaml&#39;)<br>docker_build(&#39;hello-py-image&#39;, &#39;./hello&#39;)</pre><p>Let’s explain each value:</p><ol><li>hello.yaml: the path to a yaml file with your Kubernetes Deployment</li><li>hello-py-image: the name of the image, as used in your Deployment YAML</li><li>./hello: path to the directory to docker build</li></ol><p>Now whenever you save a file in ./hello, Tilt rebuilds and redeploys your Deployment. This is easier than manually running docker build &amp;&amp; kubectl apply every time, but no faster. And in the words of the 1986 film “Top Gun”, “I feel the need. The need… for speed.”</p><h4>Phase 1: Sync Files</h4><p>Let’s use Live Update to sync files into a running pod. In the Tiltfile, we tell Tilt that this image can be updated by syncing files directly into the running container:</p><pre>k8s_yaml(&#39;hello.yaml&#39;)<br>docker_build(&#39;hello-py-image&#39;, &#39;./hello&#39;,<br>  live_update=[ sync(&#39;./hello&#39;, &#39;/&#39;) ])</pre><p>sync takes two arguments: the local path, and target path in the running container.</p><p>When you save a file in ./hello, Tilt copies the file into the running container (at the root). Of course, if we can’t reach the container for some reason (e.g. if the pod dies), Tilt notices, and builds and deploys the image from scratch.</p><h4>Phase 2: Run Commands</h4><p>Kubernetes sync tools have been limited to syncing code, which is fine for dynamic languages but doesn’t help you if you’re writing in a compiled language. This is especially frustrating for Go developers, because the Go compiler is really fast when it gets to use the cache — but a fresh image build can throw that cache away.</p><p><strong>Let’s switch gears and look at our example Go project. </strong>Here’s a simplified version of our example Go Tiltfile, using run to invoke a command on each Live Update:</p><pre>k8s_yaml(&#39;hello.yaml&#39;)<br>docker_build(&#39;hello-go-image&#39;, &#39;./hello&#39;,<br>  live_update=[<br>    sync(&#39;./hello&#39;, &#39;/app/src&#39;),<br>    run(&#39;cd /app/src &amp;&amp; go install .&#39;),<br>    restart_container(),<br>  ])</pre><p>When you save, Tilt will:</p><ol><li>copy over the changed file(s)</li><li>run the command</li><li>restart the container (so we execute the updated binary)</li></ol><h4>Phase 3: Fall Back to Full Build</h4><p>Sometimes, though, you don’t want to execute commands on the running container. For instance, updating dependencies (with npm or pip) or generating code (with protoc or thrift) may be more complexity than you want to deal with in your cluster, and you’d rather just do a fresh image build.</p><p>Live Update lets you tell Tilt to fall back to a full build when certain files are edited. Say we don’t want our running container to have internet access; we can’t download new dependencies from the container, so we want to to a full image build whenever our deps change. Here’s the snippet of the Go project Tiltfile that accomplishes this:</p><pre>docker_build(&#39;hello-go-image&#39;, &#39;./hello&#39;,<br>  live_update=[<br>    fall_back_on(&#39;hello/go.mod&#39;),<br>    sync(&#39;./hello&#39;, &#39;/app/src&#39;),<br>    run(&#39;cd /app/src &amp;&amp; go install .&#39;),<br>    restart_container(),<br>  ])</pre><p>When you save a file, Tilt will fall back if it matches fall_back_on. Here we fall back for go.mod, but in Python you might want to fall back on edits to requirements.txt, and in Javascript, package.json.</p><h4>Conclusion</h4><p>Live Update gives you the fastest Kubernetes update cycle; not only can you sync code, but unlike other Kubernetes sync tools, you can run commands and take advantage of caches and existing artifacts. You also get Tilt’s UI (you can see when your code is up-to-date or failing) and Reliability (when a pod gets restarted, Tilt will automatically resync the latest code so it’s never out-of-date). Like all of Tilt, it works with any cluster (EKS, GKE, minikube, Docker-for-Desktop, etc.).</p><p>You can get started Live Updating in 10 minutes using the <a href="https://github.com/windmilleng/live_update/tree/dbentley/initial">example repo</a>, or set up your own project using our <a href="https://docs.tilt.dev/tutorial.html">Tutorial</a>. (Already on Tilt? Skip straight to the <a href="https://docs.tilt.dev/live_update_tutorial.html">Live Update Tutorial</a>.) If you still have questions or want to get into the nitty-gritty, you can read more in our <a href="https://docs.tilt.dev/live_update_reference.html">Live Update Reference Doc</a>.</p><p>We’d love to hear what you think about this feature! Come find us on the Kubernetes Slack in <a href="https://kubernetes.slack.com/messages/CESBL84MV/">the <strong>#tilt</strong> channel</a> (you can <a href="http://slack.k8s.io/">get your invite here</a>), or reach out to <a href="https://twitter.com/windmill_eng">@windmill_eng</a> on Twitter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b2395490d68" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/fast-kubernetes-development-with-live-update-7b2395490d68">Fast Kubernetes Development with Live Update</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservices’ Hidden Problem: Understanding]]></title>
            <link>https://medium.com/windmill-engineering/microservices-hidden-problem-understanding-db42c3d0a2b6?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/db42c3d0a2b6</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[tilt]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Thu, 11 Apr 2019 14:45:56 GMT</pubDate>
            <atom:updated>2019-04-11T14:45:56.564Z</atom:updated>
            <content:encoded><![CDATA[<p>How many times have you been iterating on code and realized your microservice app was broken, but you weren’t sure where the error was hiding? When we talk to Devs, they say they spend hours each week hunting for the right log line, forced to play 20 questions with kubectl. The problem? You’re using a tool that only solves half of your problem.</p><p>After you save a file, you want to <strong>Update</strong> your developer instance to use your new code. Kubernetes updating is clumsy and slow, which has led many to write tools to improve the situation.</p><p>But these tools don’t help you <strong>Understand</strong>. When you can’t Understand, you can’t iterate. Faster Update isn’t enough.</p><blockquote>The state of the art? Open N terminals, one for each microservice.</blockquote><h4>Microservices make Understanding harder</h4><p>Microservices divide the single output stream of a monolith into N output streams, one per service. A frontend request can cause an error in any downstream service (or in several!). Services generate useful error messages, but developers have to check many nooks and crannies for errors.</p><p>This was an unsolved problem even before Kubernetes. Companies like Google, Facebook, and Twitter have invested SWE-centuries in build tools like Bazel, Buck, and Pants. But these tools focus on building and running single servers. It’s still up to the user to assemble them into a useful constellation of running processes. The state of the art? Open N terminals, one for each microservice.</p><p>Kubernetes made the problem worse. Some issues are fixable bad ergonomics (investigating one service requires multiple kubectl calls for logs vs. status). But Kubernetes fundamentally increased the scale of this problem by being so good: when it’s so easy to run many services, teams build more services. Maybe 5 terminals was manageable, but 25 isn’t.</p><p>Many developers accept this friction as a cost of debugging. That’s cutting our tools too much slack. Debugging is answering “why did this happen?”, and a computer can’t do that. But microservice developers routinely spend hours each week trying to answer “what happened?” Existing frameworks craft useful error messages that hide among the plethora of microservices. Playing 20 questions with kubectl just to find the right message is a waste of developer time.</p><h4>A Tool for Understanding</h4><p>Updating has clear requirements, so tools for Updating resemble each other (<a href="https://skaffold.dev/">Skaffold</a> is a straightforward upgrade over your custom shell script). A tool for Understanding doesn’t have a clear outline. I propose these principles, derived from the problems described above and centered on the developer’s needs, to guide us:</p><blockquote>See <strong>the</strong> error that’s blocking progress, for as long as it’s blocking progress.<br>Understand the context and situation of the error.<br>Explore related data without copying and pasting.</blockquote><p>kubectl fails these principles, hard: you don’t see errors until you think to look for them. (The right decision for ops leads to a horrible dev experience.) Tools like skaffold avoid this failure mode by streaming and multiplexing logs. But one burst of output can scroll the error off your screen before you notice.</p><p>These principles are about assuming a new responsibility: making sure the developer sees the right piece of feedback. It’s an impossibly huge mission. (Seemingly simple follow-up questions like “what’s an error? which errors are blocking progress? how can you know an error is fixed?” lead to a never-ending spiral of corner cases.)</p><h4>Tilt: Kubernetes Microservice Update+Understand</h4><p>We’re building Tilt to offer this new take on a developer tool. Its UI reflects the richness of our engine. Tilt is more than for-loop around a file watcher like inotify; it watches your filesystem and your cluster, joins the data to create a complete picture of your development, and responds to your commands.</p><p>Our 2-minute demo shows off Tilt’s Updating and Understanding abilities:</p><ul><li>birds-eye view of the services that comprise the app</li><li>automatic update on file save</li><li>errors stay pinned in the UI</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F1fS8K_Kn7yQ%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D1fS8K_Kn7yQ&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F1fS8K_Kn7yQ%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/087a7ef6b00ccc2c5cf6396605d56de2/href">https://medium.com/media/087a7ef6b00ccc2c5cf6396605d56de2/href</a></iframe><h4>A New Kind of Tool for a New Kind of Development</h4><p><em>We built Tilt from the ground up with microservice developers in mind. </em><a href="https://tilt.dev/contact"><em>Get in touch</em></a><em> if you’d like to try it today.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6N6_Lgl8rHEhOViJHi9SFw.png" /><figcaption>Tilt lets you see your microservice surroundings</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db42c3d0a2b6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/microservices-hidden-problem-understanding-db42c3d0a2b6">Microservices’ Hidden Problem: Understanding</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[.dev is a better .io (why we moved to tilt.dev)]]></title>
            <link>https://medium.com/windmill-engineering/dev-is-a-better-io-why-we-moved-to-tilt-dev-9fc8321693d3?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fc8321693d3</guid>
            <category><![CDATA[tilt]]></category>
            <category><![CDATA[domain-names]]></category>
            <category><![CDATA[internet]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Wed, 20 Feb 2019 16:04:08 GMT</pubDate>
            <atom:updated>2019-02-20T17:00:13.179Z</atom:updated>
            <content:encoded><![CDATA[<h3>.dev is a better .io (why we moved to tilt.dev)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*HVSVAkJTh0jr7uRNh3O9JQ.jpeg" /><figcaption>Diego Garcia, home of .io</figcaption></figure><p>We’re proud for <a href="https://tilt.dev/">Tilt</a> to be an early adopter of the .dev domain. Google’s <a href="https://get.dev/">announcement blog post</a> and landing page (the precociously named <a href="https://get.dev/">get.dev</a>) describe why .dev is a good TLD; I’d like to share why I think .dev is a <em>better</em> TLD.</p><p>[Quick note on terminology: TLD stands for Top-Level Domain. Once upon a time (1984), there were a few generics TLDs like .com (companies) and .edu (education), then each country got one, like .uk (UK) or .in (India). In the early-2000s, ICANN was created to handle internet naming, and they started adding more like .biz (business) and .coop (co-operatives, not chicken coops). In 2012, they opened the floodgates: anyone could apply to create a new TLD for any purpose: Like .bank (banks), .bar (bars) and .barefoot (I don’t want to guess and I damn sure don’t want to investigate).]</p><p>Before .dev, developer tools had a lot of mediocre options: .com with a made-up word; .com but with “get” or “use” before the word; .build (primarily meant for construction)… And then there’s .io. For some reason .io became the de facto standard for developer tools. It’s short, names are available, and it looks like “I/O”, which… developer tools involve? Not really sure why it took off.</p><p>But .io isn’t a subject domain (officially a “Generic” TLD, or gTLD); it’s for a country! (“Country Code” TLD, or ccTLD). What country? The <a href="https://en.wikipedia.org/wiki/British_Indian_Ocean_Territory">British Indian Ocean Territory</a>. This archipelago of 1,000 islands and no permanent inhabitants is the web presence of most developer tools. (It’s not so uncommon: .tv is actually the ccTLD for <a href="https://en.wikipedia.org/wiki/Tuvalu">Tuvalu</a>). This is somewhat dangerous because the rules and support for ccTLDs are less protective for users than gTLDs: if the country changes it mind, they can revoke the domain (war in Libya <a href="https://techcrunch.com/2011/04/04/letter-ly-abrupt-ly-loses-domain-name-as-a-result-of-the-war-in-libya/">brought down a .ly domain</a>). But my real problem with .io, and why I’m glad .dev is here, is that the “country” involved with .io is problematic.</p><p>The British Indian Ocean Territory has 0 permanent inhabitants because the UK forcibly deported the Chagossians (the people living there) 50 years ago. Why? Maybe to protect an endangered species? Or protect them from extreme weather? No, to make room for a <a href="https://en.wikipedia.org/wiki/Naval_Support_Facility_Diego_Garcia">US military base</a> within striking distance of Asia (also used for torture during the Global War on Terror).</p><p>The money you pay for a .io domain goes not to the Chagossians but to the perpetrators. (See the GigaoOm article “<a href="https://gigaom.com/2014/06/30/the-dark-side-of-io-how-the-u-k-is-making-web-domain-profits-from-a-shady-cold-war-land-deal/">The dark side of .io: How the U.K. is making web domain profits from a shady Cold War land deal</a>”.) I don’t want to provide material support to that, so we haven’t gotten a .io domain.</p><p>And now we don’t have to! .dev is a better domain for developer tools, that gives users better security and domain owners fewer moral qualms.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9fc8321693d3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/dev-is-a-better-io-why-we-moved-to-tilt-dev-9fc8321693d3">.dev is a better .io (why we moved to tilt.dev)</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Tilt updates Kubernetes in Seconds, not Minutes]]></title>
            <link>https://medium.com/windmill-engineering/how-tilt-updates-kubernetes-in-seconds-not-minutes-28ddffe2d79f?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/28ddffe2d79f</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Mon, 07 Jan 2019 17:21:41 GMT</pubDate>
            <atom:updated>2019-01-07T21:02:09.007Z</atom:updated>
            <content:encoded><![CDATA[<p>When I bring my cat a box of toys, he loves the box and ignores the toys. I wish he’d pay attention to the work I did, but I didn’t let it bother me because he’s a cat. Then I started getting the same reaction from Kubernetes developers.</p><p>We built our new tool <a href="https://tilt.build/">Tilt</a> to make Kubernetes updates fast. Really fast. Seconds-instead-of-minutes fast. Cloud-as-fast-as-laptop fast. But when we show it to developers, they love the UI and ignore the speed.</p><p>I understand why: Tilt’s <a href="https://www.youtube.com/watch?v=MGeUUmdtdKA">Heads-Up Display</a> collects errors, from build breakages to stack traces, into one layout so problems are easy to see. Developers see it and grok that Tilt lets them stop playing 20 questions with kubectl. But developers stop using tools that get in their way, so even if you start using Tilt because of the UI, you’ll keep using it because your 2m docker build &amp;&amp; kubectl apply now takes 5s.</p><p>I’ll bring you along on our journey of slashing 4 different Kubernetes update overheads. Even though Tilt doesn’t expose each as a configurable option, I want to share the excitement of finding and smashing a sequence of bottlenecks.</p><h3>Vanilla Kubernetes Deploy</h3><p>Before we can update, we have to deploy an initial version. The Kubernetes deploy pipeline:</p><ul><li>send source code to Docker (as a build context)</li><li>run a build command in Docker to create a layer with the generated/compiled artifacts</li><li>push the resulting image to a registry</li><li>allocate a new pod, pull the image and start running</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*jnRi-JvXuwYyn9Gc9duuag.png" /><figcaption>Vanilla k8s deploy</figcaption></figure><h3>Second Time, Same as the First</h3><p>Updating kubernetes isn’t an update so much as a second deploy. Even if you just changed one file, Docker will create a new layer with your current source code and start a build from scratch. (Docker’s layers and multistage builds can help, but require much cleverness)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*GXhhCXThiOY8QNXOFDPKEA.png" /><figcaption>Two vanilla k8s deploys</figcaption></figure><h3>Incremental Build</h3><p>Tilt’s image build API makes it easy to use your build cache on subsequent builds. Realistic builds improve from 30s to 1s.</p><p>Broadly speaking, Docker images are built in two steps: first, you copy over your source code; second, you run any steps to compile code or generate artifacts (e.g. “go build”, “proto gen”, “npm install”, etc.) Tilt’s fast_build improves both steps. In the copy step, Tilt updates just the edited file(s). In the build step Tilt injects the cache from the previous run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*1etxOQd3bBcVFuLE10t-ZQ.png" /><figcaption>The second time you make an apple pie, reuse the previously created universe</figcaption></figure><h3>Incremental Deploy</h3><p>We’re not done! Kubernetes is fast at starting new pods, but it can still take seconds. Tilt reuses existing Pods.</p><p>A “Synclet” runs on the same node. When you update files, the Synclet adds them to the existing pod and restarts the container. (This is an example of the <a href="https://kubernetes.io/blog/2015/06/the-distributed-system-toolkit-patterns/">Sidecar</a> pattern).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*b0MM1kRRTvsix3uHxJ3dSA.png" /><figcaption>Don’t tear down your house each time you want to change a doorknob</figcaption></figure><h3>Skip Registry</h3><p>Container registries are amazing for images with high fan-out, but our images are used once. Tilt reduces overhead by sending updates directly to the Synclet.</p><p>(This optimization creates corner cases when pods die and restart. Tilt watches your cluster to handle these cases and keep your personal instance in sync.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*Hz6Ht0xggj6GO3vC8vmAUw.png" /><figcaption>Mitigating the man-in-the-middle makes Mallory mad</figcaption></figure><h3>Build in Cloud</h3><p>1KB of edits to a .go file creates a 10MB binary diff; or 1 extra line in package.json can imply dozens of added libraries. Tilt sends the smaller source edit and does the build on the same node with our personal instance.</p><p>Tilt manages the complexity and headaches of running build commands in your cluster so you get faster updates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*2HUWuW8PNzzDZzwaeYP_pg.png" /><figcaption>The Code is coming from inside the Cluster</figcaption></figure><h3>Stand on our shoulders</h3><p>Sound good? Want this now?</p><ul><li>Read the <a href="https://docs.tilt.build/">Docs</a> to get Tilt working with your project.</li><li>Star our <a href="https://github.com/windmilleng/tilt">GitHub</a>. Or file an issue. Or fork and submit a pull request.</li><li>Join #tilt in the <a href="http://slack.k8s.io/">Kubernetes Slack</a> to discuss/request.</li></ul><p>Once you’re working with vanilla deploys, upgrade your builds to fast_build, as described in our <a href="https://docs.tilt.build/fast_build.html">docs</a>, to get this goodness.</p><h3>Cat Photo</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OUhj_0ds9l4-ldyTripowQ.jpeg" /><figcaption>Purring contentedly in his cardboard castle</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28ddffe2d79f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/how-tilt-updates-kubernetes-in-seconds-not-minutes-28ddffe2d79f">How Tilt updates Kubernetes in Seconds, not Minutes</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[mish: Flexible Shell Notebooks]]></title>
            <link>https://medium.com/windmill-engineering/mish-flexible-shell-notebooks-3d8a0e008716?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d8a0e008716</guid>
            <category><![CDATA[terminal]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Wed, 20 Jun 2018 18:56:57 GMT</pubDate>
            <atom:updated>2018-06-21T14:29:55.739Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-2_vusBqdbQA_1oxcBFKw.gif" /><figcaption>easier refining and repeating</figcaption></figure><p>Shell makes it easy to rerun previous commands, but hard to edit them. Rerunning is &lt;up&gt;-&lt;enter&gt;, but editing requires &lt;up&gt;-&lt;left&gt;-&lt;left&gt;-&lt;backspace&gt;-&lt;wait-how-many-backspaces-was-it&gt;-&lt;etc.&gt;. If you’ve ever been irritated editing in shell, our <a href="https://github.com/windmilleng/mish">new tool </a><a href="https://github.com/windmilleng/mish">mish</a> can save you time and hassle.</p><p>mish is a terminal app that augments easy-rerun with a better editing experience: your existing editor. By storing data in a file (notes.mill)instead of as command-line arguments, mish lets you flex your muscle memory to tweak your workflow. Your cursor stays put; your keyboard shortcuts are familiar.</p><p>Your notes.mill file is your personal notebook. It’s scratch space; edit as frequently as you need to change an argument. It’s durable; you won’t lose tuned commands to the shell history limit. It’s organized; different workflows can be separated and organized.</p><p>You can get <a href="https://github.com/windmilleng/mish">mish from github</a>. In 5 minutes, you’ll have a better shell experience. Have fun! If you’re still here, I’ll give a quick tour of mish.</p><h3>Hello World</h3><p>mish works best when you run two apps side-by-side: on the left, your editor with your code and a new file notes.mill in the root of your project. Open a terminal on the right and run mish.</p><p>notes.mill is written in Mill, a dialect of python (if you tell your editor that .mill files are python, you’ll get syntax highlighting, etc.). A good hello world is:</p><pre>sh(&quot;ls&quot;)<br>sh(&quot;echo hello mish&quot;)</pre><p>Switch into the mish window and hit r to rerun.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1iZGUcjmLf8mvYYjtU0ZLg.gif" /><figcaption>selecting a workflow</figcaption></figure><h3>Workflows</h3><p>Sometimes I want to run unittests; other times I want to start a server. Mill supports this by letting you define workflows:</p><pre>def wf_hello():<br>  sh(&quot;ls&quot;)<br>  sh(&quot;echo hello mish&quot;)</pre><pre>def wf_serve():<br>  sh(&quot;./server/main.py&quot;) # run the server</pre><p>Now pressing r will reload the Mill file, but the interesting workflows are in functions. Hit f to list available workflows, and pick one to focus on.</p><h3>Refine</h3><p>My magic moment with mish, when it became an indispensable tool, is when I’m modifying command lines. I end up with a section like:</p><pre>def wf_scratch():<br>  sh(&quot;go test -run TestWatchOneFile$ ./os/watch&quot;) # run one test<br>  sh(&quot;go test ./os/watch&quot;) # run all tests in the watch package<br>  sh(&quot;go test ./...&quot;) # run all tests in the project</pre><p>Because mish will error after a failing command, this helps me iterate while I’m seeing red, until everything passes and I’m seeing green.</p><h3>Mish your way</h3><p>What will make mish click for you? Maybe it’s the way it can take fewer keystrokes to restart a server. Or making sure you generate code as you’re editing your protocol buffers. But we’re pretty sure the next time you’re editing a command in shell, you’ll have a better day if you <a href="https://github.com/windmilleng/mish">try </a><a href="https://github.com/windmilleng/mish">mish</a>.</p><p>Make sure to let us know by filling out our <a href="https://docs.google.com/forms/d/e/1FAIpQLSf8UXLG0FOeMswoW7LuUP02CeUwKBccJishJKDE_VyOqe7g_g/viewform?usp=sf_link">5-minute survey</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KbCt7S4W2Eh8EK7mqor4Pg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d8a0e008716" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/mish-flexible-shell-notebooks-3d8a0e008716">mish: Flexible Shell Notebooks</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub propelled Git to escape velocity]]></title>
            <link>https://medium.com/windmill-engineering/github-propelled-git-to-escape-velocity-7838f566722e?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/7838f566722e</guid>
            <category><![CDATA[mercurial]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Mon, 04 Jun 2018 21:01:03 GMT</pubDate>
            <atom:updated>2018-06-04T21:01:03.116Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://blogs.microsoft.com/blog/2018/06/04/microsoft-github-empowering-developers/">Microsoft + GitHub</a>! Is it more <a href="https://www.youtube.com/watch?v=DJLDF6qZUX0">Chocolate + Peanut Butter</a> or <a href="https://www.youtube.com/watch?v=JmzuRXLzqKk">Dogs + Cats</a>? Hot Take Tuesday falls on Monday this week:</p><ul><li>HackerNews is full of <a href="https://news.ycombinator.com/item?id=17229848">Sound</a> and <a href="https://news.ycombinator.com/item?id=17226225">Fury</a>, signifying nothing.</li><li><a href="https://news.ycombinator.com/item?id=17223116">GitLab</a> usage is skyrocketing.</li><li>SourceForge abides.</li><li>Glitch says it’s good (I agree!) and <a href="https://medium.com/glitch/github-glitch-and-the-future-of-social-coding-5e6faa45c8f2">outlines a new vision for social coding</a>.</li></ul><p>Adding my congratulations seems insufficient; I’ll try to provide a hot take. Conventional Wisdom is GitHub succeeded because it made good bets (on Ruby as community and git as source control).</p><p>I think GitHub’s key bet was forking, and it was so successful that GitHub spread git to new developers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/343/1*DeZ4wzaH1PT58OKzTKRVZg.jpeg" /><figcaption>Spongebob Squaregit</figcaption></figure><h3>My History at Google Code</h3><p>I saw GitHub’s early years from working at Google. In 2009, I was on the Open Source team and Google Code Project Hosting (aka code.google.com) <a href="https://www.youtube.com/watch?v=ri796Hx8las">added Mercurial support</a> to their original Subversion backend. It seemed like a reasonable bet: Mercurial had a nicer interface, better Windows support, and a wire format more compatible with Google’s request routing infrastructure.</p><p>In 2011, I started managing Google Code. It was clear that GitHub was making open source development easier. Was it because git was more popular? We added git support (as did Kiln and Bitbucket). But GitHub was more than Git.</p><h3>Pull Requests Encourage Contribution</h3><p>Open Source projects on Sourceforge and Google Code felt Professional. They had owners and issue tracking and workflows and releases. If I wanted a new feature, it felt intimidating to imagine running the gauntlet of contributing. In many cases, this intimidation was unfair because the “Owner” was one person who would have loved help.</p><p>Pull Requests were the easiest way to submit a code review. No new tools to install, no separate UI to navigate. Pull Requests made you feel like your voice mattered.</p><p>Pull Requests get the credit as GitHub’s big innovation, but this misses the bigger barrier that GitHub broke.</p><h3>Fork Doesn’t Have to Be a Four-Letter Word.</h3><p>GitHub reduced the hassle if your Pull Request was rejected (whether for a good reason or just ignored). Step 1 of making a Pull Request is to make a Fork.</p><p>Before GitHub, a Fork was an insult. “You’re so unreasonable I’m taking my toys and going home.” GitHub made it a way of life.</p><p>A rejected Pull Request isn’t a big deal if you have a fork. And it doesn’t rule out a later merge. And who knows, maybe your fork will end up becoming the most popular.</p><p>Code Review is great, but I’m an ex-Googler, so of course I think that. What really drives collaboration is freedom to try, fail, and move forward. Forking normalized that way more than Pull Requests. GitHub made it accessible and acceptable.</p><h3>Git allowed the workflow; GitHub made it popular</h3><p>This freedom to fork wasn’t built-in to git; other hosts offering git didn’t enable this workflow. (Conversely, GitHub could have built this on Mercurial)</p><p>Developers didn’t flock to git because it powered the biggest projects (Linux or gcc). They flocked to get their next project done, which was may more likely to need to change a library like “twitter-oauth-client-ruby”.</p><p>GitHub helped Git more than Git helped GitHub.</p><h3>My story, continued</h3><p>At Google Code, we realized that GitHub was great and the world didn’t need us to be another GitHub. Since then, Social Coding has grown further. Glitch is upgrading “Forking” into “Remixing”. Editors like Jetbrains and VSCode are bringing real-time collaboration to IDEs.</p><p>I moved to other projects. Google Code shut down (with lots of work to make it easy to migrate archives). But I kept thinking about how to make game-changing developer tools.</p><p>The next frontier is the part of development before source control; the workflows locked up in individual developers’ shell histories/brains. It’s hard to understand what files feed into which build commands that necessitate restarting which microservices. Who knows what files are created by which steps that could be parallelized/moved to the cloud?</p><p>We at Windmill call this Live Development: showing you the Illuminating Output that will move you forward. You spend more time in your workflow than in your source control; workflow tools can make a bigger difference than source control tools. Interested? <a href="https://medium.com/windmill-engineering/windmill-fan-program-a4c0066c356d">Sign up to be a Fan</a> and we’ll let you in on all our secrets.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7838f566722e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/github-propelled-git-to-escape-velocity-7838f566722e">GitHub propelled Git to escape velocity</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[mish: cruise control for developers]]></title>
            <link>https://medium.com/windmill-engineering/mish-cruise-control-for-developers-98629709b5ec?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/98629709b5ec</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[shell]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Thu, 31 May 2018 14:10:06 GMT</pubDate>
            <atom:updated>2018-05-31T17:28:31.343Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5SyGWMKZ3wyZq_iNOp2g_g.gif" /><figcaption>mish in action</figcaption></figure><p>Our next Windmill experiment is <a href="https://github.com/windmilleng/mish">live</a>. mish is a terminal app that automates your development loop. mish watches your files, reruns commands, and displays the output. Refining the commands as your workflow changes is easy and ergonomic.</p><p>mish is cruise control for developers. It takes minutes to start using it. It automates the repetitive so you can focus on the important. Keep your eyes on the road/code. Stay in <a href="https://en.wikipedia.org/wiki/Flow_(psychology)">Flow</a>.</p><h3>Why Automate</h3><p>Navigating through shell history isn’t hard, but it is unnecessary. Our commands are repeated because we’re in an edit-compile-test(-restart-etc.) loop. Contorted key combos, even when etched in muscle memory, take effort and steal attention in the best case.</p><p>In the worst case, they waste time. Like when you spend 5 (15? 30?) minutes figuring out why your code is having no effect, only to realize you were building the wrong binary.</p><p>Computers perform rote steps accurately and quickly. mish makes you more productive during the day, and less exhausted at the end of it.</p><h3>What’s New</h3><p><a href="https://github.com/emcrisostomo/fswatch">Autorunning</a> <a href="https://www.emacswiki.org/emacs/FlyMake">tools</a> <a href="https://marketplace.visualstudio.com/items?itemName=gabrielgrinberg.auto-run-command">exist</a>, but the number of people who use them rounds to 0. (Heck, I don’t use them.) Why is mish different?</p><p>It recognizes that your workflow is dynamic: you futz with a flag or change the set of packages under test. Autorunning tools are meant to keep you in Flow, but refinement requires stopping, editing an invocation, and restarting. Cruise control needs a dial that can be tuned after ignition.</p><p>mish can be tuned by editing a file instead of a command-line. A Millfile is easy and fun to refine because it’s a program in the Mill language.</p><h3>Mill: a Language for Refinement</h3><p>Mill is a dialect of Python (built with<a href="https://github.com/google/skylark">skylark</a>, a great Python interpreter) that makes scripting dev workflows easy. A new configuration language can be intimidating. Let’s look at a useful Millfile:</p><pre>sh(&quot;go test -v ./pkg/foo&quot;) # run a unit test</pre><p>That’s it!</p><p>The <a href="https://github.com/windmilleng/mish">README</a> describes growing your Millfile. You can run multiple commands, or watch/ignore files that trigger runs.</p><p>Because Mill deals with commands, not libraries, it works with any language, testing framework, or backend.</p><h3>It’s Dangerous to Go Alone; Take Mi(chel)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KbCt7S4W2Eh8EK7mqor4Pg.png" /><figcaption>Bonjour! Je m’appelle Michel</figcaption></figure><p>Adopting a new tool, especially a CLI, is intimidating because so many are so inscrutable. mish means to break that trend. It offers a contextual help bar in the footer. And a mascot!</p><p>mish is also short for “Michel”. Every hermit crab has to find a shell to live in; Michel picked yours. Over time, expect Michel to make more appearances; DevTools don’t have to be soulless. We hope Michel makes you smile, and they make your workflow more enjoyable. (yes, “they”; mish is a binary but Michel is <a href="https://en.wikipedia.org/wiki/Genderqueer">non-binary</a>)</p><h3>The Earliest of Days</h3><p>We started coding mish 2 weeks ago. We’re sharing it this early because our mission is fast feedback. We think this primordial state can get you fast feedback about your code. And we hope it can get us fast feedback about our hypothesis.</p><p>Sounds compelling? Or mildly intriguing? Or even totally wrong-headed? Great!</p><ul><li><a href="https://github.com/windmilleng/mish">Get </a><a href="https://github.com/windmilleng/mish">mish from github</a></li><li>15 minutes of setup</li><li>A day or two of developing as it runs in the background</li><li>20 minutes to <a href="https://docs.google.com/forms/d/e/1FAIpQLSf8UXLG0FOeMswoW7LuUP02CeUwKBccJishJKDE_VyOqe7g_g/viewform?usp=sf_link">tell us how it feels</a>. Better? Worse? Bugs getting in the way of the vision? Let us know.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98629709b5ec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/mish-cruise-control-for-developers-98629709b5ec">mish: cruise control for developers</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Windmill Fan Program]]></title>
            <link>https://medium.com/windmill-engineering/windmill-fan-program-a4c0066c356d?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4c0066c356d</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[development-tools]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Tue, 22 May 2018 19:10:14 GMT</pubDate>
            <atom:updated>2018-05-22T19:13:58.890Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tzJemAXfFDXb1FKBEdgVfg.jpeg" /><figcaption>Gopher feels the wind in their fur</figcaption></figure><p>Windmill is experimenting with Live Development. We’re building small tools we hypothesize will improve developer workflows. We need people to try them and give feedback. Other companies might call these Alpha Testers.</p><p>At Windmill, we call them Fans.</p><p>Fans get to try our experiments. Each experiment should take:</p><ul><li>2 minutes to decide if it’s right for you (e.g., it might be for an IDE you don’t use)</li><li>15–30 minutes to install and set up</li><li>1–2 days of working as you normally do, and seeing how it feels</li><li>10 minutes to give us feedback. (Or more! We’ll listen for as long as you talk)</li></ul><p>We’re launching our first experiment soon. Very soon! Before June!</p><p>Be the first to hear about future experiments by signing up below.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fairtable.com%2Fembed%2Fshr39k0vIo0QfZjrY&amp;url=https%3A%2F%2Fairtable.com%2Fshr39k0vIo0QfZjrY&amp;image=https%3A%2F%2Fstatic.airtable.com%2Fimages%2Foembed%2Fairtable.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=airtable" width="800" height="533" frameborder="0" scrolling="no"><a href="https://medium.com/media/ce0697f2666bf5c90d384f6320646d8d/href">https://medium.com/media/ce0697f2666bf5c90d384f6320646d8d/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4c0066c356d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/windmill-fan-program-a4c0066c356d">Windmill Fan Program</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Strange Loop Trip Report]]></title>
            <link>https://medium.com/windmill-engineering/strange-loop-trip-report-96dbc1cb42e9?source=rss-d3a2fbd2b0ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/96dbc1cb42e9</guid>
            <category><![CDATA[conference]]></category>
            <dc:creator><![CDATA[Dan Bentley]]></dc:creator>
            <pubDate>Tue, 03 Oct 2017 14:58:47 GMT</pubDate>
            <atom:updated>2017-10-03T14:58:47.376Z</atom:updated>
            <content:encoded><![CDATA[<p>Strange Loop is great. A technology conference in St. Louis, vaguely focused on programming languages as tools, that’s grown to 2,000 people. A few things stood out:</p><h3>Project Alloy</h3><p><a href="https://www.projectalloy.org/">Project Alloy</a> shifts the ratio by sponsoring (and mentoring) underrepresented people to go to conferences. This year, they were able to sponsor 120 (!!!) attendees. It’s great to see conference sessions where the questions asked reflect a diversity of backgrounds.</p><h3>Haxl</h3><h3>Dan Bentley on Twitter</h3><p>At a talk about Haxl https://t.co/nAIfegAAKr Nick, don&#39;t read below this. ... Maybe I need to be writing a Haskell library?</p><p><a href="https://www.youtube.com/watch?v=sT6VJkkhy0o">Haxl</a> lets you separate I/O from logic in your program. I’m really receptive to the idea of a “Big Hammer” from the talk: you have to change the way you do things, but once you do, you get all these benefits. MapReduce, TensorFlow, Haxl. We hope Windmill.</p><p>I’m back home now, and the spell has worn off, but it’s such a rush to find an idea that can let you reenvision your work.</p><h3>Caches</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FkxMKnx__uso%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DkxMKnx__uso&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FkxMKnx__uso%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/6168a0465b01b55cab39981f49f1e2fe/href">https://medium.com/media/6168a0465b01b55cab39981f49f1e2fe/href</a></iframe><p>My ex-coworker Bonnie Eisenman gave a great talk about how Twitter’s user service caches. But it’s not really a story about one service; it’s about how caching can grow with a service’s needs, and how to think about deploying them for what needs. A talk inspired by real production pain.</p><h3>The Truth About Mentoring Minorities</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FsBD1SGuH2aI%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DsBD1SGuH2aI&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FsBD1SGuH2aI%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f72e46af98df0a5d5c8313a061916ff/href">https://medium.com/media/8f72e46af98df0a5d5c8313a061916ff/href</a></iframe><p>The talk started with the statement “<a href="https://twitter.com/dbentley/status/913841647124926465">if talking about race makes you uncomfortable, get comfortable being uncomfortable.</a>” (I live-tweeted most of this talk, because it was so powerful.)</p><p>We want Windmill to be safe, inclusive, diverse. It was good to hear more about how to do this, and a few things in there that I know I need to improve on. (For instance, my hesitation to say things for fear of stereotyping).</p><h3>Datafun: A Functional Query Language</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FgC295d3V9gE%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DgC295d3V9gE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FgC295d3V9gE%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ba9fb063d4585594556c8546c409e782/href">https://medium.com/media/ba9fb063d4585594556c8546c409e782/href</a></iframe><p>The speaker “rntz” prefaced the talk: “most talks are ‘we saw problem X, we did work Y, and found improvement Z’; this talk is earlier, it’s just ‘we’re doing work Y’”. Hah! I liked seeing the in-progress thought process.</p><p>Also, got a reference to a super relevant <a href="https://arxiv.org/abs/1312.0658">paper</a> that confirms my gut intuition about a portion of Windmill (changing inputs to a function is a form of derivative).</p><h3>Wrap-Up</h3><p>First, thanks to the organizers of Strange Loop. Great conference, and impressive that the talk videos are already up. And yay for making diversity such a focus (still not perfect, but no one is).</p><p>Going to a conference isn’t just seeing talks. It’s also seeing people. Great to meet up with friends old, current, and (hopefully) future. And holding the pre-conference party at City Museum? Incredible! <a href="https://en.wikipedia.org/wiki/City_Museum">Wikipedia</a> describes it as “a play house museum”. The conference rents it out completely, so your maneuvering through twists and turns is free of fear of kicking seven-year-olds. You should go to Strange Loop next year, and fly in a day early to make the pre-party.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96dbc1cb42e9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/windmill-engineering/strange-loop-trip-report-96dbc1cb42e9">Strange Loop Trip Report</a> was originally published in <a href="https://medium.com/windmill-engineering">Tilt Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>