From 1741e52e837b74eb982759edd4d5895b602beba0 Mon Sep 17 00:00:00 2001 From: rhymes Date: Tue, 24 Nov 2020 18:11:13 +0100 Subject: [PATCH] Add missing features to new feed importer (#11501) * Add explanatory comment to how RssReaderFetchUserWorker works * Add Feeds::ImportWorker worker * Enable Feeds::Import for single user feed fetching behind a feature flag * Add Feeds::ValidateUrl service * Add feature flag to user's validate feed URL feature * Remove todo notices * Add feature flag to fetch_all_rss task * Add feature flag to RssReaderWorker * Bring back short-circuit for Articles::RssReaderWorker --- app/controllers/users_controller.rb | 13 ++- app/models/user.rb | 11 ++- app/services/feeds/import.rb | 3 - app/services/feeds/validate_url.rb | 26 ++++++ .../articles/dev_feeds_import_worker.rb | 23 ----- app/workers/articles/dev_rss_reader_worker.rb | 18 ---- app/workers/articles/rss_reader_worker.rb | 8 +- app/workers/feeds/import_articles_worker.rb | 19 ++++ lib/tasks/fetch.rake | 9 +- spec/models/user_spec.rb | 44 +++++++++ spec/requests/user/user_settings_spec.rb | 26 ++++++ spec/services/feeds/import_spec.rb | 40 ++++---- spec/services/feeds/validate_url_spec.rb | 18 ++++ .../feeds_import_medium_vaidehi.yml | 92 +++++++++++++++++++ .../feeds_validate_url_invalid.yml | 65 +++++++++++++ .../articles/dev_feeds_import_worker_spec.rb | 54 ----------- .../articles/dev_rss_reader_worker_spec.rb | 39 -------- .../articles/rss_reader_worker_spec.rb | 36 +++++++- .../feeds/import_articles_worker_spec.rb | 28 ++++++ 19 files changed, 406 insertions(+), 166 deletions(-) create mode 100644 app/services/feeds/validate_url.rb delete mode 100644 app/workers/articles/dev_feeds_import_worker.rb delete mode 100644 app/workers/articles/dev_rss_reader_worker.rb create mode 100644 app/workers/feeds/import_articles_worker.rb create mode 100644 spec/services/feeds/validate_url_spec.rb create mode 100644 spec/support/fixtures/vcr_cassettes/feeds_import_medium_vaidehi.yml create mode 100644 spec/support/fixtures/vcr_cassettes/feeds_validate_url_invalid.yml delete mode 100644 spec/workers/articles/dev_feeds_import_worker_spec.rb delete mode 100644 spec/workers/articles/dev_rss_reader_worker_spec.rb create mode 100644 spec/workers/feeds/import_articles_worker_spec.rb diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb index 689728805..958077651 100644 --- a/app/controllers/users_controller.rb +++ b/app/controllers/users_controller.rb @@ -40,7 +40,10 @@ class UsersController < ApplicationController set_current_tab(params["user"]["tab"]) if @user.update(permitted_attributes(@user)) - RssReaderFetchUserWorker.perform_async(@user.id) if @user.feed_url.present? + # NOTE: [@rhymes] this queues a job to fetch the feed each time the profile is updated, regardless if the user + # explicitly requested "Feed fetch now" or simply updated any other field + import_articles_from_feed(@user) + notice = "Your profile was successfully updated." if config_changed? notice = "Your config has been updated. Refresh to see all changes." @@ -325,4 +328,12 @@ class UsersController < ApplicationController def destroy_request_in_progress? Rails.cache.exist?("user-destroy-token-#{@user.id}") end + + 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) + end end diff --git a/app/models/user.rb b/app/models/user.rb index aa615eddd..b35cf09f7 100644 --- a/app/models/user.rb +++ b/app/models/user.rb @@ -598,9 +598,16 @@ class User < ApplicationRecord def validate_feed_url return if feed_url.blank? - return if RssReader.new.valid_feed_url?(feed_url) - errors.add(:feed_url, "is not a valid RSS/Atom feed") + valid = if FeatureFlag.enabled?(:feeds_import) + Feeds::ValidateUrl.call(feed_url) + else + RssReader.new.valid_feed_url?(feed_url) + end + + errors.add(:feed_url, "is not a valid RSS/Atom feed") unless valid + rescue StandardError => e + errors.add(:feed_url, e.message) end def validate_mastodon_url diff --git a/app/services/feeds/import.rb b/app/services/feeds/import.rb index a84ce13d7..590f3723d 100644 --- a/app/services/feeds/import.rb +++ b/app/services/feeds/import.rb @@ -1,6 +1,3 @@ -# TODO: [rhymes] -# => add Feeds::ImportUser to fetch a single user -# => add Feeds::ValidateFeedUrl to validate a single feed URL module Feeds class Import def self.call(users: nil) diff --git a/app/services/feeds/validate_url.rb b/app/services/feeds/validate_url.rb new file mode 100644 index 000000000..67e722200 --- /dev/null +++ b/app/services/feeds/validate_url.rb @@ -0,0 +1,26 @@ +module Feeds + class ValidateUrl + def self.call(feed_url) + new(feed_url).call + end + + def initialize(feed_url) + @feed_url = feed_url + end + + def call + return false if feed_url.blank? + + xml = HTTParty.get(feed_url, timeout: 10).body + Feedjira.parse(xml) + + true + rescue Feedjira::NoParserAvailable + false + end + + private + + attr_reader :feed_url + end +end diff --git a/app/workers/articles/dev_feeds_import_worker.rb b/app/workers/articles/dev_feeds_import_worker.rb deleted file mode 100644 index b6bd9186d..000000000 --- a/app/workers/articles/dev_feeds_import_worker.rb +++ /dev/null @@ -1,23 +0,0 @@ -# NOTE: [rhymes] -# This script will soon be removed. We need it to collect monitoring data on -# Datadog about the production behavior of the `Feeds::Import` class -module Articles - class DevFeedsImportWorker - include Sidekiq::Worker - - sidekiq_options queue: :medium_priority, retry: 10 - - def perform(user_ids = []) - return unless SiteConfig.community_name == "DEV" - return if Rails.cache.read("cancel_feeds_import").present? - - users = if user_ids.present? - User.where(id: user_ids) - else - User.with_feed - end - - ::Feeds::Import.call(users: users) - end - end -end diff --git a/app/workers/articles/dev_rss_reader_worker.rb b/app/workers/articles/dev_rss_reader_worker.rb deleted file mode 100644 index 761b0d627..000000000 --- a/app/workers/articles/dev_rss_reader_worker.rb +++ /dev/null @@ -1,18 +0,0 @@ -# NOTE: [rhymes] -# This script will soon be removed. We need it to collect monitoring data on -# Datadog about the production behavior of the `RssReader` class -module Articles - class DevRssReaderWorker - include Sidekiq::Worker - - sidekiq_options queue: :medium_priority, retry: 10 - - def perform - return unless SiteConfig.community_name == "DEV" - return if Rails.cache.read("cancel_rss_job").present? - - # we force fetch to have realistic data - RssReader.get_all_articles(force: true) - end - end -end diff --git a/app/workers/articles/rss_reader_worker.rb b/app/workers/articles/rss_reader_worker.rb index ef29a3946..767657e66 100644 --- a/app/workers/articles/rss_reader_worker.rb +++ b/app/workers/articles/rss_reader_worker.rb @@ -10,8 +10,12 @@ module Articles # for our large DEV community. Smaller Forems should be able to handle it no problem return if SiteConfig.community_name == "DEV" - # don't force fetch. Fetch "random" subset instead of all of them. - RssReader.get_all_articles(force: false) + if FeatureFlag.enabled?(:feeds_import) + ::Feeds::ImportArticlesWorker.perform_async + else + # don't force fetch. Fetch "random" subset instead of all of them. + ::RssReader.get_all_articles(force: false) + end end end end diff --git a/app/workers/feeds/import_articles_worker.rb b/app/workers/feeds/import_articles_worker.rb new file mode 100644 index 000000000..7c8414550 --- /dev/null +++ b/app/workers/feeds/import_articles_worker.rb @@ -0,0 +1,19 @@ +module Feeds + class ImportArticlesWorker + include Sidekiq::Worker + + sidekiq_options queue: :medium_priority, retry: 10 + + def perform(user_ids = []) + user_ids = Array.wrap(user_ids) + + users = if user_ids.present? + User.where(id: user_ids) + else + User.with_feed + end + + ::Feeds::Import.call(users: users) + end + end +end diff --git a/lib/tasks/fetch.rake b/lib/tasks/fetch.rake index 24b8087e8..d1cf05fed 100644 --- a/lib/tasks/fetch.rake +++ b/lib/tasks/fetch.rake @@ -1,9 +1,12 @@ desc "This task is called by the Heroku scheduler add-on" task fetch_all_rss: :environment do - Rails.application.eager_load! - - RssReader.get_all_articles(force: false) # don't force fetch. Fetch "random" subset instead of all of them. + if FeatureFlag.enabled?(:feeds_import) + Feeds::Import.call + else + # don't force fetch. Fetch "random" subset instead of all of them. + RssReader.get_all_articles(force: false) + end end task fetch_feeds_import: :environment do diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb index b313ec059..1a799abc8 100644 --- a/spec/models/user_spec.rb +++ b/spec/models/user_spec.rb @@ -267,6 +267,50 @@ RSpec.describe User, type: :model do expect(user.errors[:base].to_s).to include("could not be saved. Rate limit reached") expect(limiter).to have_received(:track_limit_by_action).with(:user_update).twice end + + context "when validating feed_url with RSSReader", vcr: true do + it "is valid with no feed_url" do + user.feed_url = nil + + expect(user).to be_valid + end + + it "is not valid with an invalid feed_url", vcr: { cassette_name: "feeds_validate_url_invalid" } do + user.feed_url = "http://example.com" + + expect(user).not_to be_valid + end + + it "is valid with a valid feed_url", vcr: { cassette_name: "feeds_import_medium_vaidehi" } do + user.feed_url = "https://medium.com/feed/@vaidehijoshi" + + expect(user).to be_valid + end + end + + context "with Feeds::ValidateUrl" do + before do + allow(FeatureFlag).to receive(:enabled?).with(:feeds_import).and_return(true) + end + + it "is valid with no feed_url" do + user.feed_url = nil + + expect(user).to be_valid + end + + it "is not valid with an invalid feed_url", vcr: { cassette_name: "feeds_validate_url_invalid" } do + user.feed_url = "http://example.com" + + expect(user).not_to be_valid + end + + it "is valid with a valid feed_url", vcr: { cassette_name: "feeds_import_medium_vaidehi" } do + user.feed_url = "https://medium.com/feed/@vaidehijoshi" + + expect(user).to be_valid + end + end end describe "#after_commit" do diff --git a/spec/requests/user/user_settings_spec.rb b/spec/requests/user/user_settings_spec.rb index f3d6cfd77..fa967ec36 100644 --- a/spec/requests/user/user_settings_spec.rb +++ b/spec/requests/user/user_settings_spec.rb @@ -254,6 +254,32 @@ RSpec.describe "UserSettings", type: :request do end end end + + context "when requesting a fetch of the feed", vcr: { cassette_name: "feeds_import_medium_vaidehi" } do + let(:feed_url) { "https://medium.com/feed/@vaidehijoshi" } + let(:user) { create(:user, feed_url: feed_url) } + + it "invokes RssReaderFetchUserWorker" do + allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(user.id) + allow(RssReaderFetchUserWorker).to receive(:perform_async).with(user.id) + + put user_path(user.id), params: { user: { feed_url: feed_url } } + + expect(Feeds::ImportArticlesWorker).not_to have_received(:perform_async) + expect(RssReaderFetchUserWorker).to have_received(:perform_async).with(user.id) + end + + it "invokes Feeds::ImportArticlesWorker if feeds_import feature flag is on" do + allow(Feeds::ImportArticlesWorker).to receive(:perform_async).with(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(RssReaderFetchUserWorker).not_to have_received(:perform_async).with(user.id) + end + end end describe "POST /users/update_language_settings" do diff --git a/spec/services/feeds/import_spec.rb b/spec/services/feeds/import_spec.rb index fafa954a9..b9f7b6f5f 100644 --- a/spec/services/feeds/import_spec.rb +++ b/spec/services/feeds/import_spec.rb @@ -26,7 +26,7 @@ RSpec.describe Feeds::Import, type: :service, vcr: true, db_strategy: :truncatio expect { described_class.call }.not_to change(Article, :count) end - it "parses correctly", vcr: { cassette_name: "rss_reader_fetch_articles" } do + it "parses correctly", vcr: { cassette_name: "feeds_import" } do described_class.call verify format: :txt do @@ -128,29 +128,29 @@ RSpec.describe Feeds::Import, type: :service, vcr: true, db_strategy: :truncatio end end - # describe "feeds parsing and regressions" do - # it "parses https://medium.com/feed/@dvirsegal correctly", vcr: { cassette_name: "feeds_import_dvirsegal" } do - # user = create(:user, feed_url: "https://medium.com/feed/@dvirsegal") + describe "feeds parsing and regressions" do + it "parses https://medium.com/feed/@dvirsegal correctly", vcr: { cassette_name: "rss_reader_dvirsegal" } do + user = create(:user, feed_url: "https://medium.com/feed/@dvirsegal") - # expect do - # rss_reader.fetch_user(user) - # end.to change(user.articles, :count).by(10) - # end + expect do + described_class.call(users: User.where(id: user.id)) + end.to change(user.articles, :count).by(10) + end - # it "converts/replaces tags to ", vcr: { cassette_name: "feeds_import_swimburger" } do - # user = create(:user, feed_url: "https://swimburger.net/atom.xml") + it "converts/replaces tags to ", vcr: { cassette_name: "rss_reader_swimburger" } do + user = create(:user, feed_url: "https://swimburger.net/atom.xml") - # expect do - # rss_reader.fetch_user(user) - # end.to change(user.articles, :count).by(10) + expect do + described_class.call(users: User.where(id: user.id)) + end.to change(user.articles, :count).by(10) - # body_markdown = user.articles.last.body_markdown + body_markdown = user.articles.last.body_markdown - # expect(body_markdown).not_to include("") - # expected_image_markdown = - # "![Screenshot of Azure left navigation pane](https://swimburger.net/media/lxypkhak/azure-create-a-resource.png)" + expect(body_markdown).not_to include("") + expected_image_markdown = + "![Screenshot of Azure left navigation pane](https://swimburger.net/media/lxypkhak/azure-create-a-resource.png)" - # expect(body_markdown).to include(expected_image_markdown) - # end - # end + expect(body_markdown).to include(expected_image_markdown) + end + end end diff --git a/spec/services/feeds/validate_url_spec.rb b/spec/services/feeds/validate_url_spec.rb new file mode 100644 index 000000000..b380aeacd --- /dev/null +++ b/spec/services/feeds/validate_url_spec.rb @@ -0,0 +1,18 @@ +require "rails_helper" + +RSpec.describe Feeds::ValidateUrl, type: :service, vcr: true do + let(:invalid_feed_url) { "https://example.com" } + let(:valid_feed_url) { "https://medium.com/feed/@vaidehijoshi" } + + it "returns false for empty URL" do + expect(described_class.call("")).to be(false) + end + + it "returns false for an invalid feed URL", vcr: { cassette_name: "feeds_validate_url_invalid" } do + expect(described_class.call(invalid_feed_url)).to be(false) + end + + it "returns true for an valid feed URL", vcr: { cassette_name: "feeds_import_medium_vaidehi" } do + expect(described_class.call(valid_feed_url)).to be(true) + end +end diff --git a/spec/support/fixtures/vcr_cassettes/feeds_import_medium_vaidehi.yml b/spec/support/fixtures/vcr_cassettes/feeds_import_medium_vaidehi.yml new file mode 100644 index 000000000..c74f23ba6 --- /dev/null +++ b/spec/support/fixtures/vcr_cassettes/feeds_import_medium_vaidehi.yml @@ -0,0 +1,92 @@ +--- +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, 18 Nov 2020 17:05:10 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, 18 Nov 2020 17:20:10 GMT + Link: + - ; rel="humans" + Medium-Fulfilled-By: + - valencia/main-20201117-223424-4d135bc8e3 + Pragma: + - private + X-Content-Type-Options: + - nosniff + X-Envoy-Upstream-Service-Time: + - '220' + X-Frame-Options: + - sameorigin + X-Obvious-Info: + - 43014-cee85b8,cee85b82720 + X-Obvious-Tid: + - 1605719110423:bb5dfa4377a1 + X-Opentracing: + - '{"ot-tracer-spanid":"35f084c21c9d0b40","ot-tracer-traceid":"24c67cc203bf4dc1","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: + - 067dea4ab50000fa586eb34000000001 + Expect-Ct: + - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct" + Server: + - cloudflare + Cf-Ray: + - 5f4346578f3ffa58-AMS + 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, 18 Nov 2020 17:05:10 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, 18 Nov 2020 17:05:10 GMT +recorded_with: VCR 6.0.0 diff --git a/spec/support/fixtures/vcr_cassettes/feeds_validate_url_invalid.yml b/spec/support/fixtures/vcr_cassettes/feeds_validate_url_invalid.yml new file mode 100644 index 000000000..3fe97d247 --- /dev/null +++ b/spec/support/fixtures/vcr_cassettes/feeds_validate_url_invalid.yml @@ -0,0 +1,65 @@ +--- +http_interactions: +- request: + method: get + uri: https://example.com/ + 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: + Accept-Ranges: + - bytes + Age: + - '596646' + Cache-Control: + - max-age=604800 + Content-Type: + - text/html; charset=UTF-8 + Date: + - Thu, 19 Nov 2020 17:47:30 GMT + Etag: + - '"3147526947"' + Expires: + - Thu, 26 Nov 2020 17:47:30 GMT + Last-Modified: + - Thu, 17 Oct 2019 07:18:26 GMT + Server: + - ECS (dcb/7FA3) + Vary: + - Accept-Encoding + X-Cache: + - HIT + Content-Length: + - '648' + body: + encoding: ASCII-8BIT + string: "\n\n\n Example Domain\n\n + \ \n \n \n \n\n\n\n
\n

Example Domain

\n + \

This domain is for use in illustrative examples in documents. You may + use this\n domain in literature without prior coordination or asking for + permission.

\n

More + information...

\n
\n\n\n" + recorded_at: Thu, 19 Nov 2020 17:47:30 GMT +recorded_with: VCR 6.0.0 diff --git a/spec/workers/articles/dev_feeds_import_worker_spec.rb b/spec/workers/articles/dev_feeds_import_worker_spec.rb deleted file mode 100644 index a3e26bc07..000000000 --- a/spec/workers/articles/dev_feeds_import_worker_spec.rb +++ /dev/null @@ -1,54 +0,0 @@ -require "rails_helper" - -RSpec.describe Articles::DevFeedsImportWorker, type: :worker do - let(:worker) { subject } - - include_examples "#enqueues_on_correct_queue", "medium_priority" - - describe "#perform" do - it "does not call the Feeds::Import for non DEV communities" do - allow(SiteConfig).to receive(:community_name).and_return("NotDEV") - allow(Feeds::Import).to receive(:call) - - worker.perform - - expect(Feeds::Import).not_to have_received(:call) - end - - it "does not call Feeds::Import if the cache instructs it to cancel" do - allow(SiteConfig).to receive(:community_name).and_return("DEV") - allow(Rails.cache).to receive(:read).with("cancel_feeds_import").and_return("true") - - allow(Feeds::Import).to receive(:call) - - worker.perform - - expect(Feeds::Import).not_to have_received(:call) - end - - it "calls the Feeds::Import to get all articles" do - allow(SiteConfig).to receive(:community_name).and_return("DEV") - allow(Rails.cache).to receive(:read).with("cancel_feeds_import").and_return(nil) - allow(Feeds::Import).to receive(:call) - - worker.perform - - expect(Feeds::Import).to have_received(:call) - end - - context "with user ids" do - before do - allow(SiteConfig).to receive(:community_name).and_return("DEV") - end - - it "calls Feeds::Import with the correct users if given user ids" do - user = create(:user) - allow(Feeds::Import).to receive(:call) - - worker.perform([user.id]) - - expect(Feeds::Import).to have_received(:call).with(users: User.where(id: [user.id])) - end - end - end -end diff --git a/spec/workers/articles/dev_rss_reader_worker_spec.rb b/spec/workers/articles/dev_rss_reader_worker_spec.rb deleted file mode 100644 index b168e2dc2..000000000 --- a/spec/workers/articles/dev_rss_reader_worker_spec.rb +++ /dev/null @@ -1,39 +0,0 @@ -require "rails_helper" - -RSpec.describe Articles::DevRssReaderWorker, type: :worker do - let(:worker) { subject } - - include_examples "#enqueues_on_correct_queue", "medium_priority" - - describe "#perform" do - it "does not call the RssReader for non DEV communities" do - allow(SiteConfig).to receive(:community_name).and_return("NotDEV") - allow(RssReader).to receive(:get_all_articles) - - worker.perform - - expect(RssReader).not_to have_received(:get_all_articles) - end - - it "does not call the RssReader if the cache instructs it to cancel" do - allow(SiteConfig).to receive(:community_name).and_return("DEV") - allow(Rails.cache).to receive(:read).with("cancel_rss_job").and_return("true") - - allow(RssReader).to receive(:get_all_articles) - - worker.perform - - expect(RssReader).not_to have_received(:get_all_articles) - end - - it "calls the RssReader to get all articles" do - allow(SiteConfig).to receive(:community_name).and_return("DEV") - allow(Rails.cache).to receive(:read).with("cancel_rss_job").and_return(nil) - allow(RssReader).to receive(:get_all_articles) - - worker.perform - - expect(RssReader).to have_received(:get_all_articles).with(force: true) - end - end -end diff --git a/spec/workers/articles/rss_reader_worker_spec.rb b/spec/workers/articles/rss_reader_worker_spec.rb index d8f814261..0e24ce1e5 100644 --- a/spec/workers/articles/rss_reader_worker_spec.rb +++ b/spec/workers/articles/rss_reader_worker_spec.rb @@ -6,10 +6,44 @@ RSpec.describe Articles::RssReaderWorker, type: :worker do include_examples "#enqueues_on_correct_queue", "medium_priority" describe "#perform" do - it "updates RssReader articles" do + it "instructs RssReader to fetch all articles" do allow(RssReader).to receive(:get_all_articles) + worker.perform + expect(RssReader).to have_received(:get_all_articles).with(force: false) end + + it "does not enqueue Feeds::ImportArticlesWorker if the :feeds_import flag is not enabled" do + allow(RssReader).to receive(:get_all_articles) + + sidekiq_assert_no_enqueued_jobs do + worker.perform + end + + expect(RssReader).to have_received(:get_all_articles).with(force: false) + end + + it "enqueues Feeds::ImportArticlesWorker if the :feeds_import flag is enabled" do + 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 + worker.perform + end + + expect(RssReader).not_to have_received(:get_all_articles) + end + + it "short circuits if it's running on DEV" do + allow(SiteConfig).to receive(:community_name).and_return("DEV") + allow(RssReader).to receive(:get_all_articles) + allow(FeatureFlag).to receive(:enabled?) + + worker.perform + + expect(RssReader).not_to have_received(:get_all_articles) + expect(FeatureFlag).not_to have_received(:enabled?) + end end end diff --git a/spec/workers/feeds/import_articles_worker_spec.rb b/spec/workers/feeds/import_articles_worker_spec.rb new file mode 100644 index 000000000..1c2d85615 --- /dev/null +++ b/spec/workers/feeds/import_articles_worker_spec.rb @@ -0,0 +1,28 @@ +require "rails_helper" + +RSpec.describe Feeds::ImportArticlesWorker, type: :worker do + let(:worker) { subject } + + include_examples "#enqueues_on_correct_queue", "medium_priority" + + describe "#perform" do + it "calls the Feeds::Import to get all articles" do + allow(Feeds::Import).to receive(:call) + + worker.perform + + expect(Feeds::Import).to have_received(:call) + end + + context "with user ids" do + it "calls Feeds::Import with the correct users if given user ids" do + user = create(:user) + allow(Feeds::Import).to receive(:call) + + worker.perform([user.id]) + + expect(Feeds::Import).to have_received(:call).with(users: User.where(id: [user.id])) + end + end + end +end