diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index 37450cda4..4c1f22a3d 100644
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -336,9 +336,11 @@ class UsersController < ApplicationController
   def import_articles_from_feed(user)
     return if user.feed_url.blank?
 
-    worker = FeatureFlag.enabled?(:feeds_import) ? Feeds::ImportArticlesWorker : RssReaderFetchUserWorker
-
-    worker.perform_async(user.id)
+    if FeatureFlag.enabled?(:feeds_import)
+      Feeds::ImportArticlesWorker.perform_async(nil, user.id)
+    else
+      RssReaderFetchUserWorker.perform_async(user.id)
+    end
   end
 
   def profile_params
diff --git a/app/services/feeds/import.rb b/app/services/feeds/import.rb
index 9be0520a9..0fccd9bda 100644
--- a/app/services/feeds/import.rb
+++ b/app/services/feeds/import.rb
@@ -1,12 +1,13 @@
 module Feeds
   class Import
-    def self.call(users: nil)
-      new(users: users).call
+    def self.call(users: nil, earlier_than: nil)
+      new(users: users, earlier_than: earlier_than).call
     end
 
-    def initialize(users: nil)
+    def initialize(users: nil, earlier_than: nil)
       # using nil here to avoid an unnecessary table count to check presence
       @users = users || User.with_feed
+      @earlier_than = earlier_than
 
       # NOTE: should these be configurable? Currently they are the result of empiric
       # tests trying to find a balance between memory occupation and speed
@@ -40,6 +41,9 @@ module Feeds
         total_articles_count += articles.length
 
         articles.each { |article| Slack::Messengers::ArticleFetchedFeed.call(article: article) }
+
+        # we use `feed_fetched_at` to mark the last time a particular user's feed has been fetched, parsed and imported
+        batch_of_users.update_all(feed_fetched_at: Time.current)
       end
 
       DatadogStatsClient.count("feeds::import::articles.count", total_articles_count)
@@ -48,7 +52,15 @@ module Feeds
 
     private
 
-    attr_reader :users, :users_batch_size, :num_fetchers, :num_parsers
+    attr_reader :earlier_than, :users_batch_size, :num_fetchers, :num_parsers
+
+    def users
+      return @users unless earlier_than
+
+      # Filtering users whose feed hasn't been processed in the last `earlier_than` time span.
+      # New users + any user whose feed was processed earlier than the given time
+      @users.where(feed_fetched_at: nil).or(@users.where(feed_fetched_at: ..earlier_than))
+    end
 
     # TODO: put this in separate service object
     def fetch_feeds(batch_of_users)
@@ -79,8 +91,6 @@ module Feeds
         next
       end
 
-      batch_of_users.update_all(feed_fetched_at: Time.current)
-
       result.compact.to_h
     end
 
diff --git a/app/workers/articles/rss_reader_worker.rb b/app/workers/articles/rss_reader_worker.rb
index cacb21ba2..1cfae57de 100644
--- a/app/workers/articles/rss_reader_worker.rb
+++ b/app/workers/articles/rss_reader_worker.rb
@@ -11,7 +11,7 @@ module Articles
       return if SiteConfig.dev_to?
 
       if FeatureFlag.enabled?(:feeds_import)
-        ::Feeds::ImportArticlesWorker.perform_async
+        ::Feeds::ImportArticlesWorker.perform_async(4.hours.ago)
       else
         # don't force fetch. Fetch "random" subset instead of all of them.
         ::RssReader.get_all_articles(force: false)
diff --git a/app/workers/feeds/import_articles_worker.rb b/app/workers/feeds/import_articles_worker.rb
index 7c8414550..77a1ee66d 100644
--- a/app/workers/feeds/import_articles_worker.rb
+++ b/app/workers/feeds/import_articles_worker.rb
@@ -4,16 +4,10 @@ module Feeds
 
     sidekiq_options queue: :medium_priority, retry: 10
 
-    def perform(user_ids = [])
-      user_ids = Array.wrap(user_ids)
+    def perform(earlier_than, user_ids = [])
+      users = user_ids.present? ? User.where(id: user_ids) : nil
 
-      users = if user_ids.present?
-                User.where(id: user_ids)
-              else
-                User.with_feed
-              end
-
-      ::Feeds::Import.call(users: users)
+      ::Feeds::Import.call(users: users, earlier_than: earlier_than)
     end
   end
 end
diff --git a/lib/tasks/fetch.rake b/lib/tasks/fetch.rake
index d1cf05fed..b45c53cc0 100644
--- a/lib/tasks/fetch.rake
+++ b/lib/tasks/fetch.rake
@@ -2,7 +2,7 @@ desc "This task is called by the Heroku scheduler add-on"
 
 task fetch_all_rss: :environment do
   if FeatureFlag.enabled?(:feeds_import)
-    Feeds::Import.call
+    Feeds::Import.call(earlier_than: 4.hours.ago)
   else
     # don't force fetch. Fetch "random" subset instead of all of them.
     RssReader.get_all_articles(force: false)
@@ -10,7 +10,7 @@ task fetch_all_rss: :environment do
 end
 
 task fetch_feeds_import: :environment do
-  Feeds::Import.call
+  Feeds::Import.call(earlier_than: 4.hours.ago)
 end
 
 # Temporary
diff --git a/spec/requests/user/user_settings_spec.rb b/spec/requests/user/user_settings_spec.rb
index a66d8ea21..3059880b6 100644
--- a/spec/requests/user/user_settings_spec.rb
+++ b/spec/requests/user/user_settings_spec.rb
@@ -309,7 +309,7 @@ RSpec.describe "UserSettings", type: :request do
       let(:user) { create(:user, feed_url: feed_url) }
 
       it "invokes RssReaderFetchUserWorker" do
-        allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(user.id)
+        allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(nil, user.id)
         allow(RssReaderFetchUserWorker).to receive(:perform_async).with(user.id)
 
         put user_path(user.id), params: { user: { feed_url: feed_url } }
@@ -319,13 +319,13 @@ RSpec.describe "UserSettings", type: :request do
       end
 
       it "invokes Feeds::ImportArticlesWorker if feeds_import feature flag is on" do
-        allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(user.id)
+        allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(nil, user.id)
         allow(RssReaderFetchUserWorker).to receive(:perform_async).with(user.id)
         allow(FeatureFlag).to receive(:enabled?).with(:feeds_import).and_return(true)
 
         put user_path(user.id), params: { user: { feed_url: feed_url } }
 
-        expect(Feeds::ImportArticlesWorker).to have_received(:perform_async).with(user.id)
+        expect(Feeds::ImportArticlesWorker).to have_received(:perform_async).with(nil, user.id)
         expect(RssReaderFetchUserWorker).not_to have_received(:perform_async).with(user.id)
       end
     end
diff --git a/spec/services/feeds/import_spec.rb b/spec/services/feeds/import_spec.rb
index db75fafb4..d8cc3d55c 100644
--- a/spec/services/feeds/import_spec.rb
+++ b/spec/services/feeds/import_spec.rb
@@ -44,25 +44,6 @@ RSpec.describe Feeds::Import, type: :service, vcr: true, db_strategy: :truncatio
       end
     end
 
-    it "does refetch same user over and over by default", vcr: { cassette_name: "feeds_import_multiple_times" } do
-      user = User.find_by(feed_url: nonpermanent_link)
-
-      Timecop.freeze(Time.current) do
-        user.update_columns(feed_fetched_at: Time.current)
-
-        fetched_at_time = user.reload.feed_fetched_at
-
-        # travel a few seconds in the future to simulate a new time
-        3.times do |i|
-          Timecop.travel((i + 5).seconds.from_now) do
-            described_class.call
-          end
-        end
-
-        expect(user.reload.feed_fetched_at > fetched_at_time).to be(true)
-      end
-    end
-
     it "queues as many slack messages as there are articles", vcr: { cassette_name: "feeds_import" } do
       old_count = Slack::Messengers::Worker.jobs.count
       num_articles = described_class.call
@@ -123,8 +104,61 @@ RSpec.describe Feeds::Import, type: :service, vcr: true, db_strategy: :truncatio
     end
   end
 
+  context "when refetching" do
+    before do
+      [link, nonmedium_link, nonpermanent_link].each do |feed_url|
+        create(:user, feed_url: feed_url)
+      end
+    end
+
+    it "does refetch same user over and over by default", vcr: { cassette_name: "feeds_import_multiple_times" } do
+      user = User.find_by(feed_url: nonpermanent_link)
+
+      Timecop.freeze(Time.current) do
+        user.update_columns(feed_fetched_at: Time.current)
+
+        fetched_at_time = user.reload.feed_fetched_at
+
+        # travel a few seconds in the future to simulate a new time
+        3.times do |i|
+          Timecop.travel((i + 5).seconds.from_now) do
+            described_class.call
+          end
+        end
+
+        expect(user.reload.feed_fetched_at > fetched_at_time).to be(true)
+      end
+    end
+
+    it "does not refetch recently fetched users if earlier_than is given", vcr: { cassette_name: "feeds_import" } do
+      time = 30.minutes.ago
+
+      Timecop.freeze(time) do
+        described_class.call
+      end
+
+      # we delete the articles to make sure it won't trigger the duplicate check
+      Article.delete_all
+
+      expect { described_class.call(earlier_than: 1.hour.ago) }.not_to change(Article, :count)
+    end
+
+    it "refetches recently fetched users if earlier_than is now", vcr: { cassette_name: "feeds_import_twice" } do
+      time = 30.minutes.ago
+
+      Timecop.freeze(time) do
+        described_class.call
+      end
+
+      # we delete the articles to make sure it won't trigger the duplicate check
+      Article.delete_all
+
+      expect { described_class.call(earlier_than: Time.current) }.to change(Article, :count)
+    end
+  end
+
   context "when feed_referential_link is false" do
-    it "does not self-reference links for user" do
+    it "does not self-reference links for user", vcr: { cassette_name: "feeds_import_non_referential" } do
       # Article.find_by is used by find_and_replace_possible_links!
       # checking its invocation is a shortcut to testing the functionality.
       allow(Article).to receive(:find_by).and_call_original
diff --git a/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_a_fetching_error.yml b/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_a_fetching_error.yml
deleted file mode 100644
index a411d5ab7..000000000
--- a/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_a_fetching_error.yml
+++ /dev/null
@@ -1,286 +0,0 @@
----
-http_interactions:
-- request:
-    method: get
-    uri: https://medium.com/feed/@vaidehijoshi
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:33 GMT
-      Content-Type:
-      - text/xml; charset=UTF-8
-      Transfer-Encoding:
-      - chunked
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Cache-Control:
-      - private, must-revalidate, max-age=900
-      Content-Security-Policy:
-      - 'default-src ''self''; connect-src https://localhost https://*.instapaper.com
-        https://*.stripe.com https://glyph.medium.com https://*.paypal.com https://*.braintree-api.com
-        https://*.braintreegateway.com https://accounts.google.com https://getpocket.com
-        https://medium.com https://*.medium.com https://*.medium.com https://medium.com
-        https://*.medium.com https://*.algolia.net https://cdn-static-1.medium.com
-        https://dnqgz544uhbo8.cloudfront.net https://cdn-videos-1.medium.com https://cdn-audio-1.medium.com
-        https://lightstep.medium.systems https://*.branch.io ''self''; font-src data:
-        https://*.amazonaws.com https://*.medium.com https://glyph.medium.com https://medium.com
-        https://*.gstatic.com https://dnqgz544uhbo8.cloudfront.net https://cdn-static-1.medium.com
-        ''self''; frame-src chromenull: https: webviewprogressproxy: medium: ''self'';
-        img-src blob: data: https: ''self''; media-src https://*.cdn.vine.co https://d1fcbxp97j4nb2.cloudfront.net
-        https://d262ilb51hltx0.cloudfront.net https://*.medium.com https://gomiro.medium.com
-        https://miro.medium.com https://pbs.twimg.com ''self'' blob:; object-src ''self'';
-        script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
-        ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
-      Expires:
-      - Wed, 21 Oct 2020 15:23:33 GMT
-      Link:
-      - <https://medium.com/humans.txt>; rel="humans"
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      Pragma:
-      - private
-      X-Content-Type-Options:
-      - nosniff
-      X-Envoy-Upstream-Service-Time:
-      - '20'
-      X-Frame-Options:
-      - sameorigin
-      X-Obvious-Info:
-      - 42755-064957c,064957ce014
-      X-Obvious-Tid:
-      - 1603292913717:3854f96d2dc0
-      X-Opentracing:
-      - '{"ot-tracer-spanid":"37d25c63166e0e0a","ot-tracer-traceid":"655beab9d20a825c","ot-tracer-sampled":"true"}'
-      X-Powered-By:
-      - Medium
-      X-Ua-Compatible:
-      - IE=edge, Chrome=1
-      X-Xss-Protection:
-      - 1; mode=block
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d77e00000fc8dbd869000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be5063c93fc8d-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        <?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 Vaidehi Joshi on Medium]]></title>
        <description><![CDATA[Stories by Vaidehi Joshi on Medium]]></description>
        <link>https://medium.com/@vaidehijoshi?source=rss-8f55993c973e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QOQuWAqQd566oITj9rtCKw.jpeg</url>
            <title>Stories by Vaidehi Joshi on Medium</title>
            <link>https://medium.com/@vaidehijoshi?source=rss-8f55993c973e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 21 Oct 2020 14:56:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/@vaidehijoshi" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[On Thirty]]></title>
            <link>https://medium.com/@vaidehijoshi/on-thirty-da2d2e21a6b2?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/da2d2e21a6b2</guid>
            <category><![CDATA[thirty]]></category>
            <category><![CDATA[birthday]]></category>
            <category><![CDATA[life-lessons]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 19 Dec 2019 20:54:11 GMT</pubDate>
            <atom:updated>2019-12-19T21:06:50.571Z</atom:updated>
            <content:encoded><![CDATA[<p>I am fully aware that birthdays are just rituals. Functionally, they don’t really mean much at the end of the day; they just happen to be easy enough to use when we want to represent milestones and impactful events. And yet, I <em>love</em> these rituals. They are an opportunity to reflect and meditate on what has already passed — and in a way, they allow us to find some stillness in preparation for what is to come.</p><p>I’m turning thirty tomorrow, and I certainly don’t expect that I’ll feel much different tomorrow than I do today. But cumulatively, I feel like a much different person than I was when I started my twenties. I feel much more confident, sure-footed, firm, and grounded. It’s hard for me to pinpoint how this transformation came about; there was no single event that perpetuated this change. Instead, I have to believe that it is the sum of the experiences over the last decade and what I learned from them that incrementally changed who I am.</p><p>So, on the eve of a new decade — and in keeping with my love for self-reflection — here are thirty things that I’ve learned before turning thirty.</p><figure><img alt="A woman stands on the side of the road with snow nearby, with the branches of an evergreen tree above her." src="https://cdn-images-1.medium.com/max/1024/1*gtjTdoHuuZWJk6qXyQDvBw.jpeg" /></figure><ol><li><strong>If a relationship is important to you, carve out the time for it.</strong> I spent my twenties moving around the country and around the world. Along the way, I made a lot of very good, close friends, but also realized that maintaining those relationships as a moved took a lot of work. I had to work hard to keep the relationships that meant the most to me. I now have monthly calls with some of close friends on the other side of the country, and make an effort to see friends in the same city as me on a regular basis. My family and I have a group chat and we schedule group video calls often. Life happens to all of us, but we need to prioritize the people we care about the most.</li><li><strong>Say no.</strong> It’s okay to put your foot down when you aren’t comfortable with something, or when you’re not capable of meeting someone’s expectations or desires. It took me a long time to <em>really</em> learn this and practice it. But, whenever I say no to something, I always offer a counter option whenever in order to make it easier for someone to meet me halfway. As it turns out, everything in life is a negotiation!</li><li><strong>Buy the really good olive oil.</strong> Although I think that this applies to all food, really. I will always buy the high-quality ingredients, even if it means spending a bit more money. I can taste the difference, and I always read the ingredients list before buying something. I’ve noticed that the cheaper the item, usually the more processed and full of preservatives it is. And I’d rather spend a little extra money and know exactly what’s going into my body instead of saving a few dollars and consuming a multi-syllable chemical.</li><li><strong>Accept the fact that you can’t please everyone.</strong> If you spend your whole life trying to make other people happy, not only will you fail at that (because someone is <em>always</em> going to take issue with you), but you’ll also be miserable. It’s not worth it. Decide what is important to you and what choices make you happy, and ignore the rest of the noise and opinions.</li><li><strong>Don’t read the comments.</strong> I constantly struggle with this one because part of me still thinks of the comments as feedback. But people will always have opinions and an (anonymous) opinion is way easier to put out into the world than creative content.</li><li><strong>Advocate for yourself.</strong> No one else can advocate for you better than you can. And honestly, no one else probably will. Ask for what you want, and know your worth. It’s not arrogance to know your value and point it out to others. The sooner you become comfortable doing it, the better off you’ll be.</li><li><strong>Don’t carry around guilt.</strong> None of us are perfect and we do the best that we can. As long as you can look yourself in the mirror and know that you did all that you, could given what you knew at the time, then that’s really the best that anyone could hope for.</li><li><strong>Accept the scars you carry.</strong> I’ve learned that trauma doesn’t really go away, but it changes shapes and forms. I still get triggered sometimes, which can be a sharp reminder that I will carry painful experiences with me wherever I go. I’ve realized that this is ok, because the experience and your memory of it change over time, and they make you much stronger at the end of the day.</li><li><strong>Pay it forward.</strong> You will never be able to repay others for their kindness, support, or for helping you when you really needed it. All you can do is pay it forward to the next person.</li><li><strong>Go on self-dates.</strong> This is one of my favorite rituals, and I firmly believe that everyone should learn to spend time with themselves. I love to go to early Sunday morning movies when no one else is around. I think that this practice makes you more confident and self-aware.</li><li><strong>Use a calendar.</strong> My close friends know that I swear by a calendar. It’s the only way that I can manage order in my life without getting overwhelmed.</li><li><strong>Never compare yourself to others.</strong> This is something I’ve really started to master in the past few years, but until then, I really struggled with it. All of us are walking different paths, so it’s silly to look at someone else and their path and wonder why you’re not doing the same things that they are! Another thing worth mentioning is that even if <em>you</em> don’t compare yourself to others, other people will probably still compare themselves to you. And that’s something you just can’t control, so stay focused on the path that you’re walking on, even if they’re looking over at you.</li><li><strong>Be kind to yourself. </strong>You are your harshest critic. I used to be so unkind to myself and put myself through the wringer about my weight, my body, my accomplishments, and my failures. But the way that you talk about yourself is how you show and teach other people how to talk to you. If you are self-deprecating or unkind to yourself, then other people will learn to put you down and be unkind to you, too.</li><li><strong>Take risks.</strong> If you’re scared of trying something, remember that the worst thing that you <em>think</em> will happen is usually never that bad.</li><li><strong>Drink more tea.</strong> Herbal teas before bed are so calming and cleansing! I’ve also started switching out my afternoon coffee with tea instead, and my sleep is so much better and I am much less dehydrated.</li><li><strong>Say “I love you” more.</strong> Life is short. Even if you know it cerebrally, this reality becomes more and more real as you get older.</li><li><strong>Don’t take things personally.</strong> People around you can have bad days. I’ve had to deal with blunt, harsh, and insecure coworkers and bosses, and quickly realized that if I took everything that they said to me personally, I’d be crying in the office bathroom every other week (which I did do early on). I’ve since learned to let what others say bounce off me and back to them. Assume that people are having a bad day and, if necessary, stick up for yourself and speak back. But don’t carry their words around with you for hours or weeks on end; it will eat you alive and you’ll be the one to suffer, not them.</li><li><strong>Take your parents out to dinner.</strong> And if you can’t afford to, cook them a nice meal! We can’t ever repay the people who guided us early on in life, but we can at least show them our appreciation.</li><li><strong>Have boundaries (and stick to them). </strong>This is important when you’re working with other people, but also when it comes to doing things on your own. I have rules about how I want to conduct myself or handle situations, and I’m learning how to draw lines in the sand and not cross those boundaries with myself, or with others.</li><li><strong>Prioritize your financial health. </strong>I’m really proud of how much I’ve learned about financial stability and health in the last decade, and I honestly think that taking control of that aspect of your life is incredibly empowering. You should know where your money is, where it’s going, and how well its growing, actively and passively. We don’t talk about financial things that often, but I think we should be! There’s so much more I still have to learn but I feel like I’ve only gotten better at it over time.</li><li><strong>Vitamins are good.</strong> I take a few different vitamins, including probiotics, vitamin d, and magnesium! I always feel so much better when I take them consistently, and feel much worse when I skip a few days in a row.</li><li><strong>Let other people know that you are there for them.</strong> I have a few close people in my life that I know I could call, day or night, rain or shine. And for a handful of people, I am pretty sure that I am that person for them. The only reason I know that is because they have told me — and shown me with their actions — that I can always depend on them. Tell the people you care about that you are there because you never know when you both might need each other.</li><li><strong>Spend time away from your phone.</strong> I don’t check my phone during mealtimes anymore, and I try to spend long stretches of time (or a day) without looking at or checking it. I also think its valuable to take trips that force you to have no cell service so that you can <em>truly</em> unplug; I try to do this once a year.</li><li><strong>Drink more water.</strong> I’ve heard people give this advice all the time, but I actually feel <em>so much better </em>when I’m well hydrated (especially if I’ve been drinking dehydrating things like alcohol or coffee). I don’t usually drink enough water when I’m traveling though, and I’m trying to be better about that.</li><li><strong>Try not to waste anything, and try to reuse everything.</strong> I’ve learned so much about this from my partner. With a few rare exceptions, we eat everything that we buy, compost what we don’t, and mostly only buy things that can be reused or responsibly recycled. I know I could still do more, but it feels good to be heading in the right direction when it comes to sustainability.</li><li><strong>Stable relationships are more dependable than passionate ones.</strong> I learned this the hard way, but I’m really glad that I did. In the long run, a person that you can come home to, lean on, and build a strong foundation with is much healthier and will make you much happier than one that is volatile emotional rollercoaster.</li><li><strong>It’s okay to let people go. </strong>While I have some people who I know will be in my life for a long time, most of my friendships have quietly faded — and that’s ok. People are always changing, and we can grow in different directions. Those relationships are inevitably going to change as a result, and it’s totally normal.</li><li><strong>Never sacrifice your creative time or space.</strong> If you are someone who is artistic or creative, figure out what you need to be creative and make sure you sacrifice that for anything or anyone. For me, I need quiet, uninterrupted hours in the morning to write, and I don’t let anything get in the way of me finding those hours of creativity.</li><li><strong>Invest in your health.</strong> Take care of yourself early on, before your doctor tells you that you should; eat well, exercise often, and mitigate the stress and anxiety around you. The one thing that none of us can earn or buy or win our way into is more time.</li><li><strong>Take things as they come.</strong> It’s really easy to get caught up in planning for or daydreaming about the future. For me, sometimes that translates into panicking or having anxiety about a future that hasn’t happened yet — a complete hypothetical. I have to remind myself that so much of the world is not in my control; in fact all of it is out of my control except for myself. All any of us can do is control our own actions in the moment and our own perspective on things. I’m learning focus on what is happening <em>now</em> and teaching myself to bring my mind back to the present. And I’m trying to have faith that, when any situation arises, I’ll have the confidence and the ability to cross that bridge when I come to it.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5HIAwYoP9cM-L6lG2af3jw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da2d2e21a6b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logical Time and Lamport Clocks (Part 2)]]></title>
            <link>https://medium.com/baseds/logical-time-and-lamport-clocks-part-2-272c097dcdda?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/272c097dcdda</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 05:16:35 GMT</pubDate>
            <atom:updated>2019-12-05T05:16:35.854Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GKIi4rtNJFtTfg0Vv3RngA.jpeg" /><figcaption>Logical time and Lamport clocks (part 2)</figcaption></figure><p>Throughout the course of this series, we’ve been learning time and again that distributed systems are <em>hard</em>. When faced with hard problems, what’s one do to? Well, as we learned in <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a> of this post, sometimes the answer is to strip away the complicated parts of a problem and try to make sense of things simply, instead.</p><p>This is exactly what Leslie Lamport did when he approached the problem of synchronizing time across different processes and clocks. As we learned in <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a>, he wrote a famous paper called <a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">“Time, Clocks, and the Ordering of Events in a Distributed System”</a>, which detailed something called a <em>logical clock</em>, or a kind of counter to help keep track of events in a system. These clock counters were Lamport’s invention (and solution!) to the problem of keeping track of causally-ordered events within a system. By using a logical clock, we can more easily create a chain of events between processes in a system.</p><p>But how do these clocks actually work? And how does a clock actually figure out the time of events — especially when there are events happening all over the system? It’s time to finally find out.</p><h3>From clock to timestamp</h3><p>As we already know, logical clocks, also sometimes called <strong><em>Lamport timestamps</em></strong>, are counters. But how do those counters work under the hood? The answer may be surprisingly simple: the clocks are functions, and its the function that does the work of “counting” for us!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DmeZ7CUFks4Lq5h7BBc1OA.jpeg" /><figcaption>How should we think of logical clocks?</figcaption></figure><p>We can think of logical clocks as <strong><em>functions</em></strong>, which take in an event as their input, and returns a <strong><em>timestamp</em></strong>, which acts as the “counter”. Each node — which is often just a process — in a distributed system has <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">its own local clock</a>, and each process needs to have its own logical clock.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6AOPCM04sXjm3120Z5kI3Q.jpeg" /><figcaption>Pseudo-coding a logical clock function.</figcaption></figure><p>If we imagine the logical clock as a function that we might implement, we can think through how it works. If we were to pseudo-code that function, we could be sure that it would take an event as its argument. We <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">will recall</a> that an event can be something that occurs within a process, a send event that marks the process sending a message elsewhere, or a receive event that marks the process receiving an event from elsewhere. A logicalClock function should be able to take in any of these three types of events.</p><p>Once the logicalClock function has an event, it looks at the time on that event, and compares it to the time on the clock’s process. Once it compares the two, it chooses the larger of the options, and increments it arbitrarily. The increment step is important, because with logical clocks, time continues to march forward, and the increment step is what ensures that the timestamp returned by the function is always larger in value than the event’s time.</p><p>If this seems confusing, fear not! While pseudo-code can be helpful sometimes, but an example is even better. Now that we understand some of theory behind how a logical clock might work, let’s take a deeper look at how the clock algorithm <em>actually </em>works.</p><h3>Lamport’s clock algorithm</h3><p>In many cases, Lamport’s algorithm for determining the time of an event can be very straightforward. If an event occurs on a single process, then we intuitively can guess that the timestamp of the event will be greater than the event before it, and that the difference between the timestamps of the two events on the <em>same</em> process will depend only on how much the clock increments by (remember, that incrementation can be totally arbitrary!).</p><p>However, things aren’t so simple when dealing with send and receive events, which are signals that two processes are passing messages back and forth. Consider the illustration shown here, where we have two processes, P and Q. Process P has an event on the process <em>itself</em>: P1. The time at P1 is 2. Process Q also has an event of its own, Q1, which has a time of 2. The next event on process Q is Q2, which is a send event and marks a message being sent from process Q to process P.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KFLxitiRaeR5BFx8p_OQQA.jpeg" /><figcaption>How do we determine the time for an incoming event?</figcaption></figure><p>So what happens when the send event from process Q, or Q2, sends its message over to process P? Well, for one thing, when process Q sends its message to process P, it also sends the time at that particular moment along with its message. In the case of this example, the time at Q2 was 4, so the message sends time = 4, as part of its message data.</p><p>Once process P receives that message, it marks it with a receive event, or P2. Then, its logical clock looks at the incoming time on the event, and compares it to the currently-known time on its own process, process P. When it does this comparison, it chooses the larger of the two timestamps, and increments it arbitrarily.</p><p>Process P&#39;s clock sees that its currently-known time is 2, while the time on the incoming event is 4. The clock chooses the larger time between the two timestamps (4), increments it, and assigns the new timestamp to the receive event, P2. In more concrete terms, we can say that the clock uses an algorithm to do this, which can effectively be summarized as: max(processT, incomingT) + amount.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tVJ_jmVsbSDWTRK_eArvxg.jpeg" /><figcaption>Lamport’s algorithm for determining a timestamp.</figcaption></figure><p>In this formula, processT is the currently-known time on the current process, while incomingT is the time on the event that the process is trying to reconcile. The clock takes the max() of that, and increments it by whatever arbitrary amount the clock is using to act as a counter and ensure that the all timestamps continue to increase in value.</p><p>In our example system, we can determine that P2’s timestamp will be the result of max(2, 4) + amount; for simplicity’s sake, we can decide to make amount equal to 1, so the time at P2 is 4 + 1 = 5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PTHjL4wZ3vNEI1kWD1ebNQ.jpeg" /><figcaption>The result of Lamport’s algorithm, in action!</figcaption></figure><p>Awesome! Our logical clock is actually doing some interesting and useful work for us, and it’s doing it in a pretty elegant and simple way.</p><h3>Clocks and causality</h3><p>Now that we’ve seen how clocks derive and deliver a time to us, let’s investigate when they’re useful, as well as how they’re sometimes limiting. As we already know from <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a> of this series, Lamport introduced the concept of happens before (using the <strong>→</strong> shorthand) to indicate that one event happens before another in a system. Understanding the chain of events in a system helps us causally order them and figure out how one event causes another to happen.</p><p>Conveniently, logical clocks obey the rules of causality. This means that if we find a causal, happens before relationship in a system, then the timestamps corresponding to these two events should obey the rules of causality.</p><blockquote>If event a → b, then the timestamp returned by clock(a) should be less than (&lt;) that of the timestamp returned by clock(b).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*243bu8y3ET657oqc3gx3bg.jpeg" /><figcaption>Logical clocks should obey causality for causally-related events.</figcaption></figure><p>If we take a look at the example shown here, we’ll see that we have a system with three processes, P, Q, and R, with some clear causal relationships between the events in the system.</p><p>We can see that event P1 → Q2, because event P1 is the send event of Q2, which is the receive event, and one causes the other. On the other hand, event Q2 → R3, as Q2 sends a message to R3, which is a receive event in and of itself. Similarly, we can see that Q3 → Q4, as they both occur on the same process, one after another.</p><p>If we look at these same causal relationships, and compare them with their timestamps, we can see that the clock times for each causal relationship obeys causality as well. For the relationship of P1 → Q2, the clock time for P1 &lt; Q2, as 1 &lt; 2. The same goes for Q2 → R3 (2 &lt; 3) and Q3 → Q4 (3 &lt; 4).</p><p>However, the same rule sadly cannot be said of events in the system that are <em>not</em> causally-related! Let’s take a closer look at some of the <em>other</em> events in the same system we saw before. If we examine the events R1 and P2, we’ll see that the time at R1 is 1, while the time at P2 is 2. We might think that, because the clock time of 1 is less than (&lt;) 2, that R1 → P2. But, unfortunately, this is not the case!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h7CPeter1MHIUqYaZ0We4w.jpeg" /><figcaption>What happens when two events are not causally-related?</figcaption></figure><p>In fact, if we look at this system, we’ll se that there is actually <em>no causal path</em> between R1 and P2. These are concurrent events! <strong><em>Concurrent events</em></strong> do not have causal paths from one to another. Thus, because these two events are concurrent, here is no way to be certain that one event happened before the other. We cannot look at their timestamps and guarantee that they are causally-related!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJR13FRpIixH8lO37K_THg.jpeg" /><figcaption>The limitations of concurrent events and logical clocks.</figcaption></figure><p>In more abstract terms, we can think of it like this: if event a happens before b, then we can be sure that the timestamp of a will be less than the timestamp of b. But just because a’s timestamp is less than b, we don’t know <em>for sure</em> that a happened before b, because the two events could also be happening at the same time!</p><p>For two concurrent events, we cannot make a judgement call about the happens before relationship just based on the clock times of the events. The only thing that we can really guarantee in such a case would be that b does <em>not</em> happen before a.</p><p>This is one of the limitations of logical clocks. Indeed, Lamport even acknowledges this in his own paper, and suggests using “any arbitrary total ordering of the processes” in a system to decide how to break ties when two timestamps could very well be equivalent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eH63MYoCvVi-UNTJgd-wmA.jpeg" /><figcaption>The tl;dr of Lamport timestamps/logical clocks.</figcaption></figure><p>Lamport clocks are pretty amazing in their simplicity, but they are admittedly not foolproof. When given a set of <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">partially-ordered</a> events, we can create a <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">total ordering</a> out of them using simple clock counters and can be sure that those clocks and the timestamps they provide us with will always obey causality. However, Lamport clocks do not help us order the concurrent events in a system, or find a causal relationship between them.</p><p>There are other kinds of clocks that can be used in a distributed system to help solve this problem, but all of the other solutions came along many years after Lamport first introduced his logical clocks back in 1978. We’re lucky that he did, because he set the stage for a new way of thinking about time in distributed systems, and would end up changing the way we talk about distributed computing forever.</p><h3>Resources</h3><p>There are some great resources on Lamport’s paper on logical clocks, as well as causal ordering. If you’re curious to learn more (or read Lamport’s paper yourself), check out the resources below!</p><ol><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li><li><a href="https://www.youtube.com/watch?v=hK6m6WBk-d8&amp;t=3s">Time, Clocks and Ordering of Events in a Dist. System</a>, Dan Rubenstein</li><li><a href="https://www.youtube.com/watch?v=CMBjvCzDVkY">Time and Ordering: Lamport Timestamps</a>, Indranil Gupta</li><li><a href="https://mwhittaker.github.io/blog/lamports_logical_clocks/">Lamport’s Logical Clocks</a>, Michael Whittaker</li><li><a href="https://www.cs.rutgers.edu/~pxk/rutgers/notes/content/08-logical-clocks-slides.pdf">Logical Clocks</a>, Professor Paul Krzyzanowski</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=272c097dcdda" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-2-272c097dcdda">Logical Time and Lamport Clocks (Part 2)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logical Time and Lamport Clocks (Part 1)]]></title>
            <link>https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0317e407112</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 14 Nov 2019 16:34:19 GMT</pubDate>
            <atom:updated>2019-11-14T16:34:19.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_p7M2s9bQyKuAeC8Tjp4Xw.jpeg" /><figcaption>Logical time and Lamport clocks (part 1)</figcaption></figure><p>Over the course of this series, we’ve seen many instances of how things can more complicated than they seem. We saw this with <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">failure</a>, and we saw it with <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">replication</a>. More recently, we discovered that even the <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">concept of time</a> is more complex that we might have originally thought.</p><p>However, when the things that you thought you knew seem more convoluted than ever, sometimes the answer is to keep it simple. In other words, we can keep a problem simple by stripping out the confusing parts and trimming it down to its most essential parts. In fact, this approach is exactly what one computer scientist did in the late 70’s when he was, just like us, trying to figure out how to make sense of time in a distributed system.</p><p>The previous two posts on <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">clocks</a> and the <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">ordering of event</a>s in a distributed system have both been building up to the topic we’re finally ready to uncover: logical time and Lamport clocks! There’s a lot to cover, so we’ll spread it out between two posts. Let’s dive right into part one!</p><h3>Causality and “happens before”</h3><p>The story of logical clocks starts in 1978, when a paper was published in the <em>Communications of ACM </em>journal that would go down in history. <a href="http://www.lamport.org/">Leslie Lamport</a>, a computer scientist at Massachusetts Computer Associates, wrote about his research around ordering events in a distributed system. This paper, entitled <a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">“Time, Clocks, and the Ordering of Events in a Distributed System”</a>, would go on to be one of the most-cited papers in computer science, and would also win the Principles of Distributed Computing Influential Paper Award more than <a href="http://www.podc.org/influential/2000-influential-paper">20 years later</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B5-RflcB3mx-p_3472yMIA.jpeg" /><figcaption>Lamport’s paper on causal ordering was published in 1978!</figcaption></figure><p>In the paper, Lamport outlines how we think about time as humans, and why we need to shift our paradigm when it comes to distributed systems, and the idea of <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">partial ordering</a>. He explains that, “In a distributed system, it is sometimes impossible to say that one of two events occurred first”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_5OCO_U9wWZ1H0F4acPYyQ.jpeg" /><figcaption>Why do we care about ordering events? So that we can track causality!</figcaption></figure><p>As Lamport cites in his paper, the reason that we care about time is so that we can figure out the order in which things happen. While this is certainly harder (or sometimes impossible!) to do in a distributed system, our reason for wanting to <em>know</em> the order of some events in a system all stems back to the same desire: we care about ordering events so we can determine how those events are connected. When dealing with events in <em>any</em> system, the reason we actually want to order them is so that we can see the chain of events within the system. Within a distributed system in particular, we this means that we are often trying to determine if an event at one node affects or causes an event at another node.</p><p>But, as we’ve seen in our own study of distributed systems, this task is no easy feat. When a system is distributed, there is <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">no global clock</a>, which means that we cannot depend on any central time source. This also means that the events in our system are not <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">totally ordered</a>, which means we can’t be sure of exactly <em>when</em> every event in the system took place. Lamport’s paper acknowledges all of these constrains and empathizes with how tricky this problem really is!</p><p>Lamport’s solution is to shift our thinking. He presents a novel idea: we don’t actually need to think about causality in the context of total ordering to start. Instead, he says that we can start with a partial ordering of events, and then just deal with figuring out which events happened before other events. Once we figure out a partial ordering, we can turn it into a consistent total ordering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_PdU1sv7gRJnExmFEo3KhA.jpeg" /><figcaption>Lamport’s logical clocks allow us to shift from happened “when” to happened “before”.</figcaption></figure><p>So how do we do this? Well, to start, we need to shift from thinking about <em>when</em> an event happened to what the event happened <em>before</em>.</p><h3>Shifting from “when” to “before”</h3><p>The idea of one event happening before another is central to Lamport’s paper. He uses the <strong>→</strong> shorthand notation to indicate the <strong><em>happens before</em></strong> relationship, or the fact that one event happened before another. For example, if we know that one event, <em>a</em>, happened before another event, <em>b</em>, then we can say that <em>a</em> → <em>b</em>, or <em>a </em>happened before <em>b</em>.</p><p>The happens before relationship can also be applied transitively. In other words, we can create a chain of events where one event happened before another. If we say that <em>a</em> → <em>b </em>and <em>b → c</em>, then by using the transitive property, we can say that <em>a → c</em>, or <em>a </em>happened before <em>c. </em>As we might be able to imagine, we could very easily string together a chain of events, where one event happens before another, which happens before another, and so on and so forth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBl56kdG5zmTewcyt1J6Vg.jpeg" /><figcaption>Understanding the “happened before” notation.</figcaption></figure><p>But wait a second — we keep talking about different events in the system, but we haven’t really clarified what an event could possibly be! As it turns out, an event in a distributed system can take different forms. As we know, there can be many <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">different nodes</a> in a distributed system. Each node has its own local system clock, and it is capable of processing its own tasks. However, the nodes can also communicate between one another, sending messages back and forth.</p><p>An <strong><em>event</em></strong> encompasses all of the different things that can happen within and between nodes in a system. An event could be something that occurs on a single process or node. An event also includes any <strong><em>send events</em></strong>, where a node sends a message to another node or process. Conversely, we must also consider <strong><em>receive events</em></strong>, when a node receives an incoming message from elsewhere in the system.</p><p>In the example above, we can see examples of all three of these events. We have two processes, P and Q. There is one event, Q3, which occurs on process Q that are not related to sending or receiving any messages. This is our basic event that indicates that something occurred on the node for process Q. However, we also have a few send events: P1, Q1, Q4. These are all events that indicate that we are sending messages out from a node to somewhere else in the system. On the other hand, P2, P3, and Q2 are each receive events, which indicate that we have received some message from another node in the system.</p><p>Now that we understand what an event in a system could be, we can turn back to the happens before relationship. When we say that an event <em>a</em> <em>→</em> <em>b</em>, we are asserting that event <em>a</em> occurred before <em>b</em>, because <em>a</em> happened before <em>b</em>. We can say that these two events are <strong><em>causally ordered</em></strong>, where the ordering of the events is contingent upon one event causing another to happen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RpmP-aPCiqMfvrGB81puJg.jpeg" /><figcaption>Causally-ordered and concurrent events across two processes.</figcaption></figure><p>There are a few rules to causal ordering that are important for us to understand. In order for <em>a</em> <em>→</em> <em>b </em>to be causally ordered, one of the following three situations must be true:</p><ol><li>Events <em>a</em> and <em>b</em> must occur on the <strong><em>same</em></strong> <strong><em>process</em></strong>, and <em>a</em> must occur before <em>b</em> occurs on the process.</li><li>The events can occur on <strong><em>different</em></strong> <strong><em>processes</em></strong> so long as <em>a</em> is the send event that corresponds to <em>b, </em>which must be its receive event.</li><li>The events are <strong><em>transitively linked</em></strong> with another event in the system, but <em>a</em> still happens before <em>b</em>. For example, if <em>a</em> happens before <em>c</em>, and <em>c</em> happens before <em>b</em>, then we know that <em>a</em> <em>→ b</em>.</li></ol><p>As messages travel through time and across space from one process to another and, we can start to construct chains of causally events (also called <strong><em>causal paths</em></strong>) and see how different events across processes are connected to one another. For example, in processes P and Q, Q1<em>→</em> P3 (through event P2), and P1 <em>→ </em>Q4 (through events Q2 and Q3).</p><p>Finally, it’s worth mentioning that, if two events <em>a</em> and <em>b</em> do not happen before one another, than we can say that <em>a ≠&gt; b</em> and <em>b ≠&gt; a</em>, and that the two events are <strong><em>concurrent</em></strong>. We will cover this in much more depth in part two of this post, but for now, we should just note that concurrent events do not have causal paths from one to another.</p><h3>Logical clocks to the stage</h3><p>In addition to the idea of “happens before”, another core concept that Lamport introduces in his paper is the logical clock. As we already know, each node or process in a distributed system has its own <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">concept of time</a>, or its own local clock. However, Lamport’s take on local clocks is different that what we’ve seen before.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OAmD3WgougNwyj-xexU0dw.jpeg" /><figcaption>How do the clocks factor in?</figcaption></figure><p>Lamport suggests using something different from the typical physical clock that we all think of. Instead of using each process’s physical clock to track the order of events, we can instead use a <strong><em>counter</em></strong>. The counter can start with an initial time (like 0), and we can treat that counter as the processes own local clock.</p><p>Lamport continues with this idea by proposing that, not only will every process within a distributed system have its own counter clock, but each <em>event</em> that is recorded on a process should also have a <strong><em>value</em></strong> on that process’s local clock. Furthermore, the value of each of these events on the clock must mirror any happened before relationships. For example, if event <em>a</em> <em>→ b</em>, then the clock time for when event <em>a</em> occurred must be less than the clock time for whenever event <em>b</em> occurred; in other words, clock(<em>a</em>) &lt; clock(<em>b</em>).</p><p>By using basic counters instead of physical clocks, Lamport simplifies clocks into something a little easier to deal with. These counter clocks are called logical clocks. A <strong><em>logical clock </em></strong>is quite different from a physical clock in that there is no central notion of time, and the clock is just a counter that increments based on events in the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn9OpEEOENBcg2KouYDCXQ.jpeg" /><figcaption>Logical clocks: a definition.</figcaption></figure><p>Each process in a distributed system can use a logical clock to causally order all the events that are relevant to it. As events occur in a process — whether they are send or receive events — the process’s clock counter is incremented by an arbitrary amount. We’ll learn more about how this works in practice in part two of this post. We’ll also be introduced to Lamport’s algorithm for incrementing counters, and how to obey causality across processes. There’s so much interesting stuff to learn; thankfully we have more time and another post to cover it all!</p><h3>Resources</h3><p>Conveniently, Lamport’s work on logical clocks and causal ordering is well-taught and written about. There are a lot of great resources that introduce these topics, with varying complexities. If you’d like to do some further reading, check out some of my favorite resources, which I’ve listed below!</p><ol><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li><li><a href="https://www.youtube.com/watch?v=hK6m6WBk-d8&amp;t=3s">Time, Clocks and Ordering of Events in a Dist. System</a>, Dan Rubenstein</li><li><a href="https://www.youtube.com/watch?v=CMBjvCzDVkY">Time and Ordering: Lamport Timestamps</a>, Indranil Gupta</li><li><a href="https://mwhittaker.github.io/blog/lamports_logical_clocks/">Lamport’s Logical Clocks</a>, Michael Whittaker</li><li><a href="https://www.cs.rutgers.edu/~pxk/rutgers/notes/content/08-logical-clocks-slides.pdf">Logical Clocks</a>, Professor Paul Krzyzanowski</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0317e407112" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">Logical Time and Lamport Clocks (Part 1)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ordering Distributed Events]]></title>
            <link>https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/29c1dd9d1eff</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 24 Oct 2019 02:25:31 GMT</pubDate>
            <atom:updated>2019-10-24T02:25:31.538Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SOzfR2Cmr0dMR3wnvutvBw.jpeg" /><figcaption>Ordering distributed events</figcaption></figure><p>One of the hardest things about distributed systems is that we often find ourselves needing to approach them very differently than other problems in computing. Distributed computing forces us to reevaluate how we’d approach even the simplest obstacles in a single system model.</p><p>We recently began exploring one such example of this when we took a closer look at <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">ticking clocks</a> and how unreliable they are in a distributed system! As we learned, there is no single global clock in a distributed system, which makes it hard to ever agree on what time it is. Understanding the caveats of clocks and time is crucial to wrapping one’s head around the distributed computing model.</p><p>But why is time <em>specifically</em> so important? Why do we really care what time it is, and why does it matter that we know when things happened? And if it matters, how do we go about figuring out what time it is without a global clock to rely upon? As we’ll learn, it’s not so much the clocks and time that we care about, but rather, the events that they’re always tied to.</p><h3>Time in the human mind</h3><p>Although we’ve already dipped our toes into <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">the topic of time</a>, there’s still a lot more left for us to uncover. In fact, we won’t even be done talking about time by the end of this post! Now, it might seem odd to spend so much time learning about, well, <em>time</em>. Why does time matter so much in a distributed system, anyway? If we think about it more deeply, we might realize that we don’t specifically care about knowing what time it is in a distributed system. What we care about is be able to rely on time to help us order things.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBjTmSMWJeKb1Uh5Yu0hAg.jpeg" /><figcaption>Why does knowing the time even matter in a distributed system?</figcaption></figure><blockquote>The notion of time helps us order events in a single system as well as a distributed one.</blockquote><p>Time is particularly useful when it comes to ordering events in system. Most programmers will rely on and expect some kind of time format when they deal with data or processes; this time format is usually something like a <strong><em>timestamp</em></strong>, which are a sequence of characters that have been encoded to represent a certain moment in time. We use timestamps in order to tell when some data was created or updated, when a message was sent or received, and when a process was started or completed. In actuality, we don’t care about the timestamp on its own — it’s really the timestamp <em>being</em> <em>tied to</em> some data or event that makes it useful to us.</p><p>The trouble is, however, that we humans have our own notion of time and how it ought to work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oLYmXCvJWa677h24_gTbEw.jpeg" /><figcaption>Our concept of time is linear!</figcaption></figure><p>We tend to think of time as being linear; an event happens at “some” time, another event happens after it at “another” time, and a final event happens last, at some “final” time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Veo99jfPM2nACMuLzsTBVg.jpeg" /><figcaption>The human mental model of time assumes a few things.</figcaption></figure><p>The human mental model of time assumes a few things.</p><ol><li>First, we all agree on what time it is. We have timezones and shared clocks (including a global atomic clock), and there is rarely any discrepancy between us when it comes to what time it is in a given location.</li><li>Second, we tend to think of events happening as one after another. Event A happens first, then event B, and finally, event C.</li><li>Third, we can determine the exact order of events based on which event happened before another. In other words, if event A happened before event B, and we know the time of A and B, we know the exact ordering of the two events.</li></ol><p>While this might seem obvious to us, this mental model of time doesn’t work in the context of distributed systems! There are some major differences between our human mental model of how time works and the reality of time in distributed systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NpwdqF3XMgP-pJ7wmC_DBA.jpeg" /><figcaption>The reality of how time works in a distributed system is very different from the human mental model.</figcaption></figure><p>The first difference is one that we already know: distributed systems have <strong><em>no global clock</em></strong>, so there is just no way to be sure of what time it is on a different machine in a different location. The second difference to note is that events don’t just happen one after another! Events can happen at the same time, in parallel, or <strong><em>concurrently</em></strong>. Both of these points lead us to one more major difference: events happen in different places, in different nodes/locations in a system. But, because they can happen at the same time, and because it’s not possible to know what time it is without a global clock, the events that occur all over a distributed network are <strong><em>hard to order</em></strong>!</p><p>The human modeling of time and the reality of time in a distributed system are each two very different approaches to how we might go about ordering events in a system. In the human model approach, we know exactly what time it is, so it’s easy to figure out how to order some events — we can just use each event’s timestamp, since we know what time it is! But in the distributed system approach, we don’t have the luxury of having all the information (read: knowing the time) about all the events in the system.</p><h3>Total and partial ordering</h3><p>The human modeling of time and the more realistic view of time in a distributed system can be grouped into two very different approaches of ordering events. Let’s learn a bit more about them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VDm7nU3LRuZ2hY8LmLphFQ.jpeg" /><figcaption>Total order of events: a definition</figcaption></figure><p>Our view of time aligns well with a single system’s model of time. In a single system — as opposed to a distributed one — each event can be placed in a specific order, which is based on what time they occurred. This is also known as a <strong><em>total ordering</em></strong> of events.</p><p>When events in a system follow a total order, then every event in that system has a specific order in which it occurred. In other words, when we know exactly when <em>each</em> of the events occurred, we know the total order of all the events in a system.</p><p>For example, in the illustration shown above, if we knew that event A occurred first, followed by event B, and ending with event C, then we would know the <strong><em>total order</em></strong><em> </em>of all the events. Events in a single system can be totally ordered since we have a local clock to help us figure out exactly when an event happened, which allows us to figure out the total ordering of all the events.</p><p>Yet a distributed system is very different from a single system! Sure, an individual node in a system will know what time it is based on its local clock, but it won’t know what time it is on another node. It’s almost as if each node in a distributed system can get halfway to a total ordering…it can order its own events, but if it receives any messages/incoming events from other nodes in the system, it won’t know what to do with them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1LhwndhoenFiYhpO4Mfk3w.jpeg" /><figcaption>Partial order of events: a definition</figcaption></figure><p>This brings us to partial ordering, which is a “less sure” version of total ordering. In a <strong><em>partial order</em></strong>, we can’t be sure of the exact order of <em>all</em> the events in the system. Instead, all we can be sure about is the order of events that are reliant upon one another.</p><p>Let’s think back to our example three events: A, B, and C. In a single system or in a system with a total order, we were able to know the exact order of each of these events. But in a distributed system, that would have likely not been the case! Instead, we probably would have been sure about some of the events, but not others.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ndjf3_WbHXGSAk0s-GiGA.jpeg" /><figcaption>Understanding partial ordering with multiple events.</figcaption></figure><p>For example, let’s say that we are sure about when event B and event C occurred. In fact, let’s say that we are even sure that event B occurred before event C. But what about event A? We’re not <em>at all</em> sure about when that event occurred!</p><p>In reality, because we don’t know when event A occurred, it could have theoretically happened at any time: before event B, after event C, or even right between the two events! All we can say with certainty is that event B occurred before C.</p><blockquote>Indeed, our partial sureness about how to order these events is what makes this set of events a partial ordering— we’re only “partially” sure about the order of these events.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_6XMiMJjs39ZSPAgtnh-A.jpeg" /><figcaption>Without a global clock, distributed system events are partially ordered.</figcaption></figure><p>In a distributed system, we mostly deal with partially ordered events, simply because individual nodes can be sure about how to order local events, but they can’t always be sure about how to order events that are happening on a different node. A node in our distributed system will send messages out to other nodes, who can’t necessarily be sure of when they occurred. Similarly a node in our system will receive its own set of incoming messages, and it can’t be sure of what time those messages were sent, either!</p><p>So how do we reconcile this lack of knowledge throughout our system? Well, it involves some reframing of how we think about time…and whether we even need it at all (?!).</p><h3>Maybe time doesn’t matter</h3><p>In the beginning of this post, we asked ourselves why we even <em>cared</em> about time. We realized that the reason it kept coming up was because we relied on time to order events in our system. Along the way, we learned that sometimes we can be sure about the order of events (total ordering) and other times, well, we can’t be sure of everything (partial ordering). But if we circle back to our original question, we might realize that we don’t actually care about <em>time</em>, but rather the order in which things happen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W9xE-623o-wneth3f8xFow.jpeg" /><figcaption>Maybe time itself isn’t important! Maybe we just care about the order of things.</figcaption></figure><p>Perhaps we don’t actually need to worry about the exact time that each event in our system occurred. Instead, maybe we should try to just figure out when those events happened in a way that doesn’t <em>require us</em> to even think about clocks or time!</p><p>All we really want to know is the order in which some events occurred. And why do we care about the ordering of events? Well, the major benefit of ordering events is so that we can figure out how one event caused another to occur. So, the question is: how can we get the benefit of ordering events without all the headache of figuring out the time at which each event happened?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hcKyI_QGwyuXaaEXHaTxVQ.jpeg" /><figcaption>Causal ordering: a sneak peak!</figcaption></figure><p>The answer to this mystery is <strong><em>causal ordering</em></strong>, which helps us order events not based on the <em>time</em> that they occurred, but rather, based on cause and effect. Causal ordering reframes how we think about events. If we can just figure out which events cause <em>other</em> events, we can come up with a loose ordering of how those events occurred.</p><p>In other words: we don’t need to care about time anymore! We can sort of skirt around it, and jump right to the matter at heart: figuring out if one event came before another. In the next post, we’ll dive into the logic behind causal ordering and figuring out the chronological relationships between events. In the meantime, rest easy knowing that we’ve got a (logical) time solution ahead of us.</p><h3>Resources</h3><p>Understanding the ordering of events in a distributed system is super helpful to know before learning about more complex time-related topics. It can be hard to find resources that specifically explain total and partial ordering in the context of distributed systems, but there a few that do a pretty good job, which I’ve listed below!</p><ol><li><a href="http://book.mixu.net/distsys/time.html">Distributed Systems for Fun and Profit</a>, Mikito Takada</li><li><a href="https://stackoverflow.com/questions/4620779/partial-ordering-of-events-in-a-distributed-system">Partial ordering of events in a distributed system</a>, Jesse Bangs</li><li><a href="http://www.cs.cornell.edu/courses/cs6410/2018fa/slides/14-lamport-clocks.pdf">Distributed Systems: Ordering and Consistency</a>, Professor A.F. Cooper</li><li><a href="https://scattered-thoughts.net/writing/causal-ordering/">Causal Ordering</a>, Jamie Brandon</li><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29c1dd9d1eff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">Ordering Distributed Events</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ticking Clocks in a Distributed System]]></title>
            <link>https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef2aa4df07a3</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 03 Oct 2019 03:50:52 GMT</pubDate>
            <atom:updated>2019-10-03T03:50:52.983Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NC8BV7emVqgBtxrHGhKFDg.jpeg" /><figcaption>Ticking clocks in a distributed system</figcaption></figure><p>We often spend a lot of our lives blissfully unaware of how something works. Most of the time, this ends up being an okay thing, since we don’t really need to know how everything around us works. But there are some times when we realize just how much complexity been hidden from us, abstracted out, tucked away neatly so that we never have to think about it.</p><p>I had one of these realizations recently when I discovered that I had never thought twice about a simple thing that I work with on an hourly basis: time! I’ve been using computers for the better part of my life, first as a consumer of technology and, later, as a creator of it. It was only until I began learning about distributed systems (for this series!) that I understood that I didn’t know as much as I thought about telling time, much less how the computers that we use everyday end up deciding what time it is.</p><p>When it comes to distributed computing, time is a completely different beast. But before we can really get into time in distributed systems, we’ll first need to understand how individual machines track time. So let’s start learning about what exactly makes time so darn tricky.</p><h3>Tracking time</h3><p>Most devices these days have some concept of what day it is and what time it is. With the exception of some “internet of things” devices (like a <a href="https://www.raspberrypi.org/">Raspberry Pi</a>), all machines have some notion of time. But how do they figure out the day and time?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ejj7Tpi8dUyJrwdjiP4TOA.jpeg" /><figcaption>Real-time clocks: a definition</figcaption></figure><p>The answer is: with a clock! Now, this might seem obvious at first, but it gets a little tricker as we go on. A computer that needs to be able to tell the time will often have an internal clock that is built right into its hardware in the form of an integrated circuit. This circuit is often built right onto the motherboard. This small piece of hardware is known as a <strong><em>real-time clock</em></strong>, or <strong><em>RTC</em></strong> for short.</p><p>RTCs are particularly interesting because they come with an alternate power source (like a battery), which allows them to continue working even if a machine is powered off! This might seem obvious to us today, but the use of RTCs was a pretty significant milestone in the history of computing; early personal computers didn’t actually come with RTCs built-in, and they were added in later on. Now, we’ll find refrigerators and microwaves that have these little clocks built right in! That’s pretty wild if you think about it.</p><p>The RTC is responsible for keeping track of the current time, and we can think of it as one individual machine’s <strong><em>system clock</em></strong>. It’s important to note that this clock is specific to the “system” of the machine; in other words, any process or tasks or work that the machine does that relies on the time will inherently rely upon whatever time the <em>system clock</em> says it is.</p><p>So, how does this physical clock work, exactly? As it turns out, deep inside the integrated circuit is a crystal, which vibrates or oscillates; it’s known as a <strong><em>crystal oscillator</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-JwBPx1aOGfLcplER6wZcg.jpeg" /><figcaption>Every computer has its own physical clock</figcaption></figure><p>Without getting into the nitty-gritty (read: physics) of this works under the hood, all we really need to know for our purposes is that the vibrations of the crystal are captured and counted by the clock. As the crystal vibrates, the clock keeps count of each vibration in the form of <strong><em>ticks</em></strong>, and as it counts one tick after another, it keeps track of the time. Of course, this begs the question of where it keeps count of each tick that it records. The physical clock uses a <strong><em>binary counter circuit</em></strong>, a simple circuit that does nothing more than count in binary, in order to store these ticks. Conveniently, the binary counter circuit (the system clock) is where a machine derives its <strong><em>system time</em> </strong>from. Indeed, just as a machine has a system clock, it also has its own notion of time that is <em>based</em> on that clock!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0-piv6mSBWJOaUDrn2cRyw.jpeg" /><figcaption>System time: a definition</figcaption></figure><p>An interesting thing about system time is that it always is calculating time based on <em>when</em> the system clock began counting. This means that if we set the system clock on a new computer to be five minutes slow or two days fast, then our starting point for our system time or the “zero” of where we start our counting of time will end up being either five minutes behind or two days ahead. In other words, we’ll be measuring “ticks” based on whatever date or time we set — not on what the actual time is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*luLDI4ZsJaiTwFNvmGL7SQ.jpeg" /><figcaption>Understanding how Unix time works</figcaption></figure><p>To help avoid some of the confusion of this problem, most machines follow some kind of convention when it comes to deciding what that starting point should be. For example, machines that have Unix operating systems have standardized around <strong><em>Unix time</em></strong>, which is a way of deciding what the “zero” of where we start counting time should be. In the case of Unix time, the starting point or “zero” is the start of the <strong><em>Unix epoch</em></strong>, or January 1st, 1970, at 00:00:00 UT (Universal Time). An <strong><em>epoch</em></strong> is meant to be arbitrary; it’s nothing more than an agreed-upon starting date and time for when we should start measuring time. My personal favorite epoch is the one for Microsoft Excel programs, which is 0 January, 1990! (For the epochly-curious, check out <a href="https://en.wikipedia.org/wiki/Epoch_(computing)">this extensive list</a>.)</p><h3>Out of sync, out of control</h3><p>Now that we know that a clock can start “counting” at arbitrary times, it’s time to add another factor to the mix. Namely, what happens if we have more than one clock? This is when things start to get, well, a little out of sync.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pUX8-qVqs071jxTmcdIlwg.jpeg" /><figcaption>Computer clocks are not consistent</figcaption></figure><p>Since every machine can have its own notion of time, we can assume that two different machines will each have their own concepts of what time it is. But this is where things start to get a bit complicated: if two different machines have two different ideas of what time it is, how can we be sure that they are the same?</p><blockquote>Unfortunately for us, computer clocks are not consistent.</blockquote><p>We already know that every clock has a different idea of <em>when</em> it started counting and its “zero”, and that one clock could be inconsistent with another. However, it’s also worth mentioning that not all clocks are precise, and some are more precise than others. Over time, the preciseness of each “tick” of a clock really starts to have an impact on how that clock determines its time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ar9Gw_fTeLiHgxH3lPk_UQ.jpeg" /><figcaption>Every system clock counts differently!</figcaption></figure><p>For example, a typical quartz clock will drift quartz clocks will lose or gain approximately one second over the course of 11 or 12 days. This is due to a tiny imprecision that occurs as the clock measures a single second as it ticks. A single second may not seem like much, but over time, slight imprecisions really start to add up! The preciseness of a clock could be affected by temperature, location, the clock’s source of power, and even just how well it was constructed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*64aruhYbkcX9pgZzprey5g.jpeg" /><figcaption>Clock drift and clock skew</figcaption></figure><p>This phenomenon of limited clock precision causing two clocks to to count time differently is known as <strong><em>clock drift</em></strong>. Unfortunately, it is just a reality of any machine that needs to keep track of the time on its own. Because clock drift is so common, we often also find ourselves comparing two clocks that display two different times. This is known as <strong><em>clock skew</em></strong>, and it is the difference in time between two clocks.</p><blockquote>In a perfect world where two clocks agreed on the time, we wouldn’t ever run into either of these concepts! In such a utopia, both clock drift and skew would be zero.</blockquote><p>Alas, we do not live in such a world, and so we must think of both of these things when comparing two different machines and their times. Instead, we live in a world where things are messy and…distributed.</p><h3>No one clock to rule them all</h3><p>We’ve talked a lot about clocks and how they work and how they disagree, but what does that have to do with distributed systems, exactly? As it turns out, all of this clock talk is leading is to one of the core, foundational principles of distributed systems that, somehow (!), we haven’t covered it. Now, it’s finally time to talk about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60kDqvVEqSdv7cr4voVOmA.jpeg" /><figcaption>Clocks and distributed systems</figcaption></figure><p>As we already know, in a distributed system, all the individual components are called nodes, and they are each <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">autonomous</a>, capable of performing their own work. We also learned that each node has its own notion of time, and keeps track of its own time internally. When we combine these two facts together, we arrive at one singular conclusion:</p><blockquote>There is no one, true global clock in a distributed system.</blockquote><p>Every node in the system has its own concept of time, and there is no centralized place for the nodes in a distributed system to figure out what time it actually is. And perhaps this wouldn’t matter if we didn’t care about time so much! We use time so frequently in computing, particularly in order to figure out when an event occurred, and which event happened before another.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9pr7aFWqOz0WA02RflYkoA.jpeg" /><figcaption>How does having no global clock impact the way a system works?</figcaption></figure><p>So what happens when we don’t have a global clock in a distributed system? Well, for starters, we can’t actually know the <em>real</em> time that any two evens occurred, or the order that they occurred in. This makes is very hard to figure out how two events might be scheduled in the future. It also makes a distributed system <em>really</em> difficult to debug, since we don’t know for sure whether one event occurred before the other!</p><p>We’ll be talking more about time and the ordering of events in upcoming posts, and hopefully we’ll find some tried and true solutions for this problem. Until then, try not to look at your watch or think too much about what time it is.</p><h3>Resources</h3><p>Clocks and time in distributed systems can be one of the most unintuitive concepts to wrap your head around — especially if you’re new to distributed systems! Thankfully, there is a ton of course material out there that covers these topics in great detail. Below are some of my favorites, which I relied upon myself when I was learning about clocks and time!</p><ol><li><a href="http://www.ntp.org/ntpfaq/NTP-s-sw-clocks.htm">How do Computer Clocks work?</a>, Network Time Foundation</li><li><a href="http://people.cs.aau.dk/~bnielsen/DS-E08/material/clock.pdf">Time in Distributed Systems</a>, Brian Nielsen</li><li><a href="http://www.cs.bham.ac.uk/~bxb/courses/02_03_DS/Lecture10_Handouts.pdf">Clocks and Tim</a>e, Behzad Bordbar</li><li><a href="http://www.cs.cmu.edu/~srini/15-446/S09/lectures/08-phy_time.pdf">Synchronizing Physical Clocks</a>, Srinivasan Seshan</li><li><a href="http://infolab.stanford.edu/~burback/dadl/node87.html">Distributed System Foundations</a>, Ronald LeRoi Burback</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef2aa4df07a3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">Ticking Clocks in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Parsing Through Partitions in a Distributed System]]></title>
            <link>https://medium.com/baseds/parsing-through-partitions-in-a-distributed-system-3c1723fecc4e?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c1723fecc4e</guid>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Fri, 30 Aug 2019 23:38:47 GMT</pubDate>
            <atom:updated>2019-08-30T23:38:47.447Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*08zDlw37YpFhHuH-nEhOBA.jpeg" /><figcaption>Parsing through partitions in a distributed system!</figcaption></figure><p>When it comes to tech jargon, one thing seems to always hold true: everyone has a different opinion about what certain words mean. I realize this fact every once in awhile; most recently, I came across it while trying to learn a new distributed systems concept.</p><p>The term “partition” is used a lot in distributed system courses and books, but there are also a slew of other terms that get lumped into this category as well. Until recently, I thought I knew what the term meant in the context of a distributed system, but as it turns out, there was more to the story — and the word — than I ever realized! As I did more research, I realized that the term is used to talk about two very different concepts, both of which end up being crucial to understanding how to deal with and architect a distributed system.</p><p>As Richard Feynman <a href="https://www.youtube.com/watch?v=ga_7j72CVlc">once wisely said</a>, “names don’t constitute knowledge”. Just because people in the industry throw around a term doesn’t mean that they all necessarily know what it means, or how it can chance depending on the context! So let’s try and clear up some of this confusion and gain some real knowledge on this topic.</p><h3>Parsing the meaning of partitioning</h3><p>Before we get too deep into partitioning within a<em> system</em>, let’s first make sure we’re on the same page about what the word even means! When we talk about <strong><em>partitioning</em></strong> something, we are dividing it up, breaking it up into parts and separating it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3tzaGgBF5B4OuYeUsQXL3A.jpeg" /><figcaption>What does it mean to partition something?</figcaption></figure><p>At its core, that’s all that partitioning really is: taking the whole of something and turning it into smaller pieces of itself. So far, not too complicated, right? But what does this same term mean in the context of a distributed system? Well, we can infer that the distributed system must, in some way, be the “whole” thing that we are separating, dividing up, and breaking into smaller pieces of itself.</p><p>But this simple act can actually take two different forms, depending on the kind of partition we are creating. As <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">we already know</a>, a distributed system is made up of nodes; so, if we are dividing up the system into parts, perhaps we are dividing up the nodes? But there’s another interpretation of “partition” here, too. Rather than dividing up the nodes, perhaps we are dividing the system into smaller groups of nodes such that we are breaking up one large system into smaller subsystems. If we think about it, both of these approaches are two valid forms of partitioning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8H7K_dfMS90KSkisAsfbaA.jpeg" /><figcaption>In the context of distributed systems, “partitioning” can mean different things.</figcaption></figure><p>As it turns out, this is where things can get confusing. When dealing with a distributed system, “partitioning” can mean different things. First, it could imply the <strong><em>partitioning of data</em></strong> in the system, or dividing up the nodes into smaller pieces of themselves. But, it could also mean partitioning the system itself by <strong><em>partitioning the network </em></strong>that the system communicates through. This would mean breaking up the way that the nodes in the system talk to each other and separating them into smaller subsystems or subnetworks.</p><p>The interesting thing about these two forms of partitioning in a system is that one is intentional, while the other is more of a side effect that we need to deal with. But more on that soon. It’s important to understand the difference between the two because the same term can sometimes be used to refer to either! So let’s dig into these two forms of partitioning and understanding the reasons behind why each happen.</p><h3>Separating data</h3><p>The idea of partitioning the nodes in a system might seem odd at first, but we’ve we’ve actually seen something sort of adjacent to this before. Remember when we learned about redundancy and <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">the replication of nodes</a>? That concept also might have seemed weird initially — why would anyone <em>want</em> to repeat themselves?! — but as we started to unpack it further, we saw that there were some clear benefits to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*coMCYYa76oaLs1opVKHxoA.jpeg" /><figcaption>Recapping the pros and cons of replication.</figcaption></figure><p>As we have <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">already learned</a>, when we need to make some of our nodes more reliable or when we need to scale some part of our system (like a database), we can replicate our nodes to create more copies of the same data that are in sync with the original node. That way, if one replica fails, another working replica can handle incoming requests for some data. Overall, replication allows for a system that is more <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">transparent</a>, <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">reliable</a>, and much <a href="https://medium.com/baseds/scalability-growing-a-system-in-different-directions-ae16469c4cb3">easier to scale</a>.</p><p>There are some caveats with replication, however. We already know that keeping replicas consistent is a major challenge. But what happens if our replicas suddenly need to deal with a high load of incoming requests? It is possible that a few replicas could fail, and any user that is depending on the replica would potentially not be able to access <em>any</em> of the data at that replica (at least until another replica was able to come and take its place).</p><p>This presents a new challenge with replication: while most of users can access all of our data through working replicas, for a <em>portion</em> of users, all of our data could be <em>completely unavailable</em> if the replica that those users are accessing <em>happens</em> to fail.</p><p>But what if we had a <em>very</em> large data set? One that would make us think twice before replicating it? This is where we might want to employ a different strategy…like partitioning our data!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XGr9rPymDV3tTokJhZhHfw.jpeg" /><figcaption>Where replication doesn’t fit the bill, partitions can save the day!</figcaption></figure><p>In some situations where a dataset is so large that it cannot all fit on a single node, we can opt to partition our data.</p><blockquote>Partitioning data across nodes means that our data is distributed across our nodes; no single node can contain all of our data. Conversely, if we wanted to retrieve all of the data, we’d need to go to every single node to get it.</blockquote><p>Depending on what a dataset looks like and what pieces of data are related to one another, it may make sense to lump certain types of data together onto a single node. For example, in a system that shows posts and the related comments on a page, it might make logical sense to always put the data for a post and all of its comments together on the same node, so that our users wouldn’t need to make <em>two</em> requests to fetch <em>two</em> kinds of data in <em>two</em> different nodes.</p><p>There are lots of strategies for determining what data should live on which node. Two terms that we might come across to describe this idea are <strong><em>sharding </em></strong>and<strong><em> fragmentation</em></strong>. Both terms are used interchangeably to describe the idea of partitioning a dataset across many different nodes (we won’t go into detail about the actual implementations of these techniques in this post).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zf8T4wV_404rmZEEL1Gm4g.jpeg" /><figcaption>Sharding/fragmenting data is a kind of partitioning!</figcaption></figure><p>The important thing to note here is that whenever we see the terms “sharding” or “fragmentation”, the context is usually a partitioned database (since databases are generally where our datasets will live!). Oftentimes, databases live on multiple servers and are distributed, themselves (pretty neat, right?). So, when we encounter a situation where a database is fragmented and split it into shards, what we are really dealing with is one big dataset that has been split into <strong><em>shards</em></strong>, or smaller sets/fragments, and have been distributed across nodes.</p><blockquote>A single database node contains just one portion of a larger dataset. When more data gets added or if the dataset changes significantly, it might need to be re-partitioned into new shards across all the nodes.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9VB8k_3RR6_8CHFYDZcdFA.jpeg" /><figcaption>Replication versus partitioning data.</figcaption></figure><p>So how does this fit in with our mental model of <em>replication</em>?</p><p>Well, to start, there is one major similarity to note here: both partitioning and replication improve the performance and reliability of our system. This is simply due to the fact that having more nodes — whether they are replicas that contain all the same data, or whether they are partitions that contains some of the data — mean that the load on a single node reduces! When we add more replicas OR partitions, we effectively spread out the incoming requests for data, which helps our system scale and makes it much more performant and available to our end users.</p><p>But what about the differences between these two strategies? Replication guarantees that our end user can <em>always read</em> our whole dataset, because all of the data lives on each replica. On the other hand, partitioning guarantees that <em>some</em> of the data will be retrievable, but there is no guarantee that our end user can always retrieve the data they need if one of the partitions fails!</p><p>Another difference between replication and partitioning are the things that make them difficult! Replication is hard because it’s tricky to maintain consistency between our replicas. Partitioning is hard for two reasons: first, if our dataset changes and we need to suddenly re-partition it…well, this is no easy task. Deciding how to divide up data takes time and effort, and we definitely don’t want to be re-partitioning it all the time! Second, depending on how it is implemented, it can sometimes be ineffective. For example, if we some highly-used data that is partitioned into <em>one</em> node, we actually end up in a <em>worse</em> situation than before we partitioned the data. Why is that?</p><p>Well, imagine that all of our end users suddenly request that highly-used data at once, and the node can’t handle the high load? Or what if that one database node with the highly-used data fails? Now our end users can’t access this important partition! So it’s up to us to consider all of these potential downsides when determining the tradeoffs of these two strategies. To avoid some of the heartache that’s associated with making these decisions, many production-level distributed systems will use replication when possible, and opt for partitions only when necessary.</p><h3>Dividing a network</h3><p>Now that we know the ins and outs of what it means to partition data, we have one last thing to unpack: the idea behind partitioning the network. Don’t feel too intimidated, though, this isn’t a completely new topic for us. In fact, I’ll let you in on a little secret, though — we’ve already seen the effects of a partitioned network!</p><p>We’ve learned about the <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">many</a> <a href="https://medium.com/baseds/modes-of-failure-part-2-4d050794be2f">different</a> failure modes in this series, and as it turns out, <strong><em>network partitioning</em></strong> is actually just one form of failure in a distributed system. It occurs when a network is split up into fragments, and subsequently creates sub-networks within itself. The important bit to call out here is that it is a <strong><em>network fault</em></strong> (also called a <strong><em>network split</em></strong>) that breaks the usual communication between nodes in the network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fyFcEQQbO3E2IN6_yKj3cw.jpeg" /><figcaption>What does it mean to partition a network?</figcaption></figure><p>However, this doesn’t mean that <em>all</em> the nodes in the network cannot communicate; the only ones that can’t communicate to one another are the ones surrounding the split. This means that if a network split occurs between two nodes, those two nodes can’t talk to one another, but they can continue to talk to other nodes that are not impacted by the split.</p><blockquote>When the node connection is interrupted by a network fault, it creates subnetworks that are “partitions” of the larger network — an unintentional division of the network, if you will.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Xdxi7h6jrhBKYJXRBZAvg.jpeg" /><figcaption>Network failures can partition the network into smaller subnetworks.</figcaption></figure><p>For example, in the drawing shown here, a <strong><em>network failure</em></strong> has caused a network partition (also called a <strong><em>fragmentation</em></strong>). The point of the fragmentation forces our network to be divided into two <strong><em>subnetworks</em></strong>, which we’ve named A and B. The nodes of subnetwork A can keep talking to one another, and the nodes of subnetwork B can keep processing data and sending information between themselves. However, any of the nodes between subnetworks A and B have been fragmented, which means that they can’t talk to one another! This means that subnetwork A cannot talk to or even know the <em>state</em> of subnetwork B (and vice versa).</p><p>Now, if this situation sounds bad, you’re right — it is! We don’t want our network to randomly break and cause parts of our system to be isolated from one another. Clearly, a partitioned network is something to avoid. However, do you remember back when we learned about the <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">8 Fallacies of Distributed Computing</a>? If we think back to fallacy #1 (<em>“The network is reliable.”</em>) and Fallacy #4 (<em>“The network is secure.”) </em>then we’ll come face to face with the hard truth: <strong><em>network partitions are unavoidable</em></strong>.</p><p>So what can we do? Well, we can design our systems to try to handle them gracefully when they (inevitably) happen! This is similar to the conclusion that we came to when we were learning about <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">fault tolerance</a>, and how we are forced to consider faults and try to design our systems to handle them. Similarly, when it comes to network partitions, we need to plan for <strong><em>partition tolerance</em></strong>, which is they way that we consider the potential network faults that might pop up, as well as the failures that they might cause! A partition tolerant system is one that has attempted to account for network partitions, since we’ll all run into them eventually.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WkGxVvTcBt-hZv_VpZ0O5Q.jpeg" /><figcaption>Partition tolerance is the ability to account for network partitions.</figcaption></figure><p>Although data partitions might be an avoidable problem to solve since we may not decided that we even need to partition our data, network partitions are something that we just cannot avoid. In fact, they’ll come up again later when start learning about some interesting…theorems. But that’s a story for another post! 😉</p><h4>Resources</h4><p>Partitioning and partition tolerance comes up quite often when learning more advanced distributed system topics, so it’s important to have a strong understanding of the fundamentals. Conveniently, there are some really great resources to help with this task. I’ve listed some of my favorites below, some of which get into even more advanced aspects of partitioning; check them out if you’re eager to learn more!</p><ol><li><a href="http://dimafeng.com/2016/12/04/distributed-systems/">Distributed systems cheat sheet</a>, Dmitry Fedosov</li><li><a href="https://medium.com/@Pranaykc/understanding-partitioning-in-distributed-systems-4ac3c8010fae">Partitioning: The Magic Recipe For Distributed Systems</a>, Pranay Kumar Chaudhary</li><li><a href="http://book.mixu.net/distsys/intro.html">Distributed systems for fun and profit</a>, Mikito Takada</li><li><a href="https://www.youtube.com/watch?v=uTJvMRR40Ag">Why are Distributed Systems so hard? A network partition survival guide</a>, Denise Yu</li><li><a href="https://www.youtube.com/watch?v=W1NmbcuomVM">Replication vs Partitioning</a>, Georgia Tech</li><li><a href="https://aphyr.com/posts/281-jepsen-on-the-perils-of-network-partitions">Jepsen: On the perils of network partitions</a>, Kyle Kingsbury</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c1723fecc4e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/parsing-through-partitions-in-a-distributed-system-3c1723fecc4e">Parsing Through Partitions in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redundancy and Replication: Duplicating in a Distributed System]]></title>
            <link>https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ab4322d7378</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 14 Aug 2019 12:01:01 GMT</pubDate>
            <atom:updated>2019-08-14T12:01:01.473Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LGqKQHW3Uf4saYuCrvTShA.jpeg" /><figcaption>Redundancy and replication: duplicating in a distributed system</figcaption></figure><p>When it comes to programming, there are certain conventions, idioms, and principles that we run into and reference as a community quite often. One of those principles is the idea of “Don’t Repeat Yourself”, or DRY for short. I encountered this idea early on in my programming career, and it seemed pretty straightforward to me at the time: in order to maintain clean, concise code, it was important to ensure that one didn’t repeat the same lines or logic in our codebase.</p><p>But over the years of my career, I’ve learned and seen more, and realized that that repetition is not so cut and dry —no pun intended! Sometimes, it actually does make sense to repeat yourself at the risk of over-engineering or over-abstracting something unnecessarily. Sometimes, it makes sense to just duplicate a function or piece of logic and just “copypasta” it into another file.</p><p>And when it comes to distributed systems, it often makes a lot of sense to have many of one thing! In fact, as we start to look at duplication as a concept in distributed computing, the more obvious it becomes that repeating ourselves can actually be a huge benefit to our system as a whole. So let’s dig into duplication in a distributed system, and try to understand why we’d ever want to do it.</p><h3>Repetition: sometimes a good thing?</h3><p>When we talk about “repeating ourselves” in the the realm of distributed computing, we can mean many different things. Repetition of a line of code or a piece of logic usually indicates that we have more than one thing that isn’t quite necessary. In a distributed system, we have a special term for this called <strong><em>redundancy</em></strong>, which is all of the resources in a system that are not necessary for the system to actually function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0FJC2NmKW1CocaJCMQY4EQ.jpeg" /><figcaption>What can redundancy include?</figcaption></figure><p>However, in distributed computing, we could potentially have a whole lot of different resources, which means that we have many different things that could potentially be repeated! Thus, redundancy can encompass many different kinds of extraneous resources.</p><p>For example, repeated calls to the same function from the different places in the system, or duplicated references/variables to the same data are forms of redundancy. Similarly, duplicated execution time in a function as well as extra memory, files, or processes are also redundant, since the system doesn’t actually need those duplicated resources to function correctly.</p><p>For the purposes of this series, we’ll focus on redundancy in the context of extra memory, files or processes, which is often called <strong><em>structural redundancy</em></strong>. In the context of a distributed system, some extra memory or file (read: a database) or an extra process all can be abstracted to a term that <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">we’re already familiar</a> with: nodes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qHPOziKmRFmrA34qaaRqTA.jpeg" /><figcaption>Redundant nodes: a definition.</figcaption></figure><p>A redundant node is any node that isn’t strictly necessary for the distributed system to function correctly. In other words, any node that adds to the bare minimum functionality of the system is extraneous, and we can therefore say that it is redundant.</p><p>Well, wait a minute — if we think about this a bit more deeply for a minute, we’ll probably realize that we duplicate a lot of stuff in a distributed system! We’ve talked about adding nodes to a system pretty loosely in this series, but all of the nodes that we add can’t all be <em>necessary</em> to the system, right? So, why did we even bother adding redundant nodes? Why would anyone<em> </em>want to be explicitly and intentionally redundant in their system? Well, in order to really answer that question, we need to move from the larger concept of redundancy to the more specific topic of replication<em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*crm5kpkSO67sh5vUVWanIQ.jpeg" /><figcaption>Redundancy versus replication</figcaption></figure><p>While redundancy is what allows us to duplicate the components of our system, the duplication itself isn’t really what is useful.</p><blockquote>Redundancy doesn’t actually help us if a redundant node is out of sync with the node that it was copied <em>from</em>.</blockquote><p>A redundant node on its own isn’t all that helpful; sure, we have achieved redundancy, but who knows how long that redundant node will actually be functional for us in our system? What happens if one of the nodes changes in value or state? As it turns out, the answer to both of these questions is replication! When we replicate a node in our system, these duplicate copies actually become much more functional for us.</p><h3>Duplication and maintaining state</h3><p>Replication as a concept is much of like a subset of redundancy. Both of them involve creating redundant nodes in a system — nodes that aren’t strictly necessary for the system to work correctly.</p><p>However, <strong><em>replication</em></strong> takes a redundant node one step further; it ensures that the redundant node (a <strong><em>replica</em></strong>) is identical to all of its other copies. At first glance, this might seem simple and perhaps even obvious; we might even assume that a node that has been copied from somewhere else will be identical to the thing it was copied from, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rvoAxWXAN9vXXPZq3TishA.jpeg" /><figcaption>Replicated nodes: a definition</figcaption></figure><p>Well, not necessarily! In fact, let’s say that we copied a node and created a redundant one. But later on, we change something about the original node — perhaps we change its state, some value that it contains, or some internal behavior. What would happen to the redundant node? Well…nothing!</p><p>If we created just a simple redundant node, there is nothing in place within our system that will ensure that the redundant node will 1) know that something changed and 2) will update itself or be updated by someone else to have the correct state.</p><p>So perhaps this problem is not as obvious as we first thought! Replication attempts to solve this problem, because it ensures that all replicas of a node will be identical to one another, and will match the original node that they were replicated from. (Side note: the question of <em>how</em> to ensure this is no easy task, but we’ll learn more about that later on in the series…)</p><p>Another important thing to note here is that replication comes hand in hand with <strong><em>transparency</em></strong>, a concept that <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-1-b01c25f7dddd">we’re already</a> <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">familiar with</a>. With each replica that is added to a system, the rest of the system should still function correctly, and should ideally be unaware of any replicas that have been created.</p><blockquote>If a replica is updated, the rest of the system shouldn’t know about it, and if a node is replicated, the rest of the system shouldn’t really care.</blockquote><p>For example, if a web server or a database node is replicated, the end users of the distributed system ought not to have any idea that are interacting with a replica or the original node. (In fact they probably shouldn’t have any idea that there even <em>is</em> a replicated node!)</p><p>When this transparency is mostly maintained in a system, replication provides us with a whole lot of benefits:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hKZ00TKnZLJ-_xFp__oBrQ.jpeg" /><figcaption>Some benefits of using replication in a distributed system.</figcaption></figure><ol><li>Replication of nodes makes our system is much more <strong><em>reliable. </em></strong>If one node goes down and we have already added replicas, it’s much more likely for a replica to step in and do the job of the failing node. This makes our system more <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">fault-tolerant</a>. Having replicas in place makes our system <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">more available</a> as well, since overall there are more backup replicas to step in to take another node’s place, which means that our system shouldn’t experience too much downtime.</li><li>Replication of nodes also makes our system more <strong><em>performant</em></strong>. With more replicas in place, we now have the ability to do more work, serve more requests, and process more data. This makes our system just generally faster, reduces latency, and allows the system to handle a high throughput of data that has to be processed/delivered.</li><li>Replication of nodes makes our system much <strong><em>easier to scale</em></strong>. Scalability is <a href="https://medium.com/baseds/scalability-growing-a-system-in-different-directions-ae16469c4cb3">a big plus point</a> when it comes to building a distributed system, but it’s not always easy to achieve. With more replicated nodes, it’s is easier to scale a system by adding more databases, servers, or services as required by the demands on the system. It’s also easier to geographically scale a system when we can replicate a node and place it in a different continent or country to help scale a high workload in a specific location.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MiIQbkt3qE6cjVpvc2P7MA.jpeg" /><figcaption>Reliability, performance, and scalability through replication</figcaption></figure><p>By this point, hopefully we’re all on board with the idea of replication (right?). It’s pretty cool and nearly every distributed system will take advantage and leverage this concept to help deal with issues of reliability, performance, and fault-tolerance. Whether in the form of workers, servers, databases, or services, we’ve probably each worked with replicas in our daily lives as developers! Sounds great, right?</p><p>Well, almost. The story doesn’t quite end here. Replication is awesome, but it presents some unique challenges unto itself. I can’t promise any solutions in this post (don’t worry, we’ll talk a lot more about this as the series goes on), but at the very least, I’ll present you with some of the problems. 😉</p><h3>Consistent headaches</h3><p>In addition to transparency, the concept of replication needs one other thing to really work well: <strong><em>consistency</em></strong>. In order for a replica to actually be up-to-date with all the other replicas in the system, it needs to be consistent with the other copies. And this is not a trivial task!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvbWNZPpVWhY8FuVYsUP_w.jpeg" /><figcaption>What makes replication hard?</figcaption></figure><p>Now perhaps, at first glance, this doesn’t seem too difficult. Maybe we could always have the replicas get updates from the original copy? Or maybe the original copy can tell the replicas whenever something else changes? However, this is tricker than it sounds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vqEXEw-wdu9cUcNOwOJjyA.jpeg" /><figcaption>It’s a struggle to maintain consistency as replicas change state!</figcaption></figure><p>We learned earlier that a system must also be transparent for replication to work. <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-1-b01c25f7dddd">Transparency</a> in <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">a system</a> means that all the replicas and the original node must behave similarly, which means that a consumer of the system (like an end user or another node) could potentially write to one replica, while another consumer of the system could read from <em>another </em>replica!</p><p>So, we can’t rely on just the original node anymore as our single source of truth when it comes to the state of our node(s). The question here is, of course, how do we tell these two replicas what just happened? The replica that is being read-from needs to know about the latest write; similarly, the replica that is being written-to needs to disperse information about that write.</p><p>This is exactly what makes replication so hard; we have to contend with consistency and figure out a model for how to ensure that all of our replicas. Thankfully, we’ll cover that in much more detail later. For now, we just need to know that it’s a problem that we’ll have to deal with soon. sUntil then, feel free to replicate your little hearts away!</p><h3>Resources</h3><p>Understanding replication and redundancy is a key step to wrapping our heads around how a distributed system grows. The topics in this series will continue to build on the idea of replication, so it’s important to understand it fully. If you’re looking for further resources, the ones listed below are some great places to start (or continue learning!).</p><ol><li><a href="https://pdfs.semanticscholar.org/87dc/8e839af0633b9f2968a669c5af70453cfe0b.pdf">Redundancy and Replication: Fault Tolerance on the System Level</a>, Kurt Kanzenbach</li><li><a href="http://www8.cs.umu.se/kurser/5DV147/HT15/lectures/l8-handouts.pdf">Distributed Systems: Replication</a>, Umeå University</li><li><a href="https://www.uio.no/studier/emner/matnat/ifi/INF5040/h16/pensumliste/replication.pdf">Replication in Distributed Systems</a>, Roman Vitenberg</li><li><a href="https://www.cs.helsinki.fi/webfm_send/1256">Distributed Systems: Replication and Consistency</a>, Jussi Kangasharju</li><li><a href="http://csis.pace.edu/~marchese/CS865/Papers/wiesmannWPS+00.pdf">Understanding Replication in Databases and Distributed Systems</a>, Schiper &amp; Alonso</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ab4322d7378" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">Redundancy and Replication: Duplicating in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Foraging for the Fallacies of Distributed Computing (Part 2)]]></title>
            <link>https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-2-b8ff29beed56?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ff29beed56</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 07 Aug 2019 12:16:01 GMT</pubDate>
            <atom:updated>2019-08-07T12:16:01.900Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d2wbpLCXgXQRfsNLruq5_A.jpeg" /><figcaption>Foraging for EVEN MORE fallacies of distributed computing!</figcaption></figure><p>So much of what makes distributed systems hard to content with is the fact that, as a system grows, it changes. Furthermore, the things around the system — parts of the system itself, its dependencies, and the people who maintain it — are also each capable of changing as well.</p><p>In part one of this series, we looked into <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">the first four</a> of the famous eight fallacies of distributed computing. Conveniently, those four fallacies all centered around the network, and the misconceptions and falsehoods that many developers can fall prey to when they are dealing with a distributed system. But in part two of this series, we’re going to zoom out a bit and look at the remaining four fallacies, which feel far more abstract in nature, in my opinion.</p><p>What’s interesting to me about the second half of the fallacies is the fact that they almost seem obvious to us at first glance. You may even read them and think to yourself, <em>“how could anyone ever assume this fallacy to be true?”.</em> But as we’ll soon see as we dig into each of them, there’s more to each fallacy than meets the eye. And keeping these big-picture truths in check as we design a simple system or a complex one is harder to do than we might think. So let’s dive right in and finish up our foraging for fallacies!</p><h4>Rearranging the network</h4><p>As we already know, nodes in a distributed system must communicate via messages, which are sent through a network. However, that network is a changing, fluctuating entity. If a node is added to network, it inherently will look a little different, right? We have a new character on the stage, and the way that the network looks or how it is arranged differs depending on which nodes are involved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gdOAEwrbXa9H1Yj6a-IBrw.jpeg" /><figcaption>Topology: a definition of what it means in a network.</figcaption></figure><p>As it turns out, there’s a term for this concept, and it’s high time that we familiarized ourselves with it: <strong><em>topology</em></strong>. A network’s topology is the way that the elements in the network are laid out or arranged.</p><blockquote>Topology illustrates the way that the nodes in our distributed system relate or connect to one another, and more importantly, how they communicate with one another.</blockquote><p>For example, we could have a set of nodes in a network that are connected and communicate with one another in a ring shape, or we could have all the nodes connected in a line. Or, like in the example above, the nodes could be connected in star shape, or perhaps they could be arranged in a tree shape. All of these different examples are valid ways to lay out the nodes in a network, and each of them are different topologies.</p><p>Understanding the concept of a topology is essential to us grappling with fallacy five: <strong>Topology doesn’t change.</strong> Remember that this is a <em>fallacy</em>, which means that it is a misconception; in other words, this statement is untrue, and the topology of a network <em>does</em>, in fact, change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WJuTy1z6Y2v_8xA6oFGQxQ.jpeg" /><figcaption>Fallacy #5: Topology doesn’t changes (it does!)</figcaption></figure><p>At the surface, this statement might seem obvious; any time that we add, replace, or remove a node from our network, the way that the elements (nodes) of that network are arranged and how they relate to one another is invariably going to have to be flexible and move around to be able to handle these changes. Given what we know about how nodes can be <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">flawed</a> and how they <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">will</a> <a href="https://medium.com/baseds/modes-of-failure-part-2-4d050794be2f">fail</a>, we also can be sure that the frequency with which a new node might be added or an old node might be removed or replaced is going to be fairly consistent and high. In other words, the network’s topology is always going to be in flux and fluid!</p><p>So why is this otherwise obvious fallacy something worth noting here? Well, what makes this fallacy tricker than it seems is the fact that most of us just don’t think about the obviousness of it on a day-to-day basis. We often depend on the network behaving a certain way and doing certain things. Sometimes, we explicitly depend on the topology of the network being arranged in a certain way. For example, if our system sent messages every 30 seconds to a node in the system, and expects that node to exist at a certain location in the network, what happens if that node disappears? Or what if it moves?</p><p>If we depend on our network always “looking” a certain way, and if we expect for its nodes to always be <em>arranged</em> a certain way, we fall into the trap of this fallacy. And this can be an easy assumption to make, especially if we don’t take this fallacy into to account in our daily interactions as designers and maintainers of a distributed system! So, it’s up to us to consider the ways that we might be relying — even if inadvertently — on the topology of our system’s network.</p><h4>System management realities</h4><p>Assumptions are very easy things to make — we make them all the time! Not only can we make bad assumptions about our system and what it looks like and how it will behave in certain circumstances, but we can also make bad assumptions about who will be maintaining and dealing with that system at any given time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*46sgtw7hFKKIF9EUAz0qPA.jpeg" /><figcaption>Fallacy #6: There is one administrator (there almost certainly are more!).</figcaption></figure><p>This is brings us to fallacy six: <strong>There is one administrator. </strong>In nearly all real-life scenarios, there is usually <em>more</em> than one administrator of a distributed system. With the exception of very small applications — or perhaps a system that is a toy/hobby project that only has one person building and maintaining it — most systems end up with many people involved in the maintenance of the system.</p><p>Assuming that only one administrator exists to maintain a distributed system can have long term side-effects. For example, imagine a system where three administrators are helping to keep the system up and afloat. What happens if one of those administrators — who just so happens to be an expert in one of the aspect of the system — leaves the team? Or, what if one of the parts of the system is actually a dependency and part of an external service?</p><p>In both of these situations, one part of the system is likely under the control of someone else, and we have to consider what we’ll do if that section of the system needs maintenance, or what will happen (and who will fix the problem, not to mention how quickly) if that section of the system goes down!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V4b8VUD2y_gq2puhUGBRBw.jpeg" /><figcaption>The many aspects of maintain a system as an administrator.</figcaption></figure><p>The sixth fallacy is really important to keep in mind (and it’s so easy to forget about entirely!). We already know that regular tasks like maintaining and upgrading a system <a href="https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c">are responsible</a> for causing a great deal of software bugs. So when a system has many administrators, it’s our responsibility to make sure that the system can still be easily upgraded and maintained as more and more admins are added to the mix. Similarly, if our system depends on a third-party service, we need to consider who those external administrators are, and how we’ll handle an external dependency that needs attention.</p><p>We also need to be sure to have a way to empower all administrators of a system to debug and diagnose different parts of the system. This last piece of the puzzle is especially important, because administrators can make important decisions — like restarting a node, limiting a quantity of data, or deciding what protocols to use — and those decisions are crucial to managing a system and keeping it running correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dQ81EJDyfVzhV9xcbZeVbA.jpeg" /><figcaption>Fallacy #7: Transport cost is zero (it is not!)</figcaption></figure><p>Another “easy to dismiss” assumption is the reality of the cost of running a system. This leads us right to fallacy seven: <strong>Transport cost is zero.</strong> As we learned with <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">fallacy two</a>, it takes time for data to travel from one place to another; another name for this amount of time is <em>latency</em>. Similarly, the cost of sending data from one place to another also has other costs, too!</p><p>For example, it takes <strong><em>resources</em></strong> to be able to transport any data from one place to another within a distributed system. These resources have a price tag attached to them, and these resources cost money.</p><p>Additionally, sending data from one place to another also takes some effort and time to turn the data into a machine-readable code (and subsequently, back out of machine-readable code into data again). These processes are known as <strong><em>serialization</em></strong> and <strong><em>deserialization</em></strong>, and all data that is passed around in the system needs to be serialized and deserialized from a byte stream into some object in memory that is used to represent that data. Many developers are familiar with serialization and deserialization and use it every day; however, not all of us are necessarily considering the time and effort that these two processes take whenever they happen!</p><p>The fact that it costs time, effort, and resources remind us that it is not free to send data through our system and transport information back and forth. However, it can be easy to forget this until we get an unexpected bill from AWS or Heroku, at which point we suddenly remember this reality. Keeping this fallacy in mind is especially important as our system scales and our transport costs start to creep up on us.</p><h4>Standardization of a system</h4><p>The final fallacy is one that many of us may not have ever thought about, particularly if we have been working with frameworks and systems that have already been around for some time. The eighth fallacy brings us back to our good old friend, the network: <strong>The network is not homogeneous.</strong> Many of us probably know this fallacy to inherently be false: the nodes in a network can be anything, so there is no guarantee that they will all be the same!</p><p>In fact, most distributed systems may integrate with different kinds of devices, perhaps different protocols, and almost certainly will adapt to work with various operating systems and browsers. And because the nodes of our network(s) aren’t going to all look the same, it’s not always safe to assume that they will all be configured the same, either.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BtcXMQvWn3e-pcvwITVl3A.jpeg" /><figcaption>Fallacy #8: The network is homogeneous (it isn’t if we don’t use standards).</figcaption></figure><p>Indeed, most networks are heterogenous, but the nodes in a system’s network still need to work together and be interoperable. Conveniently, however, most of us don’t need to fear this fallacy; this is where <strong><em>standardization</em></strong> comes in to save the day! Most systems these days are architected to rely upon and utilize standardized formats that are created to create a shared language amongst different elements in a system, even if they perhaps aren’t all configured the same.</p><p>Many of us use these standards — like HTTP protocols, REST APIs, and JSON-formatted data — on a daily basis, and these standards make it much easier to deal with a heterogeneous network. But it’s still important to remember this fallacy in the off chance that one day, we find ourselves building a part of a system that isn’t using a standardized format! Rolling a proprietary protocol of one’s own means that, down the road, there will most likely be another node that will be incompatible with our non-standard format.</p><p>In fact, I think it’s worth thinking about all eight fallacies, even if we are working with systems that have been built so that we don’t need to consider these issues. Just because we don’t run into these fallacies on a daily basis doesn’t mean that they’re not powerful! In fact, they can sneak up on us just when we’re not looking, and prove that even the most experienced distributed systems engineers can make bad assumptions.</p><h4>Resources</h4><p>The fallacies of distributed computing have been fairly well-written about, and you can find some good resources on different interpretations of them, for different technologies. If you’re curious to learn more, check out the resources below!</p><ol><li><a href="https://www.rgoarchitects.com/Files/fallacies.pdf?source=post_page---------------------------">Fallacies of Distributed Computing Explained</a>, Arnon Rotem-Gal-Oz</li><li><a href="https://www.simpleorientedarchitecture.com/8-fallacies-of-distributed-systems/?source=post_page---------------------------">Understanding the 8 fallacies of Distributed Systems</a>, Victor Chircu</li><li><a href="https://multimedia.telos.com/blog/debunking-the-8-fallacies-of-distributed-systems-part-2/?source=post_page---------------------------">Debunking the 8 Fallacies of Distributed Systems</a>, Ramil Alfonso</li><li><a href="https://www.youtube.com/playlist?list=PL1DZqeVwRLnD3EjyciYAO82dT9Owiq8I5&amp;source=post_page---------------------------">Fallacies of Distributed Systems</a>, Udi Dahan</li><li><a href="https://blog.newrelic.com/engineering/the-fallacies-of-distributed-computing-reborn-the-cloud-era?source=post_page---------------------------">The Fallacies of Distributed Computing Reborn: The Cloud Era</a>, Brian Doll</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ff29beed56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-2-b8ff29beed56">Foraging for the Fallacies of Distributed Computing (Part 2)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Foraging for the Fallacies of Distributed Computing (Part 1)]]></title>
            <link>https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b35c3b85b53</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Fri, 21 Jun 2019 04:15:25 GMT</pubDate>
            <atom:updated>2019-06-21T04:15:25.723Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Tc61g8f7tKwW2Kka6EOqg.jpeg" /><figcaption>Foraging for the fallacies of distributed computing!</figcaption></figure><p>So much of computing is based on assumptions. We design systems operating on a set of assumptions. We write programs and applications assuming certain parts of their systems will work a certain way. And we also assume that some things can potentially go wrong, and we (hopefully) attempt to account for them.</p><p>One big issue with building computer-y things is that, even though we’re often dealing with complex systems, we aren’t always capable of reasoning about on a big-picture level. Distributed systems are certainly a great example of this (you knew where I was going with this, didn’t you?). Even a “simple” distributed system isn’t so simple, because by definition it involves more than one node, and the nodes in the system have to communicate and talk to one another through a network. Even in a small distributed systems with just two nodes, we make certain assumptions about how that system is going to work.</p><p>Here’s the thing about making assumptions, though: they can be wrong! As it turns out, there are some common, incorrect assumptions that we often make about distributed computing. In fact they are so ubiquitous that they have a name! I’m talking, of course, about the eight fallacies of distributed computing. And what are they? Well, it’s time to find out.</p><h4>Assumptions gone wrong</h4><p>The eight fallacies as we know them today actually started off as just four fallacies, which are the ones that we’ll cover in this post. The first four fallacies were created in the early 90’s (sometime after 1991) by two Sun Microsystems engineers, Bill Joy and Dave Lyon.</p><p>James Gosling, who was a fellow at Sun Microsystems at the time — and would later go on to create the Java programming language — classified these first four fallacies as “The Fallacies of Networked Computing”. A bit later that decade, Peter Deutsch, another Fellow at Sun, added fallacies five, six, and seven. In 1997, Gosling added the eighth and final fallacy. So much of the work done to codify this list was inspired by work that was actually happening at Sun Microsystems at the time. And while Deutsch is the one who is often credited with having “created” the eight fallacies, clearly it was a combined, group effort (as is so often the case in computing!).</p><p>Alright, so now that we’ve got some history under our belt, let’s get into some of the practical aspects of this problem. Let’s first start with understanding what we’re talking about when we say a “fallacy” of distributed computing. What does that mean, exactly?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TGWX6UuLFqWmsd8qQpyk0g.jpeg" /><figcaption>What exactly IS a fallacy when it comes to distributed computing?</figcaption></figure><p>Well, a <strong><em>fallacy</em></strong> is a kind of assumed fact or belief; however, even though it is assumed to be true, that is usually not the case in practice. A fallacy is just a belief that is a misconception. But what does that mean in the context of computing? Well, a fallacy made about a distributed system is an assumption about the system made by the developers, which often ends up being inaccurate and wrong in the long run. In other words, they are bad assumptions to make.</p><blockquote>We can think of the eight fallacies as eight common misconceptions that developers of distributed systems often fall prey to, which we want to avoid.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ixg3-ycukOvRQHUk2fR6w.jpeg" /><figcaption>The 8 fallacies of distributed computing</figcaption></figure><p>So, let’s take a look at these eight fallacies, shall we?</p><p>The eight fallacies of distributed computing are as follows:</p><ol><li>The network is reliable.</li><li>Latency is zero.</li><li>Bandwidth is infinite.</li><li>The network is secure.</li><li>Topology doesn’t change.</li><li>There is one administrator.</li><li>Transport cost is zero.</li><li>The network is homogenous.</li></ol><p>In this post, we’ll focus just on the first four fallacies, which we now know were the original “Fallacies of Networked Computing”! Conveniently, these first four fallacies are actually all anchored around one central, key character: the network. And, as we’re about to see, the network is a tricky little fellow. Of course, it’s kind of difficult to have a distributed system without a network so we have to get used to dealing with this tricky character.</p><p>Let’s learn about what makes the network hard to contend with, and why some of these fallacies are easy to assume.</p><h4>The trouble with networks</h4><p>Our distributed systems, no matter how complex or involved they are, all exist within a network. The nodes of our system have to talk to one another and send and receive messages to communicate and deliver data. Because the system is distributed, parts of it will live in different places, and the network is the anchoring point by which the components of the system will communicate.</p><p>This brings us to fallacy one: <strong>The network is reliable.</strong> Remember, these are fallacies that we’re dealing with, so the network being reliable is a true misconception; the network is <em>not</em> reliable!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ei18Fpm1eaxPkrIM00kiGw.jpeg" /><figcaption>Fallacy #1: The network is reliable (it is not).</figcaption></figure><p>So many things within a network can go wrong. Hardware can fail, the power can go out, the signal could get spotty, or the network could even become compromised! It might seem obvious that a network isn’t reliable, but as designers of a distributed system, we can sometimes forget this when we are writing code that is going to run on a distributed system. We write that code perhaps operating under this assumption, but when the network inevitably becomes <em>unreliable</em> at some point down the road, we realize that we made a bad assumption and it ends up affecting our system adversely. Thus, it becomes our job to keep this fallacy in mind and not forget that the network cannot be relied upon.</p><p>Now, before we get too much further into networks — not to mention the fallacies associated with them — there are some important terms for us to learn. When we talk about messages being sent through a network, we’re usually referring to data being sent across the network. But we can talk about data and the way it is sent in two different ways: latency and bandwidth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qdUw3Akkwl_YOZ2AnlvT-g.jpeg" /><figcaption>Latency versus bandwidth</figcaption></figure><p><strong><em>Latency</em></strong> is the measure of how <em>delayed</em> some data is to arrive, based on wherever it was sent. We can think of latency as the speed at which our data travels from one place to another, or how long it takes for the data to arrive from node A to node B in our system. Latency is a concept that many developers may already be quite familiar with, because we often refer to the latency of data in the context of milliseconds. For example, if it took a request 400 milliseconds to be served from a server (node A) to a client (node B), we can say that the latency of that data being sent was delayed by 400 milliseconds, or that it took 0.4 seconds for the message travel from the server to the client. Many performance-minded developers are often thinking of latency when they consider what to optimize or improve in their applications or systems.</p><p><strong><em>Bandwidth</em></strong>, on the other hand, is a measure of how much data can be sent from one point to another in a certain period of time. We often talk about bandwidth in the context of internet speed (for example, megabits per second or Mbps) because we’re referring to how much data can be sent over our specific network, or the capacity of our network to send some amount of data in a given span of time.</p><p>While latency is the actual speed at which data gets to its destination via the network, bandwidth is the capacity of network to send a certain amount of data to its destination. Understanding the difference between these two concepts is important to wrapping our heads around the second and third fallacies, so let’s learn about those two next!</p><h4>Some fallacies hurt more than others</h4><p>Now that we know what “latency” actually means, we are better equipped to understand fallacy two: <strong>Latency is zero</strong>. Unfortunately, this is also a misconception.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bteSk48jIOALvyM1XNO8Wg.jpeg" /><figcaption>Fallacy #2: Latency is zero (it is not).</figcaption></figure><p>This is perhaps an easy fallacy to fall prey to since, in our local environments or in the development environment, we may experience a much lower latency; in other words, we likely experience a short amount of delay time when it comes to sending or receiving data. However, that low local latency doesn’t accurately reflect the delay of what other parts of the system might feel — especially given different networks.</p><p>We’ve <a href="https://medium.com/baseds/scalability-problems-hidden-challenges-of-growing-a-system-f74313b063c3">already learned about</a> local-area networks (LAN) and wide-area networks (WAN). We know that in a WAN, data has to travel further from one node to another, since the network may span large geographical distances. This is in contrast to a LAN, which is a network with devices in the same building or room, and thus the data being sent around has much less of a distance to travel.</p><p>We cannot assume that our system will always operate on a local-area network (in fact, most distributed systems operate on a WAN), and thus we know that our data has a physical distance to travel. By proxy, we should not assume that there will be no “delay” or zero latency between some data being sent and that data being received. For example, a request that has to travel across the world from Portland to Paris will have more latency than a request traveling from a machine in one room to another.</p><blockquote>Some latency is a limitation of networks; we should be wise to not build a system that assumes that such a delay is nonexistent. We will certainly be bitten by such a false assumption in the future.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nnW5YovYJB784NzVKhBwFQ.jpeg" /><figcaption>Fallacy #3: Bandwidth is infinite (it is not).</figcaption></figure><p>The third fallacy is similar to this false assumption as well: <strong>Bandwidth is infinite.</strong> Just as latency is not zero, the capacity of a network to send data is not unlimited. As computing technology has improved over the years — and certainly since the early 90’s when the Fallacies were coined — the bandwidth of our networks keeps getting better and better, and we’re able to send more data across our data in a given amount of time.</p><p>However, even with these improvements, networks still don’t have <em>unlimited</em> capacity and cannot send infinitely large amounts of data. When we design a distributed system, it would behoove us to not assume that any amount of data can be sent across the network. For example, we may have some user of our system that has a network with a limited bandwidth and a lower capacity; for that user’s experience, sending a large amount of data (such as large images or vendored, dependent files) would mean that we’d be sending far more data than their network was capable of sending over the network in a reasonable amount of time.</p><p>Finally, we come to fallacy four, which is personally just my favorite one: <strong>The network is secure.</strong> There are just simple so many ways that a network can be attacked or compromised, from unencrypted messages to vulnerabilities in dependencies to open source code, or even just bugs in third-party softwares that our system might depend on (not to mention bugs in our own systems, too!).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O_okCt0GXJmhPM71CaKLhg.jpeg" /><figcaption>Fallacy #4: The network is secure (it DEFINITELY is not!).</figcaption></figure><p>The misconception that the network is “secure” is a hard one to overcome, since, if we really start to think about it, no network is really secure. Indeed, the only way to truly protect our networks and be 100% secure is to just not connect to the network! Of course, because we are dealing with distributed systems…this isn’t really easy to do, since we know that a network is required for communication between nodes in our system.</p><p>So, what are we to do? Well, we can try to remember that <em>true</em> security is a fallacy, and that we can just do what is in our power to try to prevent breaches and attacks when we design, build, and test our systems. Hopefully, at least that’ll keep the security issues at bay for awhile.</p><p>In part two of this post, we’ll look at the remaining four fallacies. I promise that the sad little blue network blob will make a return appearance! We’re not done with it just yet.</p><h4>Resources</h4><p>The fallacies of distributed computing have been fairly well-written about, and you can find some good resources on different interpretations of them, for different technologies. If you’re curious to learn more, check out the resources below!</p><ol><li><a href="https://www.rgoarchitects.com/Files/fallacies.pdf">Fallacies of Distributed Computing Explained</a>, Arnon Rotem-Gal-Oz</li><li><a href="https://www.simpleorientedarchitecture.com/8-fallacies-of-distributed-systems/">Understanding the 8 fallacies of Distributed Systems</a>, Victor Chircu</li><li><a href="https://multimedia.telos.com/blog/debunking-the-8-fallacies-of-distributed-systems-part-2/">Debunking the 8 Fallacies of Distributed Systems</a>, Ramil Alfonso</li><li><a href="https://www.youtube.com/playlist?list=PL1DZqeVwRLnD3EjyciYAO82dT9Owiq8I5">Fallacies of Distributed Systems</a>, Udi Dahan</li><li><a href="https://blog.newrelic.com/engineering/the-fallacies-of-distributed-computing-reborn-the-cloud-era">The Fallacies of Distributed Computing Reborn: The Cloud Era</a>, Brian Doll</li><li><a href="http://www2.sys-con.com/itsg/virtualcd/java/archives/0901/ingrid/index.html">Deutsch’s Fallacies, 10 Years After</a>, Ingrid Van Den Hoogen</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b35c3b85b53" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">Foraging for the Fallacies of Distributed Computing (Part 1)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Weeding Out Distributed System Bugs]]></title>
            <link>https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/28a01e37f70c</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 05 Jun 2019 12:31:00 GMT</pubDate>
            <atom:updated>2019-06-05T12:31:00.920Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ehnuc3UmsGJQT3dFDsTM6Q.jpeg" /><figcaption>Weeding out distributed system bugs</figcaption></figure><p>As we’ve learned more and more about distributed systems, we’ve seen the many ways that things can wrong. More specifically, we’ve seen that there are just <em>so many </em>possible scenarios<em> </em>in which a portion of a large or system can fail.</p><p>Since failure is inevitable in any sized system, we ought to do ourselves a failure and better understand it. So far, we’ve been talking about different kinds of <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">faults</a> and <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">failures</a> in a fairly abstract sense. It’s time for us to get a little more concrete, however. Sure, we vaguely understand the different flavors and profiles of how things can go wrong within a system, and why they are problematic (yet inevitable) within our system. But how can we start to understand these flaws in a system in a more tangible form?</p><p>In order to do that, we need to think more deeply about the different ways in which failures present themselves to us in the systems that we all deal with every day, as both consumers and creators of software. For most of us, failures in our systems present themselves as bugs. The ways in which a bug might <em>appear </em>to us, however, can make all the difference in how we are able to understand it in a more concrete way.</p><p>So what kinds of bugs do we deal with, exactly, and how do they impact the failures of a distributed system? Well, that’s the mystery we’re about to solve!</p><h4>(Hardware) failures of the past</h4><p>Before we dive into identifying the bugs of today, let’s take a quick detour into the past. It’s easy to get overwhelmed when thinking about failures and faults in a system, so before we get too deep into the trenches, we ought to take a moment to see how the landscape of bugs in computing have changed over the years.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaEFi-yCaBLE-CjbGjshDg.jpeg" /><figcaption>What is hardware reliability?</figcaption></figure><p>Until the 1980’s, the major focus of computing was around hardware. More specifically, much of the field was focused on how to make hardware just generally <em>better</em>. This was simply because hardware was the major limiting factor in many ways. For example, if we wanted to make a machine faster and more performant back then, we needed bigger hardware; that was the only way to have enough space for all the circuits we needed! And if we wanted more circuits — which were each already pretty large and lofty in size —then we also needed to be prepared for them to use a lot of power and exude a lot of energy and heat.</p><p>These issues begin to highlight some of the clear possible faults that could have popped up within a system just a few decades ago. As <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">we already know</a>, hardware faults — such as a circuit overheating, or a network wiring issue causing a widespread outage—are what lead to hardware failures. If any aspect of the hardware fails, then that failure will likely cause some form of downtime in a system, which we know <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">makes a system less reliable</a>. Until the 80’s, hardware faults were very much a real and common problem.</p><p>But these days, the story is a little different. We experience far less downtime due to hardware faults than we did just forty years ago. We have many years of concentrated effort that has helped improve the hardware we all rely upon on a daily basis now! In the past three decades, the size of circuits has decreased, allowing us to pack more circuits into a smaller space, and those circuits produce less heat, and use much less energy. Circuits have also become easier and cheaper to produce, making them more inexpensive in general. This has also allowed us to create smaller devices, like laptop computers, tables, and smartphones, to mention just a few.</p><p>This doesn’t mean that there are <em>no </em>hardware problems whatsoever, though! Even small devices with smaller circuits inside of them will experience hardware failures. Network issues that cause downtime are still likely to happen, even though the frequency with which they occur has definitely dropped off. Hardware disks are still prone to failures, which makes it tricky to read (much less write) data to them. And, of course, just because hardware has improved doesn’t mean that it doesn’t require maintenance and upgrades; since these are still requirements, they will still result in planned downtime.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qlr_ciosJeVs5rAnRMMvMA.jpeg" /><figcaption>How has hardware changed?</figcaption></figure><p>Overall, however, the changes we’ve seen in hardware have been quite a net positive for computing. So, if hardware has improved…what else could be a contributing factor to failures in a distribute system? Why, our dear friend <em>software</em>, of course!</p><blockquote>Even in the most well-tested systems, software failures are responsible for a significant amount of downtime. We know these “failures” by another name: bugs.</blockquote><p>Improvements in hardware notwithstanding, it is bugs in the software of distributed systems that result in unexpected and unplanned downtime. Many studies estimate that, 25 to 35% of the downtime in a system are caused by bugs in software-related code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WweBifHpUawcvKCNbsRiPg.jpeg" /><figcaption>Software failures as a major pain point in a distributed system</figcaption></figure><p>The interesting aspect of this story is the fact that, even within systems that are fairly well-established and have rigorous testing practices in place, studies have found that the actual percentage of software-related downtime doesn’t really <em>ever</em> <em>reduce</em> beyond that 25% threshold! There are just some bugs that still seem to exist, even with well thought-out tests and quality control.</p><h4>(Software) problems of the present</h4><p>The bugs that still exist in more mature systems — those that have rigorous testing, for example — are also known as <strong><em>residual bugs</em></strong>, and they can be classified into two separate categories:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k3DJCaXP_QYa1MA5CHiDWw.jpeg" /><figcaption>The two main kinds of “residual” software bugs</figcaption></figure><ol><li><strong><em>Bohrbugs</em></strong>, which are named for Niels Bohr and Ernest Rutherford’s model fo the atomic nucleus, and</li><li><strong><em>Heisenbugs</em></strong>, which are named as a pun on Werner Heisenberg’s Heisenberg uncertainty principle.</li></ol><p>These two bugs have been researched by many different computer scientists; three of the most notable ones include Jim Gray, Bruce Lindsey, and Andrea (“Anita”) Borr, and we’ll read about the fruits of their labor in a little bit. Between these two different kinds of “residual” bugs, one is definitely way easier to wrap our heads around than the other. So let’s start with that one first!</p><p>The <strong><em>Bohrbug</em></strong> is a bug that most (all?) programmers will encounter while tinkering with software. A Bohrbug is a bug that can reliably be reproduced, given the right conditions. For example, if we were able to notice that a bug occurred in a piece of software and closely observed the situation in which it happened, if it was a Bohrbug, then would be able to reproduce it by re-creating the same situation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AfUpfIUg8LbCjiYXMUum1Q.jpeg" /><figcaption>Bohrbug: a quick definition!</figcaption></figure><p>A Bohrbug is pretty easy to localize and pinpoint to a certain part of a codebase. As developers, this is a huge boon, since it means that we can reliably find and then <em>fix</em> the Bohrbug, as annoying as it might be!</p><p>Interestingly, when Jim Gray and Bruce Lindsey were researching Bohrbugs in more mature systems, they posited that the frequency of these reproducible little bugs actually reduced as a system grew older and more stable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LesnUjIMhpvlKUIxp6rBVQ.jpeg" /><figcaption>Bohrbugs in a system, over time</figcaption></figure><p>However, Anita Borr’s research added a bit more nuance to this. She found that the percentage of Bohrbugs didn’t strictly continue to drop as a system grew more stable; rather, her research found that, with each new upgrade or scheduled maintenance that was introduced into the system, there was also a slight uptick of Bohrbugs, since significant changes in the system were still very capable of introducing <em>reproducible</em> bugs.</p><p>Thankfully, even though new Bohrbugs might be introduced with these system-wide changes, at least they can be reproduced (and hopefully, fixed!). But things aren’t always that simple in the world of software (of course). Some bugs don’t always behave the same…in fact, some of them seem to behave differently when we try to investigate them!</p><h4>Dealing with difficult, distributed bugs</h4><p>There is one species of bug that is particularly relevant to distributed systems, and it’s finally time for us to come face-to-face with it in this series. I’m talking, of course, about the Heisenbug!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ap4jEguoPLwOlxyQQnhIuA.jpeg" /><figcaption>Heisenbug: a quick definition!</figcaption></figure><p>A <strong><em>Heisenbug </em></strong>can be super frustrating to deal with as a programmer. This is a bug that actually behaves <em>differently </em>when it is observed closely. As one begins to investigate a Heisenbug, it may change how it manifests itself. In some cases, when a Heisenbug is, well, being debugged, it disappears completely. And in some situations, when certain conditions are recreated in an effort to reproduce the bug, the bug just won’t appear! Pretty frustrating, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hiJKlkfgG83WkTT21UitqA.jpeg" /><figcaption>What makes Heisenbugs so hard?</figcaption></figure><p>For example, a bug such as a data structure running out of space or a portion of a program that overflows some allocated memory in a production environment might not be to easily reproduce locally or in a test; however, this exact bug could cause a system to crash, and is pretty fatal!</p><p>This is part of the reason that makes Heisenbugs so difficult to reason about. They are incredibly hard to actually <em>reason</em> about, because it’s hard to actually localize them and pin them down. And, because they’re hard to reproduce <em>reliably</em>, they’re hard to identify and thus, difficult to actually solve!</p><p>The Heisenbug is especially relevant to distributed systems because they’re more likely to occur in a distributed system than in a localized, central one. These kinds of bugs are actually indicators of problems and failures in the system that occurred much <em>earlier</em> than when the bug manifested itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ButZLrPKDFlXg56aNXqaeQ.jpeg" /><figcaption>Heisenbugs are much more common in distributed systems.</figcaption></figure><p>A Heisenbug is usually a red flag that something <em>else </em>went wrong in the system awhile ago, and it is only surface now, and it only just so happens that it is surfacing in the form of this bug.</p><blockquote>In actuality, a Heisenbug is just a long-delayed side effect of a much earlier problem.</blockquote><p>In more mature distributed systems, it is Heisenbugs — <em>not </em>Bohrbugs — that cause major failures and system crashes. If we think about it more deeply, this starts to make sense; there are many moving parts in a distributed system, and many dependencies and nodes that rely upon one another. A failure that appears to be coming from <em>one</em> node in the system might actually be three nodes removed from a failure that originated elsewhere, but propagated throughout the system. While a Bohrbug might be easy to reproduce, localize, and reason about, a Heisenbug is much tricker to think about and thus, to fix.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cvFr727zC4a4ddkaqBS3Qg.jpeg" /><figcaption>Heisenbugs in a system, over time</figcaption></figure><p>Anita Borr — my new favorite researcher on residual bugs — actually found in her research that many engineers have a hard time reasoning about Heisenbugs, and that making attempts to <em>fix</em> a Heisenbug actually cause more problems than there were to begin with! So if you’ve been feeling like Heisenbugs are tricky little creatures and hard to contend with, don’t worry; the research agrees with you!</p><h4>Resources</h4><p>Software failures in distributed systems are pretty cool to learn about, and you can learn a whole lot more about them. There is a lot of interesting research and writing on how to deal with and guard against Heisenbugs in your system. Check out some of the resources below if you’re curious to learn more!</p><ol><li><a href="https://books.google.com/books?id=X_kE8YvRJJEC&amp;pg=PA239&amp;lpg=PA239">Reliable Distributed Systems: Technologies, Web Services, and Applications</a>, Kenneth Birman</li><li><a href="https://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf">Why Do Computers Stop and What Can Be Done About It?</a>, Jim Gray</li><li><a href="https://courses.cs.washington.edu/courses/cse490h/07wi/readings/IntroductionToDistributedSystems.pdf">Introduction to Distributed Systems</a>, University of Washington</li><li><a href="https://www.cs.rutgers.edu/~rmartin/teaching/spring03/cs553/papers01/06.pdf">Heisenbugs and Bohrbugs: Why are they different?</a>, Richard Martin (?)</li><li><a href="https://pdfs.semanticscholar.org/cae7/52b327a2bbd293a6b92530e354a76b82ace2.pdf">Protecting Applications Against Heisenbugs</a>, Chris Hobbs</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28a01e37f70c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c">Weeding Out Distributed System Bugs</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>
-  recorded_at: Wed, 21 Oct 2020 15:08:33 GMT
-- request:
-    method: get
-    uri: https://circleci.com/blog/feed.xml
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Content-Type:
-      - application/xml
-      Date:
-      - Wed, 21 Oct 2020 15:08:34 GMT
-      Etag:
-      - '"db0e9f9cae7024117d00274d790975a4"'
-      Last-Modified:
-      - Tue, 20 Oct 2020 20:14:07 GMT
-      Server:
-      - nginx
-      Strict-Transport-Security:
-      - max-age=15724800
-      X-Amz-Id-2:
-      - g77uHdTYnj+mI/CXwcEN6pm0s5cax8Hk0zEuq6uEkTfdcAF/azAtd4RdmiThpCMuTmpxkpB4GNI=
-      X-Amz-Request-Id:
-      - F84205B807CB4CD8
-      X-Frame-Options:
-      - SAMEORIGIN
-      Content-Length:
-      - '150162'
-      Connection:
-      - keep-alive
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        <?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
  xml:base="https://circleci.com/"
  xmlns:atom="http://www.w3.org/2005/Atom"
  xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>The CircleCI Blog Feed - CircleCI</title>
    <description>Stay up to date with the latest news, updates, and hacks from CircleCI.</description>
    <link>https://circleci.com/blog/</link>
    <atom:link href="https://circleci.com/blog/feed.xml" rel="self" type="application/rss+xml" />
    
      
      <item>
        <title>Do I really need Kubernetes?</title>
        <link>https://circleci.com/blog/do-i-really-need-kubernetes/</link>
        <pubDate>Tue, 20 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/do-i-really-need-kubernetes/</guid>
        
          <dc:creator>Ron Powell</dc:creator>
        
        
          <description>&lt;p&gt;&lt;i&gt;&lt;i&gt;This post, written by CircleCI Technical Content Marketing Manager Ron Powell, originally appeared on The New Stack &lt;a href=&quot;https://thenewstack.io/do-i-really-need-kubernetes/&quot;&gt;here&lt;/a&gt;.&lt;/i&gt;&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;If you follow technology news, it might seem like &lt;a href=&quot;https://kubernetes.io/&quot;&gt;Kubernetes&lt;/a&gt; is everywhere. It has become hugely popular. In fact, developers and DevOps teams might feel like their application development pipeline is hopelessly outdated if they aren’t using Kubernetes.&lt;/p&gt;

&lt;p&gt;Kubernetes is an orchestration tool for containerized applications. Starting with a collection of Docker containers, Kubernetes can control resource allocation and traffic management for cloud applications and microservices.&lt;/p&gt;

&lt;p&gt;As such, it simplifies many aspects of running a service-oriented application infrastructure. Along with modern &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; and continuous deployment (CI/CD) tools, Kubernetes provides the basis for scaling these apps without huge engineering effort.&lt;/p&gt;

&lt;p&gt;There’s a lot of excitement about using Kubernetes to manage cloud and hybrid cloud environments. And it is a great tool. But teams often chase the hype and move to Kubernetes prematurely, sometimes at a great cost in time, money, and developer frustration.&lt;/p&gt;

&lt;p&gt;In this article, we will try to look beyond the hype and help you answer the question: &lt;strong&gt;do I actually need Kubernetes?&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;What does Kubernetes do, anyway?&lt;/h2&gt;
&lt;p&gt;Kubernetes is an orchestration tool for containerized applications. It is responsible for:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Deploying images and containers&lt;/li&gt;
  &lt;li&gt;Managing the scaling of containers and clusters&lt;/li&gt;
  &lt;li&gt;Resource balancing containers and clusters&lt;/li&gt;
  &lt;li&gt;Traffic management for services&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Kubernetes really shines when your application consists of multiple services running in different containers. For a monolithic application with a static user base, this may be more than necessary.&lt;/p&gt;

&lt;p&gt;The task of building, testing and delivering your application to a container registry is not part of Kubernetes. Here, CI/CD tools for building and testing applications do the job. Kubernetes, as a part of a &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;CI/CD pipeline&lt;/a&gt;, then helps you deploy changes to production without any downtime.&lt;/p&gt;

&lt;h2&gt;Improve your monolith&lt;/h2&gt;
&lt;p&gt;Most applications start their life as a monolith, and this is great! With an entire application in one place, it is quick and easy to make and deploy changes. But if your app finds success and grows, you will soon need to find ways to scale it.&lt;/p&gt;

&lt;p&gt;Does that mean it is time for Kubernetes? Probably not.&lt;/p&gt;

&lt;p&gt;It is tempting to think that only microservices orchestrated via Kubernetes can scale — you’ll read a lot of this on the internet. But scaling is usually more about the application’s internals than about the high-level architecture and tooling. For instance, you can scale a monolith by deploying multiple instances with a load balancer that supports affinity flags.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A practical first step to consider when scaling an application is &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-ii-tdd-and-bdd/&quot;&gt;Test Driven Development (TDD)&lt;/a&gt;&lt;/strong&gt;, which ensures quality and prevents defects as your application grows. While smaller modules or services are easier to test, the modularity also means increased demand for &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-i-mocking-stubbing-and-contract-testing/&quot;&gt;mocking&lt;/a&gt;, as well as additional tooling to configure and maintain. Good testing makes it easier to build and scale your application confidently.&lt;/p&gt;

&lt;p&gt;As you start to scale out a monolith, configuration management tools like Chef and Ansible come in handy. You can use them to automatically configure new servers to ensure they are ready to run your application. You can even go a step further and use a tool like &lt;a href=&quot;https://www.terraform.io/&quot;&gt;Terraform&lt;/a&gt; to help provision new server VMs, so that you won’t have to create them manually.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When other parts of your application become a bottleneck — for example, the database — you may scale those, too.&lt;/strong&gt; Various patterns allow applications to scale even though they are, by design, not very scalable. For example, if your database becomes a bottleneck, you can move frequently-accessed data to a high-performance in-memory data store, like Redis, to reduce load on your database.&lt;/p&gt;

&lt;p&gt;No matter what configuration management and provisioning tools you use, a good CI/CD pipeline is a must. You might have copied a .zip file to your server via FTP the first time you deployed your app, but that approach does &lt;i&gt;not&lt;/i&gt; scale. A streamlined CI/CD pipeline ensures that your application gets built, tested and deployed automatically, without any extra work from you or your team.&lt;/p&gt;

&lt;p&gt;Together, these practices will make your life easier if you &lt;i&gt;do&lt;/i&gt; eventually need Kubernetes.&lt;/p&gt;

&lt;p&gt;You can even auto-scale monolithic applications using cloud services like AWS Elastic Beanstalk, Google App Engine, or Azure App Service. These all impose far less administrative overhead than Kubernetes, and they all play nicely with CI/CD tools.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When working with a new application, focus on developing the best application possible.&lt;/strong&gt; Eventually, a complex tool like Kubernetes may be the right solution for managing infrastructure for your application. As you grow, however, many of the practices we’ve just discussed will be more practical.&lt;/p&gt;

&lt;h2&gt;Augment your monolith&lt;/h2&gt;
&lt;p&gt;As your application continues to grow, you will eventually reach a point where continuing to add to the monolith seems untenable. This is often because the app is near the limit of what a single dev team can work on.&lt;/p&gt;

&lt;p&gt;At this point, many teams choose to split up their monolith and move fully into microservices. While this is a rather popular decision, it is neither a necessary one nor a silver bullet. Consider starting out by adding services that augment your monolith instead of replacing it. Some of these support services may actually be microservices — so you can benefit from using small services where it makes sense, while still leveraging the benefits of your monolith.&lt;/p&gt;

&lt;p&gt;Even when introducing services and microservices, you may not need or want to start with Kubernetes. Kuberntes excels at running and scaling pods of related service and microservice containers. However, there are aspects of adopting Kubernetes that are easy to overlook at first. For example, Kubernetes does not include robust built-in tools for securing pods, nodes and clusters, and deploying Kubernetes clusters across a multi-cloud environment can add a lot of complexity.&lt;/p&gt;

&lt;p&gt;Starting with a single-cloud platform like Azure Service Fabric and AWS Fargate may make it easier to spin up and scale services, without forcing you to take on managing a Kubernetes cluster.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Another option is to avoid services with maintenance overhead altogether and opt for Functions as a Service (FaaS)&lt;/strong&gt;, such as AWS Lambda or Azure Functions. FaaS is a great way to minimize potential infrastructure overhead when adding services to your application. Moreover, a Kubernetes-orchestrated cluster — if you eventually need one — can be enhanced with FaaS capabilities. By starting with a mixture of services and functions, the migration to Kubernetes is less complicated than it sounds.&lt;/p&gt;

&lt;h2&gt;No more monolith&lt;/h2&gt;
&lt;p&gt;Now imagine that your original monolithic application has grown so much that you can barely see the original monolith.&lt;/p&gt;

&lt;p&gt;Its needs and its userbase have grown so far and so fast that you now have a wide variety of helper services, many of which need to talk to each other. You need to make sure the services that depend on each other are always running and visible to each other.&lt;/p&gt;

&lt;p&gt;In addition, your customers are demanding the kind of uptime and reliability that make you consider running across multiple availability zones, possibly even across multiple cloud vendors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;This is the point at which you probably need an orchestrator like Kubernetes.&lt;/strong&gt; It lets you easily define the modules (Pods) of related services and lets you automatically scale them and load-balance between them.&lt;/p&gt;

&lt;p&gt;For Kubernetes to be useful, here is what it would require:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;You are willing to operate a couple of virtual machines&lt;/li&gt;
  &lt;li&gt;You can assign people to do configuration and maintenance of Kubernetes&lt;/li&gt;
  &lt;li&gt;You have more than a single service to take care of&lt;/li&gt;
  &lt;li&gt;You need to automate (as much as possible) a mostly homogenous service deployment&lt;/li&gt;
  &lt;li&gt;You need to be cloud (or hosting) provider-agnostic&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Furthermore, Kubernetes has built-in support for high-availability (Amazon RDS Multi-AZ)  deployments, which makes it easier to increase app reliability and availability. Of course, it does impose overhead: it takes time and engineering resources to create and manage clusters, define pods, and create containerized apps suitable for deployment to Kubernetes. But if your app is big enough to benefit from Kubernetes, the administrative overhead is worth it.&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Kubernetes is powerful, but that does not mean it’s the right choice for every team and every app.&lt;/strong&gt; As with any piece of technology, it is made to solve a certain set of problems. If you aren’t facing the problems Kubernetes aims to solve, it is more trouble than it’s worth.&lt;/p&gt;

&lt;p&gt;Don’t just give Kubernetes a place in your infrastructure toolbox. Make Kubernetes earn it. Especially at the beginning of a new application.&lt;/p&gt;

&lt;p&gt;First, use available tools to get the app out quickly. When your application reaches a stage where deployment and scaling is becoming a job of its own, it makes sense to start thinking about orchestration — and, quite naturally, Kubernetes as your orchestration tool. Once you are ready, check out &lt;a href=&quot;https://circleci.com/blog/getting-started-with-kubernetes-how-to-set-up-your-first-cluster/&quot;&gt;Getting started with Kubernetes: how to set up your first cluster&lt;/a&gt;.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>CI pipelines for testing microservices with DeployHub and CircleCI</title>
        <link>https://circleci.com/blog/ci-pipelines-for-testing-microservices/</link>
        <pubDate>Tue, 20 Oct 2020 08:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/ci-pipelines-for-testing-microservices/</guid>
        
          <dc:creator>Tracy Ragan</dc:creator>
        
        
          <description>&lt;p&gt;Testing microservices shouldn’t be that different from testing a monolithic application. However, there are some challenges we must address to make this transition easy. The question to answer is, “how do we perform functional tests on a decomposed application?”&lt;/p&gt;

&lt;p&gt;As we move away from monolithic practices and into a Kubernetes microservice environment, we lose the concept of an application version. Instead we are faced with lots of loosely-coupled, independent functions with RESTful APIs. While the concept of API contract testing applies at the unit testing level, we have work to do to pull together our functional testing harness.&lt;/p&gt;

&lt;h2&gt;Testing microservices at a functional level&lt;/h2&gt;

&lt;p&gt;Unit testing individual APIs or microservices does not validate the readiness of a full application release. For this reason, we can not eliminate the functional testing process entirely. If we do, we risk missing situations where one microservice is using an older version of another microservice, and that causes an adverse impact. This level of anomaly can only be found when we perform functional testing on the application as a complete product.&lt;/p&gt;

&lt;p&gt;In monolithic environments, the application version is our release candidate. A new release candidate initiates the work done by our functional test harness, which in many cases lags behind the development sprints that perform unit testing on the API contracts. While development teams may make incremental coding changes, functional testing is based on a full release candidate, and the release of that candidate causes the execution of an entirely different set of linked test cases. When testing microservices, this level of functional testing is still required and critical.&lt;/p&gt;

&lt;p&gt;Ideally, we want to leave our functional testing in place even when our application is built on a set of loosely coupled services. To do this, we need visibility into the logical application version. In order to remain efficient at the functional testing level, we need some insights into what has changed between two application versions, allowing the functional testing to be targeted. What we want to avoid is constantly retesting everything simply because we have no reference as to which microservice caused a new release of the application version.&lt;/p&gt;

&lt;h2&gt;Re-imagining continuous integration&lt;/h2&gt;
&lt;p&gt;In monolithic environments, we rely on our application build (compile/link) to create a new version of the application, creating a new release candidate. This new version is then pushed to the testing team to execute a functional test. With microservices, this build goes away. Instead, our build takes a single microservice and builds a new container image. That container image is then pushed up to a container registry. Now we have a new microservice release candidate, which in turn created a new application version release candidate. Welcome to your new &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; process.&lt;/p&gt;

&lt;h2&gt;Testing microservices&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.deployhub.com/&quot;&gt;DeployHub&lt;/a&gt; resurrects the application version in a microservices implementation to support your functional testing. It does this using automated configuration management that automatically creates new application versions each time a new microservice has been registered. Since microservices are shared, a new microservice will often create multiple application release candidates. DeployHub tracks the microservice impact to all consuming applications. This impact analysis allows DeployHub to then inform CircleCI to initiate testing workflows for multiple applications, providing details on exactly which microservices caused the new application release.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-19-dh1.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;The DeployHub orb&lt;/h2&gt;
&lt;p&gt;The &lt;a href=&quot;https://circleci.com/developer/orbs/orb/deployhub/deployhub-orb&quot;&gt;DeployHub orb&lt;/a&gt; integrates into CircleCI to perform automated configuration management as soon as a new container has been created and registered. DeployHub then automatically increments the application version of all impacted applications, and runs the workflow of each. DeployHub uses a key value pair at the application level to specify the default testing environment for deployment and the name of the CircleCI testing pipeline to run post deployment. Additionally, DeployHub provides an impact analysis view that shows, at each application level, which microservice initiated the change.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-19-dh2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;See it in action&lt;/h2&gt;
&lt;p&gt;We’ve made it easy for you. Check out our demo of the DeployHub-CircleCI integration.&lt;/p&gt;

&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;a href=&quot;https://youtu.be/ETxKPApScIw&quot;&gt;
    &lt;img src=&quot;/blog/media/CircleCI+DeployHub.png&quot; alt=&quot;&quot; /&gt;
  &lt;/a&gt;
&lt;br /&gt;

  &lt;p&gt;
    &lt;a href=&quot;https://youtu.be/ETxKPApScIw&quot; style=&quot;color:#0000EE;&quot;&gt;
      Watch the full video here
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Testing microservices and their consuming applications becomes much easier with DeployHub integrated into your CircleCI &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;pipelines&lt;/a&gt;. Testing becomes driven by an automated process triggered by a release candidate event, in much the same way as we did with monolithic environments. Your functional testing suite remains unchanged and insights show you the impact of a single microservice update on all applications.&lt;/p&gt;

&lt;h2&gt;About DeployHub&lt;/h2&gt;
&lt;p&gt;DeployHub empowers organizations to achieve business agility through a managed approach to microservices. DeployHub eliminates the confusion and complexity common with microservices by providing a SaaS centralized view of microservice usage and sharing across clusters and teams.&lt;/p&gt;

&lt;p&gt;For more information and to use the DeployHub CircleCI orb, find us on the &lt;a href=&quot;https://circleci.com/orbs/registry/orb/deployhub/deployhub-orb&quot;&gt;CircleCI orb registry&lt;/a&gt;. You can also learn more about DeployHub at &lt;a href=&quot;http://www.deployhub.com&quot;&gt;DeployHub.com&lt;/a&gt;. DeployHub is based on the &lt;a href=&quot;http://www.ortelius.io&quot;&gt;Ortelius Open Source Project&lt;/a&gt;.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Continuous integration for Adonis APIs</title>
        <link>https://circleci.com/blog/continuous-integration-for-adonis-apis/</link>
        <pubDate>Fri, 16 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/continuous-integration-for-adonis-apis/</guid>
        
          <dc:creator>Fikayo Adepoju</dc:creator>
        
        
          <description>&lt;p&gt;&lt;a href=&quot;https://adonisjs.com/&quot;&gt;Adonis.js&lt;/a&gt; is one of the fastest-growing &lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; frameworks. As stated on its homepage, the framework is designed for fans of &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-ii-tdd-and-bdd/&quot;&gt;test-driven development (TDD)&lt;/a&gt;. As a feature of this design, it comes bundled with a specialized testing framework.&lt;/p&gt;

&lt;p&gt;In this tutorial, you will learn how to automate the testing of an Adonis.js API so that your tests will run on every change to your codebase.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To follow this tutorial, a few things are required:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Basic knowledge of Javascript&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; installed on your system (&amp;gt;= 8.0)&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://adonisjs.com/docs/4.1/installation#_installing_adonisjs&quot;&gt;Adonis.js CLI&lt;/a&gt; installed globally&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://github.com/&quot;&gt;GitHub&lt;/a&gt; account&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;With all these installed and set up, let’s begin the tutorial.&lt;/p&gt;

&lt;h2&gt;Cloning the Adonis.js API project&lt;/h2&gt;

&lt;p&gt;To get started, you need to clone the API project that we will be testing. In your terminal, run the following command to clone the base project:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;git clone --single-branch --branch base-project https://github.com/CIRCLECI-GWP/adonis-api-testing.git
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will immediately clone the &lt;code class=&quot;highlighter-rouge&quot;&gt;base-project&lt;/code&gt; branch of the repository into the location in which you have run the above command. This is the starting point of the API project. It has no tests setup.&lt;/p&gt;

&lt;p&gt;Next, go into the root of the project and install the required dependencies:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;cd adonis-api-testing
npm install
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then, create a new file at the root of the project with the name &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt; (note the dot &lt;code class=&quot;highlighter-rouge&quot;&gt;.&lt;/code&gt;), and paste in the following configuration:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;HOST=127.0.0.1
PORT=3333
NODE_ENV=development
APP_NAME=AdonisJs
APP_URL=http://${HOST}:${PORT}
CACHE_VIEWS=false
APP_KEY=pfi5N2ACN4tMJ5d8d8BPHfh3FEuvleej
DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_DATABASE=adonis
HASH_DRIVER=bcrypt
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The above config specifies that we are in a development environment and that we will be using a &lt;code class=&quot;highlighter-rouge&quot;&gt;SQlite&lt;/code&gt; database named &lt;code class=&quot;highlighter-rouge&quot;&gt;adonis&lt;/code&gt; for persistent storage. To get our database and database schema setup, run the Adonis.js project migrations with the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis migration:run
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-migrations-run.png&quot; alt=&quot;Migrations Run&quot; /&gt;&lt;/p&gt;

&lt;p&gt;We have now completely set up our application and can take it for a spin. Boot up the application by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis serve --dev
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This command will start the API running at &lt;code class=&quot;highlighter-rouge&quot;&gt;http://127.0.0.1:3333&lt;/code&gt;. The port might be different if &lt;code class=&quot;highlighter-rouge&quot;&gt;3333&lt;/code&gt; is already in use on your system.&lt;/p&gt;

&lt;p&gt;Our API is a simple &lt;code class=&quot;highlighter-rouge&quot;&gt;User&lt;/code&gt; accounts API. As seen in the &lt;code class=&quot;highlighter-rouge&quot;&gt;./start/routes.js&lt;/code&gt; file, it contains two main endpoints.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// start/routes.js

&quot;use strict&quot;;

const Route = use(&quot;Route&quot;);

Route.get(&quot;/&quot;, () =&amp;gt; {
  return { greeting: &quot;Welcome to the Adonis API tutorial&quot; };
});

//User api routes
Route.group(() =&amp;gt; {
  Route.post(&quot;create&quot;, &quot;UserController.create&quot;);

  Route.route(&quot;get&quot;, &quot;UserController.fetch&quot;, [&quot;GET&quot;, &quot;POST&quot;]);
}).prefix(&quot;user&quot;);
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; route calls the &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; method of &lt;code class=&quot;highlighter-rouge&quot;&gt;UserController&lt;/code&gt; to create a new user by supplying it with a &lt;code class=&quot;highlighter-rouge&quot;&gt;username&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;email&lt;/code&gt;, and &lt;code class=&quot;highlighter-rouge&quot;&gt;password&lt;/code&gt;. We also have a &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoint that simply calls the &lt;code class=&quot;highlighter-rouge&quot;&gt;fetch&lt;/code&gt; function of &lt;code class=&quot;highlighter-rouge&quot;&gt;UserController&lt;/code&gt; to return an array of users in the database. The implementation of these controller functions can be found in the &lt;code class=&quot;highlighter-rouge&quot;&gt;app/Controllers/Http/UserController.js&lt;/code&gt; file shown below.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// app/Controllers/Http/UserController.js

async create({ request, response }) {
    const data = request.post();

    const rules = {
        username: `required|unique:${User.table}`,
        email: `required|unique:${User.table}`,
        password: `required`
    };

    const messages = {
        &quot;username.required&quot;: &quot;A username is required&quot;,
        &quot;username.unique&quot;: &quot;This username is taken. Try another.&quot;,
        &quot;email.required&quot;: &quot;An Email is required&quot;,
        &quot;email.unique&quot;: &quot;Email already exists&quot;,
        &quot;password.required&quot;: &quot;A password for the user&quot;
    };

    const validation = await validate(data, rules, messages);

    if (validation.fails()) {
        const validation_messages = validation.messages().map((msgObject) =&amp;gt; {
            return msgObject.message;
        });

        return response.status(400).send({
            success: false,
            message: validation_messages
        });
    }

    try {
        let create_user = await User.createUser(data);

        let return_body = {
            success: true,
            details: create_user,
            message: &quot;User Successully created&quot;
        };

        response.send(return_body);
    } catch (error) {
        Logger.error(&quot;Error : &quot;, error);
        return response.status(500).send({
            success: false,
            message: error.toString()
        });
    }
} //create


async fetch({ request, response }) {
    const data = request.all();

    try {
      const users = await User.getUsers(data);

      response.send(users);
    } catch (error) {
      Logger.error(&quot;Error : &quot;, error);
      return response.status(500).send({
        success: false,
        message: error.toString(),
      });
    }
} //fetch
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Testing the API with Postman&lt;/h2&gt;

&lt;p&gt;Let’s now put our API to the test by calling our endpoints. We will be using &lt;a href=&quot;https://www.postman.com/&quot;&gt;Postman&lt;/a&gt; to test our endpoints. Make sure that your app is running. If not, run &lt;code class=&quot;highlighter-rouge&quot;&gt;adonis serve --dev&lt;/code&gt; once again.&lt;/p&gt;

&lt;h3&gt;Testing user creation&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-user-creation-success.png&quot; alt=&quot;User Creation - Succesfull&quot; /&gt;&lt;/p&gt;

&lt;h3&gt;Testing user fetch&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-user-fetch.png&quot; alt=&quot;User Fetch&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Setting up the testing framework&lt;/h2&gt;

&lt;p&gt;The next step is to set up the testing framework for testing Adonis.js applications. Fortunately, Adonis.js has its own specialized testing package known as &lt;a href=&quot;https://www.npmjs.com/package/@adonisjs/vow&quot;&gt;Vow&lt;/a&gt;. Install &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; with the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis install @adonisjs/vow
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The installation of this package will cause the following changes to your project:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;vowfile.js&lt;/code&gt; file will be created at the root of your project.&lt;/li&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;test&lt;/code&gt; folder will be created at the root of the project. This is where all of the tests will be contained. In order to organize tests, all unit tests are placed inside a &lt;code class=&quot;highlighter-rouge&quot;&gt;unit&lt;/code&gt; folder within this folder. Functional tests are placed inside a &lt;code class=&quot;highlighter-rouge&quot;&gt;functional&lt;/code&gt; folder. By default, a sample unit test suite is created inside &lt;code class=&quot;highlighter-rouge&quot;&gt;test/unit/example.spec.js&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;.env.testing&lt;/code&gt; file is created at the root of the project to contain environment variables specific to testing purposes. This file gets merged with &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt;, so you only need to define values you want to override from the &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt; file.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Replace the content of &lt;code class=&quot;highlighter-rouge&quot;&gt;.env.testing&lt;/code&gt; with the configuration below:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;HOST=127.0.0.1
PORT=4000
NODE_ENV=testing
APP_NAME=AdonisJs
APP_URL=http://${HOST}:${PORT}
CACHE_VIEWS=false
APP_KEY=pfi5N2ACN4tMJ5d8d8BPHfh3FEuvleej
DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_DATABASE=adonis
HASH_DRIVER=bcrypt
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The final step to complete our test setup is to add the &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; provider to our project. In the &lt;code class=&quot;highlighter-rouge&quot;&gt;./start/app.js&lt;/code&gt; file, add the following item to the &lt;code class=&quot;highlighter-rouge&quot;&gt;aceProviders&lt;/code&gt; array:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;...

const aceProviders = [
  ....,
  &quot;@adonisjs/vow/providers/VowProvider&quot;
];

...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Run the sample test that came with the &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; installation by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The sample test will run successfully.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-sample-test.png&quot; alt=&quot;Sample Tests&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Adding tests&lt;/h2&gt;

&lt;p&gt;It is now time to start adding some proper tests to our API project. We will be adding tests to test our &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoints. Run the following command to create a test suite in which we will put our tests:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis make:test User
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the options that display after running this command, select &lt;code class=&quot;highlighter-rouge&quot;&gt;Functional test&lt;/code&gt; (using the arrow keys) and press &lt;code class=&quot;highlighter-rouge&quot;&gt;Enter&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A new file for the test suite will be automatically created at &lt;code class=&quot;highlighter-rouge&quot;&gt;test/functional/user.spec.js&lt;/code&gt;. In this file, replace the contents with the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// test/functional/user.spec.js

&quot;use strict&quot;;

const { test, trait, after } = use(&quot;Test/Suite&quot;)(&quot;User&quot;);

const User = use(&quot;App/Models/User&quot;);

trait(&quot;Test/ApiClient&quot;);

const randomString = generateRandomString();

test(&quot;Test User creation&quot;, async ({ client }) =&amp;gt; {
  const userData = {
    username: randomString,
    email: `${randomString}@test.com`,
    password: &quot;123456&quot;
  };

  const response = await client.post(&quot;/user/create&quot;).send(userData).end();

  response.assertStatus(200);
}).timeout(0);

test(&quot;Fetch all users&quot;, async ({ client }) =&amp;gt; {
  const response = await client.get(&quot;/user/get&quot;).end();

  response.assertStatus(200);
  response.assertJSONSubset([
    {
      username: randomString,
      email: `${randomString}@test.com`
    }
  ]);
}).timeout(0);

//Delete the created user
after(async () =&amp;gt; {
  await (await User.findBy(&quot;username&quot;, randomString)).delete();
});

function generateRandomString(length = 7) {
  var result = &quot;&quot;;
  var characters =
    &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789&quot;;
  var charactersLength = characters.length;
  for (var i = 0; i &amp;lt; length; i++) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength));
  }
  return result;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the above test suite, the Adonis.js &lt;code class=&quot;highlighter-rouge&quot;&gt;Test/ApiClient&lt;/code&gt; trait is used to gain access to the &lt;code class=&quot;highlighter-rouge&quot;&gt;client&lt;/code&gt; object, which is used to call our endpoints. The &lt;code class=&quot;highlighter-rouge&quot;&gt;generateRandomString&lt;/code&gt; random number generator function is used to create a fake username and email for a test user.&lt;/p&gt;

&lt;p&gt;In the &lt;code class=&quot;highlighter-rouge&quot;&gt;Test User creation&lt;/code&gt; test, we create a new user by calling the &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; endpoint with the appropriate data, and checking if we get a &lt;code class=&quot;highlighter-rouge&quot;&gt;200&lt;/code&gt; response code that indicates that the operation was successful.&lt;/p&gt;

&lt;p&gt;In the &lt;code class=&quot;highlighter-rouge&quot;&gt;Fetch all users&lt;/code&gt; test, the &lt;code class=&quot;highlighter-rouge&quot;&gt;client&lt;/code&gt; object is used to call our &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoint. The response is then tested to ensure that it returns a &lt;code class=&quot;highlighter-rouge&quot;&gt;200&lt;/code&gt; status code. We also check to see if it returns an array containing the user we created in the previous test.&lt;/p&gt;

&lt;p&gt;We attach &lt;code class=&quot;highlighter-rouge&quot;&gt;.timeout(0)&lt;/code&gt; to each test to override the timeout limit for the test runner as functional and browser tests might take a while to run.&lt;/p&gt;

&lt;p&gt;Finally, we do some clean up by deleting the test user we created. This is done after both tests have completed.&lt;/p&gt;

&lt;p&gt;Time to run all the tests contained in the &lt;code class=&quot;highlighter-rouge&quot;&gt;tests&lt;/code&gt; folder. To do that, run the test command once again:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-all-tests-run.png&quot; alt=&quot;All Tests Run&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Connecting the API project to CircleCI&lt;/h2&gt;

&lt;p&gt;Our next task is to get our project set up on CircleCI. First, you need to initialize your Adonis.js project as a &lt;code class=&quot;highlighter-rouge&quot;&gt;git&lt;/code&gt; repository.&lt;/p&gt;

&lt;p&gt;Then, create a remote GitHub repository for the project, commit your changes (if any), and push the local project to the remote repository.&lt;/p&gt;

&lt;p&gt;Next, go to the &lt;strong&gt;Add Projects&lt;/strong&gt; page on the CircleCI dashboard to add the project.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-add-project.png&quot; alt=&quot;Add Project - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Set Up Project&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-add-config.png&quot; alt=&quot;Add Config - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the setup page, click &lt;strong&gt;Add Manually&lt;/strong&gt; to instruct CircleCI that we would be adding a configuration file manually and not using the sample displayed. Next, you get a prompt to either download a configuration file for the pipeline or start building.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-start-build-prompt.png&quot; alt=&quot;Build Prompt - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Start Building&lt;/strong&gt; to begin the build. This build will fail because we have not set up our configuration file yet, this we will do later on.&lt;/p&gt;

&lt;h2&gt;Automating our tests&lt;/h2&gt;

&lt;p&gt;Now that we have our project connected to CircleCI, we can write a configuration for our &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration (CI)&lt;/a&gt; pipeline that will automate our testing process.&lt;/p&gt;

&lt;p&gt;At the root of your the project, create a folder named &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci&lt;/code&gt;, and a file within it named &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;. Inside the &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt; file, enter the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
jobs:
  build:
    working_directory: ~/repo
    docker:
      - image: circleci/node:11-browsers
    steps:
      - checkout
      - run:
          name: Update NPM
          command: &quot;sudo npm install -g npm&quot;
      - restore_cache:
          key: dependency-cache-{{ checksum &quot;package-lock.json&quot; }}
      - run:
          name: Install Dependencies
          command: npm install
      - save_cache:
          key: dependency-cache-{{ checksum &quot;package-lock.json&quot; }}
          paths:
            - ./node_modules
      - run:
          name: Run Migrations
          command: |
            mv .env.testing .env
            node ace migration:run
      - run:
          name: Run tests
          command: npm run test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the configuration file above, we start by updating &lt;code class=&quot;highlighter-rouge&quot;&gt;npm&lt;/code&gt; to ensure that we are using the lastest version. Next, we install the required dependencies and cache them. We then create our environment configuration file (&lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt;) and run our migrations. With all dependencies and database set up, we run our tests.&lt;/p&gt;

&lt;p&gt;Save this file, commit, and push your changes to your repository to trigger the CI pipeline to run.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-build-successful.png&quot; alt=&quot;Build Successful - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Let’s view our test results by clicking on the build to see behind the scenes.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-tests-automated.png&quot; alt=&quot;Tests Automated - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Our tests are now running automatically when we push new code to our repository.&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;

&lt;p&gt;Test-driven development (TDD) is a best practice that a lot of developers are still struggling to integrate into their development flow. Having a framework that has TDD built into its core really makes adopting it less cumbersome. In this tutorial, we learned to set up the testing of our Adonis.js API, and how to automate the process with CircleCI.&lt;/p&gt;

&lt;p&gt;Happy coding!&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;https://twitter.com/coderonfleek?lang=en&quot;&gt;Fikayo&lt;/a&gt; is a fullstack developer and author with over a decade of experience developing web and mobile solutions. He is currently the Software Lead at Tech Specialist Consulting and develops courses for Packt and Udemy. He has a strong passion for teaching and hopes to become a full-time author.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>CircleCI + Slack: customized pipeline notifications</title>
        <link>https://circleci.com/blog/circleci-slack-integration/</link>
        <pubDate>Fri, 09 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/circleci-slack-integration/</guid>
        
          <dc:creator>Kyle Tryon</dc:creator>
        
        
          <description>&lt;p&gt;Today we are releasing the Slack orb v4.0 for CircleCI. It makes &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;pipeline&lt;/a&gt; notifications easy to implement and customize. Now with support for Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;, it also provides a visual way to create endless custom notifications. Check out the slack orb here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;Slack orb&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;Slack orb wiki&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack1.png&quot; alt=&quot;Pipeline on-hold notification example&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;What’s new?&lt;/h2&gt;

&lt;h3&gt;Simple to use.&lt;/h3&gt;
&lt;p&gt;Previously, the Slack orb utilized multiple commands and numerous orb parameters to build notifications piece-by-piece. Now, with version 4.0 and above, you can select one of several built-in available templates or customize and import your own notifications visually with Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;In the new Slack orb you will only find a single command &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt;, and a job &lt;code class=&quot;highlighter-rouge&quot;&gt;on-hold&lt;/code&gt;. The notify command is the heart of the orb and can be used to send notifications to any (or multiple) Slack channel based on &lt;em&gt;events&lt;/em&gt; like when a CircleCI job has passed or failed.&lt;/p&gt;

&lt;h3&gt;Built for teams&lt;/h3&gt;
&lt;p&gt;The new Slack orb authenticates using OAuth, rather than using &lt;a href=&quot;https://api.slack.com/messaging/webhooks&quot;&gt;incoming webhooks&lt;/a&gt; as in previous versions. With this change, you can now install a “bot” application in your Slack Workspace for your CircleCI notifications and alert multiple channels from one integration. To setup authentication, be sure to check the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki/Setup&quot;&gt;GitHub wiki for the Slack orb&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;Upgrading&lt;/h3&gt;

&lt;p&gt;Slack orb version 4.0.0 is a complete rewrite of the previous Slack orb with a new feature set and simpler design that is much easier to use. Older versions of the Slack orb will continue to operate and migrating to the new Slack orb experience is entirely optional.&lt;/p&gt;

&lt;p&gt;To migrate to the new Slack orb, the old orb must be completely removed as version 4.0 does not share any functionality with previous versions of the orb.&lt;/p&gt;

&lt;p&gt;Get started by visiting the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub wiki&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;How does it work?&lt;/h2&gt;

&lt;p&gt;&lt;a href=&quot;https://circleci.com/orbs/&quot;&gt;Orbs&lt;/a&gt; are packages of CircleCI configuration which can be imported and utilized in your configuration file.&lt;/p&gt;

&lt;p&gt;To jump ahead, you can view the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;Slack orb&lt;/a&gt; in the &lt;a href=&quot;https://circleci.com/orbs/registry/&quot;&gt;orb registry&lt;/a&gt;, and on &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/&quot;&gt;GitHub&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The main component of the Slack orb is the &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt; command, which can be used at the end of any job to send notifications based on the status of that job.&lt;/p&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;fail&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;basic_fail_1&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;There is now a single notification command with an &lt;code class=&quot;highlighter-rouge&quot;&gt;event&lt;/code&gt; parameter. The &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt; command should be placed at the end of any job as it will always run and can detect the current status of the job.&lt;/p&gt;

&lt;p&gt;You can specify notifications to &lt;code class=&quot;highlighter-rouge&quot;&gt;always&lt;/code&gt; send or to send on &lt;code class=&quot;highlighter-rouge&quot;&gt;fail&lt;/code&gt; or &lt;code class=&quot;highlighter-rouge&quot;&gt;pass&lt;/code&gt;. If a &lt;code class=&quot;highlighter-rouge&quot;&gt;branch_pattern&lt;/code&gt; parameter is specified, the current branch must also match the pattern to send the notification.&lt;/p&gt;

&lt;p&gt;For the message body, you can select one of the preconfigured templates included with the orb, or create your own custom notification.&lt;/p&gt;

&lt;p&gt;You can see a full list of available templates on the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub Wiki&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack2.png&quot; alt=&quot;Slack Orb Templates&quot; /&gt;&lt;/p&gt;

&lt;p&gt;By default, the Slack orb will attempt to post to the channel specified by the &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_DEFAULT_CHANNEL&lt;/code&gt; environment variable, but you can also select one or more channels via the &lt;code class=&quot;highlighter-rouge&quot;&gt;channel&lt;/code&gt; parameter.&lt;/p&gt;

&lt;h2&gt;A working example&lt;/h2&gt;

&lt;p&gt;Here is a semi-realistic example of a test and deploy workflow on CircleCI. It has one job which tests the application on every commit (&lt;code class=&quot;highlighter-rouge&quot;&gt;test&lt;/code&gt;), and a deployment job which only runs on a tagged commit (&lt;code class=&quot;highlighter-rouge&quot;&gt;deploy&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;In this example, we will place our workflow (&lt;code class=&quot;highlighter-rouge&quot;&gt;test-and-deploy&lt;/code&gt;) &lt;em&gt;&lt;a href=&quot;/docs/2.0/workflows/#holding-a-workflow-for-a-manual-approval&quot;&gt;On hold&lt;/a&gt;&lt;/em&gt; prior to deployment, and wait for a manual approval. After an engineer manually approves the workflow, the deployment job will execute. For this workflow, we want to set up three potential notifications for Slack:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A notification when the workflow is placed on-hold&lt;/li&gt;
  &lt;li&gt;A notification if the deployment fails&lt;/li&gt;
  &lt;li&gt;A different notification if the deployment succeeds&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The following usage example is pulled directly from the orb registry.&lt;/p&gt;

&lt;p&gt;This configuration makes two assumptions:&lt;/p&gt;
&lt;ol&gt;
  &lt;li&gt;You have stored your OAuth token as &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_ACCESS_TOKEN&lt;/code&gt; in a &lt;a href=&quot;/docs/2.0/contexts/#restricting-a-context&quot;&gt;restricted context&lt;/a&gt; named &lt;code class=&quot;highlighter-rouge&quot;&gt;slack-secrets&lt;/code&gt;&lt;/li&gt;
  &lt;li&gt;You have defined the &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_DEFAULT_CHANNEL&lt;/code&gt; as either a &lt;a href=&quot;/docs/2.0/env-vars/#setting-an-environment-variable-in-a-project&quot;&gt;project environment variable&lt;/a&gt;, or within the &lt;code class=&quot;highlighter-rouge&quot;&gt;slack-secrets&lt;/code&gt; context.&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; &lt;span class=&quot;na&quot;&gt;version&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;2.1&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;orbs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;slack&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;circleci/slack@4.0&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;jobs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# This &quot;test&quot; job will run on every commit (as per our workflow)&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# We are ok with no notifications sent for this job.&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;test&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;docker&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;image&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;cimg/base:stable&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;steps&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;run&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;echo &quot;test my app&quot;&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# This &quot;deploy&quot; job will only run on a tagged commit (as per our workflow)&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# We want to be alerted if this job fails and also when it succeeds.&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;docker&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;image&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;cimg/base:stable&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;steps&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;run&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;echo &quot;deploy my app&quot;&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# In the event the deployment has failed, alert the engineering team&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;fail&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;basic_fail_1&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;mentions&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;@EngineeringTeam&quot;&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# When there is a successful deployment, send a notification with a different template.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;pass&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;success_tagged_deploy_1&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;workflows&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;test-and-deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;jobs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# We want the test job to run on all commits, so we will list it with no filters.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# When we are on a tagged commit (example &quot;v1.0.0&quot;), we want to also place the workflow on-hold, pending manual approval for deployment.&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# We will also make use of the Slack orb's &quot;on-hold&quot; job to notify us to this on-hold workflow, making it easy to respond.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/on-hold&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack-secrets&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# Jobs with the type of &quot;approval&quot; act as place holders to pause the workflow, the job name does not matter.&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# Wait for both the test job and for the notification to send before pausing.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;pause_workflow&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;type&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;approval&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/on-hold&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# The deploy job will continue once the workflow has been manually approved.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack-secrets&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;pause_workflow&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Creating custom notifications&lt;/h2&gt;

&lt;p&gt;Previously, creating custom notifications involved using many parameters. They were limited and difficult to configure. Now, you can create nearly any notification imaginable with only a single parameter, and notifications are designed visually using Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;.
You can start with any of Slack’s built-in templates, or start fresh and design your own.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack-gif.gif&quot; alt=&quot;Slack Block Kit Builder example&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the right side of the screen above, you get the payload that contains the text we feed to the Slack orb via the &lt;code class=&quot;highlighter-rouge&quot;&gt;custom&lt;/code&gt; parameter (as an alternative to the &lt;code class=&quot;highlighter-rouge&quot;&gt;template&lt;/code&gt; parameter).&lt;/p&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;always&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;custom&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;pi&quot;&gt;|&lt;/span&gt;
      &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;no&quot;&gt;&quot;blocks&quot;: [&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;section&quot;,&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: {&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;mrkdwn&quot;,&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: &quot;Current Job: $CIRCLE_JOB&quot;&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;},&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;section&quot;,&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: {&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;mrkdwn&quot;,&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: &quot;Write some text here&quot;&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
         &lt;span class=&quot;no&quot;&gt;]&lt;/span&gt;
        &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Before copying the payload, customize the look of your notification using the components on the left side of the screen. Environment variables can be used in any text fields and the values will be replaced at runtime.&lt;/p&gt;

&lt;p&gt;For more information and examples, check out the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub Wiki&lt;/a&gt; and the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;orb registry page&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Join The Community&lt;/h2&gt;

&lt;p&gt;Orb developers and consumers are welcome to &lt;a href=&quot;https://discuss.circleci.com/c/ecosystem/orbs/62&quot;&gt;join our Discuss forum&lt;/a&gt;! We would love to hear from you, whether you have questions, comments, or concerns about the Slack orb. Need to file an issue or want to request a feature? We’d love to hear from you on &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/issues/new/choose&quot;&gt;GitHub&lt;/a&gt; as well.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Using CircleCI workflows to replicate Docker Hub automated builds</title>
        <link>https://circleci.com/blog/using-circleci-workflows-to-replicate-docker-hub-automated-builds/</link>
        <pubDate>Fri, 09 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/using-circleci-workflows-to-replicate-docker-hub-automated-builds/</guid>
        
          <dc:creator>Jonathan Cardoso</dc:creator>
        
        
          <description>&lt;p&gt;&lt;strong&gt;Note from the publisher&lt;/strong&gt;: &lt;i&gt;This content was updated by Support Engineer Nick Bialostosky on 10/9/2020 to reflect changes to Docker Hub support for access tokens.&lt;/i&gt;&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;/docs/2.0/workflows/&quot;&gt;CircleCI workflows&lt;/a&gt; is a powerful feature that can be used to make your deployment process simple and intuitive. In this article, we will learn how to use them to automatically push images to the Docker registry, just like Docker Hub’s own automated build process, but with all of the customization that your own build process offers.&lt;/p&gt;

&lt;h2&gt;CircleCI workflows&lt;/h2&gt;
&lt;blockquote&gt;
  &lt;p&gt;A &lt;strong&gt;workflow&lt;/strong&gt; is a set of rules for defining a collection of jobs and their run order. Workflows support complex job orchestration using a simple set of configuration keys to help you resolve failures sooner. - &lt;a href=&quot;/docs/2.0/workflows/&quot;&gt;CircleCI Workflows Documentation&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;In our workflow, pushing a commit to the &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt; branch will run a specific job that publishes an image with the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag on Docker Hub. Each commit will also add a Git tag to the image as an image tag and publish the image with that tag, too. Finally, we will look into how to use CircleCI’s &lt;a href=&quot;/docs/2.0/env-vars/&quot;&gt;environment variables&lt;/a&gt; to automatically publish incremental versions of our images instead of using Git tags.&lt;/p&gt;

&lt;h2&gt;Building our Docker image&lt;/h2&gt;

&lt;p&gt;Let’s start with a basic Docker image that just prints the arguments passed when it is run. The Dockerfile will look as simple as this:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;FROM alpine:3.8
    
ENTRYPOINT [ &quot;echo&quot; ]
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Building and running the image locally should show us that it is working correctly:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;$ docker build -t building-on-ci .
Sending build context to Docker daemon  4.608kB
Step 1/2 : FROM alpine:3.8
 ---&amp;gt; 196d12cf6ab1
Step 2/2 : ENTRYPOINT [ &quot;echo&quot; ]
 ---&amp;gt; Running in fe2151b22bc1
Removing intermediate container fe2151b22bc1
 ---&amp;gt; edc0ca6e654a
Successfully built edc0ca6e654a
Successfully tagged ci-workflows:latest

$ docker run building-on-ci &quot;Hello!&quot;
Hello!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now that we have our image, we need to push it to our GitHub repository.&lt;/p&gt;

&lt;p&gt;To start building our image on each commit, we are going to bootstrap our project with the following config file. In your project’s root directory, create a &lt;code class=&quot;highlighter-rouge&quot;&gt;.circle&lt;/code&gt; directory and save the following lines as &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2
jobs:
  build:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: docker build -t $IMAGE_NAME:latest .
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We are using a pre-built Docker image available from CircleCI called &lt;code class=&quot;highlighter-rouge&quot;&gt;circleci/buildpack-deps&lt;/code&gt; to run our build. CircleCI has many custom images on Docker Hub that extend the official images with extra tools that are useful in a CI/CD environment. Check the &lt;a href=&quot;/docs/2.0/circleci-images/&quot;&gt;CircleCI images&lt;/a&gt; docs for more information.&lt;/p&gt;

&lt;p&gt;There is also an environment variable called &lt;code class=&quot;highlighter-rouge&quot;&gt;IMAGE_NAME&lt;/code&gt; which we are going to use to set the name of our Docker image. It is imperative that you change it to your username/orgname instead of using mine (&lt;code class=&quot;highlighter-rouge&quot;&gt;jonathancardoso&lt;/code&gt;). Otherwise, you are going to get an error when trying to publish that image to Docker Hub.&lt;/p&gt;

&lt;p&gt;For now, our config has a single workflow called &lt;code class=&quot;highlighter-rouge&quot;&gt;build-master&lt;/code&gt; that runs a single &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job when we push a commit to the &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt; branch. This job simply builds our Docker image and does nothing more.&lt;/p&gt;

&lt;p&gt;One of our steps is called &lt;code class=&quot;highlighter-rouge&quot;&gt;setup_remote_docker&lt;/code&gt; and is one of the most important ones when building Docker images on CircleCI. Since our job steps are run inside of a Docker image, they cannot build other Docker images. The &lt;code class=&quot;highlighter-rouge&quot;&gt;setup_remote_docker&lt;/code&gt; command tells CircleCI to allocate a new Docker Engine, separate from the environment that is running our job, specifically to execute the Docker commands. Check the &lt;a href=&quot;/docs/2.0/building-docker-images/&quot;&gt;building Docker images&lt;/a&gt; docs for more information.&lt;/p&gt;

&lt;p&gt;Example of execution: &lt;a href=&quot;https://circleci.com/gh/JCMais/docker-building-on-ci/1&quot;&gt;https://circleci.com/gh/JCMais/docker-building-on-ci/1&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Publishing an image to Docker Hub with the :latest tag on every commit to master&lt;/h2&gt;

&lt;p&gt;Now that we are building our image on every commit to &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt;, we need to create a new job to also publish that image to Docker Hub.&lt;/p&gt;

&lt;p&gt;Docker Hub does not have access tokens that you can use to access your account, so we are going to need to use our own username/password to log in on the Docker Hub Registry. This is generally done by running:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker login -u &quot;username&quot; -p &quot;password&quot;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;Docker Hub now supports &lt;a href=&quot;https://docs.docker.com/docker-hub/access-tokens/&quot;&gt;access tokens&lt;/a&gt; so you can utilize a token instead of your password for the following instructions if you prefer.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;However, having your credentials in clear text like that is a bad practice because it can expose your password. We need to create new &lt;a href=&quot;/docs/2.0/env-vars&quot;&gt;CircleCI environment variables&lt;/a&gt; with our username and password. There are multiple ways to do that in CircleCI, but if multiple projects are going to push images to Docker Hub, the recommended way is to use &lt;a href=&quot;/docs/2.0/contexts/&quot;&gt;Contexts&lt;/a&gt;. Otherwise, we can set them directly in the project settings. For this article we are going with the latter method.&lt;/p&gt;

&lt;p&gt;After setting the environment variables &lt;code class=&quot;highlighter-rouge&quot;&gt;DOCKERHUB_USERNAME&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;DOCKERHUB_PASS&lt;/code&gt;, let’s create our job:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2
jobs:
  build:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: docker build -t $IMAGE_NAME:latest .
  publish-latest:
    environment:
      IMAGE_NAME: building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - setup_remote_docker
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            docker push $IMAGE_NAME:latest
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
      - publish-latest:
          requires:
            - build
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We added a new &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job to the &lt;code class=&quot;highlighter-rouge&quot;&gt;build-master&lt;/code&gt; workflow. This job tries to push the image we just built to Docker Hub. However, if we commit that change and check the build log, we will see that it fails because Docker cannot find the image &lt;code class=&quot;highlighter-rouge&quot;&gt;jonathancardoso/building-on-ci&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub1.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/workflow-run/6924a584-81be-4a31-bfbc-72225d12d256&quot;&gt;
      https://circleci.com/workflow-run/6924a584-81be-4a31-bfbc-72225d12d256
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;This happens because the jobs in a workflow are isolated from each other, the image we built on the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job is not available to &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Note the duplication we have in our configuration file. We are repeating ourselves two times with the environment variable &lt;code class=&quot;highlighter-rouge&quot;&gt;IMAGE_NAME&lt;/code&gt; definition and the Docker image that is going to be used to run our jobs.&lt;/p&gt;

&lt;p&gt;One way we could use to solve the duplication issue is by using YAML anchors. However, CircleCI has evolved, and with version &lt;code class=&quot;highlighter-rouge&quot;&gt;2.1&lt;/code&gt;, we can now reuse some configurations directly by specifying a &lt;a href=&quot;/docs/2.0/reusing-config/#authoring-reusable-executors&quot;&gt;reusable executor&lt;/a&gt;. At the top of the file we are going to change the version from &lt;code class=&quot;highlighter-rouge&quot;&gt;2&lt;/code&gt; to &lt;code class=&quot;highlighter-rouge&quot;&gt;2.1&lt;/code&gt; and add a new &lt;code class=&quot;highlighter-rouge&quot;&gt;executors&lt;/code&gt; key:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
executors:
  docker-publisher:
    environment:
      IMAGE_NAME: building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now on each job, instead of declaring &lt;code class=&quot;highlighter-rouge&quot;&gt;docker&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;environment&lt;/code&gt; keys, we are going to specify a single &lt;code class=&quot;highlighter-rouge&quot;&gt;executor&lt;/code&gt; key:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
jobs:
  build:
    executor: docker-publisher
    # ...
  publish-latest:
    executor: docker-publisher
    # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Duplication resolved. Time to fix the issue with our Docker image not being available on the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job. We are going to use &lt;a href=&quot;/docs/2.0/workflows/#using-workspaces-to-share-data-among-jobs&quot;&gt;Workflows’ workspaces&lt;/a&gt; to share the image between the two jobs.&lt;/p&gt;

&lt;p&gt;Let’s add a new run step at the end of the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job. This run step is going to save the image as a tar archive:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now, we can persist that file on the workflow workspace by adding another step called &lt;code class=&quot;highlighter-rouge&quot;&gt;persist_to_workspace&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      - persist_to_workspace:
          root: .
          paths:
            - ./image.tar
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;To retrieve the &lt;code class=&quot;highlighter-rouge&quot;&gt;image.tar&lt;/code&gt; file on the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job, we are going to add a new step, &lt;code class=&quot;highlighter-rouge&quot;&gt;attach_workspace&lt;/code&gt;, before the others:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;   # ...
   steps:
      - attach_workspace:
          at: /tmp/workspace
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;And load our archived image with &lt;code class=&quot;highlighter-rouge&quot;&gt;docker load&lt;/code&gt; just before we try to push it to the Docker Hub registry:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Our full configuration file looks like this:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
executors:
  docker-publisher:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
jobs:
  build:
    executor: docker-publisher
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: |
            docker build -t $IMAGE_NAME:latest .
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      - persist_to_workspace:
          root: .
          paths:
            - ./image.tar
  publish-latest:
    executor: docker-publisher
    steps:
      - attach_workspace:
          at: /tmp/workspace
      - setup_remote_docker
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            docker push $IMAGE_NAME:latest
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
      - publish-latest:
          requires:
            - build
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Everything should be green now!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now, we can retrieve and run our image from the Docker Hub registry:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;$ docker run jonathancardoso/building-on-ci &quot;Workflows are awesome!&quot;
Unable to find image 'jonathancardoso/building-on-ci:latest' locally
latest: Pulling from jonathancardoso/building-on-ci
4fe2ade4980c: Already exists
Digest: sha256:f719ca403b0fc6a5214823c61c750a5e48ce5809a24b882b3a45d6d119870366
Status: Downloaded newer image for jonathancardoso/building-on-ci:latest
Workflows are awesome!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Publishing Git tags as Docker image tags on Docker Hub&lt;/h2&gt;

&lt;p&gt;Depending on an image with &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag can &lt;a href=&quot;https://vsupalov.com/docker-latest-tag/&quot;&gt;easily cause confusion&lt;/a&gt; since we don’t have control over which version of the image we are running. The recommended way is to use a specific tag.&lt;/p&gt;

&lt;p&gt;Suppose we are going to use Git tags to release new versions of our Docker image, and we want CircleCI to publish our image with each Git tag as an image tag on Docker Hub. Here is how we can do it.&lt;/p&gt;

&lt;p&gt;First, we are going to add a new workflow, &lt;code class=&quot;highlighter-rouge&quot;&gt;build-tags&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
  build-tags:
    jobs:
      - build:
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/
      - publish-tag:
          requires:
            - build
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Both jobs share the same filters, which basically say that they must run for every tag that starts with &lt;code class=&quot;highlighter-rouge&quot;&gt;v&lt;/code&gt; and should not execute for branches.&lt;/p&gt;

&lt;p&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job is the same (we can reuse jobs between workflows), but the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-tag&lt;/code&gt; job will look like the following:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
  publish-tag:
    executor: docker-publisher
    steps:
      - attach_workspace:
          at: /tmp/workspace
      - setup_remote_docker
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            IMAGE_TAG=${CIRCLE_TAG/v/''}
            docker tag $IMAGE_NAME:latest $IMAGE_NAME:$IMAGE_TAG
            docker push $IMAGE_NAME:latest
            docker push $IMAGE_NAME:$IMAGE_TAG
# ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The difference between this job and &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; is that this job uses an environment variable set automatically by CircleCI called &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_TAG&lt;/code&gt;. We retrieve the value and remove the &lt;code class=&quot;highlighter-rouge&quot;&gt;v&lt;/code&gt; prefix, e.g., &lt;code class=&quot;highlighter-rouge&quot;&gt;v0.0.1&lt;/code&gt; becomes &lt;code class=&quot;highlighter-rouge&quot;&gt;0.0.1&lt;/code&gt;. We then proceed to tag our image with that version and push it to the Docker Hub Registry. We also make sure to push the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag, too, so that both are kept in sync. If we commit a tag we can see it working:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub3.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/workflow-run/ecdfbb3f-b7f6-41b6-9f56-147496791736&quot;&gt;
      https://circleci.com/workflow-run/ecdfbb3f-b7f6-41b6-9f56-147496791736
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;And if we access the Docker Hub page for the image, we can see the tag there:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub4.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/&quot;&gt;
      https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;Now, we can run our image using our tag:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker run jonathancardoso/building-on-ci:0.0.1 &quot;Tags are working!&quot;
Unable to find image 'jonathancardoso/building-on-ci:0.0.1' locally
0.0.1: Pulling from jonathancardoso/building-on-ci
4fe2ade4980c: Already exists
Digest: sha256:1a3a6c74860832704df55acdcbd875f662957d757d69fa340a48b41b890469bc
Status: Downloaded newer image for jonathancardoso/building-on-ci:0.0.1
Tags are working!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Automatic image tags for each build&lt;/h2&gt;

&lt;p&gt;What if we have an image that we don’t use frequently or one that we don’t want to use git tags for? An image that we want to have strict control over which version we are using, so we can’t rely on the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag?&lt;/p&gt;

&lt;p&gt;CircleCI allow us to do exactly that: it exposes an environment variable called &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_BUILD_NUM&lt;/code&gt; that is an ever-increasing number. Using it, we can let CircleCI publish a new version of the image for every build. Let’s modify our &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job to do exactly that:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            IMAGE_TAG=&quot;0.0.${CIRCLE_BUILD_NUM}&quot;
            docker tag $IMAGE_NAME:latest $IMAGE_NAME:$IMAGE_TAG
            docker push $IMAGE_NAME:latest
            docker push $IMAGE_NAME:$IMAGE_TAG
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We are using &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_BUILD_NUM&lt;/code&gt; to create the image tag and publishing it alongside the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag to Docker Hub Registry. If we commit that to master and wait for the workflow to finish, we can see that it was published:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub5.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/gh/JCMais/docker-building-on-ci/24&quot;&gt;
      https://circleci.com/gh/JCMais/docker-building-on-ci/24
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub6.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/&quot;&gt;
      https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;h2&gt;Summary&lt;/h2&gt;

&lt;p&gt;These versioning techniques are just building blocks. You can make tagging the versions of your image as complex or as simple as you want. You could even use this knowledge to upload an image to your own private registry, instead of Docker Hub, for specific tags.&lt;/p&gt;

&lt;p&gt;The repository used while writing this article is available on GitHub: &lt;a href=&quot;https://github.com/JCMais/docker-building-on-ci&quot;&gt;https://github.com/JCMais/docker-building-on-ci&lt;/a&gt;.&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;i&gt;Jonathan Cardoso is passionate about DevOps, open source, and gaming. He has six years of experience helping companies around the world move their objectives forward with technical solutions. He currently works remotely from Brazil as a Full-Stack Developer and DevOps specialist at HelloMD. You can follow him &lt;a href=&quot;https://twitter.com/_jonathancardos&quot;&gt;@_jonathancardos&lt;/a&gt;&lt;/i&gt;&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Continuous deployment for Next.js applications</title>
        <link>https://circleci.com/blog/continuous-deployment-for-next-js-apps/</link>
        <pubDate>Wed, 07 Oct 2020 12:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/continuous-deployment-for-next-js-apps/</guid>
        
          <dc:creator>Fikayo Adepoju</dc:creator>
        
        
          <description>&lt;p&gt;&lt;a href=&quot;https://reactjs.org/&quot;&gt;React.js&lt;/a&gt; is a very powerful front-end framework, as its popularity and adoption over the years have shown. However, building a full, production-level application involves a feature set that the React framework, on its own, doesn’t include. Features like routing, code-splitting, bundling, CSS modules, and more are needed for production-level application development. These are not capabilities that React.js offers out-of-the-box. This is where &lt;a href=&quot;https://nextjs.org/&quot;&gt;Next.js&lt;/a&gt; comes in.&lt;/p&gt;

&lt;p&gt;Next.js is the &lt;strong&gt;React framework for production&lt;/strong&gt; as advertised on the Next.js official website. It provides production-level features to React.js developers to easily build production-ready apps.&lt;/p&gt;

&lt;p&gt;In this tutorial, you will learn how to automate the deployment of Next.js applications to Heroku.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To follow this tutorial, a few things are required:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Basic knowledge of Javascript&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; installed on your system (version &amp;gt;= 10.3)&lt;/li&gt;
  &lt;li&gt;An &lt;a href=&quot;https://heroku.com/&quot;&gt;Heroku&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://github.com/&quot;&gt;GitHub&lt;/a&gt; account&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;With all these installed and set up, let’s begin the tutorial.&lt;/p&gt;

&lt;h2&gt;Creating a Next.js project&lt;/h2&gt;

&lt;p&gt;To begin, create a new Next.js project by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npx create-next-app next-cd
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will automatically create a Next.js application inside the &lt;code class=&quot;highlighter-rouge&quot;&gt;next-cd&lt;/code&gt; folder (you can give the folder any name you chose). Once the scaffolding process is done, go into the root of the project and run the application with the following commands:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;cd next-cd
npm run dev
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will boot up a development server that serves the application at its default &lt;code class=&quot;highlighter-rouge&quot;&gt;3000&lt;/code&gt; port (&lt;code class=&quot;highlighter-rouge&quot;&gt;http://localhost:3000&lt;/code&gt;). Load this URL in your browser and you will see the default homepage.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-app-default-page.png&quot; alt=&quot;New App (Local) - Next.js&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Creating an Heroku app&lt;/h2&gt;

&lt;p&gt;The next step is to set up a Heroku application to host our app. Navigate to your &lt;a href=&quot;https://dashboard.heroku.com/apps&quot;&gt;Heroku account management console&lt;/a&gt;, go to &lt;strong&gt;New&lt;/strong&gt; -&amp;gt; &lt;strong&gt;Create new app&lt;/strong&gt;, and create a new app with your preferred name.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-heroku-new-app.png&quot; alt=&quot;New App - Heroku&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Take note of the app name you just entered. You will need this later.&lt;/p&gt;

&lt;p&gt;Next, locate your Heroku API Key in the &lt;strong&gt;Account Settings&lt;/strong&gt; section of your dashboard. You will also need this later in the tutorial. You can access &lt;strong&gt;Account Settings&lt;/strong&gt; from the dropdown menu that appears when you click on your avatar at the top right of the webpage.&lt;/p&gt;

&lt;h2&gt;Setting up a CircleCI project for deployment&lt;/h2&gt;

&lt;p&gt;To set up your project on CircleCI, you need to initialize your project as a &lt;code class=&quot;highlighter-rouge&quot;&gt;git&lt;/code&gt; repository (if it isn’t already initialized).&lt;/p&gt;

&lt;p&gt;Then, create a remote GitHub repository for the project, commit your changes (if any), and push the local project to the remote repository.&lt;/p&gt;

&lt;p&gt;Next, go to the &lt;code class=&quot;highlighter-rouge&quot;&gt;Add Projects&lt;/code&gt; page on the CircleCI dashboard to add the project.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-project.png&quot; alt=&quot;Add Project - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Set Up Project&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-config.png&quot; alt=&quot;Add Config - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the set-up page, click &lt;strong&gt;Use Existing Config&lt;/strong&gt; to instruct CircleCI that we will add a configuration file manually, and not use the sample config displayed. Next, you get a prompt to either download a configuration file for the pipeline or start building.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-start-build-prompt.png&quot; alt=&quot;Build Prompt - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Start Building&lt;/strong&gt;. This build will fail because we have not added our configuration file yet. We will do that later.&lt;/p&gt;

&lt;p&gt;The final thing we need to do on the CircleCI console is set up environment variables for the project we just added. This will enable our project to have authenticated access to our Heroku application for deployments.&lt;/p&gt;

&lt;p&gt;Go to your project’s settings by clicking &lt;strong&gt;Project Settings&lt;/strong&gt; on the &lt;code class=&quot;highlighter-rouge&quot;&gt;Pipelines&lt;/code&gt; page (make sure your project is the currently selected project).&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-project-settings.png&quot; alt=&quot;Project settings - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On this page, click &lt;strong&gt;Environment Variables&lt;/strong&gt; on the side menu. Then click &lt;strong&gt;Add Environment Variable&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-variable.png&quot; alt=&quot;Add Environment variable - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Add the following environment variables:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;HEROKU_APP_NAME&lt;/code&gt;: This is the name of your Heroku application (in my case, &lt;code class=&quot;highlighter-rouge&quot;&gt;next-cd&lt;/code&gt;).&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;HEROKU_API_KEY&lt;/code&gt;: Your Heroku account API key. This can be found under the &lt;strong&gt;Account&lt;/strong&gt; tab on Heroku, under &lt;strong&gt;Account Settings&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Once added, you now have everything set up on your CircleCI console for deployment to Heroku.&lt;/p&gt;

&lt;h2&gt;Automating the deployment of the Next.js application&lt;/h2&gt;

&lt;p&gt;Now we can begin the process of building the automation script for the deployment of the Next.js application to Heroku.&lt;/p&gt;

&lt;p&gt;You need to create a &lt;code class=&quot;highlighter-rouge&quot;&gt;Procfile&lt;/code&gt; file containing instructions for Heroku to build and start the application. Create a file named &lt;code class=&quot;highlighter-rouge&quot;&gt;Procfile&lt;/code&gt; (no file extension) at the root of the project, and enter the following:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm run build
NODE_ENV=production npm run start
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The first command in this file creates a production optimized version of our Next.js application. The next command starts the application in production mode.&lt;/p&gt;

&lt;p&gt;Now we need to ensure that Heroku uses a dynamic port in production. Make this little change to the &lt;code class=&quot;highlighter-rouge&quot;&gt;start&lt;/code&gt; script in &lt;code class=&quot;highlighter-rouge&quot;&gt;package.json&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;...
&quot;start&quot;: &quot;next start -p $PORT&quot;
...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;With this, our Next.js application will now use the dynamic &lt;code class=&quot;highlighter-rouge&quot;&gt;$PORT&lt;/code&gt; variable set by Heroku in production.&lt;/p&gt;

&lt;p&gt;Finally, we create our deployment script for CircleCI to build our deployment automation pipeline. In this script, we use CircleCI’s &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/heroku&quot;&gt;Heroku orb&lt;/a&gt; to deploy our application from our GitHub repository straight to Heroku. &lt;a href=&quot;https://circleci.com/orbs/&quot;&gt;Orbs&lt;/a&gt; are easy-to-use packages that abstract a lot of boilerplate and sometimes complex commands/workflows providing a developer-friendly API for use in our configuration files.&lt;/p&gt;

&lt;p&gt;At the root of your project, create a folder named &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci&lt;/code&gt; and a file named &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt; within it. Inside &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;, enter the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
orbs:
  heroku: circleci/heroku@0.0.10
workflows:
  heroku_deploy:
    jobs:
      - heroku/deploy-via-git
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the configuration above, we pull in the Heroku orb (&lt;code class=&quot;highlighter-rouge&quot;&gt;circleci/heroku@0.0.10&lt;/code&gt;), which automatically gives us access to a powerful set of Heroku jobs and commands. One of those jobs is the &lt;code class=&quot;highlighter-rouge&quot;&gt;heroku/deploy-via-git&lt;/code&gt; job, which deploys your application straight from your GitHub repo to your Heroku account. This job already takes care of installing the Heroku CLI, installing project dependencies, running the build script, and deploying the application. It also picks up our environment variables to facilitate a smooth deployment to our Heroku application.&lt;/p&gt;

&lt;p&gt;It’s now time to test our work so far. Commit all changes to the project and push to your remote GitHub repository. This will automatically trigger the deployment pipeline.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-build-successful.png&quot; alt=&quot;Build Successful - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;By clicking on the build, you can see the deployment details.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-build-details.png&quot; alt=&quot;Build Details - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Don’t start the parade yet, sometimes a successful build doesn’t exactly equate to a successful deployment. There are still many things that can go wrong on the Heroku platform itself. To confirm that we have a successful deployment, go to your Heroku application dashboard and click &lt;code class=&quot;highlighter-rouge&quot;&gt;Open app&lt;/code&gt;. This will open the application at the Heroku-designated URL (&lt;code class=&quot;highlighter-rouge&quot;&gt;https://[APP_NAME].herokuapp.com&lt;/code&gt;). The default homepage below confirms a successful deployment. Yippee!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-site-live.png&quot; alt=&quot;Site Live - Heroku&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now, let’s confirm that our changes are automatically deployed when we push them to our remote repository. Change the &lt;code class=&quot;highlighter-rouge&quot;&gt;h1&lt;/code&gt; tag in &lt;code class=&quot;highlighter-rouge&quot;&gt;./pages/index.js&lt;/code&gt; from:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;lt;h1 className={styles.title}&amp;gt;
    Welcome to &amp;lt;a href=&quot;https://nextjs.org&quot;&amp;gt;Next.js!&amp;lt;/a&amp;gt;
&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;to:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;lt;h1 className={styles.title}&amp;gt;
    Welcome to &amp;lt;a href=&quot;https://nextjs.org&quot;&amp;gt;My Next.js! Site&amp;lt;/a&amp;gt;
&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then commit and push the changes to trigger another deployment. Once the build is successful, refresh your live site and you will see the screen below.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-site-live-refresh.png&quot; alt=&quot;Site Live - Heroku&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;

&lt;p&gt;Deploying little to large changes to an application by following a manual deployment process can quickly become a frustrating and laborious process. With CircleCI, you can automate the process, eliminating any worry about routine or human errors introduced by manual processes. In this tutorial, we have been able to successfully create an automated deployment pipeline to achieve seamless deployments for any change to our application, making them one less thing to worry about.&lt;/p&gt;

&lt;p&gt;Happy Coding!&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;https://twitter.com/coderonfleek?lang=en&quot;&gt;Fikayo&lt;/a&gt; is a fullstack developer and author with over a decade of experience developing web and mobile solutions. He is currently the Software Lead at Tech Specialist Consulting and develops courses for Packt and Udemy. He has a strong passion for teaching and hopes to become a full-time author.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>A guide to productivity for software engineers</title>
        <link>https://circleci.com/blog/a-guide-to-productivity-for-software-engineers/</link>
        <pubDate>Tue, 06 Oct 2020 06:46:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/a-guide-to-productivity-for-software-engineers/</guid>
        
          <dc:creator>Tanya Ramankova</dc:creator>
        
        
          <description>&lt;h2&gt;The evolution of task management&lt;/h2&gt;

&lt;p&gt;When you start your career as a software engineer, task and time management is pretty straightforward. Either your boss or your team agile board tells you exactly what to work on. There are some distractions like Slack and email that you have to contend with but for the most part, it’s not too bad. You enjoy coding, your tasks are fun, you easily keep them in your mental to-do list, check them off, and feel pretty accomplished at the end of the day.&lt;/p&gt;

&lt;p&gt;You are good at what you do! Before long, you are asked to stretch yourself beyond just the items on your team agile board. You start helping with design and breaking down epics, you are asked to present in company events, you volunteer to help another team to integrate with your team’s service, you find yourself spending more time answering questions in Slack that require your expertise. Your work is becoming more ambiguous, more complex and more unbounded. You find yourself procrastinating. You feel more overwhelmed. But you think to yourself, “that’s what success should feel like!” and decide that with hard work, you surely will be on top of all the spinning plates – just stash more things on your mental to-do list, you got this! And if you forget to do something, it’s not a big deal, someone will surely remind you.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Your work is becoming more ambiguous, more complex and more unbounded, and you find yourself procrastinating.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;A bit more time passes, you are promoted yet again. Now you find yourself working less and less on items from the team agile board, and your days are spent in what feels like endless meetings, reviewing designs, domain models, architecture specs, researching new technologies, leading efforts, and writing even more documents, all under a constant barrage of questions and pings in Slack and email. Less of your work seems “fun”. When you look back on your day, you realize that you spent most of it in between meetings and answering a myriad of questions in Slack. You forgot or didn’t have time to make any progress on important stuff, a few of your spinning plates are now resting on the floor, untouched, with you actively resisting to find time for them and no one there to remind you about all of the things that are getting dropped. Some days, you are not really sure if you’ve accomplished anything…&lt;/p&gt;

&lt;h2&gt;Ambiguity up, productivity down&lt;/h2&gt;

&lt;p&gt;Does this sound familiar? If so, congratulations! You’ve been successful in your engineering career and you are working for an organization that is pushing you to grow! In my career, I definitely got to the point where I could no longer rely on simple streams of tasks that worked for me up until that point: those simple times when I could just pick something up from my team agile board or answer a manageable number of requests in Slack and get back that coveted :thankyou: emoji. It eventually became unreasonable for me to expect all of my work to be “fun” to naturally motivate me. And I had to reconcile the conflict between having to do more ambiguous, complex tasks that have very long cycles while still feeling good about my day (it’s easy to see something you coded getting deployed to production and feel accomplished, it’s much harder to look at a pile of documents you’ve read or created, or Slack threads you participated in, and feel the same).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Growing in your engineering career and taking on a leadership role requires a new approach to productivity.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I’ve always been interested in productivity. After reading many books and articles on the topic and trying various techniques, I eventually figured out that &lt;em&gt;productivity is not about doing more.&lt;/em&gt; The question that kept popping up again and again on my quest to “being more productive” was very simple and had little to do with the number of things I’d done or how busy I’d been. Instead it was simply, “What have I accomplished today?”.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;The question that kept popping up again and again was, “What have I accomplished today?”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Using advice from numerous productivity resources (&lt;a href=&quot;https://www.amazon.com/dp/B00Z3G239W&quot;&gt;Productivity Project&lt;/a&gt;, &lt;a href=&quot;https://zenhabits.net/zen-to-done-ztd-the-ultimate-simple-productivity-system/&quot;&gt;Zen To Done&lt;/a&gt;, &lt;a href=&quot;https://bulletjournal.com/&quot;&gt;Bullet Journal&lt;/a&gt;, &lt;a href=&quot;https://www.amazon.com/Getting-Things-Done-Stress-Free-Productivity/dp/0143126563&quot;&gt;Getting Things Done&lt;/a&gt; and many others) I developed a sustainable system that worked for me, that could allow me to keep track of all the spinning plates without getting overwhelmed and that would help me feel like I accomplished something useful at the end of the day.&lt;/p&gt;

&lt;h2&gt;Productivity when engineering work gets ambiguous&lt;/h2&gt;

&lt;h3&gt;1. Choose my focus&lt;/h3&gt;
&lt;p&gt;The first step was to become deliberate about what I work on. As engineers we can work on many different things, some of them are purely enjoyable, some make our product better, some enable our teammates, some help other teams or our company. How do we choose what to focus on any given day?&lt;/p&gt;

&lt;p&gt;To help me decide I listed out all of the possible focus areas that I could put my energy towards: learning, coding features, making architectural improvements, mentoring/coaching, improving team or organization processes, growing engineering influence, etc. Each month (or quarter) I pick only 3 focus areas where I am going to put most of my energy. To help me decide, I answer the following questions for each of the focus areas:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Do I enjoy this? &lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help me/my career? &lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help my team right now?&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help my company right now?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;My answers might change month to month. For example, improving team processes might actually not help my team right now if there are other folks on my team who are already doing that. I try to have a combination of things that I enjoy as well as things that I might resist but which help me, my team, or my company. I begrudgingly recognize that discomfort very frequently means growth, so I force myself to try some of the areas that feel “hard” or ”not fun”. At the same time I know that these challenging areas will require significantly more energy, so choosing 3 “hard” areas at once most likely will result in me resisting to make progress in any of them. Sustainable discomfort (or growth) is the key!&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Discomfort very frequently means growth.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Once I have my areas of focus chosen I will use them as the filter throughout the month or quarter for any work that is coming my way. I’ll also seek out opportunities and originate work that fall within my top 3 focus areas. This allows me to initiate interesting streams of work that no one specifically asked me to do. Having this filter doesn’t necessarily mean that I will not do any work outside of these areas (good luck telling your boss you are refusing to do something because it doesn’t align with your focus for this month). But, if I have a choice, I’ll choose tasks that align and punt on tasks that don’t.&lt;/p&gt;

&lt;h3&gt;2. Get things done&lt;/h3&gt;
&lt;p&gt;The second step was to become deliberate in how I make progress in the areas I chose (or how I work). &lt;a href=&quot;https://zenhabits.net/zen-to-done-ztd-the-ultimate-simple-productivity-system/&quot;&gt;Zen To Done (ZTD)&lt;/a&gt; talks about choosing &lt;a href=&quot;https://zenhabits.net/big-rocks-first-double-your-productivity-this-week/&quot;&gt;big rocks&lt;/a&gt; for your week and choosing &lt;a href=&quot;https://zenhabits.net/purpose-your-day-most-important-task/&quot;&gt;MITs (most important tasks)&lt;/a&gt; for your day. The idea is that if you don’t prioritize your “big rocks”, tiny pebbles will fill your day and you won’t accomplish very much. I found that once I had my direction set I could deliberately plan my week by choosing top 2-3 projects or tasks (aka big rocks) that I’d like to make progress on this week. And then each day I could deliberately choose top 2-3 tasks that I’d like to accomplish and that would help to move my weekly big rocks forward. As you probably noticed it’s “choose top 3” all the way down!&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;if you don’t prioritize your “big rocks”, tiny pebbles will fill your day and you won’t accomplish very much.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;For any plan to work it needs to be realistic and achievable. Before the start of each week I look at my schedule to see what meetings I have that week. Do I need to prepare for any of them? If so, prep can become one of my MITs some day before the meeting. Are there any meetings related to projects in my focus areas? If so, I can choose those projects as my big rocks for that week. Looking ahead also helps me judge how much time and energy I’ll actually have next week. If I have too many context switches throughout the week, it’s unlikely I’ll have a ton of energy left to work on anything challenging. I also try to find chunks of meeting-free time in my schedule and intentionally block them off for focused work.&lt;/p&gt;

&lt;p&gt;Before the start of each day I do more tactical planning for that day: are there any tasks still remaining to accomplish my weekly big rocks? Do I need to course correct and do something that came up during the week? Is it more important than what I had planned to do? I also try to split my day into “reactive” and “focused” parts. During reactive time I let myself “wander around” and simply react to things that show up, reply to questions or requests in Slack, check email, attend meetings. But during my focus time I try my best to disconnect, shut down or at least minimize Slack, close email and other sources of notifications and actually work on what I planned to do that day. For any new task or request that pops up I simply write it down to follow up later. Writing it down (as opposed to keeping it in my brain space) gives me a peace of mind that I won’t forget to do it later but it also allows me to keep focusing on my planned work and resist the temptation of switching context. It’s quite odd just how much our brains love the idea of multitasking and getting distracted given how ineffective we actually are at doing more than one thing at a time.&lt;/p&gt;

&lt;h3&gt;3. Analyze and iterate&lt;/h3&gt;
&lt;p&gt;Planning and, more importantly, sticking to the plan is an essential part of my weekly and daily ritual. It allows me to focus on things that actually matter to me and it forces me to break down large ambiguous projects into smaller achievable tasks. Being deliberate and spending time planning has another interesting side effect: I can look back on my week or my day, review and celebrate things I’ve accomplished (a nice motivation boost!), and I can also analyze tasks that I resisted. We tend to procrastinate on things that are too hard or too boring.  Analyzing what caused me to resist a task can often help me to overcome that natural tendency. I spend a bit of time during my weekly planning thinking about “why”s for my big rocks: why should I do this project or this task? Just answering that question often motivates me enough to push through some of the harder or less “fun” items on my list. All of a sudden something that was boring becomes much more motivating. And if something is too hard or ambiguous I try to answer a simple question: what is the very next tiny step I can take to make some forward progress? Often it doesn’t need to be a very ambitious first step, sometimes just scheduling a meeting to brainstorm some ideas with someone else is enough. And once you make that first step, you can figure out the next step to take.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;By answering “why,” all of a sudden something that was boring becomes much more motivating.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Planning and being deliberate really helped me realize that you can make significant progress on large projects by taking tiny steps forward. When we train running a long distance we naturally understand this concept: if all I think about is the finish line it’s very easy for me to get discouraged as soon as I get tired: I have still too far to go, I should just stop now. But if I focus on running till that tree that is just a mile ahead and once I get there I will celebrate that small win and decide if I want to stop or if I should pick my next target, all of a sudden the path becomes manageable.&lt;/p&gt;

&lt;p&gt;Too often we don’t realize how important celebrating these small wins is to keep us going. This is especially important when working on large, complex, ambiguous and unbounded projects. We set our eyes on the end goal and refuse to enjoy the ride until the entire project is “finished”. But as you grow, your finish lines move farther and farther away. It might take months or even longer for some of your initiatives to have a visible impact (if any), and very often when it actually comes to fruition so many different folks and teams have contributed to its success that it’ll be very hard for you to look back and feel accomplished. How much did you actually matter?&lt;/p&gt;

&lt;p&gt;&lt;i&gt;Focusing on simply making progress towards things that matter and enjoying the journey is what will make you resilient, tenacious and help you reach your desired destination and choose a meaningful path along the way.&lt;/i&gt;&lt;/p&gt;

&lt;h2&gt;An example from my planner&lt;/h2&gt;

&lt;p&gt;I actually applied everything I’ve explained above to how I wrote this blog post.&lt;/p&gt;

&lt;p&gt;My first tiny step: ping our awesome content manager about my random blog idea. She suggested we have a quick meeting to brainstorm.&lt;/p&gt;

&lt;p&gt;Second tiny step: schedule said meeting. One day before the meeting, do a brain dump of what I might cover in the blog.&lt;/p&gt;

&lt;p&gt;During the meeting she asked how long would it take to get a first draft. I threw out “two weeks” (not too ambitious but not so long that it will give me time to change my mind or lose interest).&lt;/p&gt;

&lt;p&gt;For the next two weeks, “Blog” was one of my big rocks, and each day I saw if it could become one of my MITs for that day. I didn’t set out to write the whole thing on any given day – instead I set a goal to just make some forward progress. Dump ideas one day, refine and edit on another day, then realize I have a few more ideas to add, write some more, edit some more. Some days I planned to work on my blog but I didn’t and it was OK. I know that my daily and weekly planning and splitting things up into tiny steps would make it possible for me to keep going and to make progress. I got a few good writing sessions in both weeks and had the draft ready with 2 days to spare. Success!&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Why every business needs CI/CD to succeed: a Q&amp;A with Jim Rose and Cack Wilhelm</title>
        <link>https://circleci.com/blog/rise-above-your-competitors-with-ci-cd-a-q-a-with-jim-rose-and-cack-wilhelm/</link>
        <pubDate>Mon, 05 Oct 2020 08:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/rise-above-your-competitors-with-ci-cd-a-q-a-with-jim-rose-and-cack-wilhelm/</guid>
        
          <dc:creator>Molly Fosco</dc:creator>
        
        
          <description>&lt;p&gt;In April, we welcomed Cack Wilhelm, a partner at venture capital firm IVP, to the CircleCI board of directors. Cack is our first female board member and previously worked with CircleCI during our Series B while at Scale Venture Partners. At IVP, Cack focuses on investing in growth-stage technology companies.&lt;/p&gt;

&lt;p&gt;Our CEO, Jim Rose, recently sat down with Cack on &lt;a href=&quot;https://www.ivp.com/news/podcast/ivps-hypergrowth-podcast-circleci-ceo-jim-rose-on-the-rise-of-software-delivery-as-a-competitive-differentiator-and-what-its-like-hitting-the-stride-of-hypergrowth/&quot;&gt;IVP’s Hypergrowth podcast&lt;/a&gt; to discuss the rise of software delivery as a competitive differentiator, and what it’s like achieving hypergrowth and adjusting CircleCI as an organization. Jim and Cack also covered how &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; and deployment have become key in achieving success for businesses, the decision-making power of developers, and what makes CircleCI a leader in the CI/CD space. 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cack Wilhelm:&lt;/strong&gt; I’d love to hear about the secular trends behind CircleCI. What do you see in the industry right now that’s continuing to drive demand for a solution like CircleCI? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Jim Rose:&lt;/strong&gt; Back in 2011 and 2012, when CircleCI was started, this idea of being able to ship code as quickly as you made changes was pretty new. Over the last &lt;a href=&quot;https://circleci.com/blog/circleci-celebrates-nine-years-millionth-user/&quot;&gt;nine years&lt;/a&gt;, instead of being a really fringe idea, continuous deployment has become the aspirational North Star for pretty much every software delivery team out there.&lt;/p&gt;

&lt;p&gt;The minute COVID hit, for example, and everyone became not just remote-first, but remote-only, you realized you could no longer rely on a build machine sitting underneath somebody’s desk.&lt;/p&gt;

&lt;p&gt;This idea of automation, of being able to move quickly and to move reliably, has become not just a ‘nice to have.’ It’s become core to what you have to do as a software delivery team.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; What we’re really talking about here is developers — this idea of developers as first-class individuals within an organization that have a budget and decision power.&lt;/p&gt;

&lt;p&gt;You know I haven’t been in venture that long, maybe six or seven years, and I still remember talking about the IT buyer. It was very much about the IT and the security buyer, and never did we discuss the developer buyer. But given your go-to-market strategy and your emphasis on the developer, how has that buyer of system software evolved in the past six or seven years? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; For the longest time, developers were just expected to build things. They were given a set of tools, told what to build, and seen as a cost center as opposed to an opportunity and an investment. As more companies have become software-driven, that perspective has really shifted. Instead of seeing your development team as this cost center that you’re trying to control, you’re really thinking about how you can maximize the capabilities and productivity of these very expensive folks who are difficult to hire.&lt;/p&gt;

&lt;p&gt;The value of speed is very clear to an IT organization. It’s no longer about control. It’s about trying to create carrots or incentives to use the same toolset. It’s about building tools on behalf of all the software development teams inside of an enterprise.&lt;/p&gt;

&lt;p&gt;You find more often than not that developers like to &lt;a href=&quot;https://circleci.com/blog/getting-your-manager-to-say-yes-to-devops-tools/&quot;&gt;pick and choose the best tool&lt;/a&gt; for the job, whatever that particular job is, and then put the onus on the company to figure out how to work with everything else they have inside of their &lt;a href=&quot;https://circleci.com/blog/the-best-dev-tools-used-by-circleci-engineers/&quot;&gt;toolbox&lt;/a&gt;.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; I want to talk about the idea of bundling and unbundling. Mobile and Linux, for example, providing the same thing, seems like software used to really go through cycles. There was this great push for bundled and then, a push for the opposite. Where do you think we are in the cycle right now? What gives you confidence that being a best-in-breed platform, one that provides a big chunk of the software delivery lifecycle, is the right approach? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; There’s been a lot of movement in the market recently of folks trying to build end-to-end platforms in the development space. But if you look at the companies who’ve built those platforms, more often than not, 80 to 90 percent of their revenue still comes from their core product.&lt;/p&gt;

&lt;p&gt;What we’ve heard from customers is that they’re going to implement the best tool they can find for that particular problem at that particular time. Our position, our goal, and our mantra as a company is: we stay close to the customer. We make sure that we’re addressing their particular requirements and needs, and everything else will kind of work itself out.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; I’d love to switch gears and talk more specifically about CircleCI, especially the phase of hypergrowth that you’re experiencing right now. I have the good fortune of seeing CircleCI’s series B phase and then getting reinvolved with the &lt;a href=&quot;https://circleci.com/blog/announcing-circleci-s-100m-series-e/&quot;&gt;series E from IVP&lt;/a&gt;. I must admit, it was kind of fun to take a break and come back to a massively scaled, mature organization without seeing all the increments along the way.&lt;/p&gt;

&lt;p&gt;Can you share more about the growth phase coming into this recent fundraising round, and what it’s like hitting hypergrowth and adjusting the organization? I’m sure there are some differences between go-to-market functions versus engineering, and what about mundane stuff like hiring, onboarding, and office space?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; The way you scale is by making the mundane highly leverageable. The first requirement I have for everyone on our exec team is they have to be a great &lt;a href=&quot;https://circleci.com/blog/how-we-interview-software-engineers-what-we-ve-learned-what-we-ve-changed/&quot;&gt;recruiter&lt;/a&gt;. It’s not about hiring the first person — you’re going to have to hire 15 more in the next six months. How do you make that scalable and repeatable over time? It’s the same thing with infrastructure, whether it’s office space, tools, or having a globally managed set of HR policies in place.&lt;/p&gt;

&lt;p&gt;As a founder, you’re trying to get all of that in place and make it scalable, make it effective, and make it resilient to change. It’s a marathon, not a sprint, but you’re going really fast. You have to make sure you do whatever you can to pace yourself as you continue to grow.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; Amazon, Microsoft and Alphabet certainly have a large part of their businesses that are pegged to cloud infrastructure spend, just as CircleCI does. A large part of Amazon, Microsoft, Alphabet, and Google’s businesses are akin to cloud infrastructure — a lot of what CircleCI does. If you also include DataDog and Atlassian, these companies are showing really strong growth, really strong public performance. From where you’re sitting, what do you make of the public markets as they relate to CircleCI and your next move?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; I think the understanding of the public market investor has really evolved. When we had conversations with public market investors in 2015 and 2016, they had absolutely no idea what we did. They didn’t understand software development as a key differentiator for companies, not just software companies, but for companies overall. I think about companies like Amazon, Google, Netflix, Facebook, and others — their ability to build software quickly is how they generate value inside their businesses.&lt;/p&gt;

&lt;p&gt;Increasingly, too, if you look at more traditional industries that have made real investments in technology over the last four or five years, they’re reaping those gains today. Target and Wal-Mart have made tremendous gains over the last six months since COVID started because they have a pretty robust technical platform at this point.&lt;/p&gt;

&lt;p&gt;When you compare that to more traditional retailers who haven’t made that investment, you can start to see the value of software and the value of agile processes in creating corporate value. The market has definitely woken up to &lt;a href=&quot;https://circleci.com/blog/why-continuous-integration-is-key-to-stepping-up-deployment-frequency/&quot;&gt;the competitive differentiator&lt;/a&gt; that software, and being a well-oiled software delivery machine, provides.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; What are you looking forward to as you move into this next phase of growth in the next year or two years? What’s exciting?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; It’s exciting to watch companies that we may have talked to back in 2015 and weren’t ready for us, who are now leaning in and ready to adopt continuous delivery, and ready to deploy CircleCI as a foundation to that change.&lt;/p&gt;

&lt;p&gt;Some of &lt;a href=&quot;https://circleci.com/blog/we-raised-a-56m-series-d-what-s-next-for-circleci-customers/&quot;&gt;the brands we work with&lt;/a&gt; are doing incredibly interesting things from autonomous vehicles to space vehicles to machine learning to everyday mobile applications, and everything in between.&lt;/p&gt;

&lt;p&gt;When I talk to folks we’re trying to hire, I always say we’re in the engine room of the internet. We’re the company helping build all of those experiences that you consume each and every day, in a way that’s exciting and interesting and new. And whether you’re building a small open-source library or something for the U.S. Government, you can use CircleCI to support that.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Adding approval jobs to your CI pipeline</title>
        <link>https://circleci.com/blog/adding-approval-jobs-to-your-ci-pipeline/</link>
        <pubDate>Fri, 02 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/adding-approval-jobs-to-your-ci-pipeline/</guid>
        
          <dc:creator>Travis Depuy</dc:creator>
        
        
          <description>&lt;p&gt;An explicit approval process can help reduce production issues, provide an audit trail, and give your organization confidence that your engineering teams are deploying the right code.&lt;/p&gt;

&lt;p&gt;In this article, we’ll go into detail about how to set up an approval job in your &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; pipeline so your developers must request approval before the &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;CI pipeline&lt;/a&gt; deploys to production.&lt;/p&gt;

&lt;h2&gt;How does it work?&lt;/h2&gt;
&lt;p&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; job is added to your pipeline, making use of the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/xmatters/xmatters-orb&quot;&gt;xMatters orb&lt;/a&gt;, which passes a workflow’s details to &lt;a href=&quot;https://www.xmatters.com/&quot;&gt;xMatters&lt;/a&gt;. xMatters then sends out the notifications across a range of devices to reach the current on-call approval resource. Using the response options, the approver can then choose to approve or reject the request. On approval, a request is made to CircleCI’s &lt;a href=&quot;https://circleci.com/docs/api/v2/#operation/approvePendingApprovalJobById&quot;&gt;approve a job API endpoint&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Let’s walk through how to set up your approval requests so that you can maintain oversight of any changes to your production code before they happen.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To begin, you’ll need the following:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;An &lt;a href=&quot;https://www.xmatters.com/signup&quot;&gt;xMatters&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A repo with a project that needs an approval job&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The approval process we’ll be discussing uses the &lt;a href=&quot;https://circleci.com/docs/api/v2/#operation/approvePendingApprovalJobById&quot;&gt;approve a job&lt;/a&gt; API call to approve the job. The process for doing this is similar for a variety of tools but this post will focus on using &lt;a href=&quot;https://www.xmatters.com/&quot;&gt;xMatters&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Configuring CircleCI&lt;/h2&gt;

&lt;p&gt;At a high level, we need to update the &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci/config.yml&lt;/code&gt; file, set the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value, and then store the personal token in xMatters. Let’s get started.&lt;/p&gt;

&lt;p&gt;This is a simple build, hold, request approval, and deploy configuration file.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1

orbs:
  xmatters: xmatters/xmatters-orb@1.0.4

jobs:
  build:
    docker: 
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Building building building!&quot;

  request-approval:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - xmatters/notify:
          recipients: Engineering Managers

  hold:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Hold for approval&quot;

  deploy-stuff:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Deploy stuff here&quot;

workflows:
  build-test-and-approval-deploy:
    jobs:
      - build
      - request-approval
      - hold:
          type: approval
          requires:
            - build
            - request-approval
      - deploy-stuff:
          requires:
            - hold
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The items to note here are the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; jobs. You can see in the workflows section that the hold job, marked as type &lt;code class=&quot;highlighter-rouge&quot;&gt;approval&lt;/code&gt;, is dependent on the successful execution of the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; jobs. The &lt;code class=&quot;highlighter-rouge&quot;&gt;deploy-stuff&lt;/code&gt; job is then dependent on the successful execution of the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; job. This means that the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; job halts the execution of the workflow until the app is built successfully and the &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; job, which uses the xMatters orb, is executed.&lt;/p&gt;

&lt;p&gt;We’re targeting the &lt;code class=&quot;highlighter-rouge&quot;&gt;Engineering Management&lt;/code&gt; group so that the current on-call engineering manager can approve (or reject!) the pipeline. Once the hold job is approved, the pipeline continues with the &lt;code class=&quot;highlighter-rouge&quot;&gt;deploy-stuff&lt;/code&gt; job, and the code is deployed to production.&lt;/p&gt;

&lt;p&gt;We need to set the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value in the project settings in CircleCI. Before that, we will grab a personal API token so that xMatters can properly authenticate. Head over to your account settings and select the &lt;strong&gt;Personal API Tokens&lt;/strong&gt; tab.&lt;/p&gt;

&lt;p align=&quot;center&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters1.png&quot; width=&quot;900&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Create New Token&lt;/strong&gt; and copy the value to a text file until we’re ready to use it.&lt;/p&gt;

&lt;h2&gt;Configuring xMatters&lt;/h2&gt;

&lt;p&gt;Next, head over to your xMatters instance and navigate to the &lt;strong&gt;Workflows&lt;/strong&gt; screen. Click &lt;strong&gt;Import Workflow&lt;/strong&gt; and find the &lt;code class=&quot;highlighter-rouge&quot;&gt;CircleCI.zip&lt;/code&gt; file. This file can be downloaded from the repo, &lt;a href=&quot;https://github.com/xmatters/xm-labs-circleci-orb&quot;&gt;here&lt;/a&gt;. Once imported, click into the workflow and navigate to the &lt;strong&gt;Flows&lt;/strong&gt; tab. There will be two canvases listed. In this case, we want &lt;strong&gt;Approval Request&lt;/strong&gt;, which has the logic to deal with most responses.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Clicking into the canvas shows the steps laid out with the step palette on the right side.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters3.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;We are here to get the inbound URL, so double click on the &lt;strong&gt;Approval Request - Inbound from CircleCI&lt;/strong&gt; step in the upper left corner. This will display &lt;strong&gt;HTTP Trigger&lt;/strong&gt; dialog with our inbound URL. Copy this value and keep it handy for later.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters4.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Exit that window and navigate back to &lt;strong&gt;Workflows&lt;/strong&gt;. Click the &lt;strong&gt;Admin gear&lt;/strong&gt; at the bottom of the navigation menu and click &lt;strong&gt;Custom Fields&lt;/strong&gt;. These fields are metadata tied to a user. It is where we will store the access token.&lt;/p&gt;

&lt;p align=&quot;center&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters5.png&quot; width=&quot;900&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Add Field&lt;/strong&gt; and give it the name “CircleCI Token Plain”.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;It is important that you use this name, as it is used in the “Find User Property Value” step back on the flow designer canvas. If you use a different name here, make sure to change the name there as well.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;Set the type as &lt;code class=&quot;highlighter-rouge&quot;&gt;Text&lt;/code&gt;. Click &lt;strong&gt;Save&lt;/strong&gt;. We will then add the token to the user. If it is your token, click your username on the top right and click &lt;strong&gt;Profile&lt;/strong&gt;.&lt;/p&gt;

&lt;p align=&quot;right&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters6.png&quot; width=&quot;300&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Dig out the personal token we copied from CircleCI and paste it into the field we just created.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters7.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;This token is stored in plain text, but only you and your supervisor have access to view this value. We are evaluating other methods of storing this token, so keep an eye out for changes in this space!&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;Finally, head back over to CircleCI and navigate to the project that needs approvals. Make sure to select the project in the list of pipelines as this will enable the &lt;strong&gt;Project Settings&lt;/strong&gt; button in the upper right corner. Clicking this button displays the settings for the project. We’re going to add the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value as a new environment variable.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters8.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The final step entails recipient set up. If you’re targeting a group, navigate to the &lt;strong&gt;Groups&lt;/strong&gt; section, create a new group, and add the appropriate users.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;You will need to have your own token populated in the profile.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters9.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Testing and approving&lt;/h2&gt;

&lt;p&gt;That’s it! When the pipeline gets triggered, it will be on hold at the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; step we configured in the &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci/config.yml&lt;/code&gt; file.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters10.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;This will trigger a notification to the user we defined above in the &lt;code class=&quot;highlighter-rouge&quot;&gt;Create xMatters Event&lt;/code&gt; step. The designated recipient will get a notification with pipeline details as well as the necessary response options. This is how it will look on the xMatters mobile app, but the email is very similar. The image on the right is with the responses drawer open, showing the available responses.&lt;/p&gt;

&lt;p style=&quot;text-align: center&quot;&gt;
  &lt;img src=&quot;/blog/media/2020-09-27-xmatters11.png&quot; width=&quot;325&quot; alt=&quot;&quot; /&gt;
  &lt;img src=&quot;/blog/media/2020-09-27-xmatters12.png&quot; width=&quot;325&quot; alt=&quot;&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Just like that, selecting &lt;strong&gt;Approve&lt;/strong&gt; makes the API call back to CircleCI to approve the pipeline and deploy your code to production.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters13.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Hacktoberfest 2020 is upon us: celebrate open source with CircleCI orbs</title>
        <link>https://circleci.com/blog/hacktoberfest-2020-is-upon-us-celebrate-open-source-with-circleci-orbs/</link>
        <pubDate>Thu, 01 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/hacktoberfest-2020-is-upon-us-celebrate-open-source-with-circleci-orbs/</guid>
        
          <dc:creator>Jeremy Meiss</dc:creator>
        
        
          <description>&lt;p&gt;Every October, as the colors of the leaves change, and the weather turns cooler (or if you’re in the Southern Hemisphere, the opposite) a global phenomenon kicks off: Hacktoberfest!&lt;/p&gt;

&lt;p&gt;&lt;a href=&quot;https://hacktoberfest.digitalocean.com/&quot;&gt;Hacktoberfest&lt;/a&gt; is a month-long celebration of open source, started by DigitalOcean in 2014, and encourages awareness of, and participation in, the open source community. In 2019 alone, there were over &lt;em&gt;483k pull requests&lt;/em&gt; opened across over &lt;em&gt;154k repositories&lt;/em&gt;, with participants from &lt;em&gt;142 countries&lt;/em&gt; – a truly impressive achievement by the community.&lt;/p&gt;

&lt;p&gt;Here at CircleCI we’ve always believed strongly in open source, and the value that it can bring to organizations. We have a long history of &lt;a href=&quot;https://circleci.com/open-source/&quot;&gt;supporting open source projects&lt;/a&gt; on CircleCI, and many of the &lt;a href=&quot;https://circleci.com/blog/leading-open-source-ml-advancements-an-introduction-to-pytorch/&quot;&gt;largest open source projects&lt;/a&gt; use CircleCI in their pipelines.&lt;/p&gt;

&lt;p&gt;For this year’s event, anyone who meets the &lt;a href=&quot;https://hacktoberfest.digitalocean.com/details&quot;&gt;Hacktoberfest core requirements&lt;/a&gt; (minimum of 4 valid PRs submitted to an open source project) will receive event swag, including a Hacktoberfest t-shirt and stickers from the supporting sponsors.&lt;/p&gt;

&lt;h2&gt;Orbtoberfest: hack OSS with CircleCI orbs&lt;/h2&gt;

&lt;p&gt;Last year, we launched our first “&lt;a href=&quot;https://circleci.com/blog/join-the-party-get-your-hacktoberfest-prs-with-circleci-orbs/&quot;&gt;Orbtoberfest&lt;/a&gt;” to coincide with Hacktoberfest.  Orbtoberfest encouraged the community to learn about &lt;a href=&quot;https://circleci.com/docs/2.0/using-orbs/&quot;&gt;CircleCI orbs&lt;/a&gt;: reusable packages of YAML configuration that condenses repeated lines of config into a single line of code. Orbs help you package, ship, and re-use code. We’re revisitng Orbtoberfest this year, to help more developers learn about orbs and Hacktoberfest. You also have the chance to double your prize haul with our unique, limited edition swag.&lt;/p&gt;

&lt;h2&gt;How to get involved&lt;/h2&gt;
&lt;p&gt;There are a few ways to get involved this year. To participate in Hacktoberfest, &lt;a href=&quot;https://hacktoberfest.digitalocean.com/&quot;&gt;register with DigitalOcean&lt;/a&gt; and submit 4 PRs that meet the specifications outlined on their page throughout the month of October. As a reward, receive Hacktoberfest swag or donate to plant a tree instead. To participate in CircleCI Orbtoberfest, you have a few options, outlined below. We hope you’ll &lt;a href=&quot;https://circleci.com/blog/how-to-make-an-easy-and-valuable-open-source-contribution-with-circleci-orbs/&quot;&gt;contribute to CircleCI orbs&lt;/a&gt; to complete the challenge!&lt;/p&gt;

&lt;h3&gt;The challenges:&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Challenge 1&lt;/strong&gt;&lt;br /&gt;
Create a PR, &lt;strong&gt;with “Orbtoberfest” as the label&lt;/strong&gt;, to include orb usage on an existing CircleCI config and get that PR accepted or merged. Valid contributions to other CircleCI repos, like Docs, may also be considered.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prizes:&lt;/strong&gt;&lt;br /&gt;
1-3 PRs receive a sticker pack
4 PRs receive stickers and a T-shirt&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Challenge 2:&lt;/strong&gt;&lt;br /&gt;
Develop and publish an orb using the &lt;a href=&quot;/docs/2.0/orb-author-intro/&quot;&gt;Orb Development Kit&lt;/a&gt;. Make sure your orb solves a challenge that other developers might be facing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prizes:&lt;/strong&gt;&lt;br /&gt;
Sticker pack
T-shirt
Limited edition Orbtoberfest pin
&lt;br /&gt;
&lt;br /&gt;
Once you’ve completed the challenge(s) above, fill out &lt;a href=&quot;https://circleci-community.typeform.com/to/mErGL0nv&quot;&gt;this form&lt;/a&gt; to receive your swag. After the month of October is over, we will process all submissions, verify them, and let you know how you can claim your special CircleCI swag. We are so excited to see all of the contributions to open source and our orbs that will be created this year!&lt;/p&gt;

&lt;p&gt;Make sure to join the &lt;a href=&quot;https://discuss.circleci.com/t/official-hacktoberfest-and-orbtoberfest-thread/37510/&quot;&gt;Orbtoberfest&lt;/a&gt; discussion on our community forum for ideas, FAQs, and to ask any questions. You can also follow along with the conversations on Twitter via the &lt;a href=&quot;https://twitter.com/search?q=%23hacktoberfest&amp;amp;f=live&quot;&gt;#hacktoberfest&lt;/a&gt; and &lt;a href=&quot;https://twitter.com/search?q=%23orbtoberfest&amp;amp;f=live&quot;&gt;#orbtoberfest&lt;/a&gt; hashtags!&lt;/p&gt;
</description>
        
      </item>
    
  </channel>
</rss>

-  recorded_at: Wed, 21 Oct 2020 15:08:34 GMT
-- request:
-    method: get
-    uri: https://medium.com/feed/@macsiri/
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 301
-      message: Moved Permanently
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:35 GMT
-      Content-Type:
-      - text/html; charset=utf-8
-      Content-Length:
-      - '67'
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Location:
-      - https://medium.com/feed/@macsiri
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      X-Envoy-Upstream-Service-Time:
-      - '0'
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d7cdd0000fc9549b22000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      X-Content-Type-Options:
-      - nosniff
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be50e2f60fc95-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: UTF-8
-      string: "<a href=\"https://medium.com/feed/@macsiri\">Moved Permanently</a>.\n\n"
-  recorded_at: Wed, 21 Oct 2020 15:08:35 GMT
-- request:
-    method: get
-    uri: https://medium.com/feed/@macsiri
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Cookie:
-      - __cfduid=dffb80af3c7d40298f24c2f1d245a9fb01603292914; __cfruid=d0fe87c8ee53cd90daf9d0c8fd1080566051f750-1603292915
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:35 GMT
-      Content-Type:
-      - text/xml; charset=UTF-8
-      Transfer-Encoding:
-      - chunked
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Cache-Control:
-      - private, must-revalidate, max-age=900
-      Content-Security-Policy:
-      - 'default-src ''self''; connect-src https://localhost https://*.instapaper.com
-        https://*.stripe.com https://glyph.medium.com https://*.paypal.com https://*.braintree-api.com
-        https://*.braintreegateway.com https://accounts.google.com https://getpocket.com
-        https://medium.com https://*.medium.com https://*.medium.com https://medium.com
-        https://*.medium.com https://*.algolia.net https://cdn-static-1.medium.com
-        https://dnqgz544uhbo8.cloudfront.net https://cdn-videos-1.medium.com https://cdn-audio-1.medium.com
-        https://lightstep.medium.systems https://*.branch.io ''self''; font-src data:
-        https://*.amazonaws.com https://*.medium.com https://glyph.medium.com https://medium.com
-        https://*.gstatic.com https://dnqgz544uhbo8.cloudfront.net https://cdn-static-1.medium.com
-        ''self''; frame-src chromenull: https: webviewprogressproxy: medium: ''self'';
-        img-src blob: data: https: ''self''; media-src https://*.cdn.vine.co https://d1fcbxp97j4nb2.cloudfront.net
-        https://d262ilb51hltx0.cloudfront.net https://*.medium.com https://gomiro.medium.com
-        https://miro.medium.com https://pbs.twimg.com ''self'' blob:; object-src ''self'';
-        script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
-        ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
-      Expires:
-      - Wed, 21 Oct 2020 15:23:35 GMT
-      Link:
-      - <https://medium.com/humans.txt>; rel="humans"
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      Pragma:
-      - private
-      X-Content-Type-Options:
-      - nosniff
-      X-Envoy-Upstream-Service-Time:
-      - '17'
-      X-Frame-Options:
-      - sameorigin
-      X-Obvious-Info:
-      - 42755-064957c,064957ce014
-      X-Obvious-Tid:
-      - 1603292915199:806d1e9615a6
-      X-Opentracing:
-      - '{"ot-tracer-spanid":"52dcea9b6b8a1b78","ot-tracer-traceid":"2448c7e075fca57f","ot-tracer-sampled":"true"}'
-      X-Powered-By:
-      - Medium
-      X-Ua-Compatible:
-      - IE=edge, Chrome=1
-      X-Xss-Protection:
-      - 1; mode=block
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d7daf0000cd327a16a000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be50f7921cd32-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        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
-  recorded_at: Wed, 21 Oct 2020 15:08:35 GMT
-recorded_with: VCR 6.0.0
diff --git a/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_an_article_creation_error.yml b/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_an_article_creation_error.yml
deleted file mode 100644
index eecffa0c6..000000000
--- a/spec/support/fixtures/vcr_cassettes/Feeds_Import/_call/reports_an_article_creation_error.yml
+++ /dev/null
@@ -1,286 +0,0 @@
----
-http_interactions:
-- request:
-    method: get
-    uri: https://medium.com/feed/@vaidehijoshi
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:30 GMT
-      Content-Type:
-      - text/xml; charset=UTF-8
-      Transfer-Encoding:
-      - chunked
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Cache-Control:
-      - private, must-revalidate, max-age=900
-      Content-Security-Policy:
-      - 'default-src ''self''; connect-src https://localhost https://*.instapaper.com
-        https://*.stripe.com https://glyph.medium.com https://*.paypal.com https://*.braintree-api.com
-        https://*.braintreegateway.com https://accounts.google.com https://getpocket.com
-        https://medium.com https://*.medium.com https://*.medium.com https://medium.com
-        https://*.medium.com https://*.algolia.net https://cdn-static-1.medium.com
-        https://dnqgz544uhbo8.cloudfront.net https://cdn-videos-1.medium.com https://cdn-audio-1.medium.com
-        https://lightstep.medium.systems https://*.branch.io ''self''; font-src data:
-        https://*.amazonaws.com https://*.medium.com https://glyph.medium.com https://medium.com
-        https://*.gstatic.com https://dnqgz544uhbo8.cloudfront.net https://cdn-static-1.medium.com
-        ''self''; frame-src chromenull: https: webviewprogressproxy: medium: ''self'';
-        img-src blob: data: https: ''self''; media-src https://*.cdn.vine.co https://d1fcbxp97j4nb2.cloudfront.net
-        https://d262ilb51hltx0.cloudfront.net https://*.medium.com https://gomiro.medium.com
-        https://miro.medium.com https://pbs.twimg.com ''self'' blob:; object-src ''self'';
-        script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
-        ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
-      Expires:
-      - Wed, 21 Oct 2020 15:23:30 GMT
-      Link:
-      - <https://medium.com/humans.txt>; rel="humans"
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      Pragma:
-      - private
-      X-Content-Type-Options:
-      - nosniff
-      X-Envoy-Upstream-Service-Time:
-      - '21'
-      X-Frame-Options:
-      - sameorigin
-      X-Obvious-Info:
-      - 42755-064957c,064957ce014
-      X-Obvious-Tid:
-      - 1603292910115:d7ee737c10a4
-      X-Opentracing:
-      - '{"ot-tracer-spanid":"74e0d8193fac2840","ot-tracer-traceid":"340c312718bc4365","ot-tracer-sampled":"true"}'
-      X-Powered-By:
-      - Medium
-      X-Ua-Compatible:
-      - IE=edge, Chrome=1
-      X-Xss-Protection:
-      - 1; mode=block
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d69db0000cd12aca66000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be4efcc22cd12-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        <?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 Vaidehi Joshi on Medium]]></title>
        <description><![CDATA[Stories by Vaidehi Joshi on Medium]]></description>
        <link>https://medium.com/@vaidehijoshi?source=rss-8f55993c973e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QOQuWAqQd566oITj9rtCKw.jpeg</url>
            <title>Stories by Vaidehi Joshi on Medium</title>
            <link>https://medium.com/@vaidehijoshi?source=rss-8f55993c973e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 21 Oct 2020 14:56:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/@vaidehijoshi" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[On Thirty]]></title>
            <link>https://medium.com/@vaidehijoshi/on-thirty-da2d2e21a6b2?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/da2d2e21a6b2</guid>
            <category><![CDATA[thirty]]></category>
            <category><![CDATA[birthday]]></category>
            <category><![CDATA[life-lessons]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 19 Dec 2019 20:54:11 GMT</pubDate>
            <atom:updated>2019-12-19T21:06:50.571Z</atom:updated>
            <content:encoded><![CDATA[<p>I am fully aware that birthdays are just rituals. Functionally, they don’t really mean much at the end of the day; they just happen to be easy enough to use when we want to represent milestones and impactful events. And yet, I <em>love</em> these rituals. They are an opportunity to reflect and meditate on what has already passed — and in a way, they allow us to find some stillness in preparation for what is to come.</p><p>I’m turning thirty tomorrow, and I certainly don’t expect that I’ll feel much different tomorrow than I do today. But cumulatively, I feel like a much different person than I was when I started my twenties. I feel much more confident, sure-footed, firm, and grounded. It’s hard for me to pinpoint how this transformation came about; there was no single event that perpetuated this change. Instead, I have to believe that it is the sum of the experiences over the last decade and what I learned from them that incrementally changed who I am.</p><p>So, on the eve of a new decade — and in keeping with my love for self-reflection — here are thirty things that I’ve learned before turning thirty.</p><figure><img alt="A woman stands on the side of the road with snow nearby, with the branches of an evergreen tree above her." src="https://cdn-images-1.medium.com/max/1024/1*gtjTdoHuuZWJk6qXyQDvBw.jpeg" /></figure><ol><li><strong>If a relationship is important to you, carve out the time for it.</strong> I spent my twenties moving around the country and around the world. Along the way, I made a lot of very good, close friends, but also realized that maintaining those relationships as a moved took a lot of work. I had to work hard to keep the relationships that meant the most to me. I now have monthly calls with some of close friends on the other side of the country, and make an effort to see friends in the same city as me on a regular basis. My family and I have a group chat and we schedule group video calls often. Life happens to all of us, but we need to prioritize the people we care about the most.</li><li><strong>Say no.</strong> It’s okay to put your foot down when you aren’t comfortable with something, or when you’re not capable of meeting someone’s expectations or desires. It took me a long time to <em>really</em> learn this and practice it. But, whenever I say no to something, I always offer a counter option whenever in order to make it easier for someone to meet me halfway. As it turns out, everything in life is a negotiation!</li><li><strong>Buy the really good olive oil.</strong> Although I think that this applies to all food, really. I will always buy the high-quality ingredients, even if it means spending a bit more money. I can taste the difference, and I always read the ingredients list before buying something. I’ve noticed that the cheaper the item, usually the more processed and full of preservatives it is. And I’d rather spend a little extra money and know exactly what’s going into my body instead of saving a few dollars and consuming a multi-syllable chemical.</li><li><strong>Accept the fact that you can’t please everyone.</strong> If you spend your whole life trying to make other people happy, not only will you fail at that (because someone is <em>always</em> going to take issue with you), but you’ll also be miserable. It’s not worth it. Decide what is important to you and what choices make you happy, and ignore the rest of the noise and opinions.</li><li><strong>Don’t read the comments.</strong> I constantly struggle with this one because part of me still thinks of the comments as feedback. But people will always have opinions and an (anonymous) opinion is way easier to put out into the world than creative content.</li><li><strong>Advocate for yourself.</strong> No one else can advocate for you better than you can. And honestly, no one else probably will. Ask for what you want, and know your worth. It’s not arrogance to know your value and point it out to others. The sooner you become comfortable doing it, the better off you’ll be.</li><li><strong>Don’t carry around guilt.</strong> None of us are perfect and we do the best that we can. As long as you can look yourself in the mirror and know that you did all that you, could given what you knew at the time, then that’s really the best that anyone could hope for.</li><li><strong>Accept the scars you carry.</strong> I’ve learned that trauma doesn’t really go away, but it changes shapes and forms. I still get triggered sometimes, which can be a sharp reminder that I will carry painful experiences with me wherever I go. I’ve realized that this is ok, because the experience and your memory of it change over time, and they make you much stronger at the end of the day.</li><li><strong>Pay it forward.</strong> You will never be able to repay others for their kindness, support, or for helping you when you really needed it. All you can do is pay it forward to the next person.</li><li><strong>Go on self-dates.</strong> This is one of my favorite rituals, and I firmly believe that everyone should learn to spend time with themselves. I love to go to early Sunday morning movies when no one else is around. I think that this practice makes you more confident and self-aware.</li><li><strong>Use a calendar.</strong> My close friends know that I swear by a calendar. It’s the only way that I can manage order in my life without getting overwhelmed.</li><li><strong>Never compare yourself to others.</strong> This is something I’ve really started to master in the past few years, but until then, I really struggled with it. All of us are walking different paths, so it’s silly to look at someone else and their path and wonder why you’re not doing the same things that they are! Another thing worth mentioning is that even if <em>you</em> don’t compare yourself to others, other people will probably still compare themselves to you. And that’s something you just can’t control, so stay focused on the path that you’re walking on, even if they’re looking over at you.</li><li><strong>Be kind to yourself. </strong>You are your harshest critic. I used to be so unkind to myself and put myself through the wringer about my weight, my body, my accomplishments, and my failures. But the way that you talk about yourself is how you show and teach other people how to talk to you. If you are self-deprecating or unkind to yourself, then other people will learn to put you down and be unkind to you, too.</li><li><strong>Take risks.</strong> If you’re scared of trying something, remember that the worst thing that you <em>think</em> will happen is usually never that bad.</li><li><strong>Drink more tea.</strong> Herbal teas before bed are so calming and cleansing! I’ve also started switching out my afternoon coffee with tea instead, and my sleep is so much better and I am much less dehydrated.</li><li><strong>Say “I love you” more.</strong> Life is short. Even if you know it cerebrally, this reality becomes more and more real as you get older.</li><li><strong>Don’t take things personally.</strong> People around you can have bad days. I’ve had to deal with blunt, harsh, and insecure coworkers and bosses, and quickly realized that if I took everything that they said to me personally, I’d be crying in the office bathroom every other week (which I did do early on). I’ve since learned to let what others say bounce off me and back to them. Assume that people are having a bad day and, if necessary, stick up for yourself and speak back. But don’t carry their words around with you for hours or weeks on end; it will eat you alive and you’ll be the one to suffer, not them.</li><li><strong>Take your parents out to dinner.</strong> And if you can’t afford to, cook them a nice meal! We can’t ever repay the people who guided us early on in life, but we can at least show them our appreciation.</li><li><strong>Have boundaries (and stick to them). </strong>This is important when you’re working with other people, but also when it comes to doing things on your own. I have rules about how I want to conduct myself or handle situations, and I’m learning how to draw lines in the sand and not cross those boundaries with myself, or with others.</li><li><strong>Prioritize your financial health. </strong>I’m really proud of how much I’ve learned about financial stability and health in the last decade, and I honestly think that taking control of that aspect of your life is incredibly empowering. You should know where your money is, where it’s going, and how well its growing, actively and passively. We don’t talk about financial things that often, but I think we should be! There’s so much more I still have to learn but I feel like I’ve only gotten better at it over time.</li><li><strong>Vitamins are good.</strong> I take a few different vitamins, including probiotics, vitamin d, and magnesium! I always feel so much better when I take them consistently, and feel much worse when I skip a few days in a row.</li><li><strong>Let other people know that you are there for them.</strong> I have a few close people in my life that I know I could call, day or night, rain or shine. And for a handful of people, I am pretty sure that I am that person for them. The only reason I know that is because they have told me — and shown me with their actions — that I can always depend on them. Tell the people you care about that you are there because you never know when you both might need each other.</li><li><strong>Spend time away from your phone.</strong> I don’t check my phone during mealtimes anymore, and I try to spend long stretches of time (or a day) without looking at or checking it. I also think its valuable to take trips that force you to have no cell service so that you can <em>truly</em> unplug; I try to do this once a year.</li><li><strong>Drink more water.</strong> I’ve heard people give this advice all the time, but I actually feel <em>so much better </em>when I’m well hydrated (especially if I’ve been drinking dehydrating things like alcohol or coffee). I don’t usually drink enough water when I’m traveling though, and I’m trying to be better about that.</li><li><strong>Try not to waste anything, and try to reuse everything.</strong> I’ve learned so much about this from my partner. With a few rare exceptions, we eat everything that we buy, compost what we don’t, and mostly only buy things that can be reused or responsibly recycled. I know I could still do more, but it feels good to be heading in the right direction when it comes to sustainability.</li><li><strong>Stable relationships are more dependable than passionate ones.</strong> I learned this the hard way, but I’m really glad that I did. In the long run, a person that you can come home to, lean on, and build a strong foundation with is much healthier and will make you much happier than one that is volatile emotional rollercoaster.</li><li><strong>It’s okay to let people go. </strong>While I have some people who I know will be in my life for a long time, most of my friendships have quietly faded — and that’s ok. People are always changing, and we can grow in different directions. Those relationships are inevitably going to change as a result, and it’s totally normal.</li><li><strong>Never sacrifice your creative time or space.</strong> If you are someone who is artistic or creative, figure out what you need to be creative and make sure you sacrifice that for anything or anyone. For me, I need quiet, uninterrupted hours in the morning to write, and I don’t let anything get in the way of me finding those hours of creativity.</li><li><strong>Invest in your health.</strong> Take care of yourself early on, before your doctor tells you that you should; eat well, exercise often, and mitigate the stress and anxiety around you. The one thing that none of us can earn or buy or win our way into is more time.</li><li><strong>Take things as they come.</strong> It’s really easy to get caught up in planning for or daydreaming about the future. For me, sometimes that translates into panicking or having anxiety about a future that hasn’t happened yet — a complete hypothetical. I have to remind myself that so much of the world is not in my control; in fact all of it is out of my control except for myself. All any of us can do is control our own actions in the moment and our own perspective on things. I’m learning focus on what is happening <em>now</em> and teaching myself to bring my mind back to the present. And I’m trying to have faith that, when any situation arises, I’ll have the confidence and the ability to cross that bridge when I come to it.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5HIAwYoP9cM-L6lG2af3jw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da2d2e21a6b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logical Time and Lamport Clocks (Part 2)]]></title>
            <link>https://medium.com/baseds/logical-time-and-lamport-clocks-part-2-272c097dcdda?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/272c097dcdda</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 05:16:35 GMT</pubDate>
            <atom:updated>2019-12-05T05:16:35.854Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GKIi4rtNJFtTfg0Vv3RngA.jpeg" /><figcaption>Logical time and Lamport clocks (part 2)</figcaption></figure><p>Throughout the course of this series, we’ve been learning time and again that distributed systems are <em>hard</em>. When faced with hard problems, what’s one do to? Well, as we learned in <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a> of this post, sometimes the answer is to strip away the complicated parts of a problem and try to make sense of things simply, instead.</p><p>This is exactly what Leslie Lamport did when he approached the problem of synchronizing time across different processes and clocks. As we learned in <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a>, he wrote a famous paper called <a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">“Time, Clocks, and the Ordering of Events in a Distributed System”</a>, which detailed something called a <em>logical clock</em>, or a kind of counter to help keep track of events in a system. These clock counters were Lamport’s invention (and solution!) to the problem of keeping track of causally-ordered events within a system. By using a logical clock, we can more easily create a chain of events between processes in a system.</p><p>But how do these clocks actually work? And how does a clock actually figure out the time of events — especially when there are events happening all over the system? It’s time to finally find out.</p><h3>From clock to timestamp</h3><p>As we already know, logical clocks, also sometimes called <strong><em>Lamport timestamps</em></strong>, are counters. But how do those counters work under the hood? The answer may be surprisingly simple: the clocks are functions, and its the function that does the work of “counting” for us!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DmeZ7CUFks4Lq5h7BBc1OA.jpeg" /><figcaption>How should we think of logical clocks?</figcaption></figure><p>We can think of logical clocks as <strong><em>functions</em></strong>, which take in an event as their input, and returns a <strong><em>timestamp</em></strong>, which acts as the “counter”. Each node — which is often just a process — in a distributed system has <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">its own local clock</a>, and each process needs to have its own logical clock.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6AOPCM04sXjm3120Z5kI3Q.jpeg" /><figcaption>Pseudo-coding a logical clock function.</figcaption></figure><p>If we imagine the logical clock as a function that we might implement, we can think through how it works. If we were to pseudo-code that function, we could be sure that it would take an event as its argument. We <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">will recall</a> that an event can be something that occurs within a process, a send event that marks the process sending a message elsewhere, or a receive event that marks the process receiving an event from elsewhere. A logicalClock function should be able to take in any of these three types of events.</p><p>Once the logicalClock function has an event, it looks at the time on that event, and compares it to the time on the clock’s process. Once it compares the two, it chooses the larger of the options, and increments it arbitrarily. The increment step is important, because with logical clocks, time continues to march forward, and the increment step is what ensures that the timestamp returned by the function is always larger in value than the event’s time.</p><p>If this seems confusing, fear not! While pseudo-code can be helpful sometimes, but an example is even better. Now that we understand some of theory behind how a logical clock might work, let’s take a deeper look at how the clock algorithm <em>actually </em>works.</p><h3>Lamport’s clock algorithm</h3><p>In many cases, Lamport’s algorithm for determining the time of an event can be very straightforward. If an event occurs on a single process, then we intuitively can guess that the timestamp of the event will be greater than the event before it, and that the difference between the timestamps of the two events on the <em>same</em> process will depend only on how much the clock increments by (remember, that incrementation can be totally arbitrary!).</p><p>However, things aren’t so simple when dealing with send and receive events, which are signals that two processes are passing messages back and forth. Consider the illustration shown here, where we have two processes, P and Q. Process P has an event on the process <em>itself</em>: P1. The time at P1 is 2. Process Q also has an event of its own, Q1, which has a time of 2. The next event on process Q is Q2, which is a send event and marks a message being sent from process Q to process P.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KFLxitiRaeR5BFx8p_OQQA.jpeg" /><figcaption>How do we determine the time for an incoming event?</figcaption></figure><p>So what happens when the send event from process Q, or Q2, sends its message over to process P? Well, for one thing, when process Q sends its message to process P, it also sends the time at that particular moment along with its message. In the case of this example, the time at Q2 was 4, so the message sends time = 4, as part of its message data.</p><p>Once process P receives that message, it marks it with a receive event, or P2. Then, its logical clock looks at the incoming time on the event, and compares it to the currently-known time on its own process, process P. When it does this comparison, it chooses the larger of the two timestamps, and increments it arbitrarily.</p><p>Process P&#39;s clock sees that its currently-known time is 2, while the time on the incoming event is 4. The clock chooses the larger time between the two timestamps (4), increments it, and assigns the new timestamp to the receive event, P2. In more concrete terms, we can say that the clock uses an algorithm to do this, which can effectively be summarized as: max(processT, incomingT) + amount.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tVJ_jmVsbSDWTRK_eArvxg.jpeg" /><figcaption>Lamport’s algorithm for determining a timestamp.</figcaption></figure><p>In this formula, processT is the currently-known time on the current process, while incomingT is the time on the event that the process is trying to reconcile. The clock takes the max() of that, and increments it by whatever arbitrary amount the clock is using to act as a counter and ensure that the all timestamps continue to increase in value.</p><p>In our example system, we can determine that P2’s timestamp will be the result of max(2, 4) + amount; for simplicity’s sake, we can decide to make amount equal to 1, so the time at P2 is 4 + 1 = 5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PTHjL4wZ3vNEI1kWD1ebNQ.jpeg" /><figcaption>The result of Lamport’s algorithm, in action!</figcaption></figure><p>Awesome! Our logical clock is actually doing some interesting and useful work for us, and it’s doing it in a pretty elegant and simple way.</p><h3>Clocks and causality</h3><p>Now that we’ve seen how clocks derive and deliver a time to us, let’s investigate when they’re useful, as well as how they’re sometimes limiting. As we already know from <a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">part one</a> of this series, Lamport introduced the concept of happens before (using the <strong>→</strong> shorthand) to indicate that one event happens before another in a system. Understanding the chain of events in a system helps us causally order them and figure out how one event causes another to happen.</p><p>Conveniently, logical clocks obey the rules of causality. This means that if we find a causal, happens before relationship in a system, then the timestamps corresponding to these two events should obey the rules of causality.</p><blockquote>If event a → b, then the timestamp returned by clock(a) should be less than (&lt;) that of the timestamp returned by clock(b).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*243bu8y3ET657oqc3gx3bg.jpeg" /><figcaption>Logical clocks should obey causality for causally-related events.</figcaption></figure><p>If we take a look at the example shown here, we’ll see that we have a system with three processes, P, Q, and R, with some clear causal relationships between the events in the system.</p><p>We can see that event P1 → Q2, because event P1 is the send event of Q2, which is the receive event, and one causes the other. On the other hand, event Q2 → R3, as Q2 sends a message to R3, which is a receive event in and of itself. Similarly, we can see that Q3 → Q4, as they both occur on the same process, one after another.</p><p>If we look at these same causal relationships, and compare them with their timestamps, we can see that the clock times for each causal relationship obeys causality as well. For the relationship of P1 → Q2, the clock time for P1 &lt; Q2, as 1 &lt; 2. The same goes for Q2 → R3 (2 &lt; 3) and Q3 → Q4 (3 &lt; 4).</p><p>However, the same rule sadly cannot be said of events in the system that are <em>not</em> causally-related! Let’s take a closer look at some of the <em>other</em> events in the same system we saw before. If we examine the events R1 and P2, we’ll see that the time at R1 is 1, while the time at P2 is 2. We might think that, because the clock time of 1 is less than (&lt;) 2, that R1 → P2. But, unfortunately, this is not the case!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h7CPeter1MHIUqYaZ0We4w.jpeg" /><figcaption>What happens when two events are not causally-related?</figcaption></figure><p>In fact, if we look at this system, we’ll se that there is actually <em>no causal path</em> between R1 and P2. These are concurrent events! <strong><em>Concurrent events</em></strong> do not have causal paths from one to another. Thus, because these two events are concurrent, here is no way to be certain that one event happened before the other. We cannot look at their timestamps and guarantee that they are causally-related!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJR13FRpIixH8lO37K_THg.jpeg" /><figcaption>The limitations of concurrent events and logical clocks.</figcaption></figure><p>In more abstract terms, we can think of it like this: if event a happens before b, then we can be sure that the timestamp of a will be less than the timestamp of b. But just because a’s timestamp is less than b, we don’t know <em>for sure</em> that a happened before b, because the two events could also be happening at the same time!</p><p>For two concurrent events, we cannot make a judgement call about the happens before relationship just based on the clock times of the events. The only thing that we can really guarantee in such a case would be that b does <em>not</em> happen before a.</p><p>This is one of the limitations of logical clocks. Indeed, Lamport even acknowledges this in his own paper, and suggests using “any arbitrary total ordering of the processes” in a system to decide how to break ties when two timestamps could very well be equivalent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eH63MYoCvVi-UNTJgd-wmA.jpeg" /><figcaption>The tl;dr of Lamport timestamps/logical clocks.</figcaption></figure><p>Lamport clocks are pretty amazing in their simplicity, but they are admittedly not foolproof. When given a set of <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">partially-ordered</a> events, we can create a <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">total ordering</a> out of them using simple clock counters and can be sure that those clocks and the timestamps they provide us with will always obey causality. However, Lamport clocks do not help us order the concurrent events in a system, or find a causal relationship between them.</p><p>There are other kinds of clocks that can be used in a distributed system to help solve this problem, but all of the other solutions came along many years after Lamport first introduced his logical clocks back in 1978. We’re lucky that he did, because he set the stage for a new way of thinking about time in distributed systems, and would end up changing the way we talk about distributed computing forever.</p><h3>Resources</h3><p>There are some great resources on Lamport’s paper on logical clocks, as well as causal ordering. If you’re curious to learn more (or read Lamport’s paper yourself), check out the resources below!</p><ol><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li><li><a href="https://www.youtube.com/watch?v=hK6m6WBk-d8&amp;t=3s">Time, Clocks and Ordering of Events in a Dist. System</a>, Dan Rubenstein</li><li><a href="https://www.youtube.com/watch?v=CMBjvCzDVkY">Time and Ordering: Lamport Timestamps</a>, Indranil Gupta</li><li><a href="https://mwhittaker.github.io/blog/lamports_logical_clocks/">Lamport’s Logical Clocks</a>, Michael Whittaker</li><li><a href="https://www.cs.rutgers.edu/~pxk/rutgers/notes/content/08-logical-clocks-slides.pdf">Logical Clocks</a>, Professor Paul Krzyzanowski</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=272c097dcdda" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-2-272c097dcdda">Logical Time and Lamport Clocks (Part 2)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logical Time and Lamport Clocks (Part 1)]]></title>
            <link>https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0317e407112</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 14 Nov 2019 16:34:19 GMT</pubDate>
            <atom:updated>2019-11-14T16:34:19.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_p7M2s9bQyKuAeC8Tjp4Xw.jpeg" /><figcaption>Logical time and Lamport clocks (part 1)</figcaption></figure><p>Over the course of this series, we’ve seen many instances of how things can more complicated than they seem. We saw this with <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">failure</a>, and we saw it with <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">replication</a>. More recently, we discovered that even the <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">concept of time</a> is more complex that we might have originally thought.</p><p>However, when the things that you thought you knew seem more convoluted than ever, sometimes the answer is to keep it simple. In other words, we can keep a problem simple by stripping out the confusing parts and trimming it down to its most essential parts. In fact, this approach is exactly what one computer scientist did in the late 70’s when he was, just like us, trying to figure out how to make sense of time in a distributed system.</p><p>The previous two posts on <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">clocks</a> and the <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">ordering of event</a>s in a distributed system have both been building up to the topic we’re finally ready to uncover: logical time and Lamport clocks! There’s a lot to cover, so we’ll spread it out between two posts. Let’s dive right into part one!</p><h3>Causality and “happens before”</h3><p>The story of logical clocks starts in 1978, when a paper was published in the <em>Communications of ACM </em>journal that would go down in history. <a href="http://www.lamport.org/">Leslie Lamport</a>, a computer scientist at Massachusetts Computer Associates, wrote about his research around ordering events in a distributed system. This paper, entitled <a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">“Time, Clocks, and the Ordering of Events in a Distributed System”</a>, would go on to be one of the most-cited papers in computer science, and would also win the Principles of Distributed Computing Influential Paper Award more than <a href="http://www.podc.org/influential/2000-influential-paper">20 years later</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B5-RflcB3mx-p_3472yMIA.jpeg" /><figcaption>Lamport’s paper on causal ordering was published in 1978!</figcaption></figure><p>In the paper, Lamport outlines how we think about time as humans, and why we need to shift our paradigm when it comes to distributed systems, and the idea of <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">partial ordering</a>. He explains that, “In a distributed system, it is sometimes impossible to say that one of two events occurred first”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_5OCO_U9wWZ1H0F4acPYyQ.jpeg" /><figcaption>Why do we care about ordering events? So that we can track causality!</figcaption></figure><p>As Lamport cites in his paper, the reason that we care about time is so that we can figure out the order in which things happen. While this is certainly harder (or sometimes impossible!) to do in a distributed system, our reason for wanting to <em>know</em> the order of some events in a system all stems back to the same desire: we care about ordering events so we can determine how those events are connected. When dealing with events in <em>any</em> system, the reason we actually want to order them is so that we can see the chain of events within the system. Within a distributed system in particular, we this means that we are often trying to determine if an event at one node affects or causes an event at another node.</p><p>But, as we’ve seen in our own study of distributed systems, this task is no easy feat. When a system is distributed, there is <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">no global clock</a>, which means that we cannot depend on any central time source. This also means that the events in our system are not <a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">totally ordered</a>, which means we can’t be sure of exactly <em>when</em> every event in the system took place. Lamport’s paper acknowledges all of these constrains and empathizes with how tricky this problem really is!</p><p>Lamport’s solution is to shift our thinking. He presents a novel idea: we don’t actually need to think about causality in the context of total ordering to start. Instead, he says that we can start with a partial ordering of events, and then just deal with figuring out which events happened before other events. Once we figure out a partial ordering, we can turn it into a consistent total ordering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_PdU1sv7gRJnExmFEo3KhA.jpeg" /><figcaption>Lamport’s logical clocks allow us to shift from happened “when” to happened “before”.</figcaption></figure><p>So how do we do this? Well, to start, we need to shift from thinking about <em>when</em> an event happened to what the event happened <em>before</em>.</p><h3>Shifting from “when” to “before”</h3><p>The idea of one event happening before another is central to Lamport’s paper. He uses the <strong>→</strong> shorthand notation to indicate the <strong><em>happens before</em></strong> relationship, or the fact that one event happened before another. For example, if we know that one event, <em>a</em>, happened before another event, <em>b</em>, then we can say that <em>a</em> → <em>b</em>, or <em>a </em>happened before <em>b</em>.</p><p>The happens before relationship can also be applied transitively. In other words, we can create a chain of events where one event happened before another. If we say that <em>a</em> → <em>b </em>and <em>b → c</em>, then by using the transitive property, we can say that <em>a → c</em>, or <em>a </em>happened before <em>c. </em>As we might be able to imagine, we could very easily string together a chain of events, where one event happens before another, which happens before another, and so on and so forth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBl56kdG5zmTewcyt1J6Vg.jpeg" /><figcaption>Understanding the “happened before” notation.</figcaption></figure><p>But wait a second — we keep talking about different events in the system, but we haven’t really clarified what an event could possibly be! As it turns out, an event in a distributed system can take different forms. As we know, there can be many <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">different nodes</a> in a distributed system. Each node has its own local system clock, and it is capable of processing its own tasks. However, the nodes can also communicate between one another, sending messages back and forth.</p><p>An <strong><em>event</em></strong> encompasses all of the different things that can happen within and between nodes in a system. An event could be something that occurs on a single process or node. An event also includes any <strong><em>send events</em></strong>, where a node sends a message to another node or process. Conversely, we must also consider <strong><em>receive events</em></strong>, when a node receives an incoming message from elsewhere in the system.</p><p>In the example above, we can see examples of all three of these events. We have two processes, P and Q. There is one event, Q3, which occurs on process Q that are not related to sending or receiving any messages. This is our basic event that indicates that something occurred on the node for process Q. However, we also have a few send events: P1, Q1, Q4. These are all events that indicate that we are sending messages out from a node to somewhere else in the system. On the other hand, P2, P3, and Q2 are each receive events, which indicate that we have received some message from another node in the system.</p><p>Now that we understand what an event in a system could be, we can turn back to the happens before relationship. When we say that an event <em>a</em> <em>→</em> <em>b</em>, we are asserting that event <em>a</em> occurred before <em>b</em>, because <em>a</em> happened before <em>b</em>. We can say that these two events are <strong><em>causally ordered</em></strong>, where the ordering of the events is contingent upon one event causing another to happen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RpmP-aPCiqMfvrGB81puJg.jpeg" /><figcaption>Causally-ordered and concurrent events across two processes.</figcaption></figure><p>There are a few rules to causal ordering that are important for us to understand. In order for <em>a</em> <em>→</em> <em>b </em>to be causally ordered, one of the following three situations must be true:</p><ol><li>Events <em>a</em> and <em>b</em> must occur on the <strong><em>same</em></strong> <strong><em>process</em></strong>, and <em>a</em> must occur before <em>b</em> occurs on the process.</li><li>The events can occur on <strong><em>different</em></strong> <strong><em>processes</em></strong> so long as <em>a</em> is the send event that corresponds to <em>b, </em>which must be its receive event.</li><li>The events are <strong><em>transitively linked</em></strong> with another event in the system, but <em>a</em> still happens before <em>b</em>. For example, if <em>a</em> happens before <em>c</em>, and <em>c</em> happens before <em>b</em>, then we know that <em>a</em> <em>→ b</em>.</li></ol><p>As messages travel through time and across space from one process to another and, we can start to construct chains of causally events (also called <strong><em>causal paths</em></strong>) and see how different events across processes are connected to one another. For example, in processes P and Q, Q1<em>→</em> P3 (through event P2), and P1 <em>→ </em>Q4 (through events Q2 and Q3).</p><p>Finally, it’s worth mentioning that, if two events <em>a</em> and <em>b</em> do not happen before one another, than we can say that <em>a ≠&gt; b</em> and <em>b ≠&gt; a</em>, and that the two events are <strong><em>concurrent</em></strong>. We will cover this in much more depth in part two of this post, but for now, we should just note that concurrent events do not have causal paths from one to another.</p><h3>Logical clocks to the stage</h3><p>In addition to the idea of “happens before”, another core concept that Lamport introduces in his paper is the logical clock. As we already know, each node or process in a distributed system has its own <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">concept of time</a>, or its own local clock. However, Lamport’s take on local clocks is different that what we’ve seen before.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OAmD3WgougNwyj-xexU0dw.jpeg" /><figcaption>How do the clocks factor in?</figcaption></figure><p>Lamport suggests using something different from the typical physical clock that we all think of. Instead of using each process’s physical clock to track the order of events, we can instead use a <strong><em>counter</em></strong>. The counter can start with an initial time (like 0), and we can treat that counter as the processes own local clock.</p><p>Lamport continues with this idea by proposing that, not only will every process within a distributed system have its own counter clock, but each <em>event</em> that is recorded on a process should also have a <strong><em>value</em></strong> on that process’s local clock. Furthermore, the value of each of these events on the clock must mirror any happened before relationships. For example, if event <em>a</em> <em>→ b</em>, then the clock time for when event <em>a</em> occurred must be less than the clock time for whenever event <em>b</em> occurred; in other words, clock(<em>a</em>) &lt; clock(<em>b</em>).</p><p>By using basic counters instead of physical clocks, Lamport simplifies clocks into something a little easier to deal with. These counter clocks are called logical clocks. A <strong><em>logical clock </em></strong>is quite different from a physical clock in that there is no central notion of time, and the clock is just a counter that increments based on events in the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xn9OpEEOENBcg2KouYDCXQ.jpeg" /><figcaption>Logical clocks: a definition.</figcaption></figure><p>Each process in a distributed system can use a logical clock to causally order all the events that are relevant to it. As events occur in a process — whether they are send or receive events — the process’s clock counter is incremented by an arbitrary amount. We’ll learn more about how this works in practice in part two of this post. We’ll also be introduced to Lamport’s algorithm for incrementing counters, and how to obey causality across processes. There’s so much interesting stuff to learn; thankfully we have more time and another post to cover it all!</p><h3>Resources</h3><p>Conveniently, Lamport’s work on logical clocks and causal ordering is well-taught and written about. There are a lot of great resources that introduce these topics, with varying complexities. If you’d like to do some further reading, check out some of my favorite resources, which I’ve listed below!</p><ol><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li><li><a href="https://www.youtube.com/watch?v=hK6m6WBk-d8&amp;t=3s">Time, Clocks and Ordering of Events in a Dist. System</a>, Dan Rubenstein</li><li><a href="https://www.youtube.com/watch?v=CMBjvCzDVkY">Time and Ordering: Lamport Timestamps</a>, Indranil Gupta</li><li><a href="https://mwhittaker.github.io/blog/lamports_logical_clocks/">Lamport’s Logical Clocks</a>, Michael Whittaker</li><li><a href="https://www.cs.rutgers.edu/~pxk/rutgers/notes/content/08-logical-clocks-slides.pdf">Logical Clocks</a>, Professor Paul Krzyzanowski</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0317e407112" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/logical-time-and-lamport-clocks-part-1-d0317e407112">Logical Time and Lamport Clocks (Part 1)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ordering Distributed Events]]></title>
            <link>https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/29c1dd9d1eff</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 24 Oct 2019 02:25:31 GMT</pubDate>
            <atom:updated>2019-10-24T02:25:31.538Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SOzfR2Cmr0dMR3wnvutvBw.jpeg" /><figcaption>Ordering distributed events</figcaption></figure><p>One of the hardest things about distributed systems is that we often find ourselves needing to approach them very differently than other problems in computing. Distributed computing forces us to reevaluate how we’d approach even the simplest obstacles in a single system model.</p><p>We recently began exploring one such example of this when we took a closer look at <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">ticking clocks</a> and how unreliable they are in a distributed system! As we learned, there is no single global clock in a distributed system, which makes it hard to ever agree on what time it is. Understanding the caveats of clocks and time is crucial to wrapping one’s head around the distributed computing model.</p><p>But why is time <em>specifically</em> so important? Why do we really care what time it is, and why does it matter that we know when things happened? And if it matters, how do we go about figuring out what time it is without a global clock to rely upon? As we’ll learn, it’s not so much the clocks and time that we care about, but rather, the events that they’re always tied to.</p><h3>Time in the human mind</h3><p>Although we’ve already dipped our toes into <a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">the topic of time</a>, there’s still a lot more left for us to uncover. In fact, we won’t even be done talking about time by the end of this post! Now, it might seem odd to spend so much time learning about, well, <em>time</em>. Why does time matter so much in a distributed system, anyway? If we think about it more deeply, we might realize that we don’t specifically care about knowing what time it is in a distributed system. What we care about is be able to rely on time to help us order things.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBjTmSMWJeKb1Uh5Yu0hAg.jpeg" /><figcaption>Why does knowing the time even matter in a distributed system?</figcaption></figure><blockquote>The notion of time helps us order events in a single system as well as a distributed one.</blockquote><p>Time is particularly useful when it comes to ordering events in system. Most programmers will rely on and expect some kind of time format when they deal with data or processes; this time format is usually something like a <strong><em>timestamp</em></strong>, which are a sequence of characters that have been encoded to represent a certain moment in time. We use timestamps in order to tell when some data was created or updated, when a message was sent or received, and when a process was started or completed. In actuality, we don’t care about the timestamp on its own — it’s really the timestamp <em>being</em> <em>tied to</em> some data or event that makes it useful to us.</p><p>The trouble is, however, that we humans have our own notion of time and how it ought to work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oLYmXCvJWa677h24_gTbEw.jpeg" /><figcaption>Our concept of time is linear!</figcaption></figure><p>We tend to think of time as being linear; an event happens at “some” time, another event happens after it at “another” time, and a final event happens last, at some “final” time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Veo99jfPM2nACMuLzsTBVg.jpeg" /><figcaption>The human mental model of time assumes a few things.</figcaption></figure><p>The human mental model of time assumes a few things.</p><ol><li>First, we all agree on what time it is. We have timezones and shared clocks (including a global atomic clock), and there is rarely any discrepancy between us when it comes to what time it is in a given location.</li><li>Second, we tend to think of events happening as one after another. Event A happens first, then event B, and finally, event C.</li><li>Third, we can determine the exact order of events based on which event happened before another. In other words, if event A happened before event B, and we know the time of A and B, we know the exact ordering of the two events.</li></ol><p>While this might seem obvious to us, this mental model of time doesn’t work in the context of distributed systems! There are some major differences between our human mental model of how time works and the reality of time in distributed systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NpwdqF3XMgP-pJ7wmC_DBA.jpeg" /><figcaption>The reality of how time works in a distributed system is very different from the human mental model.</figcaption></figure><p>The first difference is one that we already know: distributed systems have <strong><em>no global clock</em></strong>, so there is just no way to be sure of what time it is on a different machine in a different location. The second difference to note is that events don’t just happen one after another! Events can happen at the same time, in parallel, or <strong><em>concurrently</em></strong>. Both of these points lead us to one more major difference: events happen in different places, in different nodes/locations in a system. But, because they can happen at the same time, and because it’s not possible to know what time it is without a global clock, the events that occur all over a distributed network are <strong><em>hard to order</em></strong>!</p><p>The human modeling of time and the reality of time in a distributed system are each two very different approaches to how we might go about ordering events in a system. In the human model approach, we know exactly what time it is, so it’s easy to figure out how to order some events — we can just use each event’s timestamp, since we know what time it is! But in the distributed system approach, we don’t have the luxury of having all the information (read: knowing the time) about all the events in the system.</p><h3>Total and partial ordering</h3><p>The human modeling of time and the more realistic view of time in a distributed system can be grouped into two very different approaches of ordering events. Let’s learn a bit more about them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VDm7nU3LRuZ2hY8LmLphFQ.jpeg" /><figcaption>Total order of events: a definition</figcaption></figure><p>Our view of time aligns well with a single system’s model of time. In a single system — as opposed to a distributed one — each event can be placed in a specific order, which is based on what time they occurred. This is also known as a <strong><em>total ordering</em></strong> of events.</p><p>When events in a system follow a total order, then every event in that system has a specific order in which it occurred. In other words, when we know exactly when <em>each</em> of the events occurred, we know the total order of all the events in a system.</p><p>For example, in the illustration shown above, if we knew that event A occurred first, followed by event B, and ending with event C, then we would know the <strong><em>total order</em></strong><em> </em>of all the events. Events in a single system can be totally ordered since we have a local clock to help us figure out exactly when an event happened, which allows us to figure out the total ordering of all the events.</p><p>Yet a distributed system is very different from a single system! Sure, an individual node in a system will know what time it is based on its local clock, but it won’t know what time it is on another node. It’s almost as if each node in a distributed system can get halfway to a total ordering…it can order its own events, but if it receives any messages/incoming events from other nodes in the system, it won’t know what to do with them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1LhwndhoenFiYhpO4Mfk3w.jpeg" /><figcaption>Partial order of events: a definition</figcaption></figure><p>This brings us to partial ordering, which is a “less sure” version of total ordering. In a <strong><em>partial order</em></strong>, we can’t be sure of the exact order of <em>all</em> the events in the system. Instead, all we can be sure about is the order of events that are reliant upon one another.</p><p>Let’s think back to our example three events: A, B, and C. In a single system or in a system with a total order, we were able to know the exact order of each of these events. But in a distributed system, that would have likely not been the case! Instead, we probably would have been sure about some of the events, but not others.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ndjf3_WbHXGSAk0s-GiGA.jpeg" /><figcaption>Understanding partial ordering with multiple events.</figcaption></figure><p>For example, let’s say that we are sure about when event B and event C occurred. In fact, let’s say that we are even sure that event B occurred before event C. But what about event A? We’re not <em>at all</em> sure about when that event occurred!</p><p>In reality, because we don’t know when event A occurred, it could have theoretically happened at any time: before event B, after event C, or even right between the two events! All we can say with certainty is that event B occurred before C.</p><blockquote>Indeed, our partial sureness about how to order these events is what makes this set of events a partial ordering— we’re only “partially” sure about the order of these events.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_6XMiMJjs39ZSPAgtnh-A.jpeg" /><figcaption>Without a global clock, distributed system events are partially ordered.</figcaption></figure><p>In a distributed system, we mostly deal with partially ordered events, simply because individual nodes can be sure about how to order local events, but they can’t always be sure about how to order events that are happening on a different node. A node in our distributed system will send messages out to other nodes, who can’t necessarily be sure of when they occurred. Similarly a node in our system will receive its own set of incoming messages, and it can’t be sure of what time those messages were sent, either!</p><p>So how do we reconcile this lack of knowledge throughout our system? Well, it involves some reframing of how we think about time…and whether we even need it at all (?!).</p><h3>Maybe time doesn’t matter</h3><p>In the beginning of this post, we asked ourselves why we even <em>cared</em> about time. We realized that the reason it kept coming up was because we relied on time to order events in our system. Along the way, we learned that sometimes we can be sure about the order of events (total ordering) and other times, well, we can’t be sure of everything (partial ordering). But if we circle back to our original question, we might realize that we don’t actually care about <em>time</em>, but rather the order in which things happen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W9xE-623o-wneth3f8xFow.jpeg" /><figcaption>Maybe time itself isn’t important! Maybe we just care about the order of things.</figcaption></figure><p>Perhaps we don’t actually need to worry about the exact time that each event in our system occurred. Instead, maybe we should try to just figure out when those events happened in a way that doesn’t <em>require us</em> to even think about clocks or time!</p><p>All we really want to know is the order in which some events occurred. And why do we care about the ordering of events? Well, the major benefit of ordering events is so that we can figure out how one event caused another to occur. So, the question is: how can we get the benefit of ordering events without all the headache of figuring out the time at which each event happened?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hcKyI_QGwyuXaaEXHaTxVQ.jpeg" /><figcaption>Causal ordering: a sneak peak!</figcaption></figure><p>The answer to this mystery is <strong><em>causal ordering</em></strong>, which helps us order events not based on the <em>time</em> that they occurred, but rather, based on cause and effect. Causal ordering reframes how we think about events. If we can just figure out which events cause <em>other</em> events, we can come up with a loose ordering of how those events occurred.</p><p>In other words: we don’t need to care about time anymore! We can sort of skirt around it, and jump right to the matter at heart: figuring out if one event came before another. In the next post, we’ll dive into the logic behind causal ordering and figuring out the chronological relationships between events. In the meantime, rest easy knowing that we’ve got a (logical) time solution ahead of us.</p><h3>Resources</h3><p>Understanding the ordering of events in a distributed system is super helpful to know before learning about more complex time-related topics. It can be hard to find resources that specifically explain total and partial ordering in the context of distributed systems, but there a few that do a pretty good job, which I’ve listed below!</p><ol><li><a href="http://book.mixu.net/distsys/time.html">Distributed Systems for Fun and Profit</a>, Mikito Takada</li><li><a href="https://stackoverflow.com/questions/4620779/partial-ordering-of-events-in-a-distributed-system">Partial ordering of events in a distributed system</a>, Jesse Bangs</li><li><a href="http://www.cs.cornell.edu/courses/cs6410/2018fa/slides/14-lamport-clocks.pdf">Distributed Systems: Ordering and Consistency</a>, Professor A.F. Cooper</li><li><a href="https://scattered-thoughts.net/writing/causal-ordering/">Causal Ordering</a>, Jamie Brandon</li><li><a href="https://lamport.azurewebsites.net/pubs/time-clocks.pdf">Time, Clocks, and the Ordering of Events in a Distributed System</a>, Leslie Lamport</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29c1dd9d1eff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/ordering-distributed-events-29c1dd9d1eff">Ordering Distributed Events</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ticking Clocks in a Distributed System]]></title>
            <link>https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef2aa4df07a3</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Thu, 03 Oct 2019 03:50:52 GMT</pubDate>
            <atom:updated>2019-10-03T03:50:52.983Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NC8BV7emVqgBtxrHGhKFDg.jpeg" /><figcaption>Ticking clocks in a distributed system</figcaption></figure><p>We often spend a lot of our lives blissfully unaware of how something works. Most of the time, this ends up being an okay thing, since we don’t really need to know how everything around us works. But there are some times when we realize just how much complexity been hidden from us, abstracted out, tucked away neatly so that we never have to think about it.</p><p>I had one of these realizations recently when I discovered that I had never thought twice about a simple thing that I work with on an hourly basis: time! I’ve been using computers for the better part of my life, first as a consumer of technology and, later, as a creator of it. It was only until I began learning about distributed systems (for this series!) that I understood that I didn’t know as much as I thought about telling time, much less how the computers that we use everyday end up deciding what time it is.</p><p>When it comes to distributed computing, time is a completely different beast. But before we can really get into time in distributed systems, we’ll first need to understand how individual machines track time. So let’s start learning about what exactly makes time so darn tricky.</p><h3>Tracking time</h3><p>Most devices these days have some concept of what day it is and what time it is. With the exception of some “internet of things” devices (like a <a href="https://www.raspberrypi.org/">Raspberry Pi</a>), all machines have some notion of time. But how do they figure out the day and time?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ejj7Tpi8dUyJrwdjiP4TOA.jpeg" /><figcaption>Real-time clocks: a definition</figcaption></figure><p>The answer is: with a clock! Now, this might seem obvious at first, but it gets a little tricker as we go on. A computer that needs to be able to tell the time will often have an internal clock that is built right into its hardware in the form of an integrated circuit. This circuit is often built right onto the motherboard. This small piece of hardware is known as a <strong><em>real-time clock</em></strong>, or <strong><em>RTC</em></strong> for short.</p><p>RTCs are particularly interesting because they come with an alternate power source (like a battery), which allows them to continue working even if a machine is powered off! This might seem obvious to us today, but the use of RTCs was a pretty significant milestone in the history of computing; early personal computers didn’t actually come with RTCs built-in, and they were added in later on. Now, we’ll find refrigerators and microwaves that have these little clocks built right in! That’s pretty wild if you think about it.</p><p>The RTC is responsible for keeping track of the current time, and we can think of it as one individual machine’s <strong><em>system clock</em></strong>. It’s important to note that this clock is specific to the “system” of the machine; in other words, any process or tasks or work that the machine does that relies on the time will inherently rely upon whatever time the <em>system clock</em> says it is.</p><p>So, how does this physical clock work, exactly? As it turns out, deep inside the integrated circuit is a crystal, which vibrates or oscillates; it’s known as a <strong><em>crystal oscillator</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-JwBPx1aOGfLcplER6wZcg.jpeg" /><figcaption>Every computer has its own physical clock</figcaption></figure><p>Without getting into the nitty-gritty (read: physics) of this works under the hood, all we really need to know for our purposes is that the vibrations of the crystal are captured and counted by the clock. As the crystal vibrates, the clock keeps count of each vibration in the form of <strong><em>ticks</em></strong>, and as it counts one tick after another, it keeps track of the time. Of course, this begs the question of where it keeps count of each tick that it records. The physical clock uses a <strong><em>binary counter circuit</em></strong>, a simple circuit that does nothing more than count in binary, in order to store these ticks. Conveniently, the binary counter circuit (the system clock) is where a machine derives its <strong><em>system time</em> </strong>from. Indeed, just as a machine has a system clock, it also has its own notion of time that is <em>based</em> on that clock!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0-piv6mSBWJOaUDrn2cRyw.jpeg" /><figcaption>System time: a definition</figcaption></figure><p>An interesting thing about system time is that it always is calculating time based on <em>when</em> the system clock began counting. This means that if we set the system clock on a new computer to be five minutes slow or two days fast, then our starting point for our system time or the “zero” of where we start our counting of time will end up being either five minutes behind or two days ahead. In other words, we’ll be measuring “ticks” based on whatever date or time we set — not on what the actual time is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*luLDI4ZsJaiTwFNvmGL7SQ.jpeg" /><figcaption>Understanding how Unix time works</figcaption></figure><p>To help avoid some of the confusion of this problem, most machines follow some kind of convention when it comes to deciding what that starting point should be. For example, machines that have Unix operating systems have standardized around <strong><em>Unix time</em></strong>, which is a way of deciding what the “zero” of where we start counting time should be. In the case of Unix time, the starting point or “zero” is the start of the <strong><em>Unix epoch</em></strong>, or January 1st, 1970, at 00:00:00 UT (Universal Time). An <strong><em>epoch</em></strong> is meant to be arbitrary; it’s nothing more than an agreed-upon starting date and time for when we should start measuring time. My personal favorite epoch is the one for Microsoft Excel programs, which is 0 January, 1990! (For the epochly-curious, check out <a href="https://en.wikipedia.org/wiki/Epoch_(computing)">this extensive list</a>.)</p><h3>Out of sync, out of control</h3><p>Now that we know that a clock can start “counting” at arbitrary times, it’s time to add another factor to the mix. Namely, what happens if we have more than one clock? This is when things start to get, well, a little out of sync.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pUX8-qVqs071jxTmcdIlwg.jpeg" /><figcaption>Computer clocks are not consistent</figcaption></figure><p>Since every machine can have its own notion of time, we can assume that two different machines will each have their own concepts of what time it is. But this is where things start to get a bit complicated: if two different machines have two different ideas of what time it is, how can we be sure that they are the same?</p><blockquote>Unfortunately for us, computer clocks are not consistent.</blockquote><p>We already know that every clock has a different idea of <em>when</em> it started counting and its “zero”, and that one clock could be inconsistent with another. However, it’s also worth mentioning that not all clocks are precise, and some are more precise than others. Over time, the preciseness of each “tick” of a clock really starts to have an impact on how that clock determines its time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ar9Gw_fTeLiHgxH3lPk_UQ.jpeg" /><figcaption>Every system clock counts differently!</figcaption></figure><p>For example, a typical quartz clock will drift quartz clocks will lose or gain approximately one second over the course of 11 or 12 days. This is due to a tiny imprecision that occurs as the clock measures a single second as it ticks. A single second may not seem like much, but over time, slight imprecisions really start to add up! The preciseness of a clock could be affected by temperature, location, the clock’s source of power, and even just how well it was constructed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*64aruhYbkcX9pgZzprey5g.jpeg" /><figcaption>Clock drift and clock skew</figcaption></figure><p>This phenomenon of limited clock precision causing two clocks to to count time differently is known as <strong><em>clock drift</em></strong>. Unfortunately, it is just a reality of any machine that needs to keep track of the time on its own. Because clock drift is so common, we often also find ourselves comparing two clocks that display two different times. This is known as <strong><em>clock skew</em></strong>, and it is the difference in time between two clocks.</p><blockquote>In a perfect world where two clocks agreed on the time, we wouldn’t ever run into either of these concepts! In such a utopia, both clock drift and skew would be zero.</blockquote><p>Alas, we do not live in such a world, and so we must think of both of these things when comparing two different machines and their times. Instead, we live in a world where things are messy and…distributed.</p><h3>No one clock to rule them all</h3><p>We’ve talked a lot about clocks and how they work and how they disagree, but what does that have to do with distributed systems, exactly? As it turns out, all of this clock talk is leading is to one of the core, foundational principles of distributed systems that, somehow (!), we haven’t covered it. Now, it’s finally time to talk about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60kDqvVEqSdv7cr4voVOmA.jpeg" /><figcaption>Clocks and distributed systems</figcaption></figure><p>As we already know, in a distributed system, all the individual components are called nodes, and they are each <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">autonomous</a>, capable of performing their own work. We also learned that each node has its own notion of time, and keeps track of its own time internally. When we combine these two facts together, we arrive at one singular conclusion:</p><blockquote>There is no one, true global clock in a distributed system.</blockquote><p>Every node in the system has its own concept of time, and there is no centralized place for the nodes in a distributed system to figure out what time it actually is. And perhaps this wouldn’t matter if we didn’t care about time so much! We use time so frequently in computing, particularly in order to figure out when an event occurred, and which event happened before another.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9pr7aFWqOz0WA02RflYkoA.jpeg" /><figcaption>How does having no global clock impact the way a system works?</figcaption></figure><p>So what happens when we don’t have a global clock in a distributed system? Well, for starters, we can’t actually know the <em>real</em> time that any two evens occurred, or the order that they occurred in. This makes is very hard to figure out how two events might be scheduled in the future. It also makes a distributed system <em>really</em> difficult to debug, since we don’t know for sure whether one event occurred before the other!</p><p>We’ll be talking more about time and the ordering of events in upcoming posts, and hopefully we’ll find some tried and true solutions for this problem. Until then, try not to look at your watch or think too much about what time it is.</p><h3>Resources</h3><p>Clocks and time in distributed systems can be one of the most unintuitive concepts to wrap your head around — especially if you’re new to distributed systems! Thankfully, there is a ton of course material out there that covers these topics in great detail. Below are some of my favorites, which I relied upon myself when I was learning about clocks and time!</p><ol><li><a href="http://www.ntp.org/ntpfaq/NTP-s-sw-clocks.htm">How do Computer Clocks work?</a>, Network Time Foundation</li><li><a href="http://people.cs.aau.dk/~bnielsen/DS-E08/material/clock.pdf">Time in Distributed Systems</a>, Brian Nielsen</li><li><a href="http://www.cs.bham.ac.uk/~bxb/courses/02_03_DS/Lecture10_Handouts.pdf">Clocks and Tim</a>e, Behzad Bordbar</li><li><a href="http://www.cs.cmu.edu/~srini/15-446/S09/lectures/08-phy_time.pdf">Synchronizing Physical Clocks</a>, Srinivasan Seshan</li><li><a href="http://infolab.stanford.edu/~burback/dadl/node87.html">Distributed System Foundations</a>, Ronald LeRoi Burback</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef2aa4df07a3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/ticking-clocks-in-a-distributed-system-ef2aa4df07a3">Ticking Clocks in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Parsing Through Partitions in a Distributed System]]></title>
            <link>https://medium.com/baseds/parsing-through-partitions-in-a-distributed-system-3c1723fecc4e?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c1723fecc4e</guid>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Fri, 30 Aug 2019 23:38:47 GMT</pubDate>
            <atom:updated>2019-08-30T23:38:47.447Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*08zDlw37YpFhHuH-nEhOBA.jpeg" /><figcaption>Parsing through partitions in a distributed system!</figcaption></figure><p>When it comes to tech jargon, one thing seems to always hold true: everyone has a different opinion about what certain words mean. I realize this fact every once in awhile; most recently, I came across it while trying to learn a new distributed systems concept.</p><p>The term “partition” is used a lot in distributed system courses and books, but there are also a slew of other terms that get lumped into this category as well. Until recently, I thought I knew what the term meant in the context of a distributed system, but as it turns out, there was more to the story — and the word — than I ever realized! As I did more research, I realized that the term is used to talk about two very different concepts, both of which end up being crucial to understanding how to deal with and architect a distributed system.</p><p>As Richard Feynman <a href="https://www.youtube.com/watch?v=ga_7j72CVlc">once wisely said</a>, “names don’t constitute knowledge”. Just because people in the industry throw around a term doesn’t mean that they all necessarily know what it means, or how it can chance depending on the context! So let’s try and clear up some of this confusion and gain some real knowledge on this topic.</p><h3>Parsing the meaning of partitioning</h3><p>Before we get too deep into partitioning within a<em> system</em>, let’s first make sure we’re on the same page about what the word even means! When we talk about <strong><em>partitioning</em></strong> something, we are dividing it up, breaking it up into parts and separating it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3tzaGgBF5B4OuYeUsQXL3A.jpeg" /><figcaption>What does it mean to partition something?</figcaption></figure><p>At its core, that’s all that partitioning really is: taking the whole of something and turning it into smaller pieces of itself. So far, not too complicated, right? But what does this same term mean in the context of a distributed system? Well, we can infer that the distributed system must, in some way, be the “whole” thing that we are separating, dividing up, and breaking into smaller pieces of itself.</p><p>But this simple act can actually take two different forms, depending on the kind of partition we are creating. As <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">we already know</a>, a distributed system is made up of nodes; so, if we are dividing up the system into parts, perhaps we are dividing up the nodes? But there’s another interpretation of “partition” here, too. Rather than dividing up the nodes, perhaps we are dividing the system into smaller groups of nodes such that we are breaking up one large system into smaller subsystems. If we think about it, both of these approaches are two valid forms of partitioning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8H7K_dfMS90KSkisAsfbaA.jpeg" /><figcaption>In the context of distributed systems, “partitioning” can mean different things.</figcaption></figure><p>As it turns out, this is where things can get confusing. When dealing with a distributed system, “partitioning” can mean different things. First, it could imply the <strong><em>partitioning of data</em></strong> in the system, or dividing up the nodes into smaller pieces of themselves. But, it could also mean partitioning the system itself by <strong><em>partitioning the network </em></strong>that the system communicates through. This would mean breaking up the way that the nodes in the system talk to each other and separating them into smaller subsystems or subnetworks.</p><p>The interesting thing about these two forms of partitioning in a system is that one is intentional, while the other is more of a side effect that we need to deal with. But more on that soon. It’s important to understand the difference between the two because the same term can sometimes be used to refer to either! So let’s dig into these two forms of partitioning and understanding the reasons behind why each happen.</p><h3>Separating data</h3><p>The idea of partitioning the nodes in a system might seem odd at first, but we’ve we’ve actually seen something sort of adjacent to this before. Remember when we learned about redundancy and <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">the replication of nodes</a>? That concept also might have seemed weird initially — why would anyone <em>want</em> to repeat themselves?! — but as we started to unpack it further, we saw that there were some clear benefits to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*coMCYYa76oaLs1opVKHxoA.jpeg" /><figcaption>Recapping the pros and cons of replication.</figcaption></figure><p>As we have <a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">already learned</a>, when we need to make some of our nodes more reliable or when we need to scale some part of our system (like a database), we can replicate our nodes to create more copies of the same data that are in sync with the original node. That way, if one replica fails, another working replica can handle incoming requests for some data. Overall, replication allows for a system that is more <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">transparent</a>, <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">reliable</a>, and much <a href="https://medium.com/baseds/scalability-growing-a-system-in-different-directions-ae16469c4cb3">easier to scale</a>.</p><p>There are some caveats with replication, however. We already know that keeping replicas consistent is a major challenge. But what happens if our replicas suddenly need to deal with a high load of incoming requests? It is possible that a few replicas could fail, and any user that is depending on the replica would potentially not be able to access <em>any</em> of the data at that replica (at least until another replica was able to come and take its place).</p><p>This presents a new challenge with replication: while most of users can access all of our data through working replicas, for a <em>portion</em> of users, all of our data could be <em>completely unavailable</em> if the replica that those users are accessing <em>happens</em> to fail.</p><p>But what if we had a <em>very</em> large data set? One that would make us think twice before replicating it? This is where we might want to employ a different strategy…like partitioning our data!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XGr9rPymDV3tTokJhZhHfw.jpeg" /><figcaption>Where replication doesn’t fit the bill, partitions can save the day!</figcaption></figure><p>In some situations where a dataset is so large that it cannot all fit on a single node, we can opt to partition our data.</p><blockquote>Partitioning data across nodes means that our data is distributed across our nodes; no single node can contain all of our data. Conversely, if we wanted to retrieve all of the data, we’d need to go to every single node to get it.</blockquote><p>Depending on what a dataset looks like and what pieces of data are related to one another, it may make sense to lump certain types of data together onto a single node. For example, in a system that shows posts and the related comments on a page, it might make logical sense to always put the data for a post and all of its comments together on the same node, so that our users wouldn’t need to make <em>two</em> requests to fetch <em>two</em> kinds of data in <em>two</em> different nodes.</p><p>There are lots of strategies for determining what data should live on which node. Two terms that we might come across to describe this idea are <strong><em>sharding </em></strong>and<strong><em> fragmentation</em></strong>. Both terms are used interchangeably to describe the idea of partitioning a dataset across many different nodes (we won’t go into detail about the actual implementations of these techniques in this post).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zf8T4wV_404rmZEEL1Gm4g.jpeg" /><figcaption>Sharding/fragmenting data is a kind of partitioning!</figcaption></figure><p>The important thing to note here is that whenever we see the terms “sharding” or “fragmentation”, the context is usually a partitioned database (since databases are generally where our datasets will live!). Oftentimes, databases live on multiple servers and are distributed, themselves (pretty neat, right?). So, when we encounter a situation where a database is fragmented and split it into shards, what we are really dealing with is one big dataset that has been split into <strong><em>shards</em></strong>, or smaller sets/fragments, and have been distributed across nodes.</p><blockquote>A single database node contains just one portion of a larger dataset. When more data gets added or if the dataset changes significantly, it might need to be re-partitioned into new shards across all the nodes.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9VB8k_3RR6_8CHFYDZcdFA.jpeg" /><figcaption>Replication versus partitioning data.</figcaption></figure><p>So how does this fit in with our mental model of <em>replication</em>?</p><p>Well, to start, there is one major similarity to note here: both partitioning and replication improve the performance and reliability of our system. This is simply due to the fact that having more nodes — whether they are replicas that contain all the same data, or whether they are partitions that contains some of the data — mean that the load on a single node reduces! When we add more replicas OR partitions, we effectively spread out the incoming requests for data, which helps our system scale and makes it much more performant and available to our end users.</p><p>But what about the differences between these two strategies? Replication guarantees that our end user can <em>always read</em> our whole dataset, because all of the data lives on each replica. On the other hand, partitioning guarantees that <em>some</em> of the data will be retrievable, but there is no guarantee that our end user can always retrieve the data they need if one of the partitions fails!</p><p>Another difference between replication and partitioning are the things that make them difficult! Replication is hard because it’s tricky to maintain consistency between our replicas. Partitioning is hard for two reasons: first, if our dataset changes and we need to suddenly re-partition it…well, this is no easy task. Deciding how to divide up data takes time and effort, and we definitely don’t want to be re-partitioning it all the time! Second, depending on how it is implemented, it can sometimes be ineffective. For example, if we some highly-used data that is partitioned into <em>one</em> node, we actually end up in a <em>worse</em> situation than before we partitioned the data. Why is that?</p><p>Well, imagine that all of our end users suddenly request that highly-used data at once, and the node can’t handle the high load? Or what if that one database node with the highly-used data fails? Now our end users can’t access this important partition! So it’s up to us to consider all of these potential downsides when determining the tradeoffs of these two strategies. To avoid some of the heartache that’s associated with making these decisions, many production-level distributed systems will use replication when possible, and opt for partitions only when necessary.</p><h3>Dividing a network</h3><p>Now that we know the ins and outs of what it means to partition data, we have one last thing to unpack: the idea behind partitioning the network. Don’t feel too intimidated, though, this isn’t a completely new topic for us. In fact, I’ll let you in on a little secret, though — we’ve already seen the effects of a partitioned network!</p><p>We’ve learned about the <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">many</a> <a href="https://medium.com/baseds/modes-of-failure-part-2-4d050794be2f">different</a> failure modes in this series, and as it turns out, <strong><em>network partitioning</em></strong> is actually just one form of failure in a distributed system. It occurs when a network is split up into fragments, and subsequently creates sub-networks within itself. The important bit to call out here is that it is a <strong><em>network fault</em></strong> (also called a <strong><em>network split</em></strong>) that breaks the usual communication between nodes in the network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fyFcEQQbO3E2IN6_yKj3cw.jpeg" /><figcaption>What does it mean to partition a network?</figcaption></figure><p>However, this doesn’t mean that <em>all</em> the nodes in the network cannot communicate; the only ones that can’t communicate to one another are the ones surrounding the split. This means that if a network split occurs between two nodes, those two nodes can’t talk to one another, but they can continue to talk to other nodes that are not impacted by the split.</p><blockquote>When the node connection is interrupted by a network fault, it creates subnetworks that are “partitions” of the larger network — an unintentional division of the network, if you will.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Xdxi7h6jrhBKYJXRBZAvg.jpeg" /><figcaption>Network failures can partition the network into smaller subnetworks.</figcaption></figure><p>For example, in the drawing shown here, a <strong><em>network failure</em></strong> has caused a network partition (also called a <strong><em>fragmentation</em></strong>). The point of the fragmentation forces our network to be divided into two <strong><em>subnetworks</em></strong>, which we’ve named A and B. The nodes of subnetwork A can keep talking to one another, and the nodes of subnetwork B can keep processing data and sending information between themselves. However, any of the nodes between subnetworks A and B have been fragmented, which means that they can’t talk to one another! This means that subnetwork A cannot talk to or even know the <em>state</em> of subnetwork B (and vice versa).</p><p>Now, if this situation sounds bad, you’re right — it is! We don’t want our network to randomly break and cause parts of our system to be isolated from one another. Clearly, a partitioned network is something to avoid. However, do you remember back when we learned about the <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">8 Fallacies of Distributed Computing</a>? If we think back to fallacy #1 (<em>“The network is reliable.”</em>) and Fallacy #4 (<em>“The network is secure.”) </em>then we’ll come face to face with the hard truth: <strong><em>network partitions are unavoidable</em></strong>.</p><p>So what can we do? Well, we can design our systems to try to handle them gracefully when they (inevitably) happen! This is similar to the conclusion that we came to when we were learning about <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">fault tolerance</a>, and how we are forced to consider faults and try to design our systems to handle them. Similarly, when it comes to network partitions, we need to plan for <strong><em>partition tolerance</em></strong>, which is they way that we consider the potential network faults that might pop up, as well as the failures that they might cause! A partition tolerant system is one that has attempted to account for network partitions, since we’ll all run into them eventually.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WkGxVvTcBt-hZv_VpZ0O5Q.jpeg" /><figcaption>Partition tolerance is the ability to account for network partitions.</figcaption></figure><p>Although data partitions might be an avoidable problem to solve since we may not decided that we even need to partition our data, network partitions are something that we just cannot avoid. In fact, they’ll come up again later when start learning about some interesting…theorems. But that’s a story for another post! 😉</p><h4>Resources</h4><p>Partitioning and partition tolerance comes up quite often when learning more advanced distributed system topics, so it’s important to have a strong understanding of the fundamentals. Conveniently, there are some really great resources to help with this task. I’ve listed some of my favorites below, some of which get into even more advanced aspects of partitioning; check them out if you’re eager to learn more!</p><ol><li><a href="http://dimafeng.com/2016/12/04/distributed-systems/">Distributed systems cheat sheet</a>, Dmitry Fedosov</li><li><a href="https://medium.com/@Pranaykc/understanding-partitioning-in-distributed-systems-4ac3c8010fae">Partitioning: The Magic Recipe For Distributed Systems</a>, Pranay Kumar Chaudhary</li><li><a href="http://book.mixu.net/distsys/intro.html">Distributed systems for fun and profit</a>, Mikito Takada</li><li><a href="https://www.youtube.com/watch?v=uTJvMRR40Ag">Why are Distributed Systems so hard? A network partition survival guide</a>, Denise Yu</li><li><a href="https://www.youtube.com/watch?v=W1NmbcuomVM">Replication vs Partitioning</a>, Georgia Tech</li><li><a href="https://aphyr.com/posts/281-jepsen-on-the-perils-of-network-partitions">Jepsen: On the perils of network partitions</a>, Kyle Kingsbury</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c1723fecc4e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/parsing-through-partitions-in-a-distributed-system-3c1723fecc4e">Parsing Through Partitions in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redundancy and Replication: Duplicating in a Distributed System]]></title>
            <link>https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ab4322d7378</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 14 Aug 2019 12:01:01 GMT</pubDate>
            <atom:updated>2019-08-14T12:01:01.473Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LGqKQHW3Uf4saYuCrvTShA.jpeg" /><figcaption>Redundancy and replication: duplicating in a distributed system</figcaption></figure><p>When it comes to programming, there are certain conventions, idioms, and principles that we run into and reference as a community quite often. One of those principles is the idea of “Don’t Repeat Yourself”, or DRY for short. I encountered this idea early on in my programming career, and it seemed pretty straightforward to me at the time: in order to maintain clean, concise code, it was important to ensure that one didn’t repeat the same lines or logic in our codebase.</p><p>But over the years of my career, I’ve learned and seen more, and realized that that repetition is not so cut and dry —no pun intended! Sometimes, it actually does make sense to repeat yourself at the risk of over-engineering or over-abstracting something unnecessarily. Sometimes, it makes sense to just duplicate a function or piece of logic and just “copypasta” it into another file.</p><p>And when it comes to distributed systems, it often makes a lot of sense to have many of one thing! In fact, as we start to look at duplication as a concept in distributed computing, the more obvious it becomes that repeating ourselves can actually be a huge benefit to our system as a whole. So let’s dig into duplication in a distributed system, and try to understand why we’d ever want to do it.</p><h3>Repetition: sometimes a good thing?</h3><p>When we talk about “repeating ourselves” in the the realm of distributed computing, we can mean many different things. Repetition of a line of code or a piece of logic usually indicates that we have more than one thing that isn’t quite necessary. In a distributed system, we have a special term for this called <strong><em>redundancy</em></strong>, which is all of the resources in a system that are not necessary for the system to actually function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0FJC2NmKW1CocaJCMQY4EQ.jpeg" /><figcaption>What can redundancy include?</figcaption></figure><p>However, in distributed computing, we could potentially have a whole lot of different resources, which means that we have many different things that could potentially be repeated! Thus, redundancy can encompass many different kinds of extraneous resources.</p><p>For example, repeated calls to the same function from the different places in the system, or duplicated references/variables to the same data are forms of redundancy. Similarly, duplicated execution time in a function as well as extra memory, files, or processes are also redundant, since the system doesn’t actually need those duplicated resources to function correctly.</p><p>For the purposes of this series, we’ll focus on redundancy in the context of extra memory, files or processes, which is often called <strong><em>structural redundancy</em></strong>. In the context of a distributed system, some extra memory or file (read: a database) or an extra process all can be abstracted to a term that <a href="https://medium.com/baseds/many-nodes-one-distributed-system-9921f85205c4">we’re already familiar</a> with: nodes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qHPOziKmRFmrA34qaaRqTA.jpeg" /><figcaption>Redundant nodes: a definition.</figcaption></figure><p>A redundant node is any node that isn’t strictly necessary for the distributed system to function correctly. In other words, any node that adds to the bare minimum functionality of the system is extraneous, and we can therefore say that it is redundant.</p><p>Well, wait a minute — if we think about this a bit more deeply for a minute, we’ll probably realize that we duplicate a lot of stuff in a distributed system! We’ve talked about adding nodes to a system pretty loosely in this series, but all of the nodes that we add can’t all be <em>necessary</em> to the system, right? So, why did we even bother adding redundant nodes? Why would anyone<em> </em>want to be explicitly and intentionally redundant in their system? Well, in order to really answer that question, we need to move from the larger concept of redundancy to the more specific topic of replication<em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*crm5kpkSO67sh5vUVWanIQ.jpeg" /><figcaption>Redundancy versus replication</figcaption></figure><p>While redundancy is what allows us to duplicate the components of our system, the duplication itself isn’t really what is useful.</p><blockquote>Redundancy doesn’t actually help us if a redundant node is out of sync with the node that it was copied <em>from</em>.</blockquote><p>A redundant node on its own isn’t all that helpful; sure, we have achieved redundancy, but who knows how long that redundant node will actually be functional for us in our system? What happens if one of the nodes changes in value or state? As it turns out, the answer to both of these questions is replication! When we replicate a node in our system, these duplicate copies actually become much more functional for us.</p><h3>Duplication and maintaining state</h3><p>Replication as a concept is much of like a subset of redundancy. Both of them involve creating redundant nodes in a system — nodes that aren’t strictly necessary for the system to work correctly.</p><p>However, <strong><em>replication</em></strong> takes a redundant node one step further; it ensures that the redundant node (a <strong><em>replica</em></strong>) is identical to all of its other copies. At first glance, this might seem simple and perhaps even obvious; we might even assume that a node that has been copied from somewhere else will be identical to the thing it was copied from, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rvoAxWXAN9vXXPZq3TishA.jpeg" /><figcaption>Replicated nodes: a definition</figcaption></figure><p>Well, not necessarily! In fact, let’s say that we copied a node and created a redundant one. But later on, we change something about the original node — perhaps we change its state, some value that it contains, or some internal behavior. What would happen to the redundant node? Well…nothing!</p><p>If we created just a simple redundant node, there is nothing in place within our system that will ensure that the redundant node will 1) know that something changed and 2) will update itself or be updated by someone else to have the correct state.</p><p>So perhaps this problem is not as obvious as we first thought! Replication attempts to solve this problem, because it ensures that all replicas of a node will be identical to one another, and will match the original node that they were replicated from. (Side note: the question of <em>how</em> to ensure this is no easy task, but we’ll learn more about that later on in the series…)</p><p>Another important thing to note here is that replication comes hand in hand with <strong><em>transparency</em></strong>, a concept that <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-1-b01c25f7dddd">we’re already</a> <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">familiar with</a>. With each replica that is added to a system, the rest of the system should still function correctly, and should ideally be unaware of any replicas that have been created.</p><blockquote>If a replica is updated, the rest of the system shouldn’t know about it, and if a node is replicated, the rest of the system shouldn’t really care.</blockquote><p>For example, if a web server or a database node is replicated, the end users of the distributed system ought not to have any idea that are interacting with a replica or the original node. (In fact they probably shouldn’t have any idea that there even <em>is</em> a replicated node!)</p><p>When this transparency is mostly maintained in a system, replication provides us with a whole lot of benefits:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hKZ00TKnZLJ-_xFp__oBrQ.jpeg" /><figcaption>Some benefits of using replication in a distributed system.</figcaption></figure><ol><li>Replication of nodes makes our system is much more <strong><em>reliable. </em></strong>If one node goes down and we have already added replicas, it’s much more likely for a replica to step in and do the job of the failing node. This makes our system more <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">fault-tolerant</a>. Having replicas in place makes our system <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">more available</a> as well, since overall there are more backup replicas to step in to take another node’s place, which means that our system shouldn’t experience too much downtime.</li><li>Replication of nodes also makes our system more <strong><em>performant</em></strong>. With more replicas in place, we now have the ability to do more work, serve more requests, and process more data. This makes our system just generally faster, reduces latency, and allows the system to handle a high throughput of data that has to be processed/delivered.</li><li>Replication of nodes makes our system much <strong><em>easier to scale</em></strong>. Scalability is <a href="https://medium.com/baseds/scalability-growing-a-system-in-different-directions-ae16469c4cb3">a big plus point</a> when it comes to building a distributed system, but it’s not always easy to achieve. With more replicated nodes, it’s is easier to scale a system by adding more databases, servers, or services as required by the demands on the system. It’s also easier to geographically scale a system when we can replicate a node and place it in a different continent or country to help scale a high workload in a specific location.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MiIQbkt3qE6cjVpvc2P7MA.jpeg" /><figcaption>Reliability, performance, and scalability through replication</figcaption></figure><p>By this point, hopefully we’re all on board with the idea of replication (right?). It’s pretty cool and nearly every distributed system will take advantage and leverage this concept to help deal with issues of reliability, performance, and fault-tolerance. Whether in the form of workers, servers, databases, or services, we’ve probably each worked with replicas in our daily lives as developers! Sounds great, right?</p><p>Well, almost. The story doesn’t quite end here. Replication is awesome, but it presents some unique challenges unto itself. I can’t promise any solutions in this post (don’t worry, we’ll talk a lot more about this as the series goes on), but at the very least, I’ll present you with some of the problems. 😉</p><h3>Consistent headaches</h3><p>In addition to transparency, the concept of replication needs one other thing to really work well: <strong><em>consistency</em></strong>. In order for a replica to actually be up-to-date with all the other replicas in the system, it needs to be consistent with the other copies. And this is not a trivial task!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvbWNZPpVWhY8FuVYsUP_w.jpeg" /><figcaption>What makes replication hard?</figcaption></figure><p>Now perhaps, at first glance, this doesn’t seem too difficult. Maybe we could always have the replicas get updates from the original copy? Or maybe the original copy can tell the replicas whenever something else changes? However, this is tricker than it sounds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vqEXEw-wdu9cUcNOwOJjyA.jpeg" /><figcaption>It’s a struggle to maintain consistency as replicas change state!</figcaption></figure><p>We learned earlier that a system must also be transparent for replication to work. <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-1-b01c25f7dddd">Transparency</a> in <a href="https://medium.com/baseds/transparency-illusions-of-a-single-system-part-2-2b21c5047774">a system</a> means that all the replicas and the original node must behave similarly, which means that a consumer of the system (like an end user or another node) could potentially write to one replica, while another consumer of the system could read from <em>another </em>replica!</p><p>So, we can’t rely on just the original node anymore as our single source of truth when it comes to the state of our node(s). The question here is, of course, how do we tell these two replicas what just happened? The replica that is being read-from needs to know about the latest write; similarly, the replica that is being written-to needs to disperse information about that write.</p><p>This is exactly what makes replication so hard; we have to contend with consistency and figure out a model for how to ensure that all of our replicas. Thankfully, we’ll cover that in much more detail later. For now, we just need to know that it’s a problem that we’ll have to deal with soon. sUntil then, feel free to replicate your little hearts away!</p><h3>Resources</h3><p>Understanding replication and redundancy is a key step to wrapping our heads around how a distributed system grows. The topics in this series will continue to build on the idea of replication, so it’s important to understand it fully. If you’re looking for further resources, the ones listed below are some great places to start (or continue learning!).</p><ol><li><a href="https://pdfs.semanticscholar.org/87dc/8e839af0633b9f2968a669c5af70453cfe0b.pdf">Redundancy and Replication: Fault Tolerance on the System Level</a>, Kurt Kanzenbach</li><li><a href="http://www8.cs.umu.se/kurser/5DV147/HT15/lectures/l8-handouts.pdf">Distributed Systems: Replication</a>, Umeå University</li><li><a href="https://www.uio.no/studier/emner/matnat/ifi/INF5040/h16/pensumliste/replication.pdf">Replication in Distributed Systems</a>, Roman Vitenberg</li><li><a href="https://www.cs.helsinki.fi/webfm_send/1256">Distributed Systems: Replication and Consistency</a>, Jussi Kangasharju</li><li><a href="http://csis.pace.edu/~marchese/CS865/Papers/wiesmannWPS+00.pdf">Understanding Replication in Databases and Distributed Systems</a>, Schiper &amp; Alonso</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ab4322d7378" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/redundancy-and-replication-duplicating-in-a-distributed-system-7ab4322d7378">Redundancy and Replication: Duplicating in a Distributed System</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Foraging for the Fallacies of Distributed Computing (Part 2)]]></title>
            <link>https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-2-b8ff29beed56?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ff29beed56</guid>
            <category><![CDATA[code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 07 Aug 2019 12:16:01 GMT</pubDate>
            <atom:updated>2019-08-07T12:16:01.900Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d2wbpLCXgXQRfsNLruq5_A.jpeg" /><figcaption>Foraging for EVEN MORE fallacies of distributed computing!</figcaption></figure><p>So much of what makes distributed systems hard to content with is the fact that, as a system grows, it changes. Furthermore, the things around the system — parts of the system itself, its dependencies, and the people who maintain it — are also each capable of changing as well.</p><p>In part one of this series, we looked into <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">the first four</a> of the famous eight fallacies of distributed computing. Conveniently, those four fallacies all centered around the network, and the misconceptions and falsehoods that many developers can fall prey to when they are dealing with a distributed system. But in part two of this series, we’re going to zoom out a bit and look at the remaining four fallacies, which feel far more abstract in nature, in my opinion.</p><p>What’s interesting to me about the second half of the fallacies is the fact that they almost seem obvious to us at first glance. You may even read them and think to yourself, <em>“how could anyone ever assume this fallacy to be true?”.</em> But as we’ll soon see as we dig into each of them, there’s more to each fallacy than meets the eye. And keeping these big-picture truths in check as we design a simple system or a complex one is harder to do than we might think. So let’s dive right in and finish up our foraging for fallacies!</p><h4>Rearranging the network</h4><p>As we already know, nodes in a distributed system must communicate via messages, which are sent through a network. However, that network is a changing, fluctuating entity. If a node is added to network, it inherently will look a little different, right? We have a new character on the stage, and the way that the network looks or how it is arranged differs depending on which nodes are involved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gdOAEwrbXa9H1Yj6a-IBrw.jpeg" /><figcaption>Topology: a definition of what it means in a network.</figcaption></figure><p>As it turns out, there’s a term for this concept, and it’s high time that we familiarized ourselves with it: <strong><em>topology</em></strong>. A network’s topology is the way that the elements in the network are laid out or arranged.</p><blockquote>Topology illustrates the way that the nodes in our distributed system relate or connect to one another, and more importantly, how they communicate with one another.</blockquote><p>For example, we could have a set of nodes in a network that are connected and communicate with one another in a ring shape, or we could have all the nodes connected in a line. Or, like in the example above, the nodes could be connected in star shape, or perhaps they could be arranged in a tree shape. All of these different examples are valid ways to lay out the nodes in a network, and each of them are different topologies.</p><p>Understanding the concept of a topology is essential to us grappling with fallacy five: <strong>Topology doesn’t change.</strong> Remember that this is a <em>fallacy</em>, which means that it is a misconception; in other words, this statement is untrue, and the topology of a network <em>does</em>, in fact, change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WJuTy1z6Y2v_8xA6oFGQxQ.jpeg" /><figcaption>Fallacy #5: Topology doesn’t changes (it does!)</figcaption></figure><p>At the surface, this statement might seem obvious; any time that we add, replace, or remove a node from our network, the way that the elements (nodes) of that network are arranged and how they relate to one another is invariably going to have to be flexible and move around to be able to handle these changes. Given what we know about how nodes can be <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">flawed</a> and how they <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">will</a> <a href="https://medium.com/baseds/modes-of-failure-part-2-4d050794be2f">fail</a>, we also can be sure that the frequency with which a new node might be added or an old node might be removed or replaced is going to be fairly consistent and high. In other words, the network’s topology is always going to be in flux and fluid!</p><p>So why is this otherwise obvious fallacy something worth noting here? Well, what makes this fallacy tricker than it seems is the fact that most of us just don’t think about the obviousness of it on a day-to-day basis. We often depend on the network behaving a certain way and doing certain things. Sometimes, we explicitly depend on the topology of the network being arranged in a certain way. For example, if our system sent messages every 30 seconds to a node in the system, and expects that node to exist at a certain location in the network, what happens if that node disappears? Or what if it moves?</p><p>If we depend on our network always “looking” a certain way, and if we expect for its nodes to always be <em>arranged</em> a certain way, we fall into the trap of this fallacy. And this can be an easy assumption to make, especially if we don’t take this fallacy into to account in our daily interactions as designers and maintainers of a distributed system! So, it’s up to us to consider the ways that we might be relying — even if inadvertently — on the topology of our system’s network.</p><h4>System management realities</h4><p>Assumptions are very easy things to make — we make them all the time! Not only can we make bad assumptions about our system and what it looks like and how it will behave in certain circumstances, but we can also make bad assumptions about who will be maintaining and dealing with that system at any given time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*46sgtw7hFKKIF9EUAz0qPA.jpeg" /><figcaption>Fallacy #6: There is one administrator (there almost certainly are more!).</figcaption></figure><p>This is brings us to fallacy six: <strong>There is one administrator. </strong>In nearly all real-life scenarios, there is usually <em>more</em> than one administrator of a distributed system. With the exception of very small applications — or perhaps a system that is a toy/hobby project that only has one person building and maintaining it — most systems end up with many people involved in the maintenance of the system.</p><p>Assuming that only one administrator exists to maintain a distributed system can have long term side-effects. For example, imagine a system where three administrators are helping to keep the system up and afloat. What happens if one of those administrators — who just so happens to be an expert in one of the aspect of the system — leaves the team? Or, what if one of the parts of the system is actually a dependency and part of an external service?</p><p>In both of these situations, one part of the system is likely under the control of someone else, and we have to consider what we’ll do if that section of the system needs maintenance, or what will happen (and who will fix the problem, not to mention how quickly) if that section of the system goes down!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V4b8VUD2y_gq2puhUGBRBw.jpeg" /><figcaption>The many aspects of maintain a system as an administrator.</figcaption></figure><p>The sixth fallacy is really important to keep in mind (and it’s so easy to forget about entirely!). We already know that regular tasks like maintaining and upgrading a system <a href="https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c">are responsible</a> for causing a great deal of software bugs. So when a system has many administrators, it’s our responsibility to make sure that the system can still be easily upgraded and maintained as more and more admins are added to the mix. Similarly, if our system depends on a third-party service, we need to consider who those external administrators are, and how we’ll handle an external dependency that needs attention.</p><p>We also need to be sure to have a way to empower all administrators of a system to debug and diagnose different parts of the system. This last piece of the puzzle is especially important, because administrators can make important decisions — like restarting a node, limiting a quantity of data, or deciding what protocols to use — and those decisions are crucial to managing a system and keeping it running correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dQ81EJDyfVzhV9xcbZeVbA.jpeg" /><figcaption>Fallacy #7: Transport cost is zero (it is not!)</figcaption></figure><p>Another “easy to dismiss” assumption is the reality of the cost of running a system. This leads us right to fallacy seven: <strong>Transport cost is zero.</strong> As we learned with <a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">fallacy two</a>, it takes time for data to travel from one place to another; another name for this amount of time is <em>latency</em>. Similarly, the cost of sending data from one place to another also has other costs, too!</p><p>For example, it takes <strong><em>resources</em></strong> to be able to transport any data from one place to another within a distributed system. These resources have a price tag attached to them, and these resources cost money.</p><p>Additionally, sending data from one place to another also takes some effort and time to turn the data into a machine-readable code (and subsequently, back out of machine-readable code into data again). These processes are known as <strong><em>serialization</em></strong> and <strong><em>deserialization</em></strong>, and all data that is passed around in the system needs to be serialized and deserialized from a byte stream into some object in memory that is used to represent that data. Many developers are familiar with serialization and deserialization and use it every day; however, not all of us are necessarily considering the time and effort that these two processes take whenever they happen!</p><p>The fact that it costs time, effort, and resources remind us that it is not free to send data through our system and transport information back and forth. However, it can be easy to forget this until we get an unexpected bill from AWS or Heroku, at which point we suddenly remember this reality. Keeping this fallacy in mind is especially important as our system scales and our transport costs start to creep up on us.</p><h4>Standardization of a system</h4><p>The final fallacy is one that many of us may not have ever thought about, particularly if we have been working with frameworks and systems that have already been around for some time. The eighth fallacy brings us back to our good old friend, the network: <strong>The network is not homogeneous.</strong> Many of us probably know this fallacy to inherently be false: the nodes in a network can be anything, so there is no guarantee that they will all be the same!</p><p>In fact, most distributed systems may integrate with different kinds of devices, perhaps different protocols, and almost certainly will adapt to work with various operating systems and browsers. And because the nodes of our network(s) aren’t going to all look the same, it’s not always safe to assume that they will all be configured the same, either.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BtcXMQvWn3e-pcvwITVl3A.jpeg" /><figcaption>Fallacy #8: The network is homogeneous (it isn’t if we don’t use standards).</figcaption></figure><p>Indeed, most networks are heterogenous, but the nodes in a system’s network still need to work together and be interoperable. Conveniently, however, most of us don’t need to fear this fallacy; this is where <strong><em>standardization</em></strong> comes in to save the day! Most systems these days are architected to rely upon and utilize standardized formats that are created to create a shared language amongst different elements in a system, even if they perhaps aren’t all configured the same.</p><p>Many of us use these standards — like HTTP protocols, REST APIs, and JSON-formatted data — on a daily basis, and these standards make it much easier to deal with a heterogeneous network. But it’s still important to remember this fallacy in the off chance that one day, we find ourselves building a part of a system that isn’t using a standardized format! Rolling a proprietary protocol of one’s own means that, down the road, there will most likely be another node that will be incompatible with our non-standard format.</p><p>In fact, I think it’s worth thinking about all eight fallacies, even if we are working with systems that have been built so that we don’t need to consider these issues. Just because we don’t run into these fallacies on a daily basis doesn’t mean that they’re not powerful! In fact, they can sneak up on us just when we’re not looking, and prove that even the most experienced distributed systems engineers can make bad assumptions.</p><h4>Resources</h4><p>The fallacies of distributed computing have been fairly well-written about, and you can find some good resources on different interpretations of them, for different technologies. If you’re curious to learn more, check out the resources below!</p><ol><li><a href="https://www.rgoarchitects.com/Files/fallacies.pdf?source=post_page---------------------------">Fallacies of Distributed Computing Explained</a>, Arnon Rotem-Gal-Oz</li><li><a href="https://www.simpleorientedarchitecture.com/8-fallacies-of-distributed-systems/?source=post_page---------------------------">Understanding the 8 fallacies of Distributed Systems</a>, Victor Chircu</li><li><a href="https://multimedia.telos.com/blog/debunking-the-8-fallacies-of-distributed-systems-part-2/?source=post_page---------------------------">Debunking the 8 Fallacies of Distributed Systems</a>, Ramil Alfonso</li><li><a href="https://www.youtube.com/playlist?list=PL1DZqeVwRLnD3EjyciYAO82dT9Owiq8I5&amp;source=post_page---------------------------">Fallacies of Distributed Systems</a>, Udi Dahan</li><li><a href="https://blog.newrelic.com/engineering/the-fallacies-of-distributed-computing-reborn-the-cloud-era?source=post_page---------------------------">The Fallacies of Distributed Computing Reborn: The Cloud Era</a>, Brian Doll</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ff29beed56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-2-b8ff29beed56">Foraging for the Fallacies of Distributed Computing (Part 2)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Foraging for the Fallacies of Distributed Computing (Part 1)]]></title>
            <link>https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b35c3b85b53</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Fri, 21 Jun 2019 04:15:25 GMT</pubDate>
            <atom:updated>2019-06-21T04:15:25.723Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Tc61g8f7tKwW2Kka6EOqg.jpeg" /><figcaption>Foraging for the fallacies of distributed computing!</figcaption></figure><p>So much of computing is based on assumptions. We design systems operating on a set of assumptions. We write programs and applications assuming certain parts of their systems will work a certain way. And we also assume that some things can potentially go wrong, and we (hopefully) attempt to account for them.</p><p>One big issue with building computer-y things is that, even though we’re often dealing with complex systems, we aren’t always capable of reasoning about on a big-picture level. Distributed systems are certainly a great example of this (you knew where I was going with this, didn’t you?). Even a “simple” distributed system isn’t so simple, because by definition it involves more than one node, and the nodes in the system have to communicate and talk to one another through a network. Even in a small distributed systems with just two nodes, we make certain assumptions about how that system is going to work.</p><p>Here’s the thing about making assumptions, though: they can be wrong! As it turns out, there are some common, incorrect assumptions that we often make about distributed computing. In fact they are so ubiquitous that they have a name! I’m talking, of course, about the eight fallacies of distributed computing. And what are they? Well, it’s time to find out.</p><h4>Assumptions gone wrong</h4><p>The eight fallacies as we know them today actually started off as just four fallacies, which are the ones that we’ll cover in this post. The first four fallacies were created in the early 90’s (sometime after 1991) by two Sun Microsystems engineers, Bill Joy and Dave Lyon.</p><p>James Gosling, who was a fellow at Sun Microsystems at the time — and would later go on to create the Java programming language — classified these first four fallacies as “The Fallacies of Networked Computing”. A bit later that decade, Peter Deutsch, another Fellow at Sun, added fallacies five, six, and seven. In 1997, Gosling added the eighth and final fallacy. So much of the work done to codify this list was inspired by work that was actually happening at Sun Microsystems at the time. And while Deutsch is the one who is often credited with having “created” the eight fallacies, clearly it was a combined, group effort (as is so often the case in computing!).</p><p>Alright, so now that we’ve got some history under our belt, let’s get into some of the practical aspects of this problem. Let’s first start with understanding what we’re talking about when we say a “fallacy” of distributed computing. What does that mean, exactly?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TGWX6UuLFqWmsd8qQpyk0g.jpeg" /><figcaption>What exactly IS a fallacy when it comes to distributed computing?</figcaption></figure><p>Well, a <strong><em>fallacy</em></strong> is a kind of assumed fact or belief; however, even though it is assumed to be true, that is usually not the case in practice. A fallacy is just a belief that is a misconception. But what does that mean in the context of computing? Well, a fallacy made about a distributed system is an assumption about the system made by the developers, which often ends up being inaccurate and wrong in the long run. In other words, they are bad assumptions to make.</p><blockquote>We can think of the eight fallacies as eight common misconceptions that developers of distributed systems often fall prey to, which we want to avoid.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ixg3-ycukOvRQHUk2fR6w.jpeg" /><figcaption>The 8 fallacies of distributed computing</figcaption></figure><p>So, let’s take a look at these eight fallacies, shall we?</p><p>The eight fallacies of distributed computing are as follows:</p><ol><li>The network is reliable.</li><li>Latency is zero.</li><li>Bandwidth is infinite.</li><li>The network is secure.</li><li>Topology doesn’t change.</li><li>There is one administrator.</li><li>Transport cost is zero.</li><li>The network is homogenous.</li></ol><p>In this post, we’ll focus just on the first four fallacies, which we now know were the original “Fallacies of Networked Computing”! Conveniently, these first four fallacies are actually all anchored around one central, key character: the network. And, as we’re about to see, the network is a tricky little fellow. Of course, it’s kind of difficult to have a distributed system without a network so we have to get used to dealing with this tricky character.</p><p>Let’s learn about what makes the network hard to contend with, and why some of these fallacies are easy to assume.</p><h4>The trouble with networks</h4><p>Our distributed systems, no matter how complex or involved they are, all exist within a network. The nodes of our system have to talk to one another and send and receive messages to communicate and deliver data. Because the system is distributed, parts of it will live in different places, and the network is the anchoring point by which the components of the system will communicate.</p><p>This brings us to fallacy one: <strong>The network is reliable.</strong> Remember, these are fallacies that we’re dealing with, so the network being reliable is a true misconception; the network is <em>not</em> reliable!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ei18Fpm1eaxPkrIM00kiGw.jpeg" /><figcaption>Fallacy #1: The network is reliable (it is not).</figcaption></figure><p>So many things within a network can go wrong. Hardware can fail, the power can go out, the signal could get spotty, or the network could even become compromised! It might seem obvious that a network isn’t reliable, but as designers of a distributed system, we can sometimes forget this when we are writing code that is going to run on a distributed system. We write that code perhaps operating under this assumption, but when the network inevitably becomes <em>unreliable</em> at some point down the road, we realize that we made a bad assumption and it ends up affecting our system adversely. Thus, it becomes our job to keep this fallacy in mind and not forget that the network cannot be relied upon.</p><p>Now, before we get too much further into networks — not to mention the fallacies associated with them — there are some important terms for us to learn. When we talk about messages being sent through a network, we’re usually referring to data being sent across the network. But we can talk about data and the way it is sent in two different ways: latency and bandwidth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qdUw3Akkwl_YOZ2AnlvT-g.jpeg" /><figcaption>Latency versus bandwidth</figcaption></figure><p><strong><em>Latency</em></strong> is the measure of how <em>delayed</em> some data is to arrive, based on wherever it was sent. We can think of latency as the speed at which our data travels from one place to another, or how long it takes for the data to arrive from node A to node B in our system. Latency is a concept that many developers may already be quite familiar with, because we often refer to the latency of data in the context of milliseconds. For example, if it took a request 400 milliseconds to be served from a server (node A) to a client (node B), we can say that the latency of that data being sent was delayed by 400 milliseconds, or that it took 0.4 seconds for the message travel from the server to the client. Many performance-minded developers are often thinking of latency when they consider what to optimize or improve in their applications or systems.</p><p><strong><em>Bandwidth</em></strong>, on the other hand, is a measure of how much data can be sent from one point to another in a certain period of time. We often talk about bandwidth in the context of internet speed (for example, megabits per second or Mbps) because we’re referring to how much data can be sent over our specific network, or the capacity of our network to send some amount of data in a given span of time.</p><p>While latency is the actual speed at which data gets to its destination via the network, bandwidth is the capacity of network to send a certain amount of data to its destination. Understanding the difference between these two concepts is important to wrapping our heads around the second and third fallacies, so let’s learn about those two next!</p><h4>Some fallacies hurt more than others</h4><p>Now that we know what “latency” actually means, we are better equipped to understand fallacy two: <strong>Latency is zero</strong>. Unfortunately, this is also a misconception.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bteSk48jIOALvyM1XNO8Wg.jpeg" /><figcaption>Fallacy #2: Latency is zero (it is not).</figcaption></figure><p>This is perhaps an easy fallacy to fall prey to since, in our local environments or in the development environment, we may experience a much lower latency; in other words, we likely experience a short amount of delay time when it comes to sending or receiving data. However, that low local latency doesn’t accurately reflect the delay of what other parts of the system might feel — especially given different networks.</p><p>We’ve <a href="https://medium.com/baseds/scalability-problems-hidden-challenges-of-growing-a-system-f74313b063c3">already learned about</a> local-area networks (LAN) and wide-area networks (WAN). We know that in a WAN, data has to travel further from one node to another, since the network may span large geographical distances. This is in contrast to a LAN, which is a network with devices in the same building or room, and thus the data being sent around has much less of a distance to travel.</p><p>We cannot assume that our system will always operate on a local-area network (in fact, most distributed systems operate on a WAN), and thus we know that our data has a physical distance to travel. By proxy, we should not assume that there will be no “delay” or zero latency between some data being sent and that data being received. For example, a request that has to travel across the world from Portland to Paris will have more latency than a request traveling from a machine in one room to another.</p><blockquote>Some latency is a limitation of networks; we should be wise to not build a system that assumes that such a delay is nonexistent. We will certainly be bitten by such a false assumption in the future.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nnW5YovYJB784NzVKhBwFQ.jpeg" /><figcaption>Fallacy #3: Bandwidth is infinite (it is not).</figcaption></figure><p>The third fallacy is similar to this false assumption as well: <strong>Bandwidth is infinite.</strong> Just as latency is not zero, the capacity of a network to send data is not unlimited. As computing technology has improved over the years — and certainly since the early 90’s when the Fallacies were coined — the bandwidth of our networks keeps getting better and better, and we’re able to send more data across our data in a given amount of time.</p><p>However, even with these improvements, networks still don’t have <em>unlimited</em> capacity and cannot send infinitely large amounts of data. When we design a distributed system, it would behoove us to not assume that any amount of data can be sent across the network. For example, we may have some user of our system that has a network with a limited bandwidth and a lower capacity; for that user’s experience, sending a large amount of data (such as large images or vendored, dependent files) would mean that we’d be sending far more data than their network was capable of sending over the network in a reasonable amount of time.</p><p>Finally, we come to fallacy four, which is personally just my favorite one: <strong>The network is secure.</strong> There are just simple so many ways that a network can be attacked or compromised, from unencrypted messages to vulnerabilities in dependencies to open source code, or even just bugs in third-party softwares that our system might depend on (not to mention bugs in our own systems, too!).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O_okCt0GXJmhPM71CaKLhg.jpeg" /><figcaption>Fallacy #4: The network is secure (it DEFINITELY is not!).</figcaption></figure><p>The misconception that the network is “secure” is a hard one to overcome, since, if we really start to think about it, no network is really secure. Indeed, the only way to truly protect our networks and be 100% secure is to just not connect to the network! Of course, because we are dealing with distributed systems…this isn’t really easy to do, since we know that a network is required for communication between nodes in our system.</p><p>So, what are we to do? Well, we can try to remember that <em>true</em> security is a fallacy, and that we can just do what is in our power to try to prevent breaches and attacks when we design, build, and test our systems. Hopefully, at least that’ll keep the security issues at bay for awhile.</p><p>In part two of this post, we’ll look at the remaining four fallacies. I promise that the sad little blue network blob will make a return appearance! We’re not done with it just yet.</p><h4>Resources</h4><p>The fallacies of distributed computing have been fairly well-written about, and you can find some good resources on different interpretations of them, for different technologies. If you’re curious to learn more, check out the resources below!</p><ol><li><a href="https://www.rgoarchitects.com/Files/fallacies.pdf">Fallacies of Distributed Computing Explained</a>, Arnon Rotem-Gal-Oz</li><li><a href="https://www.simpleorientedarchitecture.com/8-fallacies-of-distributed-systems/">Understanding the 8 fallacies of Distributed Systems</a>, Victor Chircu</li><li><a href="https://multimedia.telos.com/blog/debunking-the-8-fallacies-of-distributed-systems-part-2/">Debunking the 8 Fallacies of Distributed Systems</a>, Ramil Alfonso</li><li><a href="https://www.youtube.com/playlist?list=PL1DZqeVwRLnD3EjyciYAO82dT9Owiq8I5">Fallacies of Distributed Systems</a>, Udi Dahan</li><li><a href="https://blog.newrelic.com/engineering/the-fallacies-of-distributed-computing-reborn-the-cloud-era">The Fallacies of Distributed Computing Reborn: The Cloud Era</a>, Brian Doll</li><li><a href="http://www2.sys-con.com/itsg/virtualcd/java/archives/0901/ingrid/index.html">Deutsch’s Fallacies, 10 Years After</a>, Ingrid Van Den Hoogen</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b35c3b85b53" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/foraging-for-the-fallacies-of-distributed-computing-part-1-1b35c3b85b53">Foraging for the Fallacies of Distributed Computing (Part 1)</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Weeding Out Distributed System Bugs]]></title>
            <link>https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c?source=rss-8f55993c973e------2</link>
            <guid isPermaLink="false">https://medium.com/p/28a01e37f70c</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Vaidehi Joshi]]></dc:creator>
            <pubDate>Wed, 05 Jun 2019 12:31:00 GMT</pubDate>
            <atom:updated>2019-06-05T12:31:00.920Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ehnuc3UmsGJQT3dFDsTM6Q.jpeg" /><figcaption>Weeding out distributed system bugs</figcaption></figure><p>As we’ve learned more and more about distributed systems, we’ve seen the many ways that things can wrong. More specifically, we’ve seen that there are just <em>so many </em>possible scenarios<em> </em>in which a portion of a large or system can fail.</p><p>Since failure is inevitable in any sized system, we ought to do ourselves a failure and better understand it. So far, we’ve been talking about different kinds of <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">faults</a> and <a href="https://medium.com/baseds/modes-of-failure-part-1-6687504bfed6">failures</a> in a fairly abstract sense. It’s time for us to get a little more concrete, however. Sure, we vaguely understand the different flavors and profiles of how things can go wrong within a system, and why they are problematic (yet inevitable) within our system. But how can we start to understand these flaws in a system in a more tangible form?</p><p>In order to do that, we need to think more deeply about the different ways in which failures present themselves to us in the systems that we all deal with every day, as both consumers and creators of software. For most of us, failures in our systems present themselves as bugs. The ways in which a bug might <em>appear </em>to us, however, can make all the difference in how we are able to understand it in a more concrete way.</p><p>So what kinds of bugs do we deal with, exactly, and how do they impact the failures of a distributed system? Well, that’s the mystery we’re about to solve!</p><h4>(Hardware) failures of the past</h4><p>Before we dive into identifying the bugs of today, let’s take a quick detour into the past. It’s easy to get overwhelmed when thinking about failures and faults in a system, so before we get too deep into the trenches, we ought to take a moment to see how the landscape of bugs in computing have changed over the years.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaEFi-yCaBLE-CjbGjshDg.jpeg" /><figcaption>What is hardware reliability?</figcaption></figure><p>Until the 1980’s, the major focus of computing was around hardware. More specifically, much of the field was focused on how to make hardware just generally <em>better</em>. This was simply because hardware was the major limiting factor in many ways. For example, if we wanted to make a machine faster and more performant back then, we needed bigger hardware; that was the only way to have enough space for all the circuits we needed! And if we wanted more circuits — which were each already pretty large and lofty in size —then we also needed to be prepared for them to use a lot of power and exude a lot of energy and heat.</p><p>These issues begin to highlight some of the clear possible faults that could have popped up within a system just a few decades ago. As <a href="https://medium.com/baseds/fantastic-faults-and-what-to-call-them-56d91a1b198c">we already know</a>, hardware faults — such as a circuit overheating, or a network wiring issue causing a widespread outage—are what lead to hardware failures. If any aspect of the hardware fails, then that failure will likely cause some form of downtime in a system, which we know <a href="https://medium.com/baseds/ready-and-available-distributed-systems-161023aca378">makes a system less reliable</a>. Until the 80’s, hardware faults were very much a real and common problem.</p><p>But these days, the story is a little different. We experience far less downtime due to hardware faults than we did just forty years ago. We have many years of concentrated effort that has helped improve the hardware we all rely upon on a daily basis now! In the past three decades, the size of circuits has decreased, allowing us to pack more circuits into a smaller space, and those circuits produce less heat, and use much less energy. Circuits have also become easier and cheaper to produce, making them more inexpensive in general. This has also allowed us to create smaller devices, like laptop computers, tables, and smartphones, to mention just a few.</p><p>This doesn’t mean that there are <em>no </em>hardware problems whatsoever, though! Even small devices with smaller circuits inside of them will experience hardware failures. Network issues that cause downtime are still likely to happen, even though the frequency with which they occur has definitely dropped off. Hardware disks are still prone to failures, which makes it tricky to read (much less write) data to them. And, of course, just because hardware has improved doesn’t mean that it doesn’t require maintenance and upgrades; since these are still requirements, they will still result in planned downtime.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qlr_ciosJeVs5rAnRMMvMA.jpeg" /><figcaption>How has hardware changed?</figcaption></figure><p>Overall, however, the changes we’ve seen in hardware have been quite a net positive for computing. So, if hardware has improved…what else could be a contributing factor to failures in a distribute system? Why, our dear friend <em>software</em>, of course!</p><blockquote>Even in the most well-tested systems, software failures are responsible for a significant amount of downtime. We know these “failures” by another name: bugs.</blockquote><p>Improvements in hardware notwithstanding, it is bugs in the software of distributed systems that result in unexpected and unplanned downtime. Many studies estimate that, 25 to 35% of the downtime in a system are caused by bugs in software-related code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WweBifHpUawcvKCNbsRiPg.jpeg" /><figcaption>Software failures as a major pain point in a distributed system</figcaption></figure><p>The interesting aspect of this story is the fact that, even within systems that are fairly well-established and have rigorous testing practices in place, studies have found that the actual percentage of software-related downtime doesn’t really <em>ever</em> <em>reduce</em> beyond that 25% threshold! There are just some bugs that still seem to exist, even with well thought-out tests and quality control.</p><h4>(Software) problems of the present</h4><p>The bugs that still exist in more mature systems — those that have rigorous testing, for example — are also known as <strong><em>residual bugs</em></strong>, and they can be classified into two separate categories:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k3DJCaXP_QYa1MA5CHiDWw.jpeg" /><figcaption>The two main kinds of “residual” software bugs</figcaption></figure><ol><li><strong><em>Bohrbugs</em></strong>, which are named for Niels Bohr and Ernest Rutherford’s model fo the atomic nucleus, and</li><li><strong><em>Heisenbugs</em></strong>, which are named as a pun on Werner Heisenberg’s Heisenberg uncertainty principle.</li></ol><p>These two bugs have been researched by many different computer scientists; three of the most notable ones include Jim Gray, Bruce Lindsey, and Andrea (“Anita”) Borr, and we’ll read about the fruits of their labor in a little bit. Between these two different kinds of “residual” bugs, one is definitely way easier to wrap our heads around than the other. So let’s start with that one first!</p><p>The <strong><em>Bohrbug</em></strong> is a bug that most (all?) programmers will encounter while tinkering with software. A Bohrbug is a bug that can reliably be reproduced, given the right conditions. For example, if we were able to notice that a bug occurred in a piece of software and closely observed the situation in which it happened, if it was a Bohrbug, then would be able to reproduce it by re-creating the same situation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AfUpfIUg8LbCjiYXMUum1Q.jpeg" /><figcaption>Bohrbug: a quick definition!</figcaption></figure><p>A Bohrbug is pretty easy to localize and pinpoint to a certain part of a codebase. As developers, this is a huge boon, since it means that we can reliably find and then <em>fix</em> the Bohrbug, as annoying as it might be!</p><p>Interestingly, when Jim Gray and Bruce Lindsey were researching Bohrbugs in more mature systems, they posited that the frequency of these reproducible little bugs actually reduced as a system grew older and more stable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LesnUjIMhpvlKUIxp6rBVQ.jpeg" /><figcaption>Bohrbugs in a system, over time</figcaption></figure><p>However, Anita Borr’s research added a bit more nuance to this. She found that the percentage of Bohrbugs didn’t strictly continue to drop as a system grew more stable; rather, her research found that, with each new upgrade or scheduled maintenance that was introduced into the system, there was also a slight uptick of Bohrbugs, since significant changes in the system were still very capable of introducing <em>reproducible</em> bugs.</p><p>Thankfully, even though new Bohrbugs might be introduced with these system-wide changes, at least they can be reproduced (and hopefully, fixed!). But things aren’t always that simple in the world of software (of course). Some bugs don’t always behave the same…in fact, some of them seem to behave differently when we try to investigate them!</p><h4>Dealing with difficult, distributed bugs</h4><p>There is one species of bug that is particularly relevant to distributed systems, and it’s finally time for us to come face-to-face with it in this series. I’m talking, of course, about the Heisenbug!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ap4jEguoPLwOlxyQQnhIuA.jpeg" /><figcaption>Heisenbug: a quick definition!</figcaption></figure><p>A <strong><em>Heisenbug </em></strong>can be super frustrating to deal with as a programmer. This is a bug that actually behaves <em>differently </em>when it is observed closely. As one begins to investigate a Heisenbug, it may change how it manifests itself. In some cases, when a Heisenbug is, well, being debugged, it disappears completely. And in some situations, when certain conditions are recreated in an effort to reproduce the bug, the bug just won’t appear! Pretty frustrating, right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hiJKlkfgG83WkTT21UitqA.jpeg" /><figcaption>What makes Heisenbugs so hard?</figcaption></figure><p>For example, a bug such as a data structure running out of space or a portion of a program that overflows some allocated memory in a production environment might not be to easily reproduce locally or in a test; however, this exact bug could cause a system to crash, and is pretty fatal!</p><p>This is part of the reason that makes Heisenbugs so difficult to reason about. They are incredibly hard to actually <em>reason</em> about, because it’s hard to actually localize them and pin them down. And, because they’re hard to reproduce <em>reliably</em>, they’re hard to identify and thus, difficult to actually solve!</p><p>The Heisenbug is especially relevant to distributed systems because they’re more likely to occur in a distributed system than in a localized, central one. These kinds of bugs are actually indicators of problems and failures in the system that occurred much <em>earlier</em> than when the bug manifested itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ButZLrPKDFlXg56aNXqaeQ.jpeg" /><figcaption>Heisenbugs are much more common in distributed systems.</figcaption></figure><p>A Heisenbug is usually a red flag that something <em>else </em>went wrong in the system awhile ago, and it is only surface now, and it only just so happens that it is surfacing in the form of this bug.</p><blockquote>In actuality, a Heisenbug is just a long-delayed side effect of a much earlier problem.</blockquote><p>In more mature distributed systems, it is Heisenbugs — <em>not </em>Bohrbugs — that cause major failures and system crashes. If we think about it more deeply, this starts to make sense; there are many moving parts in a distributed system, and many dependencies and nodes that rely upon one another. A failure that appears to be coming from <em>one</em> node in the system might actually be three nodes removed from a failure that originated elsewhere, but propagated throughout the system. While a Bohrbug might be easy to reproduce, localize, and reason about, a Heisenbug is much tricker to think about and thus, to fix.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cvFr727zC4a4ddkaqBS3Qg.jpeg" /><figcaption>Heisenbugs in a system, over time</figcaption></figure><p>Anita Borr — my new favorite researcher on residual bugs — actually found in her research that many engineers have a hard time reasoning about Heisenbugs, and that making attempts to <em>fix</em> a Heisenbug actually cause more problems than there were to begin with! So if you’ve been feeling like Heisenbugs are tricky little creatures and hard to contend with, don’t worry; the research agrees with you!</p><h4>Resources</h4><p>Software failures in distributed systems are pretty cool to learn about, and you can learn a whole lot more about them. There is a lot of interesting research and writing on how to deal with and guard against Heisenbugs in your system. Check out some of the resources below if you’re curious to learn more!</p><ol><li><a href="https://books.google.com/books?id=X_kE8YvRJJEC&amp;pg=PA239&amp;lpg=PA239">Reliable Distributed Systems: Technologies, Web Services, and Applications</a>, Kenneth Birman</li><li><a href="https://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf">Why Do Computers Stop and What Can Be Done About It?</a>, Jim Gray</li><li><a href="https://courses.cs.washington.edu/courses/cse490h/07wi/readings/IntroductionToDistributedSystems.pdf">Introduction to Distributed Systems</a>, University of Washington</li><li><a href="https://www.cs.rutgers.edu/~rmartin/teaching/spring03/cs553/papers01/06.pdf">Heisenbugs and Bohrbugs: Why are they different?</a>, Richard Martin (?)</li><li><a href="https://pdfs.semanticscholar.org/cae7/52b327a2bbd293a6b92530e354a76b82ace2.pdf">Protecting Applications Against Heisenbugs</a>, Chris Hobbs</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28a01e37f70c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/baseds/weeding-out-distributed-system-bugs-28a01e37f70c">Weeding Out Distributed System Bugs</a> was originally published in <a href="https://medium.com/baseds">baseds</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>
-  recorded_at: Wed, 21 Oct 2020 15:08:30 GMT
-- request:
-    method: get
-    uri: https://circleci.com/blog/feed.xml
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Content-Type:
-      - application/xml
-      Date:
-      - Wed, 21 Oct 2020 15:08:31 GMT
-      Etag:
-      - '"db0e9f9cae7024117d00274d790975a4"'
-      Last-Modified:
-      - Tue, 20 Oct 2020 20:14:07 GMT
-      Server:
-      - nginx
-      Strict-Transport-Security:
-      - max-age=15724800
-      X-Amz-Id-2:
-      - IollSuCioZiDva8EOVj4102L2JG+i5bkdHtNXN8bVBz5/o7zijg1kgioJhtrC1+qjuv8/0d86hw=
-      X-Amz-Request-Id:
-      - AFF61742C84B13AA
-      X-Frame-Options:
-      - SAMEORIGIN
-      Content-Length:
-      - '150162'
-      Connection:
-      - keep-alive
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        <?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
  xml:base="https://circleci.com/"
  xmlns:atom="http://www.w3.org/2005/Atom"
  xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>The CircleCI Blog Feed - CircleCI</title>
    <description>Stay up to date with the latest news, updates, and hacks from CircleCI.</description>
    <link>https://circleci.com/blog/</link>
    <atom:link href="https://circleci.com/blog/feed.xml" rel="self" type="application/rss+xml" />
    
      
      <item>
        <title>Do I really need Kubernetes?</title>
        <link>https://circleci.com/blog/do-i-really-need-kubernetes/</link>
        <pubDate>Tue, 20 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/do-i-really-need-kubernetes/</guid>
        
          <dc:creator>Ron Powell</dc:creator>
        
        
          <description>&lt;p&gt;&lt;i&gt;&lt;i&gt;This post, written by CircleCI Technical Content Marketing Manager Ron Powell, originally appeared on The New Stack &lt;a href=&quot;https://thenewstack.io/do-i-really-need-kubernetes/&quot;&gt;here&lt;/a&gt;.&lt;/i&gt;&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;If you follow technology news, it might seem like &lt;a href=&quot;https://kubernetes.io/&quot;&gt;Kubernetes&lt;/a&gt; is everywhere. It has become hugely popular. In fact, developers and DevOps teams might feel like their application development pipeline is hopelessly outdated if they aren’t using Kubernetes.&lt;/p&gt;

&lt;p&gt;Kubernetes is an orchestration tool for containerized applications. Starting with a collection of Docker containers, Kubernetes can control resource allocation and traffic management for cloud applications and microservices.&lt;/p&gt;

&lt;p&gt;As such, it simplifies many aspects of running a service-oriented application infrastructure. Along with modern &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; and continuous deployment (CI/CD) tools, Kubernetes provides the basis for scaling these apps without huge engineering effort.&lt;/p&gt;

&lt;p&gt;There’s a lot of excitement about using Kubernetes to manage cloud and hybrid cloud environments. And it is a great tool. But teams often chase the hype and move to Kubernetes prematurely, sometimes at a great cost in time, money, and developer frustration.&lt;/p&gt;

&lt;p&gt;In this article, we will try to look beyond the hype and help you answer the question: &lt;strong&gt;do I actually need Kubernetes?&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;What does Kubernetes do, anyway?&lt;/h2&gt;
&lt;p&gt;Kubernetes is an orchestration tool for containerized applications. It is responsible for:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Deploying images and containers&lt;/li&gt;
  &lt;li&gt;Managing the scaling of containers and clusters&lt;/li&gt;
  &lt;li&gt;Resource balancing containers and clusters&lt;/li&gt;
  &lt;li&gt;Traffic management for services&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Kubernetes really shines when your application consists of multiple services running in different containers. For a monolithic application with a static user base, this may be more than necessary.&lt;/p&gt;

&lt;p&gt;The task of building, testing and delivering your application to a container registry is not part of Kubernetes. Here, CI/CD tools for building and testing applications do the job. Kubernetes, as a part of a &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;CI/CD pipeline&lt;/a&gt;, then helps you deploy changes to production without any downtime.&lt;/p&gt;

&lt;h2&gt;Improve your monolith&lt;/h2&gt;
&lt;p&gt;Most applications start their life as a monolith, and this is great! With an entire application in one place, it is quick and easy to make and deploy changes. But if your app finds success and grows, you will soon need to find ways to scale it.&lt;/p&gt;

&lt;p&gt;Does that mean it is time for Kubernetes? Probably not.&lt;/p&gt;

&lt;p&gt;It is tempting to think that only microservices orchestrated via Kubernetes can scale — you’ll read a lot of this on the internet. But scaling is usually more about the application’s internals than about the high-level architecture and tooling. For instance, you can scale a monolith by deploying multiple instances with a load balancer that supports affinity flags.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A practical first step to consider when scaling an application is &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-ii-tdd-and-bdd/&quot;&gt;Test Driven Development (TDD)&lt;/a&gt;&lt;/strong&gt;, which ensures quality and prevents defects as your application grows. While smaller modules or services are easier to test, the modularity also means increased demand for &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-i-mocking-stubbing-and-contract-testing/&quot;&gt;mocking&lt;/a&gt;, as well as additional tooling to configure and maintain. Good testing makes it easier to build and scale your application confidently.&lt;/p&gt;

&lt;p&gt;As you start to scale out a monolith, configuration management tools like Chef and Ansible come in handy. You can use them to automatically configure new servers to ensure they are ready to run your application. You can even go a step further and use a tool like &lt;a href=&quot;https://www.terraform.io/&quot;&gt;Terraform&lt;/a&gt; to help provision new server VMs, so that you won’t have to create them manually.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When other parts of your application become a bottleneck — for example, the database — you may scale those, too.&lt;/strong&gt; Various patterns allow applications to scale even though they are, by design, not very scalable. For example, if your database becomes a bottleneck, you can move frequently-accessed data to a high-performance in-memory data store, like Redis, to reduce load on your database.&lt;/p&gt;

&lt;p&gt;No matter what configuration management and provisioning tools you use, a good CI/CD pipeline is a must. You might have copied a .zip file to your server via FTP the first time you deployed your app, but that approach does &lt;i&gt;not&lt;/i&gt; scale. A streamlined CI/CD pipeline ensures that your application gets built, tested and deployed automatically, without any extra work from you or your team.&lt;/p&gt;

&lt;p&gt;Together, these practices will make your life easier if you &lt;i&gt;do&lt;/i&gt; eventually need Kubernetes.&lt;/p&gt;

&lt;p&gt;You can even auto-scale monolithic applications using cloud services like AWS Elastic Beanstalk, Google App Engine, or Azure App Service. These all impose far less administrative overhead than Kubernetes, and they all play nicely with CI/CD tools.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When working with a new application, focus on developing the best application possible.&lt;/strong&gt; Eventually, a complex tool like Kubernetes may be the right solution for managing infrastructure for your application. As you grow, however, many of the practices we’ve just discussed will be more practical.&lt;/p&gt;

&lt;h2&gt;Augment your monolith&lt;/h2&gt;
&lt;p&gt;As your application continues to grow, you will eventually reach a point where continuing to add to the monolith seems untenable. This is often because the app is near the limit of what a single dev team can work on.&lt;/p&gt;

&lt;p&gt;At this point, many teams choose to split up their monolith and move fully into microservices. While this is a rather popular decision, it is neither a necessary one nor a silver bullet. Consider starting out by adding services that augment your monolith instead of replacing it. Some of these support services may actually be microservices — so you can benefit from using small services where it makes sense, while still leveraging the benefits of your monolith.&lt;/p&gt;

&lt;p&gt;Even when introducing services and microservices, you may not need or want to start with Kubernetes. Kuberntes excels at running and scaling pods of related service and microservice containers. However, there are aspects of adopting Kubernetes that are easy to overlook at first. For example, Kubernetes does not include robust built-in tools for securing pods, nodes and clusters, and deploying Kubernetes clusters across a multi-cloud environment can add a lot of complexity.&lt;/p&gt;

&lt;p&gt;Starting with a single-cloud platform like Azure Service Fabric and AWS Fargate may make it easier to spin up and scale services, without forcing you to take on managing a Kubernetes cluster.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Another option is to avoid services with maintenance overhead altogether and opt for Functions as a Service (FaaS)&lt;/strong&gt;, such as AWS Lambda or Azure Functions. FaaS is a great way to minimize potential infrastructure overhead when adding services to your application. Moreover, a Kubernetes-orchestrated cluster — if you eventually need one — can be enhanced with FaaS capabilities. By starting with a mixture of services and functions, the migration to Kubernetes is less complicated than it sounds.&lt;/p&gt;

&lt;h2&gt;No more monolith&lt;/h2&gt;
&lt;p&gt;Now imagine that your original monolithic application has grown so much that you can barely see the original monolith.&lt;/p&gt;

&lt;p&gt;Its needs and its userbase have grown so far and so fast that you now have a wide variety of helper services, many of which need to talk to each other. You need to make sure the services that depend on each other are always running and visible to each other.&lt;/p&gt;

&lt;p&gt;In addition, your customers are demanding the kind of uptime and reliability that make you consider running across multiple availability zones, possibly even across multiple cloud vendors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;This is the point at which you probably need an orchestrator like Kubernetes.&lt;/strong&gt; It lets you easily define the modules (Pods) of related services and lets you automatically scale them and load-balance between them.&lt;/p&gt;

&lt;p&gt;For Kubernetes to be useful, here is what it would require:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;You are willing to operate a couple of virtual machines&lt;/li&gt;
  &lt;li&gt;You can assign people to do configuration and maintenance of Kubernetes&lt;/li&gt;
  &lt;li&gt;You have more than a single service to take care of&lt;/li&gt;
  &lt;li&gt;You need to automate (as much as possible) a mostly homogenous service deployment&lt;/li&gt;
  &lt;li&gt;You need to be cloud (or hosting) provider-agnostic&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Furthermore, Kubernetes has built-in support for high-availability (Amazon RDS Multi-AZ)  deployments, which makes it easier to increase app reliability and availability. Of course, it does impose overhead: it takes time and engineering resources to create and manage clusters, define pods, and create containerized apps suitable for deployment to Kubernetes. But if your app is big enough to benefit from Kubernetes, the administrative overhead is worth it.&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Kubernetes is powerful, but that does not mean it’s the right choice for every team and every app.&lt;/strong&gt; As with any piece of technology, it is made to solve a certain set of problems. If you aren’t facing the problems Kubernetes aims to solve, it is more trouble than it’s worth.&lt;/p&gt;

&lt;p&gt;Don’t just give Kubernetes a place in your infrastructure toolbox. Make Kubernetes earn it. Especially at the beginning of a new application.&lt;/p&gt;

&lt;p&gt;First, use available tools to get the app out quickly. When your application reaches a stage where deployment and scaling is becoming a job of its own, it makes sense to start thinking about orchestration — and, quite naturally, Kubernetes as your orchestration tool. Once you are ready, check out &lt;a href=&quot;https://circleci.com/blog/getting-started-with-kubernetes-how-to-set-up-your-first-cluster/&quot;&gt;Getting started with Kubernetes: how to set up your first cluster&lt;/a&gt;.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>CI pipelines for testing microservices with DeployHub and CircleCI</title>
        <link>https://circleci.com/blog/ci-pipelines-for-testing-microservices/</link>
        <pubDate>Tue, 20 Oct 2020 08:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/ci-pipelines-for-testing-microservices/</guid>
        
          <dc:creator>Tracy Ragan</dc:creator>
        
        
          <description>&lt;p&gt;Testing microservices shouldn’t be that different from testing a monolithic application. However, there are some challenges we must address to make this transition easy. The question to answer is, “how do we perform functional tests on a decomposed application?”&lt;/p&gt;

&lt;p&gt;As we move away from monolithic practices and into a Kubernetes microservice environment, we lose the concept of an application version. Instead we are faced with lots of loosely-coupled, independent functions with RESTful APIs. While the concept of API contract testing applies at the unit testing level, we have work to do to pull together our functional testing harness.&lt;/p&gt;

&lt;h2&gt;Testing microservices at a functional level&lt;/h2&gt;

&lt;p&gt;Unit testing individual APIs or microservices does not validate the readiness of a full application release. For this reason, we can not eliminate the functional testing process entirely. If we do, we risk missing situations where one microservice is using an older version of another microservice, and that causes an adverse impact. This level of anomaly can only be found when we perform functional testing on the application as a complete product.&lt;/p&gt;

&lt;p&gt;In monolithic environments, the application version is our release candidate. A new release candidate initiates the work done by our functional test harness, which in many cases lags behind the development sprints that perform unit testing on the API contracts. While development teams may make incremental coding changes, functional testing is based on a full release candidate, and the release of that candidate causes the execution of an entirely different set of linked test cases. When testing microservices, this level of functional testing is still required and critical.&lt;/p&gt;

&lt;p&gt;Ideally, we want to leave our functional testing in place even when our application is built on a set of loosely coupled services. To do this, we need visibility into the logical application version. In order to remain efficient at the functional testing level, we need some insights into what has changed between two application versions, allowing the functional testing to be targeted. What we want to avoid is constantly retesting everything simply because we have no reference as to which microservice caused a new release of the application version.&lt;/p&gt;

&lt;h2&gt;Re-imagining continuous integration&lt;/h2&gt;
&lt;p&gt;In monolithic environments, we rely on our application build (compile/link) to create a new version of the application, creating a new release candidate. This new version is then pushed to the testing team to execute a functional test. With microservices, this build goes away. Instead, our build takes a single microservice and builds a new container image. That container image is then pushed up to a container registry. Now we have a new microservice release candidate, which in turn created a new application version release candidate. Welcome to your new &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; process.&lt;/p&gt;

&lt;h2&gt;Testing microservices&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.deployhub.com/&quot;&gt;DeployHub&lt;/a&gt; resurrects the application version in a microservices implementation to support your functional testing. It does this using automated configuration management that automatically creates new application versions each time a new microservice has been registered. Since microservices are shared, a new microservice will often create multiple application release candidates. DeployHub tracks the microservice impact to all consuming applications. This impact analysis allows DeployHub to then inform CircleCI to initiate testing workflows for multiple applications, providing details on exactly which microservices caused the new application release.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-19-dh1.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;The DeployHub orb&lt;/h2&gt;
&lt;p&gt;The &lt;a href=&quot;https://circleci.com/developer/orbs/orb/deployhub/deployhub-orb&quot;&gt;DeployHub orb&lt;/a&gt; integrates into CircleCI to perform automated configuration management as soon as a new container has been created and registered. DeployHub then automatically increments the application version of all impacted applications, and runs the workflow of each. DeployHub uses a key value pair at the application level to specify the default testing environment for deployment and the name of the CircleCI testing pipeline to run post deployment. Additionally, DeployHub provides an impact analysis view that shows, at each application level, which microservice initiated the change.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-19-dh2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;See it in action&lt;/h2&gt;
&lt;p&gt;We’ve made it easy for you. Check out our demo of the DeployHub-CircleCI integration.&lt;/p&gt;

&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;a href=&quot;https://youtu.be/ETxKPApScIw&quot;&gt;
    &lt;img src=&quot;/blog/media/CircleCI+DeployHub.png&quot; alt=&quot;&quot; /&gt;
  &lt;/a&gt;
&lt;br /&gt;

  &lt;p&gt;
    &lt;a href=&quot;https://youtu.be/ETxKPApScIw&quot; style=&quot;color:#0000EE;&quot;&gt;
      Watch the full video here
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Testing microservices and their consuming applications becomes much easier with DeployHub integrated into your CircleCI &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;pipelines&lt;/a&gt;. Testing becomes driven by an automated process triggered by a release candidate event, in much the same way as we did with monolithic environments. Your functional testing suite remains unchanged and insights show you the impact of a single microservice update on all applications.&lt;/p&gt;

&lt;h2&gt;About DeployHub&lt;/h2&gt;
&lt;p&gt;DeployHub empowers organizations to achieve business agility through a managed approach to microservices. DeployHub eliminates the confusion and complexity common with microservices by providing a SaaS centralized view of microservice usage and sharing across clusters and teams.&lt;/p&gt;

&lt;p&gt;For more information and to use the DeployHub CircleCI orb, find us on the &lt;a href=&quot;https://circleci.com/orbs/registry/orb/deployhub/deployhub-orb&quot;&gt;CircleCI orb registry&lt;/a&gt;. You can also learn more about DeployHub at &lt;a href=&quot;http://www.deployhub.com&quot;&gt;DeployHub.com&lt;/a&gt;. DeployHub is based on the &lt;a href=&quot;http://www.ortelius.io&quot;&gt;Ortelius Open Source Project&lt;/a&gt;.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Continuous integration for Adonis APIs</title>
        <link>https://circleci.com/blog/continuous-integration-for-adonis-apis/</link>
        <pubDate>Fri, 16 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/continuous-integration-for-adonis-apis/</guid>
        
          <dc:creator>Fikayo Adepoju</dc:creator>
        
        
          <description>&lt;p&gt;&lt;a href=&quot;https://adonisjs.com/&quot;&gt;Adonis.js&lt;/a&gt; is one of the fastest-growing &lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; frameworks. As stated on its homepage, the framework is designed for fans of &lt;a href=&quot;https://circleci.com/blog/how-to-test-software-part-ii-tdd-and-bdd/&quot;&gt;test-driven development (TDD)&lt;/a&gt;. As a feature of this design, it comes bundled with a specialized testing framework.&lt;/p&gt;

&lt;p&gt;In this tutorial, you will learn how to automate the testing of an Adonis.js API so that your tests will run on every change to your codebase.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To follow this tutorial, a few things are required:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Basic knowledge of Javascript&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; installed on your system (&amp;gt;= 8.0)&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://adonisjs.com/docs/4.1/installation#_installing_adonisjs&quot;&gt;Adonis.js CLI&lt;/a&gt; installed globally&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://github.com/&quot;&gt;GitHub&lt;/a&gt; account&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;With all these installed and set up, let’s begin the tutorial.&lt;/p&gt;

&lt;h2&gt;Cloning the Adonis.js API project&lt;/h2&gt;

&lt;p&gt;To get started, you need to clone the API project that we will be testing. In your terminal, run the following command to clone the base project:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;git clone --single-branch --branch base-project https://github.com/CIRCLECI-GWP/adonis-api-testing.git
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will immediately clone the &lt;code class=&quot;highlighter-rouge&quot;&gt;base-project&lt;/code&gt; branch of the repository into the location in which you have run the above command. This is the starting point of the API project. It has no tests setup.&lt;/p&gt;

&lt;p&gt;Next, go into the root of the project and install the required dependencies:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;cd adonis-api-testing
npm install
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then, create a new file at the root of the project with the name &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt; (note the dot &lt;code class=&quot;highlighter-rouge&quot;&gt;.&lt;/code&gt;), and paste in the following configuration:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;HOST=127.0.0.1
PORT=3333
NODE_ENV=development
APP_NAME=AdonisJs
APP_URL=http://${HOST}:${PORT}
CACHE_VIEWS=false
APP_KEY=pfi5N2ACN4tMJ5d8d8BPHfh3FEuvleej
DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_DATABASE=adonis
HASH_DRIVER=bcrypt
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The above config specifies that we are in a development environment and that we will be using a &lt;code class=&quot;highlighter-rouge&quot;&gt;SQlite&lt;/code&gt; database named &lt;code class=&quot;highlighter-rouge&quot;&gt;adonis&lt;/code&gt; for persistent storage. To get our database and database schema setup, run the Adonis.js project migrations with the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis migration:run
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-migrations-run.png&quot; alt=&quot;Migrations Run&quot; /&gt;&lt;/p&gt;

&lt;p&gt;We have now completely set up our application and can take it for a spin. Boot up the application by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis serve --dev
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This command will start the API running at &lt;code class=&quot;highlighter-rouge&quot;&gt;http://127.0.0.1:3333&lt;/code&gt;. The port might be different if &lt;code class=&quot;highlighter-rouge&quot;&gt;3333&lt;/code&gt; is already in use on your system.&lt;/p&gt;

&lt;p&gt;Our API is a simple &lt;code class=&quot;highlighter-rouge&quot;&gt;User&lt;/code&gt; accounts API. As seen in the &lt;code class=&quot;highlighter-rouge&quot;&gt;./start/routes.js&lt;/code&gt; file, it contains two main endpoints.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// start/routes.js

&quot;use strict&quot;;

const Route = use(&quot;Route&quot;);

Route.get(&quot;/&quot;, () =&amp;gt; {
  return { greeting: &quot;Welcome to the Adonis API tutorial&quot; };
});

//User api routes
Route.group(() =&amp;gt; {
  Route.post(&quot;create&quot;, &quot;UserController.create&quot;);

  Route.route(&quot;get&quot;, &quot;UserController.fetch&quot;, [&quot;GET&quot;, &quot;POST&quot;]);
}).prefix(&quot;user&quot;);
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; route calls the &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; method of &lt;code class=&quot;highlighter-rouge&quot;&gt;UserController&lt;/code&gt; to create a new user by supplying it with a &lt;code class=&quot;highlighter-rouge&quot;&gt;username&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;email&lt;/code&gt;, and &lt;code class=&quot;highlighter-rouge&quot;&gt;password&lt;/code&gt;. We also have a &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoint that simply calls the &lt;code class=&quot;highlighter-rouge&quot;&gt;fetch&lt;/code&gt; function of &lt;code class=&quot;highlighter-rouge&quot;&gt;UserController&lt;/code&gt; to return an array of users in the database. The implementation of these controller functions can be found in the &lt;code class=&quot;highlighter-rouge&quot;&gt;app/Controllers/Http/UserController.js&lt;/code&gt; file shown below.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// app/Controllers/Http/UserController.js

async create({ request, response }) {
    const data = request.post();

    const rules = {
        username: `required|unique:${User.table}`,
        email: `required|unique:${User.table}`,
        password: `required`
    };

    const messages = {
        &quot;username.required&quot;: &quot;A username is required&quot;,
        &quot;username.unique&quot;: &quot;This username is taken. Try another.&quot;,
        &quot;email.required&quot;: &quot;An Email is required&quot;,
        &quot;email.unique&quot;: &quot;Email already exists&quot;,
        &quot;password.required&quot;: &quot;A password for the user&quot;
    };

    const validation = await validate(data, rules, messages);

    if (validation.fails()) {
        const validation_messages = validation.messages().map((msgObject) =&amp;gt; {
            return msgObject.message;
        });

        return response.status(400).send({
            success: false,
            message: validation_messages
        });
    }

    try {
        let create_user = await User.createUser(data);

        let return_body = {
            success: true,
            details: create_user,
            message: &quot;User Successully created&quot;
        };

        response.send(return_body);
    } catch (error) {
        Logger.error(&quot;Error : &quot;, error);
        return response.status(500).send({
            success: false,
            message: error.toString()
        });
    }
} //create


async fetch({ request, response }) {
    const data = request.all();

    try {
      const users = await User.getUsers(data);

      response.send(users);
    } catch (error) {
      Logger.error(&quot;Error : &quot;, error);
      return response.status(500).send({
        success: false,
        message: error.toString(),
      });
    }
} //fetch
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Testing the API with Postman&lt;/h2&gt;

&lt;p&gt;Let’s now put our API to the test by calling our endpoints. We will be using &lt;a href=&quot;https://www.postman.com/&quot;&gt;Postman&lt;/a&gt; to test our endpoints. Make sure that your app is running. If not, run &lt;code class=&quot;highlighter-rouge&quot;&gt;adonis serve --dev&lt;/code&gt; once again.&lt;/p&gt;

&lt;h3&gt;Testing user creation&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-user-creation-success.png&quot; alt=&quot;User Creation - Succesfull&quot; /&gt;&lt;/p&gt;

&lt;h3&gt;Testing user fetch&lt;/h3&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-user-fetch.png&quot; alt=&quot;User Fetch&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Setting up the testing framework&lt;/h2&gt;

&lt;p&gt;The next step is to set up the testing framework for testing Adonis.js applications. Fortunately, Adonis.js has its own specialized testing package known as &lt;a href=&quot;https://www.npmjs.com/package/@adonisjs/vow&quot;&gt;Vow&lt;/a&gt;. Install &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; with the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis install @adonisjs/vow
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The installation of this package will cause the following changes to your project:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;vowfile.js&lt;/code&gt; file will be created at the root of your project.&lt;/li&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;test&lt;/code&gt; folder will be created at the root of the project. This is where all of the tests will be contained. In order to organize tests, all unit tests are placed inside a &lt;code class=&quot;highlighter-rouge&quot;&gt;unit&lt;/code&gt; folder within this folder. Functional tests are placed inside a &lt;code class=&quot;highlighter-rouge&quot;&gt;functional&lt;/code&gt; folder. By default, a sample unit test suite is created inside &lt;code class=&quot;highlighter-rouge&quot;&gt;test/unit/example.spec.js&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;.env.testing&lt;/code&gt; file is created at the root of the project to contain environment variables specific to testing purposes. This file gets merged with &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt;, so you only need to define values you want to override from the &lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt; file.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Replace the content of &lt;code class=&quot;highlighter-rouge&quot;&gt;.env.testing&lt;/code&gt; with the configuration below:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;HOST=127.0.0.1
PORT=4000
NODE_ENV=testing
APP_NAME=AdonisJs
APP_URL=http://${HOST}:${PORT}
CACHE_VIEWS=false
APP_KEY=pfi5N2ACN4tMJ5d8d8BPHfh3FEuvleej
DB_CONNECTION=sqlite
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_DATABASE=adonis
HASH_DRIVER=bcrypt
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The final step to complete our test setup is to add the &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; provider to our project. In the &lt;code class=&quot;highlighter-rouge&quot;&gt;./start/app.js&lt;/code&gt; file, add the following item to the &lt;code class=&quot;highlighter-rouge&quot;&gt;aceProviders&lt;/code&gt; array:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;...

const aceProviders = [
  ....,
  &quot;@adonisjs/vow/providers/VowProvider&quot;
];

...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Run the sample test that came with the &lt;code class=&quot;highlighter-rouge&quot;&gt;Vow&lt;/code&gt; installation by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The sample test will run successfully.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-sample-test.png&quot; alt=&quot;Sample Tests&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Adding tests&lt;/h2&gt;

&lt;p&gt;It is now time to start adding some proper tests to our API project. We will be adding tests to test our &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoints. Run the following command to create a test suite in which we will put our tests:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis make:test User
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the options that display after running this command, select &lt;code class=&quot;highlighter-rouge&quot;&gt;Functional test&lt;/code&gt; (using the arrow keys) and press &lt;code class=&quot;highlighter-rouge&quot;&gt;Enter&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A new file for the test suite will be automatically created at &lt;code class=&quot;highlighter-rouge&quot;&gt;test/functional/user.spec.js&lt;/code&gt;. In this file, replace the contents with the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// test/functional/user.spec.js

&quot;use strict&quot;;

const { test, trait, after } = use(&quot;Test/Suite&quot;)(&quot;User&quot;);

const User = use(&quot;App/Models/User&quot;);

trait(&quot;Test/ApiClient&quot;);

const randomString = generateRandomString();

test(&quot;Test User creation&quot;, async ({ client }) =&amp;gt; {
  const userData = {
    username: randomString,
    email: `${randomString}@test.com`,
    password: &quot;123456&quot;
  };

  const response = await client.post(&quot;/user/create&quot;).send(userData).end();

  response.assertStatus(200);
}).timeout(0);

test(&quot;Fetch all users&quot;, async ({ client }) =&amp;gt; {
  const response = await client.get(&quot;/user/get&quot;).end();

  response.assertStatus(200);
  response.assertJSONSubset([
    {
      username: randomString,
      email: `${randomString}@test.com`
    }
  ]);
}).timeout(0);

//Delete the created user
after(async () =&amp;gt; {
  await (await User.findBy(&quot;username&quot;, randomString)).delete();
});

function generateRandomString(length = 7) {
  var result = &quot;&quot;;
  var characters =
    &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789&quot;;
  var charactersLength = characters.length;
  for (var i = 0; i &amp;lt; length; i++) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength));
  }
  return result;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the above test suite, the Adonis.js &lt;code class=&quot;highlighter-rouge&quot;&gt;Test/ApiClient&lt;/code&gt; trait is used to gain access to the &lt;code class=&quot;highlighter-rouge&quot;&gt;client&lt;/code&gt; object, which is used to call our endpoints. The &lt;code class=&quot;highlighter-rouge&quot;&gt;generateRandomString&lt;/code&gt; random number generator function is used to create a fake username and email for a test user.&lt;/p&gt;

&lt;p&gt;In the &lt;code class=&quot;highlighter-rouge&quot;&gt;Test User creation&lt;/code&gt; test, we create a new user by calling the &lt;code class=&quot;highlighter-rouge&quot;&gt;create&lt;/code&gt; endpoint with the appropriate data, and checking if we get a &lt;code class=&quot;highlighter-rouge&quot;&gt;200&lt;/code&gt; response code that indicates that the operation was successful.&lt;/p&gt;

&lt;p&gt;In the &lt;code class=&quot;highlighter-rouge&quot;&gt;Fetch all users&lt;/code&gt; test, the &lt;code class=&quot;highlighter-rouge&quot;&gt;client&lt;/code&gt; object is used to call our &lt;code class=&quot;highlighter-rouge&quot;&gt;get&lt;/code&gt; endpoint. The response is then tested to ensure that it returns a &lt;code class=&quot;highlighter-rouge&quot;&gt;200&lt;/code&gt; status code. We also check to see if it returns an array containing the user we created in the previous test.&lt;/p&gt;

&lt;p&gt;We attach &lt;code class=&quot;highlighter-rouge&quot;&gt;.timeout(0)&lt;/code&gt; to each test to override the timeout limit for the test runner as functional and browser tests might take a while to run.&lt;/p&gt;

&lt;p&gt;Finally, we do some clean up by deleting the test user we created. This is done after both tests have completed.&lt;/p&gt;

&lt;p&gt;Time to run all the tests contained in the &lt;code class=&quot;highlighter-rouge&quot;&gt;tests&lt;/code&gt; folder. To do that, run the test command once again:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;adonis test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-all-tests-run.png&quot; alt=&quot;All Tests Run&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Connecting the API project to CircleCI&lt;/h2&gt;

&lt;p&gt;Our next task is to get our project set up on CircleCI. First, you need to initialize your Adonis.js project as a &lt;code class=&quot;highlighter-rouge&quot;&gt;git&lt;/code&gt; repository.&lt;/p&gt;

&lt;p&gt;Then, create a remote GitHub repository for the project, commit your changes (if any), and push the local project to the remote repository.&lt;/p&gt;

&lt;p&gt;Next, go to the &lt;strong&gt;Add Projects&lt;/strong&gt; page on the CircleCI dashboard to add the project.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-add-project.png&quot; alt=&quot;Add Project - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Set Up Project&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-add-config.png&quot; alt=&quot;Add Config - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the setup page, click &lt;strong&gt;Add Manually&lt;/strong&gt; to instruct CircleCI that we would be adding a configuration file manually and not using the sample displayed. Next, you get a prompt to either download a configuration file for the pipeline or start building.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-start-build-prompt.png&quot; alt=&quot;Build Prompt - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Start Building&lt;/strong&gt; to begin the build. This build will fail because we have not set up our configuration file yet, this we will do later on.&lt;/p&gt;

&lt;h2&gt;Automating our tests&lt;/h2&gt;

&lt;p&gt;Now that we have our project connected to CircleCI, we can write a configuration for our &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration (CI)&lt;/a&gt; pipeline that will automate our testing process.&lt;/p&gt;

&lt;p&gt;At the root of your the project, create a folder named &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci&lt;/code&gt;, and a file within it named &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;. Inside the &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt; file, enter the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
jobs:
  build:
    working_directory: ~/repo
    docker:
      - image: circleci/node:11-browsers
    steps:
      - checkout
      - run:
          name: Update NPM
          command: &quot;sudo npm install -g npm&quot;
      - restore_cache:
          key: dependency-cache-{{ checksum &quot;package-lock.json&quot; }}
      - run:
          name: Install Dependencies
          command: npm install
      - save_cache:
          key: dependency-cache-{{ checksum &quot;package-lock.json&quot; }}
          paths:
            - ./node_modules
      - run:
          name: Run Migrations
          command: |
            mv .env.testing .env
            node ace migration:run
      - run:
          name: Run tests
          command: npm run test
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the configuration file above, we start by updating &lt;code class=&quot;highlighter-rouge&quot;&gt;npm&lt;/code&gt; to ensure that we are using the lastest version. Next, we install the required dependencies and cache them. We then create our environment configuration file (&lt;code class=&quot;highlighter-rouge&quot;&gt;.env&lt;/code&gt;) and run our migrations. With all dependencies and database set up, we run our tests.&lt;/p&gt;

&lt;p&gt;Save this file, commit, and push your changes to your repository to trigger the CI pipeline to run.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-build-successful.png&quot; alt=&quot;Build Successful - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Let’s view our test results by clicking on the build to see behind the scenes.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-02-tests-automated.png&quot; alt=&quot;Tests Automated - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Our tests are now running automatically when we push new code to our repository.&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;

&lt;p&gt;Test-driven development (TDD) is a best practice that a lot of developers are still struggling to integrate into their development flow. Having a framework that has TDD built into its core really makes adopting it less cumbersome. In this tutorial, we learned to set up the testing of our Adonis.js API, and how to automate the process with CircleCI.&lt;/p&gt;

&lt;p&gt;Happy coding!&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;https://twitter.com/coderonfleek?lang=en&quot;&gt;Fikayo&lt;/a&gt; is a fullstack developer and author with over a decade of experience developing web and mobile solutions. He is currently the Software Lead at Tech Specialist Consulting and develops courses for Packt and Udemy. He has a strong passion for teaching and hopes to become a full-time author.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>CircleCI + Slack: customized pipeline notifications</title>
        <link>https://circleci.com/blog/circleci-slack-integration/</link>
        <pubDate>Fri, 09 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/circleci-slack-integration/</guid>
        
          <dc:creator>Kyle Tryon</dc:creator>
        
        
          <description>&lt;p&gt;Today we are releasing the Slack orb v4.0 for CircleCI. It makes &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;pipeline&lt;/a&gt; notifications easy to implement and customize. Now with support for Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;, it also provides a visual way to create endless custom notifications. Check out the slack orb here:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;Slack orb&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;Slack orb wiki&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack1.png&quot; alt=&quot;Pipeline on-hold notification example&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;What’s new?&lt;/h2&gt;

&lt;h3&gt;Simple to use.&lt;/h3&gt;
&lt;p&gt;Previously, the Slack orb utilized multiple commands and numerous orb parameters to build notifications piece-by-piece. Now, with version 4.0 and above, you can select one of several built-in available templates or customize and import your own notifications visually with Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;In the new Slack orb you will only find a single command &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt;, and a job &lt;code class=&quot;highlighter-rouge&quot;&gt;on-hold&lt;/code&gt;. The notify command is the heart of the orb and can be used to send notifications to any (or multiple) Slack channel based on &lt;em&gt;events&lt;/em&gt; like when a CircleCI job has passed or failed.&lt;/p&gt;

&lt;h3&gt;Built for teams&lt;/h3&gt;
&lt;p&gt;The new Slack orb authenticates using OAuth, rather than using &lt;a href=&quot;https://api.slack.com/messaging/webhooks&quot;&gt;incoming webhooks&lt;/a&gt; as in previous versions. With this change, you can now install a “bot” application in your Slack Workspace for your CircleCI notifications and alert multiple channels from one integration. To setup authentication, be sure to check the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki/Setup&quot;&gt;GitHub wiki for the Slack orb&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;Upgrading&lt;/h3&gt;

&lt;p&gt;Slack orb version 4.0.0 is a complete rewrite of the previous Slack orb with a new feature set and simpler design that is much easier to use. Older versions of the Slack orb will continue to operate and migrating to the new Slack orb experience is entirely optional.&lt;/p&gt;

&lt;p&gt;To migrate to the new Slack orb, the old orb must be completely removed as version 4.0 does not share any functionality with previous versions of the orb.&lt;/p&gt;

&lt;p&gt;Get started by visiting the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub wiki&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;How does it work?&lt;/h2&gt;

&lt;p&gt;&lt;a href=&quot;https://circleci.com/orbs/&quot;&gt;Orbs&lt;/a&gt; are packages of CircleCI configuration which can be imported and utilized in your configuration file.&lt;/p&gt;

&lt;p&gt;To jump ahead, you can view the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;Slack orb&lt;/a&gt; in the &lt;a href=&quot;https://circleci.com/orbs/registry/&quot;&gt;orb registry&lt;/a&gt;, and on &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/&quot;&gt;GitHub&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The main component of the Slack orb is the &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt; command, which can be used at the end of any job to send notifications based on the status of that job.&lt;/p&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;fail&lt;/span&gt;
      &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;basic_fail_1&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;There is now a single notification command with an &lt;code class=&quot;highlighter-rouge&quot;&gt;event&lt;/code&gt; parameter. The &lt;code class=&quot;highlighter-rouge&quot;&gt;notify&lt;/code&gt; command should be placed at the end of any job as it will always run and can detect the current status of the job.&lt;/p&gt;

&lt;p&gt;You can specify notifications to &lt;code class=&quot;highlighter-rouge&quot;&gt;always&lt;/code&gt; send or to send on &lt;code class=&quot;highlighter-rouge&quot;&gt;fail&lt;/code&gt; or &lt;code class=&quot;highlighter-rouge&quot;&gt;pass&lt;/code&gt;. If a &lt;code class=&quot;highlighter-rouge&quot;&gt;branch_pattern&lt;/code&gt; parameter is specified, the current branch must also match the pattern to send the notification.&lt;/p&gt;

&lt;p&gt;For the message body, you can select one of the preconfigured templates included with the orb, or create your own custom notification.&lt;/p&gt;

&lt;p&gt;You can see a full list of available templates on the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub Wiki&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack2.png&quot; alt=&quot;Slack Orb Templates&quot; /&gt;&lt;/p&gt;

&lt;p&gt;By default, the Slack orb will attempt to post to the channel specified by the &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_DEFAULT_CHANNEL&lt;/code&gt; environment variable, but you can also select one or more channels via the &lt;code class=&quot;highlighter-rouge&quot;&gt;channel&lt;/code&gt; parameter.&lt;/p&gt;

&lt;h2&gt;A working example&lt;/h2&gt;

&lt;p&gt;Here is a semi-realistic example of a test and deploy workflow on CircleCI. It has one job which tests the application on every commit (&lt;code class=&quot;highlighter-rouge&quot;&gt;test&lt;/code&gt;), and a deployment job which only runs on a tagged commit (&lt;code class=&quot;highlighter-rouge&quot;&gt;deploy&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;In this example, we will place our workflow (&lt;code class=&quot;highlighter-rouge&quot;&gt;test-and-deploy&lt;/code&gt;) &lt;em&gt;&lt;a href=&quot;/docs/2.0/workflows/#holding-a-workflow-for-a-manual-approval&quot;&gt;On hold&lt;/a&gt;&lt;/em&gt; prior to deployment, and wait for a manual approval. After an engineer manually approves the workflow, the deployment job will execute. For this workflow, we want to set up three potential notifications for Slack:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A notification when the workflow is placed on-hold&lt;/li&gt;
  &lt;li&gt;A notification if the deployment fails&lt;/li&gt;
  &lt;li&gt;A different notification if the deployment succeeds&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The following usage example is pulled directly from the orb registry.&lt;/p&gt;

&lt;p&gt;This configuration makes two assumptions:&lt;/p&gt;
&lt;ol&gt;
  &lt;li&gt;You have stored your OAuth token as &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_ACCESS_TOKEN&lt;/code&gt; in a &lt;a href=&quot;/docs/2.0/contexts/#restricting-a-context&quot;&gt;restricted context&lt;/a&gt; named &lt;code class=&quot;highlighter-rouge&quot;&gt;slack-secrets&lt;/code&gt;&lt;/li&gt;
  &lt;li&gt;You have defined the &lt;code class=&quot;highlighter-rouge&quot;&gt;$SLACK_DEFAULT_CHANNEL&lt;/code&gt; as either a &lt;a href=&quot;/docs/2.0/env-vars/#setting-an-environment-variable-in-a-project&quot;&gt;project environment variable&lt;/a&gt;, or within the &lt;code class=&quot;highlighter-rouge&quot;&gt;slack-secrets&lt;/code&gt; context.&lt;/li&gt;
&lt;/ol&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; &lt;span class=&quot;na&quot;&gt;version&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;2.1&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;orbs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;slack&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;circleci/slack@4.0&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;jobs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# This &quot;test&quot; job will run on every commit (as per our workflow)&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# We are ok with no notifications sent for this job.&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;test&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;docker&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;image&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;cimg/base:stable&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;steps&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;run&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;echo &quot;test my app&quot;&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# This &quot;deploy&quot; job will only run on a tagged commit (as per our workflow)&lt;/span&gt;
   &lt;span class=&quot;c1&quot;&gt;# We want to be alerted if this job fails and also when it succeeds.&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;docker&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;image&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;cimg/base:stable&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;steps&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;run&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;echo &quot;deploy my app&quot;&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# In the event the deployment has failed, alert the engineering team&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;fail&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;basic_fail_1&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;mentions&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s2&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;@EngineeringTeam&quot;&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# When there is a successful deployment, send a notification with a different template.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;pass&lt;/span&gt;
           &lt;span class=&quot;na&quot;&gt;template&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;success_tagged_deploy_1&lt;/span&gt;
 &lt;span class=&quot;na&quot;&gt;workflows&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
   &lt;span class=&quot;na&quot;&gt;test-and-deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
     &lt;span class=&quot;na&quot;&gt;jobs&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# We want the test job to run on all commits, so we will list it with no filters.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# When we are on a tagged commit (example &quot;v1.0.0&quot;), we want to also place the workflow on-hold, pending manual approval for deployment.&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# We will also make use of the Slack orb's &quot;on-hold&quot; job to notify us to this on-hold workflow, making it easy to respond.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/on-hold&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack-secrets&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# Jobs with the type of &quot;approval&quot; act as place holders to pause the workflow, the job name does not matter.&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# Wait for both the test job and for the notification to send before pausing.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;pause_workflow&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;type&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;approval&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;test&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/on-hold&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;# The deploy job will continue once the workflow has been manually approved.&lt;/span&gt;
       &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;na&quot;&gt;deploy&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;context&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack-secrets&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;requires&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;pause_workflow&lt;/span&gt;
          &lt;span class=&quot;na&quot;&gt;filters&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
            &lt;span class=&quot;na&quot;&gt;tags&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
              &lt;span class=&quot;na&quot;&gt;only&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;/^v.*/&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Creating custom notifications&lt;/h2&gt;

&lt;p&gt;Previously, creating custom notifications involved using many parameters. They were limited and difficult to configure. Now, you can create nearly any notification imaginable with only a single parameter, and notifications are designed visually using Slack’s &lt;a href=&quot;https://app.slack.com/block-kit-builder&quot;&gt;Block Kit Builder&lt;/a&gt;.
You can start with any of Slack’s built-in templates, or start fresh and design your own.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-25-slack-gif.gif&quot; alt=&quot;Slack Block Kit Builder example&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the right side of the screen above, you get the payload that contains the text we feed to the Slack orb via the &lt;code class=&quot;highlighter-rouge&quot;&gt;custom&lt;/code&gt; parameter (as an alternative to the &lt;code class=&quot;highlighter-rouge&quot;&gt;template&lt;/code&gt; parameter).&lt;/p&gt;

&lt;div class=&quot;language-yaml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;pi&quot;&gt;-&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;slack/notify&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;event&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;always&lt;/span&gt;
    &lt;span class=&quot;na&quot;&gt;custom&lt;/span&gt;&lt;span class=&quot;pi&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;pi&quot;&gt;|&lt;/span&gt;
      &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;no&quot;&gt;&quot;blocks&quot;: [&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;section&quot;,&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: {&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;mrkdwn&quot;,&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: &quot;Current Job: $CIRCLE_JOB&quot;&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;},&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;section&quot;,&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: {&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;type&quot;: &quot;mrkdwn&quot;,&lt;/span&gt;
              &lt;span class=&quot;no&quot;&gt;&quot;text&quot;: &quot;Write some text here&quot;&lt;/span&gt;
            &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
          &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
         &lt;span class=&quot;no&quot;&gt;]&lt;/span&gt;
        &lt;span class=&quot;no&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Before copying the payload, customize the look of your notification using the components on the left side of the screen. Environment variables can be used in any text fields and the values will be replaced at runtime.&lt;/p&gt;

&lt;p&gt;For more information and examples, check out the &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/wiki&quot;&gt;GitHub Wiki&lt;/a&gt; and the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/slack&quot;&gt;orb registry page&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Join The Community&lt;/h2&gt;

&lt;p&gt;Orb developers and consumers are welcome to &lt;a href=&quot;https://discuss.circleci.com/c/ecosystem/orbs/62&quot;&gt;join our Discuss forum&lt;/a&gt;! We would love to hear from you, whether you have questions, comments, or concerns about the Slack orb. Need to file an issue or want to request a feature? We’d love to hear from you on &lt;a href=&quot;https://github.com/CircleCI-Public/slack-orb/issues/new/choose&quot;&gt;GitHub&lt;/a&gt; as well.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Using CircleCI workflows to replicate Docker Hub automated builds</title>
        <link>https://circleci.com/blog/using-circleci-workflows-to-replicate-docker-hub-automated-builds/</link>
        <pubDate>Fri, 09 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/using-circleci-workflows-to-replicate-docker-hub-automated-builds/</guid>
        
          <dc:creator>Jonathan Cardoso</dc:creator>
        
        
          <description>&lt;p&gt;&lt;strong&gt;Note from the publisher&lt;/strong&gt;: &lt;i&gt;This content was updated by Support Engineer Nick Bialostosky on 10/9/2020 to reflect changes to Docker Hub support for access tokens.&lt;/i&gt;&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;/docs/2.0/workflows/&quot;&gt;CircleCI workflows&lt;/a&gt; is a powerful feature that can be used to make your deployment process simple and intuitive. In this article, we will learn how to use them to automatically push images to the Docker registry, just like Docker Hub’s own automated build process, but with all of the customization that your own build process offers.&lt;/p&gt;

&lt;h2&gt;CircleCI workflows&lt;/h2&gt;
&lt;blockquote&gt;
  &lt;p&gt;A &lt;strong&gt;workflow&lt;/strong&gt; is a set of rules for defining a collection of jobs and their run order. Workflows support complex job orchestration using a simple set of configuration keys to help you resolve failures sooner. - &lt;a href=&quot;/docs/2.0/workflows/&quot;&gt;CircleCI Workflows Documentation&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;In our workflow, pushing a commit to the &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt; branch will run a specific job that publishes an image with the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag on Docker Hub. Each commit will also add a Git tag to the image as an image tag and publish the image with that tag, too. Finally, we will look into how to use CircleCI’s &lt;a href=&quot;/docs/2.0/env-vars/&quot;&gt;environment variables&lt;/a&gt; to automatically publish incremental versions of our images instead of using Git tags.&lt;/p&gt;

&lt;h2&gt;Building our Docker image&lt;/h2&gt;

&lt;p&gt;Let’s start with a basic Docker image that just prints the arguments passed when it is run. The Dockerfile will look as simple as this:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;FROM alpine:3.8
    
ENTRYPOINT [ &quot;echo&quot; ]
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Building and running the image locally should show us that it is working correctly:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;$ docker build -t building-on-ci .
Sending build context to Docker daemon  4.608kB
Step 1/2 : FROM alpine:3.8
 ---&amp;gt; 196d12cf6ab1
Step 2/2 : ENTRYPOINT [ &quot;echo&quot; ]
 ---&amp;gt; Running in fe2151b22bc1
Removing intermediate container fe2151b22bc1
 ---&amp;gt; edc0ca6e654a
Successfully built edc0ca6e654a
Successfully tagged ci-workflows:latest

$ docker run building-on-ci &quot;Hello!&quot;
Hello!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now that we have our image, we need to push it to our GitHub repository.&lt;/p&gt;

&lt;p&gt;To start building our image on each commit, we are going to bootstrap our project with the following config file. In your project’s root directory, create a &lt;code class=&quot;highlighter-rouge&quot;&gt;.circle&lt;/code&gt; directory and save the following lines as &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2
jobs:
  build:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: docker build -t $IMAGE_NAME:latest .
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We are using a pre-built Docker image available from CircleCI called &lt;code class=&quot;highlighter-rouge&quot;&gt;circleci/buildpack-deps&lt;/code&gt; to run our build. CircleCI has many custom images on Docker Hub that extend the official images with extra tools that are useful in a CI/CD environment. Check the &lt;a href=&quot;/docs/2.0/circleci-images/&quot;&gt;CircleCI images&lt;/a&gt; docs for more information.&lt;/p&gt;

&lt;p&gt;There is also an environment variable called &lt;code class=&quot;highlighter-rouge&quot;&gt;IMAGE_NAME&lt;/code&gt; which we are going to use to set the name of our Docker image. It is imperative that you change it to your username/orgname instead of using mine (&lt;code class=&quot;highlighter-rouge&quot;&gt;jonathancardoso&lt;/code&gt;). Otherwise, you are going to get an error when trying to publish that image to Docker Hub.&lt;/p&gt;

&lt;p&gt;For now, our config has a single workflow called &lt;code class=&quot;highlighter-rouge&quot;&gt;build-master&lt;/code&gt; that runs a single &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job when we push a commit to the &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt; branch. This job simply builds our Docker image and does nothing more.&lt;/p&gt;

&lt;p&gt;One of our steps is called &lt;code class=&quot;highlighter-rouge&quot;&gt;setup_remote_docker&lt;/code&gt; and is one of the most important ones when building Docker images on CircleCI. Since our job steps are run inside of a Docker image, they cannot build other Docker images. The &lt;code class=&quot;highlighter-rouge&quot;&gt;setup_remote_docker&lt;/code&gt; command tells CircleCI to allocate a new Docker Engine, separate from the environment that is running our job, specifically to execute the Docker commands. Check the &lt;a href=&quot;/docs/2.0/building-docker-images/&quot;&gt;building Docker images&lt;/a&gt; docs for more information.&lt;/p&gt;

&lt;p&gt;Example of execution: &lt;a href=&quot;https://circleci.com/gh/JCMais/docker-building-on-ci/1&quot;&gt;https://circleci.com/gh/JCMais/docker-building-on-ci/1&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Publishing an image to Docker Hub with the :latest tag on every commit to master&lt;/h2&gt;

&lt;p&gt;Now that we are building our image on every commit to &lt;code class=&quot;highlighter-rouge&quot;&gt;master&lt;/code&gt;, we need to create a new job to also publish that image to Docker Hub.&lt;/p&gt;

&lt;p&gt;Docker Hub does not have access tokens that you can use to access your account, so we are going to need to use our own username/password to log in on the Docker Hub Registry. This is generally done by running:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker login -u &quot;username&quot; -p &quot;password&quot;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;Docker Hub now supports &lt;a href=&quot;https://docs.docker.com/docker-hub/access-tokens/&quot;&gt;access tokens&lt;/a&gt; so you can utilize a token instead of your password for the following instructions if you prefer.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;However, having your credentials in clear text like that is a bad practice because it can expose your password. We need to create new &lt;a href=&quot;/docs/2.0/env-vars&quot;&gt;CircleCI environment variables&lt;/a&gt; with our username and password. There are multiple ways to do that in CircleCI, but if multiple projects are going to push images to Docker Hub, the recommended way is to use &lt;a href=&quot;/docs/2.0/contexts/&quot;&gt;Contexts&lt;/a&gt;. Otherwise, we can set them directly in the project settings. For this article we are going with the latter method.&lt;/p&gt;

&lt;p&gt;After setting the environment variables &lt;code class=&quot;highlighter-rouge&quot;&gt;DOCKERHUB_USERNAME&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;DOCKERHUB_PASS&lt;/code&gt;, let’s create our job:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2
jobs:
  build:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: docker build -t $IMAGE_NAME:latest .
  publish-latest:
    environment:
      IMAGE_NAME: building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
    steps:
      - setup_remote_docker
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            docker push $IMAGE_NAME:latest
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
      - publish-latest:
          requires:
            - build
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We added a new &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job to the &lt;code class=&quot;highlighter-rouge&quot;&gt;build-master&lt;/code&gt; workflow. This job tries to push the image we just built to Docker Hub. However, if we commit that change and check the build log, we will see that it fails because Docker cannot find the image &lt;code class=&quot;highlighter-rouge&quot;&gt;jonathancardoso/building-on-ci&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub1.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/workflow-run/6924a584-81be-4a31-bfbc-72225d12d256&quot;&gt;
      https://circleci.com/workflow-run/6924a584-81be-4a31-bfbc-72225d12d256
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;This happens because the jobs in a workflow are isolated from each other, the image we built on the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job is not available to &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Note the duplication we have in our configuration file. We are repeating ourselves two times with the environment variable &lt;code class=&quot;highlighter-rouge&quot;&gt;IMAGE_NAME&lt;/code&gt; definition and the Docker image that is going to be used to run our jobs.&lt;/p&gt;

&lt;p&gt;One way we could use to solve the duplication issue is by using YAML anchors. However, CircleCI has evolved, and with version &lt;code class=&quot;highlighter-rouge&quot;&gt;2.1&lt;/code&gt;, we can now reuse some configurations directly by specifying a &lt;a href=&quot;/docs/2.0/reusing-config/#authoring-reusable-executors&quot;&gt;reusable executor&lt;/a&gt;. At the top of the file we are going to change the version from &lt;code class=&quot;highlighter-rouge&quot;&gt;2&lt;/code&gt; to &lt;code class=&quot;highlighter-rouge&quot;&gt;2.1&lt;/code&gt; and add a new &lt;code class=&quot;highlighter-rouge&quot;&gt;executors&lt;/code&gt; key:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
executors:
  docker-publisher:
    environment:
      IMAGE_NAME: building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now on each job, instead of declaring &lt;code class=&quot;highlighter-rouge&quot;&gt;docker&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;environment&lt;/code&gt; keys, we are going to specify a single &lt;code class=&quot;highlighter-rouge&quot;&gt;executor&lt;/code&gt; key:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
jobs:
  build:
    executor: docker-publisher
    # ...
  publish-latest:
    executor: docker-publisher
    # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Duplication resolved. Time to fix the issue with our Docker image not being available on the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job. We are going to use &lt;a href=&quot;/docs/2.0/workflows/#using-workspaces-to-share-data-among-jobs&quot;&gt;Workflows’ workspaces&lt;/a&gt; to share the image between the two jobs.&lt;/p&gt;

&lt;p&gt;Let’s add a new run step at the end of the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job. This run step is going to save the image as a tar archive:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now, we can persist that file on the workflow workspace by adding another step called &lt;code class=&quot;highlighter-rouge&quot;&gt;persist_to_workspace&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      - persist_to_workspace:
          root: .
          paths:
            - ./image.tar
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;To retrieve the &lt;code class=&quot;highlighter-rouge&quot;&gt;image.tar&lt;/code&gt; file on the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job, we are going to add a new step, &lt;code class=&quot;highlighter-rouge&quot;&gt;attach_workspace&lt;/code&gt;, before the others:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;   # ...
   steps:
      - attach_workspace:
          at: /tmp/workspace
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;And load our archived image with &lt;code class=&quot;highlighter-rouge&quot;&gt;docker load&lt;/code&gt; just before we try to push it to the Docker Hub registry:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Our full configuration file looks like this:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
executors:
  docker-publisher:
    environment:
      IMAGE_NAME: jonathancardoso/building-on-ci
    docker:
      - image: circleci/buildpack-deps:stretch
jobs:
  build:
    executor: docker-publisher
    steps:
      - checkout
      - setup_remote_docker
      - run:
          name: Build Docker image
          command: |
            docker build -t $IMAGE_NAME:latest .
      - run:
          name: Archive Docker image
          command: docker save -o image.tar $IMAGE_NAME
      - persist_to_workspace:
          root: .
          paths:
            - ./image.tar
  publish-latest:
    executor: docker-publisher
    steps:
      - attach_workspace:
          at: /tmp/workspace
      - setup_remote_docker
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            docker push $IMAGE_NAME:latest
workflows:
  version: 2
  build-master:
    jobs:
      - build:
          filters:
            branches:
              only: master
      - publish-latest:
          requires:
            - build
          filters:
            branches:
              only: master
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Everything should be green now!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now, we can retrieve and run our image from the Docker Hub registry:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;$ docker run jonathancardoso/building-on-ci &quot;Workflows are awesome!&quot;
Unable to find image 'jonathancardoso/building-on-ci:latest' locally
latest: Pulling from jonathancardoso/building-on-ci
4fe2ade4980c: Already exists
Digest: sha256:f719ca403b0fc6a5214823c61c750a5e48ce5809a24b882b3a45d6d119870366
Status: Downloaded newer image for jonathancardoso/building-on-ci:latest
Workflows are awesome!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Publishing Git tags as Docker image tags on Docker Hub&lt;/h2&gt;

&lt;p&gt;Depending on an image with &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag can &lt;a href=&quot;https://vsupalov.com/docker-latest-tag/&quot;&gt;easily cause confusion&lt;/a&gt; since we don’t have control over which version of the image we are running. The recommended way is to use a specific tag.&lt;/p&gt;

&lt;p&gt;Suppose we are going to use Git tags to release new versions of our Docker image, and we want CircleCI to publish our image with each Git tag as an image tag on Docker Hub. Here is how we can do it.&lt;/p&gt;

&lt;p&gt;First, we are going to add a new workflow, &lt;code class=&quot;highlighter-rouge&quot;&gt;build-tags&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
  build-tags:
    jobs:
      - build:
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/
      - publish-tag:
          requires:
            - build
          filters:
            tags:
              only: /^v.*/
            branches:
              ignore: /.*/
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Both jobs share the same filters, which basically say that they must run for every tag that starts with &lt;code class=&quot;highlighter-rouge&quot;&gt;v&lt;/code&gt; and should not execute for branches.&lt;/p&gt;

&lt;p&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; job is the same (we can reuse jobs between workflows), but the &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-tag&lt;/code&gt; job will look like the following:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;# ...
  publish-tag:
    executor: docker-publisher
    steps:
      - attach_workspace:
          at: /tmp/workspace
      - setup_remote_docker
      - run:
          name: Load archived Docker image
          command: docker load -i /tmp/workspace/image.tar
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            IMAGE_TAG=${CIRCLE_TAG/v/''}
            docker tag $IMAGE_NAME:latest $IMAGE_NAME:$IMAGE_TAG
            docker push $IMAGE_NAME:latest
            docker push $IMAGE_NAME:$IMAGE_TAG
# ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The difference between this job and &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; is that this job uses an environment variable set automatically by CircleCI called &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_TAG&lt;/code&gt;. We retrieve the value and remove the &lt;code class=&quot;highlighter-rouge&quot;&gt;v&lt;/code&gt; prefix, e.g., &lt;code class=&quot;highlighter-rouge&quot;&gt;v0.0.1&lt;/code&gt; becomes &lt;code class=&quot;highlighter-rouge&quot;&gt;0.0.1&lt;/code&gt;. We then proceed to tag our image with that version and push it to the Docker Hub Registry. We also make sure to push the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag, too, so that both are kept in sync. If we commit a tag we can see it working:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub3.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/workflow-run/ecdfbb3f-b7f6-41b6-9f56-147496791736&quot;&gt;
      https://circleci.com/workflow-run/ecdfbb3f-b7f6-41b6-9f56-147496791736
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;And if we access the Docker Hub page for the image, we can see the tag there:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub4.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/&quot;&gt;
      https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;Now, we can run our image using our tag:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;docker run jonathancardoso/building-on-ci:0.0.1 &quot;Tags are working!&quot;
Unable to find image 'jonathancardoso/building-on-ci:0.0.1' locally
0.0.1: Pulling from jonathancardoso/building-on-ci
4fe2ade4980c: Already exists
Digest: sha256:1a3a6c74860832704df55acdcbd875f662957d757d69fa340a48b41b890469bc
Status: Downloaded newer image for jonathancardoso/building-on-ci:0.0.1
Tags are working!
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2&gt;Automatic image tags for each build&lt;/h2&gt;

&lt;p&gt;What if we have an image that we don’t use frequently or one that we don’t want to use git tags for? An image that we want to have strict control over which version we are using, so we can’t rely on the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag?&lt;/p&gt;

&lt;p&gt;CircleCI allow us to do exactly that: it exposes an environment variable called &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_BUILD_NUM&lt;/code&gt; that is an ever-increasing number. Using it, we can let CircleCI publish a new version of the image for every build. Let’s modify our &lt;code class=&quot;highlighter-rouge&quot;&gt;publish-latest&lt;/code&gt; job to do exactly that:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;      # ...
      - run:
          name: Publish Docker Image to Docker Hub
          command: |
            echo &quot;$DOCKERHUB_PASS&quot; | docker login -u &quot;$DOCKERHUB_USERNAME&quot; --password-stdin
            IMAGE_TAG=&quot;0.0.${CIRCLE_BUILD_NUM}&quot;
            docker tag $IMAGE_NAME:latest $IMAGE_NAME:$IMAGE_TAG
            docker push $IMAGE_NAME:latest
            docker push $IMAGE_NAME:$IMAGE_TAG
      # ...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;We are using &lt;code class=&quot;highlighter-rouge&quot;&gt;CIRCLE_BUILD_NUM&lt;/code&gt; to create the image tag and publishing it alongside the &lt;code class=&quot;highlighter-rouge&quot;&gt;latest&lt;/code&gt; tag to Docker Hub Registry. If we commit that to master and wait for the workflow to finish, we can see that it was published:&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub5.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://circleci.com/gh/JCMais/docker-building-on-ci/24&quot;&gt;
      https://circleci.com/gh/JCMais/docker-building-on-ci/24
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-10-09-hub6.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
&lt;div style=&quot;text-align: center&quot;&gt;
  &lt;p&gt;
    &lt;a href=&quot;https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/&quot;&gt;
      https://hub.docker.com/r/jonathancardoso/building-on-ci/tags/
    &lt;/a&gt;
  &lt;/p&gt;
&lt;/div&gt;

&lt;h2&gt;Summary&lt;/h2&gt;

&lt;p&gt;These versioning techniques are just building blocks. You can make tagging the versions of your image as complex or as simple as you want. You could even use this knowledge to upload an image to your own private registry, instead of Docker Hub, for specific tags.&lt;/p&gt;

&lt;p&gt;The repository used while writing this article is available on GitHub: &lt;a href=&quot;https://github.com/JCMais/docker-building-on-ci&quot;&gt;https://github.com/JCMais/docker-building-on-ci&lt;/a&gt;.&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;i&gt;Jonathan Cardoso is passionate about DevOps, open source, and gaming. He has six years of experience helping companies around the world move their objectives forward with technical solutions. He currently works remotely from Brazil as a Full-Stack Developer and DevOps specialist at HelloMD. You can follow him &lt;a href=&quot;https://twitter.com/_jonathancardos&quot;&gt;@_jonathancardos&lt;/a&gt;&lt;/i&gt;&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Continuous deployment for Next.js applications</title>
        <link>https://circleci.com/blog/continuous-deployment-for-next-js-apps/</link>
        <pubDate>Wed, 07 Oct 2020 12:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/continuous-deployment-for-next-js-apps/</guid>
        
          <dc:creator>Fikayo Adepoju</dc:creator>
        
        
          <description>&lt;p&gt;&lt;a href=&quot;https://reactjs.org/&quot;&gt;React.js&lt;/a&gt; is a very powerful front-end framework, as its popularity and adoption over the years have shown. However, building a full, production-level application involves a feature set that the React framework, on its own, doesn’t include. Features like routing, code-splitting, bundling, CSS modules, and more are needed for production-level application development. These are not capabilities that React.js offers out-of-the-box. This is where &lt;a href=&quot;https://nextjs.org/&quot;&gt;Next.js&lt;/a&gt; comes in.&lt;/p&gt;

&lt;p&gt;Next.js is the &lt;strong&gt;React framework for production&lt;/strong&gt; as advertised on the Next.js official website. It provides production-level features to React.js developers to easily build production-ready apps.&lt;/p&gt;

&lt;p&gt;In this tutorial, you will learn how to automate the deployment of Next.js applications to Heroku.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To follow this tutorial, a few things are required:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;Basic knowledge of Javascript&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://nodejs.org&quot;&gt;Node.js&lt;/a&gt; installed on your system (version &amp;gt;= 10.3)&lt;/li&gt;
  &lt;li&gt;An &lt;a href=&quot;https://heroku.com/&quot;&gt;Heroku&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A &lt;a href=&quot;https://github.com/&quot;&gt;GitHub&lt;/a&gt; account&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;With all these installed and set up, let’s begin the tutorial.&lt;/p&gt;

&lt;h2&gt;Creating a Next.js project&lt;/h2&gt;

&lt;p&gt;To begin, create a new Next.js project by running the following command:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npx create-next-app next-cd
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will automatically create a Next.js application inside the &lt;code class=&quot;highlighter-rouge&quot;&gt;next-cd&lt;/code&gt; folder (you can give the folder any name you chose). Once the scaffolding process is done, go into the root of the project and run the application with the following commands:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;cd next-cd
npm run dev
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This will boot up a development server that serves the application at its default &lt;code class=&quot;highlighter-rouge&quot;&gt;3000&lt;/code&gt; port (&lt;code class=&quot;highlighter-rouge&quot;&gt;http://localhost:3000&lt;/code&gt;). Load this URL in your browser and you will see the default homepage.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-app-default-page.png&quot; alt=&quot;New App (Local) - Next.js&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Creating an Heroku app&lt;/h2&gt;

&lt;p&gt;The next step is to set up a Heroku application to host our app. Navigate to your &lt;a href=&quot;https://dashboard.heroku.com/apps&quot;&gt;Heroku account management console&lt;/a&gt;, go to &lt;strong&gt;New&lt;/strong&gt; -&amp;gt; &lt;strong&gt;Create new app&lt;/strong&gt;, and create a new app with your preferred name.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-heroku-new-app.png&quot; alt=&quot;New App - Heroku&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Take note of the app name you just entered. You will need this later.&lt;/p&gt;

&lt;p&gt;Next, locate your Heroku API Key in the &lt;strong&gt;Account Settings&lt;/strong&gt; section of your dashboard. You will also need this later in the tutorial. You can access &lt;strong&gt;Account Settings&lt;/strong&gt; from the dropdown menu that appears when you click on your avatar at the top right of the webpage.&lt;/p&gt;

&lt;h2&gt;Setting up a CircleCI project for deployment&lt;/h2&gt;

&lt;p&gt;To set up your project on CircleCI, you need to initialize your project as a &lt;code class=&quot;highlighter-rouge&quot;&gt;git&lt;/code&gt; repository (if it isn’t already initialized).&lt;/p&gt;

&lt;p&gt;Then, create a remote GitHub repository for the project, commit your changes (if any), and push the local project to the remote repository.&lt;/p&gt;

&lt;p&gt;Next, go to the &lt;code class=&quot;highlighter-rouge&quot;&gt;Add Projects&lt;/code&gt; page on the CircleCI dashboard to add the project.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-project.png&quot; alt=&quot;Add Project - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Set Up Project&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-config.png&quot; alt=&quot;Add Config - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On the set-up page, click &lt;strong&gt;Use Existing Config&lt;/strong&gt; to instruct CircleCI that we will add a configuration file manually, and not use the sample config displayed. Next, you get a prompt to either download a configuration file for the pipeline or start building.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-start-build-prompt.png&quot; alt=&quot;Build Prompt - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Start Building&lt;/strong&gt;. This build will fail because we have not added our configuration file yet. We will do that later.&lt;/p&gt;

&lt;p&gt;The final thing we need to do on the CircleCI console is set up environment variables for the project we just added. This will enable our project to have authenticated access to our Heroku application for deployments.&lt;/p&gt;

&lt;p&gt;Go to your project’s settings by clicking &lt;strong&gt;Project Settings&lt;/strong&gt; on the &lt;code class=&quot;highlighter-rouge&quot;&gt;Pipelines&lt;/code&gt; page (make sure your project is the currently selected project).&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-project-settings.png&quot; alt=&quot;Project settings - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;On this page, click &lt;strong&gt;Environment Variables&lt;/strong&gt; on the side menu. Then click &lt;strong&gt;Add Environment Variable&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-add-variable.png&quot; alt=&quot;Add Environment variable - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Add the following environment variables:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;HEROKU_APP_NAME&lt;/code&gt;: This is the name of your Heroku application (in my case, &lt;code class=&quot;highlighter-rouge&quot;&gt;next-cd&lt;/code&gt;).&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;HEROKU_API_KEY&lt;/code&gt;: Your Heroku account API key. This can be found under the &lt;strong&gt;Account&lt;/strong&gt; tab on Heroku, under &lt;strong&gt;Account Settings&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Once added, you now have everything set up on your CircleCI console for deployment to Heroku.&lt;/p&gt;

&lt;h2&gt;Automating the deployment of the Next.js application&lt;/h2&gt;

&lt;p&gt;Now we can begin the process of building the automation script for the deployment of the Next.js application to Heroku.&lt;/p&gt;

&lt;p&gt;You need to create a &lt;code class=&quot;highlighter-rouge&quot;&gt;Procfile&lt;/code&gt; file containing instructions for Heroku to build and start the application. Create a file named &lt;code class=&quot;highlighter-rouge&quot;&gt;Procfile&lt;/code&gt; (no file extension) at the root of the project, and enter the following:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;npm run build
NODE_ENV=production npm run start
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The first command in this file creates a production optimized version of our Next.js application. The next command starts the application in production mode.&lt;/p&gt;

&lt;p&gt;Now we need to ensure that Heroku uses a dynamic port in production. Make this little change to the &lt;code class=&quot;highlighter-rouge&quot;&gt;start&lt;/code&gt; script in &lt;code class=&quot;highlighter-rouge&quot;&gt;package.json&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;...
&quot;start&quot;: &quot;next start -p $PORT&quot;
...
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;With this, our Next.js application will now use the dynamic &lt;code class=&quot;highlighter-rouge&quot;&gt;$PORT&lt;/code&gt; variable set by Heroku in production.&lt;/p&gt;

&lt;p&gt;Finally, we create our deployment script for CircleCI to build our deployment automation pipeline. In this script, we use CircleCI’s &lt;a href=&quot;https://circleci.com/developer/orbs/orb/circleci/heroku&quot;&gt;Heroku orb&lt;/a&gt; to deploy our application from our GitHub repository straight to Heroku. &lt;a href=&quot;https://circleci.com/orbs/&quot;&gt;Orbs&lt;/a&gt; are easy-to-use packages that abstract a lot of boilerplate and sometimes complex commands/workflows providing a developer-friendly API for use in our configuration files.&lt;/p&gt;

&lt;p&gt;At the root of your project, create a folder named &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci&lt;/code&gt; and a file named &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt; within it. Inside &lt;code class=&quot;highlighter-rouge&quot;&gt;config.yml&lt;/code&gt;, enter the following code:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1
orbs:
  heroku: circleci/heroku@0.0.10
workflows:
  heroku_deploy:
    jobs:
      - heroku/deploy-via-git
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In the configuration above, we pull in the Heroku orb (&lt;code class=&quot;highlighter-rouge&quot;&gt;circleci/heroku@0.0.10&lt;/code&gt;), which automatically gives us access to a powerful set of Heroku jobs and commands. One of those jobs is the &lt;code class=&quot;highlighter-rouge&quot;&gt;heroku/deploy-via-git&lt;/code&gt; job, which deploys your application straight from your GitHub repo to your Heroku account. This job already takes care of installing the Heroku CLI, installing project dependencies, running the build script, and deploying the application. It also picks up our environment variables to facilitate a smooth deployment to our Heroku application.&lt;/p&gt;

&lt;p&gt;It’s now time to test our work so far. Commit all changes to the project and push to your remote GitHub repository. This will automatically trigger the deployment pipeline.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-build-successful.png&quot; alt=&quot;Build Successful - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;By clicking on the build, you can see the deployment details.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-build-details.png&quot; alt=&quot;Build Details - CircleCI&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Don’t start the parade yet, sometimes a successful build doesn’t exactly equate to a successful deployment. There are still many things that can go wrong on the Heroku platform itself. To confirm that we have a successful deployment, go to your Heroku application dashboard and click &lt;code class=&quot;highlighter-rouge&quot;&gt;Open app&lt;/code&gt;. This will open the application at the Heroku-designated URL (&lt;code class=&quot;highlighter-rouge&quot;&gt;https://[APP_NAME].herokuapp.com&lt;/code&gt;). The default homepage below confirms a successful deployment. Yippee!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-site-live.png&quot; alt=&quot;Site Live - Heroku&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Now, let’s confirm that our changes are automatically deployed when we push them to our remote repository. Change the &lt;code class=&quot;highlighter-rouge&quot;&gt;h1&lt;/code&gt; tag in &lt;code class=&quot;highlighter-rouge&quot;&gt;./pages/index.js&lt;/code&gt; from:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;lt;h1 className={styles.title}&amp;gt;
    Welcome to &amp;lt;a href=&quot;https://nextjs.org&quot;&amp;gt;Next.js!&amp;lt;/a&amp;gt;
&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;to:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;lt;h1 className={styles.title}&amp;gt;
    Welcome to &amp;lt;a href=&quot;https://nextjs.org&quot;&amp;gt;My Next.js! Site&amp;lt;/a&amp;gt;
&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then commit and push the changes to trigger another deployment. Once the build is successful, refresh your live site and you will see the screen below.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-08-19-site-live-refresh.png&quot; alt=&quot;Site Live - Heroku&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Conclusion&lt;/h2&gt;

&lt;p&gt;Deploying little to large changes to an application by following a manual deployment process can quickly become a frustrating and laborious process. With CircleCI, you can automate the process, eliminating any worry about routine or human errors introduced by manual processes. In this tutorial, we have been able to successfully create an automated deployment pipeline to achieve seamless deployments for any change to our application, making them one less thing to worry about.&lt;/p&gt;

&lt;p&gt;Happy Coding!&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;&lt;a href=&quot;https://twitter.com/coderonfleek?lang=en&quot;&gt;Fikayo&lt;/a&gt; is a fullstack developer and author with over a decade of experience developing web and mobile solutions. He is currently the Software Lead at Tech Specialist Consulting and develops courses for Packt and Udemy. He has a strong passion for teaching and hopes to become a full-time author.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>A guide to productivity for software engineers</title>
        <link>https://circleci.com/blog/a-guide-to-productivity-for-software-engineers/</link>
        <pubDate>Tue, 06 Oct 2020 06:46:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/a-guide-to-productivity-for-software-engineers/</guid>
        
          <dc:creator>Tanya Ramankova</dc:creator>
        
        
          <description>&lt;h2&gt;The evolution of task management&lt;/h2&gt;

&lt;p&gt;When you start your career as a software engineer, task and time management is pretty straightforward. Either your boss or your team agile board tells you exactly what to work on. There are some distractions like Slack and email that you have to contend with but for the most part, it’s not too bad. You enjoy coding, your tasks are fun, you easily keep them in your mental to-do list, check them off, and feel pretty accomplished at the end of the day.&lt;/p&gt;

&lt;p&gt;You are good at what you do! Before long, you are asked to stretch yourself beyond just the items on your team agile board. You start helping with design and breaking down epics, you are asked to present in company events, you volunteer to help another team to integrate with your team’s service, you find yourself spending more time answering questions in Slack that require your expertise. Your work is becoming more ambiguous, more complex and more unbounded. You find yourself procrastinating. You feel more overwhelmed. But you think to yourself, “that’s what success should feel like!” and decide that with hard work, you surely will be on top of all the spinning plates – just stash more things on your mental to-do list, you got this! And if you forget to do something, it’s not a big deal, someone will surely remind you.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Your work is becoming more ambiguous, more complex and more unbounded, and you find yourself procrastinating.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;A bit more time passes, you are promoted yet again. Now you find yourself working less and less on items from the team agile board, and your days are spent in what feels like endless meetings, reviewing designs, domain models, architecture specs, researching new technologies, leading efforts, and writing even more documents, all under a constant barrage of questions and pings in Slack and email. Less of your work seems “fun”. When you look back on your day, you realize that you spent most of it in between meetings and answering a myriad of questions in Slack. You forgot or didn’t have time to make any progress on important stuff, a few of your spinning plates are now resting on the floor, untouched, with you actively resisting to find time for them and no one there to remind you about all of the things that are getting dropped. Some days, you are not really sure if you’ve accomplished anything…&lt;/p&gt;

&lt;h2&gt;Ambiguity up, productivity down&lt;/h2&gt;

&lt;p&gt;Does this sound familiar? If so, congratulations! You’ve been successful in your engineering career and you are working for an organization that is pushing you to grow! In my career, I definitely got to the point where I could no longer rely on simple streams of tasks that worked for me up until that point: those simple times when I could just pick something up from my team agile board or answer a manageable number of requests in Slack and get back that coveted :thankyou: emoji. It eventually became unreasonable for me to expect all of my work to be “fun” to naturally motivate me. And I had to reconcile the conflict between having to do more ambiguous, complex tasks that have very long cycles while still feeling good about my day (it’s easy to see something you coded getting deployed to production and feel accomplished, it’s much harder to look at a pile of documents you’ve read or created, or Slack threads you participated in, and feel the same).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Growing in your engineering career and taking on a leadership role requires a new approach to productivity.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I’ve always been interested in productivity. After reading many books and articles on the topic and trying various techniques, I eventually figured out that &lt;em&gt;productivity is not about doing more.&lt;/em&gt; The question that kept popping up again and again on my quest to “being more productive” was very simple and had little to do with the number of things I’d done or how busy I’d been. Instead it was simply, “What have I accomplished today?”.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;The question that kept popping up again and again was, “What have I accomplished today?”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Using advice from numerous productivity resources (&lt;a href=&quot;https://www.amazon.com/dp/B00Z3G239W&quot;&gt;Productivity Project&lt;/a&gt;, &lt;a href=&quot;https://zenhabits.net/zen-to-done-ztd-the-ultimate-simple-productivity-system/&quot;&gt;Zen To Done&lt;/a&gt;, &lt;a href=&quot;https://bulletjournal.com/&quot;&gt;Bullet Journal&lt;/a&gt;, &lt;a href=&quot;https://www.amazon.com/Getting-Things-Done-Stress-Free-Productivity/dp/0143126563&quot;&gt;Getting Things Done&lt;/a&gt; and many others) I developed a sustainable system that worked for me, that could allow me to keep track of all the spinning plates without getting overwhelmed and that would help me feel like I accomplished something useful at the end of the day.&lt;/p&gt;

&lt;h2&gt;Productivity when engineering work gets ambiguous&lt;/h2&gt;

&lt;h3&gt;1. Choose my focus&lt;/h3&gt;
&lt;p&gt;The first step was to become deliberate about what I work on. As engineers we can work on many different things, some of them are purely enjoyable, some make our product better, some enable our teammates, some help other teams or our company. How do we choose what to focus on any given day?&lt;/p&gt;

&lt;p&gt;To help me decide I listed out all of the possible focus areas that I could put my energy towards: learning, coding features, making architectural improvements, mentoring/coaching, improving team or organization processes, growing engineering influence, etc. Each month (or quarter) I pick only 3 focus areas where I am going to put most of my energy. To help me decide, I answer the following questions for each of the focus areas:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Do I enjoy this? &lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help me/my career? &lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help my team right now?&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;Does this help my company right now?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;My answers might change month to month. For example, improving team processes might actually not help my team right now if there are other folks on my team who are already doing that. I try to have a combination of things that I enjoy as well as things that I might resist but which help me, my team, or my company. I begrudgingly recognize that discomfort very frequently means growth, so I force myself to try some of the areas that feel “hard” or ”not fun”. At the same time I know that these challenging areas will require significantly more energy, so choosing 3 “hard” areas at once most likely will result in me resisting to make progress in any of them. Sustainable discomfort (or growth) is the key!&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Discomfort very frequently means growth.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Once I have my areas of focus chosen I will use them as the filter throughout the month or quarter for any work that is coming my way. I’ll also seek out opportunities and originate work that fall within my top 3 focus areas. This allows me to initiate interesting streams of work that no one specifically asked me to do. Having this filter doesn’t necessarily mean that I will not do any work outside of these areas (good luck telling your boss you are refusing to do something because it doesn’t align with your focus for this month). But, if I have a choice, I’ll choose tasks that align and punt on tasks that don’t.&lt;/p&gt;

&lt;h3&gt;2. Get things done&lt;/h3&gt;
&lt;p&gt;The second step was to become deliberate in how I make progress in the areas I chose (or how I work). &lt;a href=&quot;https://zenhabits.net/zen-to-done-ztd-the-ultimate-simple-productivity-system/&quot;&gt;Zen To Done (ZTD)&lt;/a&gt; talks about choosing &lt;a href=&quot;https://zenhabits.net/big-rocks-first-double-your-productivity-this-week/&quot;&gt;big rocks&lt;/a&gt; for your week and choosing &lt;a href=&quot;https://zenhabits.net/purpose-your-day-most-important-task/&quot;&gt;MITs (most important tasks)&lt;/a&gt; for your day. The idea is that if you don’t prioritize your “big rocks”, tiny pebbles will fill your day and you won’t accomplish very much. I found that once I had my direction set I could deliberately plan my week by choosing top 2-3 projects or tasks (aka big rocks) that I’d like to make progress on this week. And then each day I could deliberately choose top 2-3 tasks that I’d like to accomplish and that would help to move my weekly big rocks forward. As you probably noticed it’s “choose top 3” all the way down!&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;if you don’t prioritize your “big rocks”, tiny pebbles will fill your day and you won’t accomplish very much.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;For any plan to work it needs to be realistic and achievable. Before the start of each week I look at my schedule to see what meetings I have that week. Do I need to prepare for any of them? If so, prep can become one of my MITs some day before the meeting. Are there any meetings related to projects in my focus areas? If so, I can choose those projects as my big rocks for that week. Looking ahead also helps me judge how much time and energy I’ll actually have next week. If I have too many context switches throughout the week, it’s unlikely I’ll have a ton of energy left to work on anything challenging. I also try to find chunks of meeting-free time in my schedule and intentionally block them off for focused work.&lt;/p&gt;

&lt;p&gt;Before the start of each day I do more tactical planning for that day: are there any tasks still remaining to accomplish my weekly big rocks? Do I need to course correct and do something that came up during the week? Is it more important than what I had planned to do? I also try to split my day into “reactive” and “focused” parts. During reactive time I let myself “wander around” and simply react to things that show up, reply to questions or requests in Slack, check email, attend meetings. But during my focus time I try my best to disconnect, shut down or at least minimize Slack, close email and other sources of notifications and actually work on what I planned to do that day. For any new task or request that pops up I simply write it down to follow up later. Writing it down (as opposed to keeping it in my brain space) gives me a peace of mind that I won’t forget to do it later but it also allows me to keep focusing on my planned work and resist the temptation of switching context. It’s quite odd just how much our brains love the idea of multitasking and getting distracted given how ineffective we actually are at doing more than one thing at a time.&lt;/p&gt;

&lt;h3&gt;3. Analyze and iterate&lt;/h3&gt;
&lt;p&gt;Planning and, more importantly, sticking to the plan is an essential part of my weekly and daily ritual. It allows me to focus on things that actually matter to me and it forces me to break down large ambiguous projects into smaller achievable tasks. Being deliberate and spending time planning has another interesting side effect: I can look back on my week or my day, review and celebrate things I’ve accomplished (a nice motivation boost!), and I can also analyze tasks that I resisted. We tend to procrastinate on things that are too hard or too boring.  Analyzing what caused me to resist a task can often help me to overcome that natural tendency. I spend a bit of time during my weekly planning thinking about “why”s for my big rocks: why should I do this project or this task? Just answering that question often motivates me enough to push through some of the harder or less “fun” items on my list. All of a sudden something that was boring becomes much more motivating. And if something is too hard or ambiguous I try to answer a simple question: what is the very next tiny step I can take to make some forward progress? Often it doesn’t need to be a very ambitious first step, sometimes just scheduling a meeting to brainstorm some ideas with someone else is enough. And once you make that first step, you can figure out the next step to take.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;By answering “why,” all of a sudden something that was boring becomes much more motivating.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Planning and being deliberate really helped me realize that you can make significant progress on large projects by taking tiny steps forward. When we train running a long distance we naturally understand this concept: if all I think about is the finish line it’s very easy for me to get discouraged as soon as I get tired: I have still too far to go, I should just stop now. But if I focus on running till that tree that is just a mile ahead and once I get there I will celebrate that small win and decide if I want to stop or if I should pick my next target, all of a sudden the path becomes manageable.&lt;/p&gt;

&lt;p&gt;Too often we don’t realize how important celebrating these small wins is to keep us going. This is especially important when working on large, complex, ambiguous and unbounded projects. We set our eyes on the end goal and refuse to enjoy the ride until the entire project is “finished”. But as you grow, your finish lines move farther and farther away. It might take months or even longer for some of your initiatives to have a visible impact (if any), and very often when it actually comes to fruition so many different folks and teams have contributed to its success that it’ll be very hard for you to look back and feel accomplished. How much did you actually matter?&lt;/p&gt;

&lt;p&gt;&lt;i&gt;Focusing on simply making progress towards things that matter and enjoying the journey is what will make you resilient, tenacious and help you reach your desired destination and choose a meaningful path along the way.&lt;/i&gt;&lt;/p&gt;

&lt;h2&gt;An example from my planner&lt;/h2&gt;

&lt;p&gt;I actually applied everything I’ve explained above to how I wrote this blog post.&lt;/p&gt;

&lt;p&gt;My first tiny step: ping our awesome content manager about my random blog idea. She suggested we have a quick meeting to brainstorm.&lt;/p&gt;

&lt;p&gt;Second tiny step: schedule said meeting. One day before the meeting, do a brain dump of what I might cover in the blog.&lt;/p&gt;

&lt;p&gt;During the meeting she asked how long would it take to get a first draft. I threw out “two weeks” (not too ambitious but not so long that it will give me time to change my mind or lose interest).&lt;/p&gt;

&lt;p&gt;For the next two weeks, “Blog” was one of my big rocks, and each day I saw if it could become one of my MITs for that day. I didn’t set out to write the whole thing on any given day – instead I set a goal to just make some forward progress. Dump ideas one day, refine and edit on another day, then realize I have a few more ideas to add, write some more, edit some more. Some days I planned to work on my blog but I didn’t and it was OK. I know that my daily and weekly planning and splitting things up into tiny steps would make it possible for me to keep going and to make progress. I got a few good writing sessions in both weeks and had the draft ready with 2 days to spare. Success!&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Why every business needs CI/CD to succeed: a Q&amp;A with Jim Rose and Cack Wilhelm</title>
        <link>https://circleci.com/blog/rise-above-your-competitors-with-ci-cd-a-q-a-with-jim-rose-and-cack-wilhelm/</link>
        <pubDate>Mon, 05 Oct 2020 08:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/rise-above-your-competitors-with-ci-cd-a-q-a-with-jim-rose-and-cack-wilhelm/</guid>
        
          <dc:creator>Molly Fosco</dc:creator>
        
        
          <description>&lt;p&gt;In April, we welcomed Cack Wilhelm, a partner at venture capital firm IVP, to the CircleCI board of directors. Cack is our first female board member and previously worked with CircleCI during our Series B while at Scale Venture Partners. At IVP, Cack focuses on investing in growth-stage technology companies.&lt;/p&gt;

&lt;p&gt;Our CEO, Jim Rose, recently sat down with Cack on &lt;a href=&quot;https://www.ivp.com/news/podcast/ivps-hypergrowth-podcast-circleci-ceo-jim-rose-on-the-rise-of-software-delivery-as-a-competitive-differentiator-and-what-its-like-hitting-the-stride-of-hypergrowth/&quot;&gt;IVP’s Hypergrowth podcast&lt;/a&gt; to discuss the rise of software delivery as a competitive differentiator, and what it’s like achieving hypergrowth and adjusting CircleCI as an organization. Jim and Cack also covered how &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; and deployment have become key in achieving success for businesses, the decision-making power of developers, and what makes CircleCI a leader in the CI/CD space. 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cack Wilhelm:&lt;/strong&gt; I’d love to hear about the secular trends behind CircleCI. What do you see in the industry right now that’s continuing to drive demand for a solution like CircleCI? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Jim Rose:&lt;/strong&gt; Back in 2011 and 2012, when CircleCI was started, this idea of being able to ship code as quickly as you made changes was pretty new. Over the last &lt;a href=&quot;https://circleci.com/blog/circleci-celebrates-nine-years-millionth-user/&quot;&gt;nine years&lt;/a&gt;, instead of being a really fringe idea, continuous deployment has become the aspirational North Star for pretty much every software delivery team out there.&lt;/p&gt;

&lt;p&gt;The minute COVID hit, for example, and everyone became not just remote-first, but remote-only, you realized you could no longer rely on a build machine sitting underneath somebody’s desk.&lt;/p&gt;

&lt;p&gt;This idea of automation, of being able to move quickly and to move reliably, has become not just a ‘nice to have.’ It’s become core to what you have to do as a software delivery team.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; What we’re really talking about here is developers — this idea of developers as first-class individuals within an organization that have a budget and decision power.&lt;/p&gt;

&lt;p&gt;You know I haven’t been in venture that long, maybe six or seven years, and I still remember talking about the IT buyer. It was very much about the IT and the security buyer, and never did we discuss the developer buyer. But given your go-to-market strategy and your emphasis on the developer, how has that buyer of system software evolved in the past six or seven years? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; For the longest time, developers were just expected to build things. They were given a set of tools, told what to build, and seen as a cost center as opposed to an opportunity and an investment. As more companies have become software-driven, that perspective has really shifted. Instead of seeing your development team as this cost center that you’re trying to control, you’re really thinking about how you can maximize the capabilities and productivity of these very expensive folks who are difficult to hire.&lt;/p&gt;

&lt;p&gt;The value of speed is very clear to an IT organization. It’s no longer about control. It’s about trying to create carrots or incentives to use the same toolset. It’s about building tools on behalf of all the software development teams inside of an enterprise.&lt;/p&gt;

&lt;p&gt;You find more often than not that developers like to &lt;a href=&quot;https://circleci.com/blog/getting-your-manager-to-say-yes-to-devops-tools/&quot;&gt;pick and choose the best tool&lt;/a&gt; for the job, whatever that particular job is, and then put the onus on the company to figure out how to work with everything else they have inside of their &lt;a href=&quot;https://circleci.com/blog/the-best-dev-tools-used-by-circleci-engineers/&quot;&gt;toolbox&lt;/a&gt;.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; I want to talk about the idea of bundling and unbundling. Mobile and Linux, for example, providing the same thing, seems like software used to really go through cycles. There was this great push for bundled and then, a push for the opposite. Where do you think we are in the cycle right now? What gives you confidence that being a best-in-breed platform, one that provides a big chunk of the software delivery lifecycle, is the right approach? 
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; There’s been a lot of movement in the market recently of folks trying to build end-to-end platforms in the development space. But if you look at the companies who’ve built those platforms, more often than not, 80 to 90 percent of their revenue still comes from their core product.&lt;/p&gt;

&lt;p&gt;What we’ve heard from customers is that they’re going to implement the best tool they can find for that particular problem at that particular time. Our position, our goal, and our mantra as a company is: we stay close to the customer. We make sure that we’re addressing their particular requirements and needs, and everything else will kind of work itself out.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; I’d love to switch gears and talk more specifically about CircleCI, especially the phase of hypergrowth that you’re experiencing right now. I have the good fortune of seeing CircleCI’s series B phase and then getting reinvolved with the &lt;a href=&quot;https://circleci.com/blog/announcing-circleci-s-100m-series-e/&quot;&gt;series E from IVP&lt;/a&gt;. I must admit, it was kind of fun to take a break and come back to a massively scaled, mature organization without seeing all the increments along the way.&lt;/p&gt;

&lt;p&gt;Can you share more about the growth phase coming into this recent fundraising round, and what it’s like hitting hypergrowth and adjusting the organization? I’m sure there are some differences between go-to-market functions versus engineering, and what about mundane stuff like hiring, onboarding, and office space?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; The way you scale is by making the mundane highly leverageable. The first requirement I have for everyone on our exec team is they have to be a great &lt;a href=&quot;https://circleci.com/blog/how-we-interview-software-engineers-what-we-ve-learned-what-we-ve-changed/&quot;&gt;recruiter&lt;/a&gt;. It’s not about hiring the first person — you’re going to have to hire 15 more in the next six months. How do you make that scalable and repeatable over time? It’s the same thing with infrastructure, whether it’s office space, tools, or having a globally managed set of HR policies in place.&lt;/p&gt;

&lt;p&gt;As a founder, you’re trying to get all of that in place and make it scalable, make it effective, and make it resilient to change. It’s a marathon, not a sprint, but you’re going really fast. You have to make sure you do whatever you can to pace yourself as you continue to grow.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; Amazon, Microsoft and Alphabet certainly have a large part of their businesses that are pegged to cloud infrastructure spend, just as CircleCI does. A large part of Amazon, Microsoft, Alphabet, and Google’s businesses are akin to cloud infrastructure — a lot of what CircleCI does. If you also include DataDog and Atlassian, these companies are showing really strong growth, really strong public performance. From where you’re sitting, what do you make of the public markets as they relate to CircleCI and your next move?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; I think the understanding of the public market investor has really evolved. When we had conversations with public market investors in 2015 and 2016, they had absolutely no idea what we did. They didn’t understand software development as a key differentiator for companies, not just software companies, but for companies overall. I think about companies like Amazon, Google, Netflix, Facebook, and others — their ability to build software quickly is how they generate value inside their businesses.&lt;/p&gt;

&lt;p&gt;Increasingly, too, if you look at more traditional industries that have made real investments in technology over the last four or five years, they’re reaping those gains today. Target and Wal-Mart have made tremendous gains over the last six months since COVID started because they have a pretty robust technical platform at this point.&lt;/p&gt;

&lt;p&gt;When you compare that to more traditional retailers who haven’t made that investment, you can start to see the value of software and the value of agile processes in creating corporate value. The market has definitely woken up to &lt;a href=&quot;https://circleci.com/blog/why-continuous-integration-is-key-to-stepping-up-deployment-frequency/&quot;&gt;the competitive differentiator&lt;/a&gt; that software, and being a well-oiled software delivery machine, provides.
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CW:&lt;/strong&gt; What are you looking forward to as you move into this next phase of growth in the next year or two years? What’s exciting?
&lt;br /&gt;
&lt;br /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JR:&lt;/strong&gt; It’s exciting to watch companies that we may have talked to back in 2015 and weren’t ready for us, who are now leaning in and ready to adopt continuous delivery, and ready to deploy CircleCI as a foundation to that change.&lt;/p&gt;

&lt;p&gt;Some of &lt;a href=&quot;https://circleci.com/blog/we-raised-a-56m-series-d-what-s-next-for-circleci-customers/&quot;&gt;the brands we work with&lt;/a&gt; are doing incredibly interesting things from autonomous vehicles to space vehicles to machine learning to everyday mobile applications, and everything in between.&lt;/p&gt;

&lt;p&gt;When I talk to folks we’re trying to hire, I always say we’re in the engine room of the internet. We’re the company helping build all of those experiences that you consume each and every day, in a way that’s exciting and interesting and new. And whether you’re building a small open-source library or something for the U.S. Government, you can use CircleCI to support that.&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Adding approval jobs to your CI pipeline</title>
        <link>https://circleci.com/blog/adding-approval-jobs-to-your-ci-pipeline/</link>
        <pubDate>Fri, 02 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/adding-approval-jobs-to-your-ci-pipeline/</guid>
        
          <dc:creator>Travis Depuy</dc:creator>
        
        
          <description>&lt;p&gt;An explicit approval process can help reduce production issues, provide an audit trail, and give your organization confidence that your engineering teams are deploying the right code.&lt;/p&gt;

&lt;p&gt;In this article, we’ll go into detail about how to set up an approval job in your &lt;a href=&quot;https://circleci.com/continuous-integration/&quot;&gt;continuous integration&lt;/a&gt; pipeline so your developers must request approval before the &lt;a href=&quot;https://circleci.com/blog/what-is-a-ci-cd-pipeline/&quot;&gt;CI pipeline&lt;/a&gt; deploys to production.&lt;/p&gt;

&lt;h2&gt;How does it work?&lt;/h2&gt;
&lt;p&gt;A &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; job is added to your pipeline, making use of the &lt;a href=&quot;https://circleci.com/developer/orbs/orb/xmatters/xmatters-orb&quot;&gt;xMatters orb&lt;/a&gt;, which passes a workflow’s details to &lt;a href=&quot;https://www.xmatters.com/&quot;&gt;xMatters&lt;/a&gt;. xMatters then sends out the notifications across a range of devices to reach the current on-call approval resource. Using the response options, the approver can then choose to approve or reject the request. On approval, a request is made to CircleCI’s &lt;a href=&quot;https://circleci.com/docs/api/v2/#operation/approvePendingApprovalJobById&quot;&gt;approve a job API endpoint&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Let’s walk through how to set up your approval requests so that you can maintain oversight of any changes to your production code before they happen.&lt;/p&gt;

&lt;h2&gt;Prerequisites&lt;/h2&gt;

&lt;p&gt;To begin, you’ll need the following:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;A &lt;a href=&quot;https://circleci.com/signup/&quot;&gt;CircleCI&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;An &lt;a href=&quot;https://www.xmatters.com/signup&quot;&gt;xMatters&lt;/a&gt; account&lt;/li&gt;
  &lt;li&gt;A repo with a project that needs an approval job&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The approval process we’ll be discussing uses the &lt;a href=&quot;https://circleci.com/docs/api/v2/#operation/approvePendingApprovalJobById&quot;&gt;approve a job&lt;/a&gt; API call to approve the job. The process for doing this is similar for a variety of tools but this post will focus on using &lt;a href=&quot;https://www.xmatters.com/&quot;&gt;xMatters&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Configuring CircleCI&lt;/h2&gt;

&lt;p&gt;At a high level, we need to update the &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci/config.yml&lt;/code&gt; file, set the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value, and then store the personal token in xMatters. Let’s get started.&lt;/p&gt;

&lt;p&gt;This is a simple build, hold, request approval, and deploy configuration file.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;version: 2.1

orbs:
  xmatters: xmatters/xmatters-orb@1.0.4

jobs:
  build:
    docker: 
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Building building building!&quot;

  request-approval:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - xmatters/notify:
          recipients: Engineering Managers

  hold:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Hold for approval&quot;

  deploy-stuff:
    docker:
      - image: circleci/node:4.8.2
    steps:
      - run: echo &quot;Deploy stuff here&quot;

workflows:
  build-test-and-approval-deploy:
    jobs:
      - build
      - request-approval
      - hold:
          type: approval
          requires:
            - build
            - request-approval
      - deploy-stuff:
          requires:
            - hold
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The items to note here are the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; jobs. You can see in the workflows section that the hold job, marked as type &lt;code class=&quot;highlighter-rouge&quot;&gt;approval&lt;/code&gt;, is dependent on the successful execution of the &lt;code class=&quot;highlighter-rouge&quot;&gt;build&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; jobs. The &lt;code class=&quot;highlighter-rouge&quot;&gt;deploy-stuff&lt;/code&gt; job is then dependent on the successful execution of the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; job. This means that the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; job halts the execution of the workflow until the app is built successfully and the &lt;code class=&quot;highlighter-rouge&quot;&gt;request-approval&lt;/code&gt; job, which uses the xMatters orb, is executed.&lt;/p&gt;

&lt;p&gt;We’re targeting the &lt;code class=&quot;highlighter-rouge&quot;&gt;Engineering Management&lt;/code&gt; group so that the current on-call engineering manager can approve (or reject!) the pipeline. Once the hold job is approved, the pipeline continues with the &lt;code class=&quot;highlighter-rouge&quot;&gt;deploy-stuff&lt;/code&gt; job, and the code is deployed to production.&lt;/p&gt;

&lt;p&gt;We need to set the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value in the project settings in CircleCI. Before that, we will grab a personal API token so that xMatters can properly authenticate. Head over to your account settings and select the &lt;strong&gt;Personal API Tokens&lt;/strong&gt; tab.&lt;/p&gt;

&lt;p align=&quot;center&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters1.png&quot; width=&quot;900&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Create New Token&lt;/strong&gt; and copy the value to a text file until we’re ready to use it.&lt;/p&gt;

&lt;h2&gt;Configuring xMatters&lt;/h2&gt;

&lt;p&gt;Next, head over to your xMatters instance and navigate to the &lt;strong&gt;Workflows&lt;/strong&gt; screen. Click &lt;strong&gt;Import Workflow&lt;/strong&gt; and find the &lt;code class=&quot;highlighter-rouge&quot;&gt;CircleCI.zip&lt;/code&gt; file. This file can be downloaded from the repo, &lt;a href=&quot;https://github.com/xmatters/xm-labs-circleci-orb&quot;&gt;here&lt;/a&gt;. Once imported, click into the workflow and navigate to the &lt;strong&gt;Flows&lt;/strong&gt; tab. There will be two canvases listed. In this case, we want &lt;strong&gt;Approval Request&lt;/strong&gt;, which has the logic to deal with most responses.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters2.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Clicking into the canvas shows the steps laid out with the step palette on the right side.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters3.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;We are here to get the inbound URL, so double click on the &lt;strong&gt;Approval Request - Inbound from CircleCI&lt;/strong&gt; step in the upper left corner. This will display &lt;strong&gt;HTTP Trigger&lt;/strong&gt; dialog with our inbound URL. Copy this value and keep it handy for later.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters4.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;Exit that window and navigate back to &lt;strong&gt;Workflows&lt;/strong&gt;. Click the &lt;strong&gt;Admin gear&lt;/strong&gt; at the bottom of the navigation menu and click &lt;strong&gt;Custom Fields&lt;/strong&gt;. These fields are metadata tied to a user. It is where we will store the access token.&lt;/p&gt;

&lt;p align=&quot;center&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters5.png&quot; width=&quot;900&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Click &lt;strong&gt;Add Field&lt;/strong&gt; and give it the name “CircleCI Token Plain”.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;It is important that you use this name, as it is used in the “Find User Property Value” step back on the flow designer canvas. If you use a different name here, make sure to change the name there as well.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;Set the type as &lt;code class=&quot;highlighter-rouge&quot;&gt;Text&lt;/code&gt;. Click &lt;strong&gt;Save&lt;/strong&gt;. We will then add the token to the user. If it is your token, click your username on the top right and click &lt;strong&gt;Profile&lt;/strong&gt;.&lt;/p&gt;

&lt;p align=&quot;right&quot;&gt;
   &lt;img src=&quot;/blog/media/2020-09-27-xmatters6.png&quot; width=&quot;300&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Dig out the personal token we copied from CircleCI and paste it into the field we just created.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters7.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;This token is stored in plain text, but only you and your supervisor have access to view this value. We are evaluating other methods of storing this token, so keep an eye out for changes in this space!&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;Finally, head back over to CircleCI and navigate to the project that needs approvals. Make sure to select the project in the list of pipelines as this will enable the &lt;strong&gt;Project Settings&lt;/strong&gt; button in the upper right corner. Clicking this button displays the settings for the project. We’re going to add the &lt;code class=&quot;highlighter-rouge&quot;&gt;XM_URL&lt;/code&gt; value as a new environment variable.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters8.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;The final step entails recipient set up. If you’re targeting a group, navigate to the &lt;strong&gt;Groups&lt;/strong&gt; section, create a new group, and add the appropriate users.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: &lt;i&gt;You will need to have your own token populated in the profile.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters9.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;h2&gt;Testing and approving&lt;/h2&gt;

&lt;p&gt;That’s it! When the pipeline gets triggered, it will be on hold at the &lt;code class=&quot;highlighter-rouge&quot;&gt;hold&lt;/code&gt; step we configured in the &lt;code class=&quot;highlighter-rouge&quot;&gt;.circleci/config.yml&lt;/code&gt; file.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters10.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;

&lt;p&gt;This will trigger a notification to the user we defined above in the &lt;code class=&quot;highlighter-rouge&quot;&gt;Create xMatters Event&lt;/code&gt; step. The designated recipient will get a notification with pipeline details as well as the necessary response options. This is how it will look on the xMatters mobile app, but the email is very similar. The image on the right is with the responses drawer open, showing the available responses.&lt;/p&gt;

&lt;p style=&quot;text-align: center&quot;&gt;
  &lt;img src=&quot;/blog/media/2020-09-27-xmatters11.png&quot; width=&quot;325&quot; alt=&quot;&quot; /&gt;
  &lt;img src=&quot;/blog/media/2020-09-27-xmatters12.png&quot; width=&quot;325&quot; alt=&quot;&quot; /&gt;
&lt;/p&gt;

&lt;p&gt;Just like that, selecting &lt;strong&gt;Approve&lt;/strong&gt; makes the API call back to CircleCI to approve the pipeline and deploy your code to production.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/blog/media/2020-09-27-xmatters13.png&quot; alt=&quot;&quot; /&gt;&lt;/p&gt;
</description>
        
      </item>
    
      
      <item>
        <title>Hacktoberfest 2020 is upon us: celebrate open source with CircleCI orbs</title>
        <link>https://circleci.com/blog/hacktoberfest-2020-is-upon-us-celebrate-open-source-with-circleci-orbs/</link>
        <pubDate>Thu, 01 Oct 2020 09:00:00 -0700</pubDate>
        <guid isPermaLink="true">https://circleci.com/blog/hacktoberfest-2020-is-upon-us-celebrate-open-source-with-circleci-orbs/</guid>
        
          <dc:creator>Jeremy Meiss</dc:creator>
        
        
          <description>&lt;p&gt;Every October, as the colors of the leaves change, and the weather turns cooler (or if you’re in the Southern Hemisphere, the opposite) a global phenomenon kicks off: Hacktoberfest!&lt;/p&gt;

&lt;p&gt;&lt;a href=&quot;https://hacktoberfest.digitalocean.com/&quot;&gt;Hacktoberfest&lt;/a&gt; is a month-long celebration of open source, started by DigitalOcean in 2014, and encourages awareness of, and participation in, the open source community. In 2019 alone, there were over &lt;em&gt;483k pull requests&lt;/em&gt; opened across over &lt;em&gt;154k repositories&lt;/em&gt;, with participants from &lt;em&gt;142 countries&lt;/em&gt; – a truly impressive achievement by the community.&lt;/p&gt;

&lt;p&gt;Here at CircleCI we’ve always believed strongly in open source, and the value that it can bring to organizations. We have a long history of &lt;a href=&quot;https://circleci.com/open-source/&quot;&gt;supporting open source projects&lt;/a&gt; on CircleCI, and many of the &lt;a href=&quot;https://circleci.com/blog/leading-open-source-ml-advancements-an-introduction-to-pytorch/&quot;&gt;largest open source projects&lt;/a&gt; use CircleCI in their pipelines.&lt;/p&gt;

&lt;p&gt;For this year’s event, anyone who meets the &lt;a href=&quot;https://hacktoberfest.digitalocean.com/details&quot;&gt;Hacktoberfest core requirements&lt;/a&gt; (minimum of 4 valid PRs submitted to an open source project) will receive event swag, including a Hacktoberfest t-shirt and stickers from the supporting sponsors.&lt;/p&gt;

&lt;h2&gt;Orbtoberfest: hack OSS with CircleCI orbs&lt;/h2&gt;

&lt;p&gt;Last year, we launched our first “&lt;a href=&quot;https://circleci.com/blog/join-the-party-get-your-hacktoberfest-prs-with-circleci-orbs/&quot;&gt;Orbtoberfest&lt;/a&gt;” to coincide with Hacktoberfest.  Orbtoberfest encouraged the community to learn about &lt;a href=&quot;https://circleci.com/docs/2.0/using-orbs/&quot;&gt;CircleCI orbs&lt;/a&gt;: reusable packages of YAML configuration that condenses repeated lines of config into a single line of code. Orbs help you package, ship, and re-use code. We’re revisitng Orbtoberfest this year, to help more developers learn about orbs and Hacktoberfest. You also have the chance to double your prize haul with our unique, limited edition swag.&lt;/p&gt;

&lt;h2&gt;How to get involved&lt;/h2&gt;
&lt;p&gt;There are a few ways to get involved this year. To participate in Hacktoberfest, &lt;a href=&quot;https://hacktoberfest.digitalocean.com/&quot;&gt;register with DigitalOcean&lt;/a&gt; and submit 4 PRs that meet the specifications outlined on their page throughout the month of October. As a reward, receive Hacktoberfest swag or donate to plant a tree instead. To participate in CircleCI Orbtoberfest, you have a few options, outlined below. We hope you’ll &lt;a href=&quot;https://circleci.com/blog/how-to-make-an-easy-and-valuable-open-source-contribution-with-circleci-orbs/&quot;&gt;contribute to CircleCI orbs&lt;/a&gt; to complete the challenge!&lt;/p&gt;

&lt;h3&gt;The challenges:&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Challenge 1&lt;/strong&gt;&lt;br /&gt;
Create a PR, &lt;strong&gt;with “Orbtoberfest” as the label&lt;/strong&gt;, to include orb usage on an existing CircleCI config and get that PR accepted or merged. Valid contributions to other CircleCI repos, like Docs, may also be considered.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prizes:&lt;/strong&gt;&lt;br /&gt;
1-3 PRs receive a sticker pack
4 PRs receive stickers and a T-shirt&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Challenge 2:&lt;/strong&gt;&lt;br /&gt;
Develop and publish an orb using the &lt;a href=&quot;/docs/2.0/orb-author-intro/&quot;&gt;Orb Development Kit&lt;/a&gt;. Make sure your orb solves a challenge that other developers might be facing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Prizes:&lt;/strong&gt;&lt;br /&gt;
Sticker pack
T-shirt
Limited edition Orbtoberfest pin
&lt;br /&gt;
&lt;br /&gt;
Once you’ve completed the challenge(s) above, fill out &lt;a href=&quot;https://circleci-community.typeform.com/to/mErGL0nv&quot;&gt;this form&lt;/a&gt; to receive your swag. After the month of October is over, we will process all submissions, verify them, and let you know how you can claim your special CircleCI swag. We are so excited to see all of the contributions to open source and our orbs that will be created this year!&lt;/p&gt;

&lt;p&gt;Make sure to join the &lt;a href=&quot;https://discuss.circleci.com/t/official-hacktoberfest-and-orbtoberfest-thread/37510/&quot;&gt;Orbtoberfest&lt;/a&gt; discussion on our community forum for ideas, FAQs, and to ask any questions. You can also follow along with the conversations on Twitter via the &lt;a href=&quot;https://twitter.com/search?q=%23hacktoberfest&amp;amp;f=live&quot;&gt;#hacktoberfest&lt;/a&gt; and &lt;a href=&quot;https://twitter.com/search?q=%23orbtoberfest&amp;amp;f=live&quot;&gt;#orbtoberfest&lt;/a&gt; hashtags!&lt;/p&gt;
</description>
        
      </item>
    
  </channel>
</rss>

-  recorded_at: Wed, 21 Oct 2020 15:08:31 GMT
-- request:
-    method: get
-    uri: https://medium.com/feed/@macsiri/
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 301
-      message: Moved Permanently
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:31 GMT
-      Content-Type:
-      - text/html; charset=utf-8
-      Content-Length:
-      - '67'
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Location:
-      - https://medium.com/feed/@macsiri
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      X-Envoy-Upstream-Service-Time:
-      - '1'
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d706b0000cd0a97b8d000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      X-Content-Type-Options:
-      - nosniff
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be4fa492dcd0a-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: UTF-8
-      string: "<a href=\"https://medium.com/feed/@macsiri\">Moved Permanently</a>.\n\n"
-  recorded_at: Wed, 21 Oct 2020 15:08:31 GMT
-- request:
-    method: get
-    uri: https://medium.com/feed/@macsiri
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Cookie:
-      - __cfduid=dbdb508a99b43ab3e3eac55b15191543b1603292911; __cfruid=770a5be1e27909caf84c7bd86d70847695a83641-1603292911
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-      Accept:
-      - "*/*"
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Wed, 21 Oct 2020 15:08:32 GMT
-      Content-Type:
-      - text/xml; charset=UTF-8
-      Transfer-Encoding:
-      - chunked
-      Connection:
-      - keep-alive
-      Sepia-Upstream:
-      - medium
-      Cache-Control:
-      - private, must-revalidate, max-age=900
-      Content-Security-Policy:
-      - 'default-src ''self''; connect-src https://localhost https://*.instapaper.com
-        https://*.stripe.com https://glyph.medium.com https://*.paypal.com https://*.braintree-api.com
-        https://*.braintreegateway.com https://accounts.google.com https://getpocket.com
-        https://medium.com https://*.medium.com https://*.medium.com https://medium.com
-        https://*.medium.com https://*.algolia.net https://cdn-static-1.medium.com
-        https://dnqgz544uhbo8.cloudfront.net https://cdn-videos-1.medium.com https://cdn-audio-1.medium.com
-        https://lightstep.medium.systems https://*.branch.io ''self''; font-src data:
-        https://*.amazonaws.com https://*.medium.com https://glyph.medium.com https://medium.com
-        https://*.gstatic.com https://dnqgz544uhbo8.cloudfront.net https://cdn-static-1.medium.com
-        ''self''; frame-src chromenull: https: webviewprogressproxy: medium: ''self'';
-        img-src blob: data: https: ''self''; media-src https://*.cdn.vine.co https://d1fcbxp97j4nb2.cloudfront.net
-        https://d262ilb51hltx0.cloudfront.net https://*.medium.com https://gomiro.medium.com
-        https://miro.medium.com https://pbs.twimg.com ''self'' blob:; object-src ''self'';
-        script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
-        ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
-      Expires:
-      - Wed, 21 Oct 2020 15:23:32 GMT
-      Link:
-      - <https://medium.com/humans.txt>; rel="humans"
-      Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
-      Pragma:
-      - private
-      X-Content-Type-Options:
-      - nosniff
-      X-Envoy-Upstream-Service-Time:
-      - '20'
-      X-Frame-Options:
-      - sameorigin
-      X-Obvious-Info:
-      - 42755-064957c,064957ce014
-      X-Obvious-Tid:
-      - 1603292912095:f99aa8848e99
-      X-Opentracing:
-      - '{"ot-tracer-spanid":"287206d02e177dda","ot-tracer-traceid":"7d2a8a382be53df4","ot-tracer-sampled":"true"}'
-      X-Powered-By:
-      - Medium
-      X-Ua-Compatible:
-      - IE=edge, Chrome=1
-      X-Xss-Protection:
-      - 1; mode=block
-      Strict-Transport-Security:
-      - max-age=15552000; includeSubDomains; preload
-      Cf-Cache-Status:
-      - DYNAMIC
-      Cf-Request-Id:
-      - 05ed4d71470000cd16ee982000000001
-      Expect-Ct:
-      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
-      Server:
-      - cloudflare
-      Cf-Ray:
-      - 5e5be4fbaaf0cd16-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
-    body:
-      encoding: ASCII-8BIT
-      string: !binary |-
-        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
-  recorded_at: Wed, 21 Oct 2020 15:08:32 GMT
-recorded_with: VCR 6.0.0
diff --git a/spec/support/fixtures/vcr_cassettes/Feeds_Import/when_feed_referential_link_is_false/does_not_self-reference_links_for_user.yml b/spec/support/fixtures/vcr_cassettes/feeds_import_non_referential.yml
similarity index 86%
rename from spec/support/fixtures/vcr_cassettes/Feeds_Import/when_feed_referential_link_is_false/does_not_self-reference_links_for_user.yml
rename to spec/support/fixtures/vcr_cassettes/feeds_import_non_referential.yml
index a5f175c48..234171289 100644
--- a/spec/support/fixtures/vcr_cassettes/Feeds_Import/when_feed_referential_link_is_false/does_not_self-reference_links_for_user.yml
+++ b/spec/support/fixtures/vcr_cassettes/feeds_import_non_referential.yml
@@ -19,11 +19,11 @@ http_interactions:
       message: Moved Permanently
     headers:
       Date:
-      - Wed, 21 Oct 2020 15:08:42 GMT
+      - Tue, 05 Jan 2021 10:57:45 GMT
       Content-Type:
       - text/html; charset=utf-8
-      Content-Length:
-      - '67'
+      Transfer-Encoding:
+      - chunked
       Connection:
       - keep-alive
       Sepia-Upstream:
@@ -31,7 +31,7 @@ http_interactions:
       Location:
       - https://medium.com/feed/@macsiri
       Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
+      - valencia/main-20210104-181409-1cdaa084a4
       X-Envoy-Upstream-Service-Time:
       - '0'
       Strict-Transport-Security:
@@ -39,7 +39,7 @@ http_interactions:
       Cf-Cache-Status:
       - DYNAMIC
       Cf-Request-Id:
-      - 05ed4d9bd60000cd421587d000000001
+      - 0773cb29480000202c8429a000000001
       Expect-Ct:
       - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
       X-Content-Type-Options:
@@ -47,13 +47,11 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 5e5be53fbc48cd42-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
+      - 60ccae220bc0202c-AMS
     body:
       encoding: UTF-8
       string: "<a href=\"https://medium.com/feed/@macsiri\">Moved Permanently</a>.\n\n"
-  recorded_at: Wed, 21 Oct 2020 15:08:42 GMT
+  recorded_at: Tue, 05 Jan 2021 10:57:45 GMT
 - request:
     method: get
     uri: https://medium.com/feed/@macsiri
@@ -62,7 +60,7 @@ http_interactions:
       string: ''
     headers:
       Cookie:
-      - __cfduid=d83cfe3836c1078607110a5fc80192d021603292922; __cfruid=880a68186330688cb4c6ad62b07be5b6b3deb196-1603292922
+      - __cfduid=d8732a06803e42f32ecfdc844b8d661951609844265; __cfruid=292fef9ba6897464c521e21a2629c0c602c9c8bf-1609844265
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
@@ -75,7 +73,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Wed, 21 Oct 2020 15:08:43 GMT
+      - Tue, 05 Jan 2021 10:57:45 GMT
       Content-Type:
       - text/xml; charset=UTF-8
       Transfer-Encoding:
@@ -103,25 +101,25 @@ http_interactions:
         script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
         ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
       Expires:
-      - Wed, 21 Oct 2020 15:23:43 GMT
+      - Tue, 05 Jan 2021 11:12:45 GMT
       Link:
       - <https://medium.com/humans.txt>; rel="humans"
       Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
+      - valencia/main-20210104-181409-1cdaa084a4
       Pragma:
       - private
       X-Content-Type-Options:
       - nosniff
       X-Envoy-Upstream-Service-Time:
-      - '28'
+      - '25'
       X-Frame-Options:
       - sameorigin
       X-Obvious-Info:
-      - 42755-064957c,064957ce014
+      - 20210104-2143-root,c5c3cfea
       X-Obvious-Tid:
-      - 1603292923457:6b789e9f56e2
+      - 1609844265589:9000882f023b
       X-Opentracing:
-      - '{"ot-tracer-spanid":"6c5f43e0091c2721","ot-tracer-traceid":"13b558f883cacd4b","ot-tracer-sampled":"true"}'
+      - '{"ot-tracer-spanid":"01657f995d888773","ot-tracer-traceid":"55ee1604bb8b7c04","ot-tracer-sampled":"true"}'
       X-Powered-By:
       - Medium
       X-Ua-Compatible:
@@ -133,20 +131,18 @@ http_interactions:
       Cf-Cache-Status:
       - DYNAMIC
       Cf-Request-Id:
-      - 05ed4d9cc20000cd22c89f1000000001
+      - 0773cb2a2e000072e12f938000000001
       Expect-Ct:
       - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
       Server:
       - cloudflare
       Cf-Ray:
-      - 5e5be5413cbbcd22-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
+      - 60ccae23785a72e1-AMS
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Wed, 21 Oct 2020 15:08:43 GMT
+        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
+  recorded_at: Tue, 05 Jan 2021 10:57:45 GMT
 - request:
     method: get
     uri: https://medium.com/feed/@macsiri/
@@ -166,7 +162,7 @@ http_interactions:
       message: Moved Permanently
     headers:
       Date:
-      - Wed, 21 Oct 2020 15:08:43 GMT
+      - Tue, 05 Jan 2021 10:57:46 GMT
       Content-Type:
       - text/html; charset=utf-8
       Content-Length:
@@ -178,15 +174,15 @@ http_interactions:
       Location:
       - https://medium.com/feed/@macsiri
       Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
+      - valencia/main-20210104-181409-1cdaa084a4
       X-Envoy-Upstream-Service-Time:
-      - '0'
+      - '1'
       Strict-Transport-Security:
       - max-age=15552000; includeSubDomains; preload
       Cf-Cache-Status:
       - DYNAMIC
       Cf-Request-Id:
-      - 05ed4d9f8f00006f5e1d04f000000001
+      - 0773cb2bec00000c251586d000000001
       Expect-Ct:
       - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
       X-Content-Type-Options:
@@ -194,13 +190,11 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 5e5be545bfa26f5e-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
+      - 60ccae264ceb0c25-AMS
     body:
       encoding: UTF-8
       string: "<a href=\"https://medium.com/feed/@macsiri\">Moved Permanently</a>.\n\n"
-  recorded_at: Wed, 21 Oct 2020 15:08:43 GMT
+  recorded_at: Tue, 05 Jan 2021 10:57:46 GMT
 - request:
     method: get
     uri: https://medium.com/feed/@macsiri
@@ -209,7 +203,7 @@ http_interactions:
       string: ''
     headers:
       Cookie:
-      - __cfduid=daac524c146a8e4ed83dffa11bf7831841603292923; __cfruid=971d649524849cc948f271bd5d117d5241609288-1603292923
+      - __cfduid=d927720fa307a489a0e4570dc3f5a52901609844265; __cfruid=40e6245b8f091a70c52c9be4823a670bf7a5d9fc-1609844266
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       Accept:
@@ -222,7 +216,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Wed, 21 Oct 2020 15:08:44 GMT
+      - Tue, 05 Jan 2021 10:57:46 GMT
       Content-Type:
       - text/xml; charset=UTF-8
       Transfer-Encoding:
@@ -250,25 +244,25 @@ http_interactions:
         script-src ''unsafe-eval'' ''unsafe-inline'' about: https: ''self''; style-src
         ''unsafe-inline'' data: https: ''self''; report-uri https://csp.medium.com'
       Expires:
-      - Wed, 21 Oct 2020 15:23:44 GMT
+      - Tue, 05 Jan 2021 11:12:46 GMT
       Link:
       - <https://medium.com/humans.txt>; rel="humans"
       Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
+      - valencia/main-20210104-181409-1cdaa084a4
       Pragma:
       - private
       X-Content-Type-Options:
       - nosniff
       X-Envoy-Upstream-Service-Time:
-      - '18'
+      - '26'
       X-Frame-Options:
       - sameorigin
       X-Obvious-Info:
-      - 42755-064957c,064957ce014
+      - 20210104-2143-root,c5c3cfea
       X-Obvious-Tid:
-      - 1603292924076:facb34c15125
+      - 1609844266261:54a4ba76250a
       X-Opentracing:
-      - '{"ot-tracer-spanid":"7bc003f3319c9f86","ot-tracer-traceid":"bec7ae62fc9c30f","ot-tracer-sampled":"true"}'
+      - '{"ot-tracer-spanid":"684d0c6467ce6efc","ot-tracer-traceid":"37d22fb7f03b7d7c","ot-tracer-sampled":"true"}'
       X-Powered-By:
       - Medium
       X-Ua-Compatible:
@@ -280,20 +274,18 @@ http_interactions:
       Cf-Cache-Status:
       - DYNAMIC
       Cf-Request-Id:
-      - 05ed4da05a0000fc85e4326000000001
+      - 0773cb2cd000000b6bc987b000000001
       Expect-Ct:
       - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
       Server:
       - cloudflare
       Cf-Ray:
-      - 5e5be546fd13fc85-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
+      - 60ccae27bdc30b6b-AMS
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Wed, 21 Oct 2020 15:08:44 GMT
+        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
+  recorded_at: Tue, 05 Jan 2021 10:57:46 GMT
 - request:
     method: head
     uri: https://medium.com/media/7da74bb30f8a2a82b0acb89b213a018b/href
@@ -311,7 +303,7 @@ http_interactions:
       message: Found
     headers:
       Date:
-      - Wed, 21 Oct 2020 15:08:44 GMT
+      - Tue, 05 Jan 2021 10:57:46 GMT
       Content-Type:
       - application/octet-stream
       Connection:
@@ -343,21 +335,21 @@ http_interactions:
       Location:
       - https://www.youtube.com/watch?v=QOCaacO8wus
       Medium-Fulfilled-By:
-      - valencia/main-20201020-231910-0a4c7cfeb9
+      - valencia/main-20210104-181409-1cdaa084a4
       Pragma:
       - no-cache
       X-Content-Type-Options:
       - nosniff
       X-Envoy-Upstream-Service-Time:
-      - '30'
+      - '25'
       X-Frame-Options:
       - sameorigin
       X-Obvious-Info:
-      - 42755-064957c,064957ce014
+      - 20210104-2143-root,c5c3cfea
       X-Obvious-Tid:
-      - 1603292924310:1e3c8ec71d6b
+      - 1609844266524:673c7867471
       X-Opentracing:
-      - '{"ot-tracer-spanid":"2106f8c71bf88029","ot-tracer-traceid":"24a4d6c332613457","ot-tracer-sampled":"true"}'
+      - '{"ot-tracer-spanid":"3dfce9f31be6c115","ot-tracer-traceid":"7f51680f6e3c8068","ot-tracer-sampled":"true"}'
       X-Powered-By:
       - Medium
       X-Ua-Compatible:
@@ -369,19 +361,17 @@ http_interactions:
       Cf-Cache-Status:
       - DYNAMIC
       Cf-Request-Id:
-      - 05ed4da1460000cd12a7846000000001
+      - 0773cb2dd600001ec6db8b8000000001
       Expect-Ct:
       - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
       Server:
       - cloudflare
       Cf-Ray:
-      - 5e5be5486a56cd12-FCO
-      Alt-Svc:
-      - h3-27=":443"; ma=86400, h3-28=":443"; ma=86400, h3-29=":443"; ma=86400
+      - 60ccae2958831ec6-AMS
     body:
       encoding: UTF-8
       string: ''
-  recorded_at: Wed, 21 Oct 2020 15:08:44 GMT
+  recorded_at: Tue, 05 Jan 2021 10:57:46 GMT
 - request:
     method: head
     uri: https://www.youtube.com/watch?v=QOCaacO8wus
@@ -390,9 +380,9 @@ http_interactions:
       string: ''
     headers:
       Cookie:
-      - __cfduid=d710802b86c601c1f85332982e65540ed1603292924; uid=lo_816c906a1d4c;
-        sid=1:zgLu99gBjDX13bL+EEFc3mQhnySJKMd/blKROgN08J7s1jAmcYvPCbOYVgdUiHnc; optimizelyEndUserId=lo_816c906a1d4c;
-        __cfruid=07c9d9036041f2061f5bef987538d26d0cabbbe9-1603292924
+      - __cfduid=d342db94751fb5b32a1a6dbe140d713a71609844266; uid=lo_54d2efc3f833;
+        sid=1:5lg+C8ZH3d9VBrPdJ5sjYHUO/EwQVsTYEA1fM5c/yH0EJsN3Dmo7iP/7SNCokX5j; optimizelyEndUserId=lo_54d2efc3f833;
+        __cfruid=40e6245b8f091a70c52c9be4823a670bf7a5d9fc-1609844266
       Accept:
       - "*/*"
       User-Agent:
@@ -402,41 +392,38 @@ http_interactions:
       code: 200
       message: OK
     headers:
-      Strict-Transport-Security:
-      - max-age=31536000
-      Cache-Control:
-      - no-cache
-      X-Content-Type-Options:
-      - nosniff
-      X-Frame-Options:
-      - SAMEORIGIN
-      Expires:
-      - Tue, 27 Apr 1971 19:44:06 GMT
       Content-Type:
       - text/html; charset=utf-8
+      X-Content-Type-Options:
+      - nosniff
+      Cache-Control:
+      - no-cache, no-store, max-age=0, must-revalidate
+      Pragma:
+      - no-cache
+      Expires:
+      - Mon, 01 Jan 1990 00:00:00 GMT
+      Date:
+      - Tue, 05 Jan 2021 10:57:46 GMT
+      Content-Length:
+      - '593255'
+      X-Frame-Options:
+      - SAMEORIGIN
+      Strict-Transport-Security:
+      - max-age=31536000
       P3p:
       - CP="This is not a P3P policy! See http://support.google.com/accounts/answer/151657?hl=it
         for more info."
-      Date:
-      - Wed, 21 Oct 2020 15:08:45 GMT
       Server:
-      - YouTube Frontend Proxy
+      - ESF
       X-Xss-Protection:
       - '0'
-      Transfer-Encoding:
-      - chunked
       Alt-Svc:
-      - h3-Q050=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-27=":443"; ma=2592000,h3-T051=":443";
-        ma=2592000,h3-T050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443";
-        ma=2592000,quic=":443"; ma=2592000; v="46,43"
-      Accept-Ranges:
-      - none
-      Vary:
-      - Accept-Encoding
+      - h3-29=":443"; ma=2592000,h3-T051=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443";
+        ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
     body:
       encoding: UTF-8
       string: ''
-  recorded_at: Wed, 21 Oct 2020 15:08:45 GMT
+  recorded_at: Tue, 05 Jan 2021 10:57:47 GMT
 - request:
     method: post
     uri: https://api.twitter.com/oauth2/token
@@ -468,11 +455,11 @@ http_interactions:
       Content-Type:
       - application/json;charset=utf-8
       Date:
-      - Wed, 21 Oct 2020 15:08:45 GMT
+      - Tue, 05 Jan 2021 10:57:47 GMT
       Expires:
       - Tue, 31 Mar 1981 05:00:00 GMT
       Last-Modified:
-      - Wed, 21 Oct 2020 15:08:45 GMT
+      - Tue, 05 Jan 2021 10:57:47 GMT
       Ml:
       - A
       Pragma:
@@ -484,15 +471,15 @@ http_interactions:
       Strict-Transport-Security:
       - max-age=631138519
       X-Connection-Hash:
-      - 3c570a664600ccf15ac913124d231aa1
+      - 866551f69fb2cd5b9c89df99bdeb8b7c
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
       - DENY
       X-Response-Time:
-      - '119'
+      - '122'
       X-Transaction:
-      - 00dc42be00e75563
+      - 002af67500c07490
       X-Tsa-Request-Body-Time:
       - '0'
       X-Twitter-Response-Tags:
@@ -504,7 +491,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: '{"token_type":"bearer","access_token":"ACCESS_TOKEN"}'
-  recorded_at: Wed, 21 Oct 2020 15:08:45 GMT
+  recorded_at: Tue, 05 Jan 2021 10:57:47 GMT
 - request:
     method: get
     uri: https://api.twitter.com/1.1/statuses/show/948256083352735744.json?tweet_mode=extended
@@ -528,15 +515,15 @@ http_interactions:
       Content-Disposition:
       - attachment; filename=json.json
       Content-Length:
-      - '3726'
+      - '3793'
       Content-Type:
       - application/json;charset=utf-8
       Date:
-      - Wed, 21 Oct 2020 15:08:45 GMT
+      - Tue, 05 Jan 2021 10:57:47 GMT
       Expires:
       - Tue, 31 Mar 1981 05:00:00 GMT
       Last-Modified:
-      - Wed, 21 Oct 2020 15:08:45 GMT
+      - Tue, 05 Jan 2021 10:57:47 GMT
       Pragma:
       - no-cache
       Server:
@@ -548,7 +535,7 @@ http_interactions:
       X-Access-Level:
       - read
       X-Connection-Hash:
-      - 3e1ba958ec677554f478ca2ac75187e2
+      - 4e41cbe08b1af10431f77ff198a237c1
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -556,13 +543,13 @@ http_interactions:
       X-Rate-Limit-Limit:
       - '900'
       X-Rate-Limit-Remaining:
-      - '896'
+      - '897'
       X-Rate-Limit-Reset:
-      - '1603293126'
+      - '1609844647'
       X-Response-Time:
-      - '125'
+      - '130'
       X-Transaction:
-      - 00c0d91300e84f9e
+      - '008f04a500ec9a32'
       X-Twitter-Response-Tags:
       - BouncerCompliant
       X-Xss-Protection:
@@ -574,8 +561,8 @@ http_interactions:
         href=\"http:\/\/twitter.com\/download\/iphone\" rel=\"nofollow\"\u003eTwitter
         for iPhone\u003c\/a\u003e","in_reply_to_status_id":948243620846620673,"in_reply_to_status_id_str":"948243620846620673","in_reply_to_user_id":161419043,"in_reply_to_user_id_str":"161419043","in_reply_to_screen_name":"bendhalpern","user":{"id":161419043,"id_str":"161419043","name":"Ben
         Halpern \ud83c\udf31","screen_name":"bendhalpern","location":"Brooklyn, NY\/Beacon,
-        NY","description":"Creator and Co-founder of @forem. Coder, buddhist, feminist,
-        Batman. He\/Him.","url":"https:\/\/t.co\/qqIzCffhit","entities":{"url":{"urls":[{"url":"https:\/\/t.co\/qqIzCffhit","expanded_url":"http:\/\/dev.to\/ben","display_url":"dev.to\/ben","indices":[0,23]}]},"description":{"urls":[]}},"protected":false,"followers_count":41016,"friends_count":2183,"listed_count":744,"created_at":"Wed
-        Jun 30 20:15:57 +0000 2010","favourites_count":37032,"utc_offset":null,"time_zone":null,"geo_enabled":true,"verified":true,"statuses_count":16582,"lang":null,"contributors_enabled":false,"is_translator":false,"is_translation_enabled":false,"profile_background_color":"EDECE9","profile_background_image_url":"http:\/\/abs.twimg.com\/images\/themes\/theme3\/bg.gif","profile_background_image_url_https":"https:\/\/abs.twimg.com\/images\/themes\/theme3\/bg.gif","profile_background_tile":false,"profile_image_url":"http:\/\/pbs.twimg.com\/profile_images\/1303466766094553088\/4-ZkBcZM_normal.jpg","profile_image_url_https":"https:\/\/pbs.twimg.com\/profile_images\/1303466766094553088\/4-ZkBcZM_normal.jpg","profile_banner_url":"https:\/\/pbs.twimg.com\/profile_banners\/161419043\/1492834234","profile_link_color":"3A1E75","profile_sidebar_border_color":"FFFFFF","profile_sidebar_fill_color":"E3E2DE","profile_text_color":"634047","profile_use_background_image":true,"has_extended_profile":true,"default_profile":false,"default_profile_image":false,"following":null,"follow_request_sent":null,"notifications":null,"translator_type":"none"},"geo":null,"coordinates":null,"place":null,"contributors":null,"is_quote_status":false,"retweet_count":63,"favorite_count":504,"favorited":false,"retweeted":false,"possibly_sensitive":false,"possibly_sensitive_appealable":false,"lang":"en"}'
-  recorded_at: Wed, 21 Oct 2020 15:08:45 GMT
+        NY","description":"Creator of @thepracticaldev and building @forem with @jessleenyc,
+        @peterkimfrank and our great team. Coder, buddhist, feminist, Batman. He\/Him.","url":"https:\/\/t.co\/qqIzCffhit","entities":{"url":{"urls":[{"url":"https:\/\/t.co\/qqIzCffhit","expanded_url":"http:\/\/dev.to\/ben","display_url":"dev.to\/ben","indices":[0,23]}]},"description":{"urls":[]}},"protected":false,"followers_count":40953,"friends_count":2205,"listed_count":755,"created_at":"Wed
+        Jun 30 20:15:57 +0000 2010","favourites_count":37578,"utc_offset":null,"time_zone":null,"geo_enabled":true,"verified":true,"statuses_count":16986,"lang":null,"contributors_enabled":false,"is_translator":false,"is_translation_enabled":false,"profile_background_color":"EDECE9","profile_background_image_url":"http:\/\/abs.twimg.com\/images\/themes\/theme3\/bg.gif","profile_background_image_url_https":"https:\/\/abs.twimg.com\/images\/themes\/theme3\/bg.gif","profile_background_tile":false,"profile_image_url":"http:\/\/pbs.twimg.com\/profile_images\/1303466766094553088\/4-ZkBcZM_normal.jpg","profile_image_url_https":"https:\/\/pbs.twimg.com\/profile_images\/1303466766094553088\/4-ZkBcZM_normal.jpg","profile_banner_url":"https:\/\/pbs.twimg.com\/profile_banners\/161419043\/1492834234","profile_link_color":"3A1E75","profile_sidebar_border_color":"FFFFFF","profile_sidebar_fill_color":"E3E2DE","profile_text_color":"634047","profile_use_background_image":true,"has_extended_profile":true,"default_profile":false,"default_profile_image":false,"following":null,"follow_request_sent":null,"notifications":null,"translator_type":"none"},"geo":null,"coordinates":null,"place":null,"contributors":null,"is_quote_status":false,"retweet_count":62,"favorite_count":504,"favorited":false,"retweeted":false,"possibly_sensitive":false,"possibly_sensitive_appealable":false,"lang":"en"}'
+  recorded_at: Tue, 05 Jan 2021 10:57:47 GMT
 recorded_with: VCR 6.0.0
diff --git a/spec/workers/articles/rss_reader_worker_spec.rb b/spec/workers/articles/rss_reader_worker_spec.rb
index 76d0f711e..e283f6a3b 100644
--- a/spec/workers/articles/rss_reader_worker_spec.rb
+++ b/spec/workers/articles/rss_reader_worker_spec.rb
@@ -25,14 +25,16 @@ RSpec.describe Articles::RssReaderWorker, type: :worker do
     end
 
     it "enqueues Feeds::ImportArticlesWorker if the :feeds_import flag is enabled" do
+      allow(Feeds::ImportArticlesWorker).to receive(:perform_async)
       allow(RssReader).to receive(:get_all_articles)
       allow(FeatureFlag).to receive(:enabled?).with(:feeds_import).and_return(true)
 
-      sidekiq_assert_enqueued_jobs(1, only: Feeds::ImportArticlesWorker) do
+      Timecop.freeze(Time.current) do
         worker.perform
-      end
 
-      expect(RssReader).not_to have_received(:get_all_articles)
+        expect(RssReader).not_to have_received(:get_all_articles)
+        expect(Feeds::ImportArticlesWorker).to have_received(:perform_async).with(4.hours.ago)
+      end
     end
 
     it "short circuits if it's running on DEV" do
diff --git a/spec/workers/feeds/import_articles_worker_spec.rb b/spec/workers/feeds/import_articles_worker_spec.rb
index 1c2d85615..26c29a05a 100644
--- a/spec/workers/feeds/import_articles_worker_spec.rb
+++ b/spec/workers/feeds/import_articles_worker_spec.rb
@@ -9,7 +9,7 @@ RSpec.describe Feeds::ImportArticlesWorker, type: :worker do
     it "calls the Feeds::Import to get all articles" do
       allow(Feeds::Import).to receive(:call)
 
-      worker.perform
+      worker.perform(1.hour.ago)
 
       expect(Feeds::Import).to have_received(:call)
     end
@@ -19,9 +19,21 @@ RSpec.describe Feeds::ImportArticlesWorker, type: :worker do
         user = create(:user)
         allow(Feeds::Import).to receive(:call)
 
-        worker.perform([user.id])
+        worker.perform(nil, [user.id])
 
-        expect(Feeds::Import).to have_received(:call).with(users: User.where(id: [user.id]))
+        expect(Feeds::Import).to have_received(:call).with(users: User.where(id: [user.id]), earlier_than: nil)
+      end
+    end
+
+    context "with earlier_than time" do
+      it "calls Feeds::Import with the correct time if given" do
+        allow(Feeds::Import).to receive(:call)
+
+        Timecop.freeze(Time.current) do
+          worker.perform(4.hours.ago)
+
+          expect(Feeds::Import).to have_received(:call).with(users: nil, earlier_than: 4.hours.ago)
+        end
       end
     end
   end