Useful Stuff I Read This Week


Here are 8 posts I thought were worth sharing this week.

Being Nice and Effective – Link

In this post, Subbu Allamaraju shares his thoughts on how you can be both a nice and effective leader . He talks about six different leadership styles and how those leadership styles create positive and negative climates. I am in my first engineering leadership role and still figuring out my leadership style. Based on my limited leadership experience I think a leader can have multiple leadership styles depending on the situation. There are times you have to course correct and change your leadership style based on the situation and context. Also, I think leaders can be “nice” and “not nice” depending on the context. Leadership is hard. 

42 things I learned from building a production database – Link

Not a deep technical post. Many useful pieces of advice by Mahesh Balakrishnan in this post. He worked on a Chubby like system at Facebook. My favorites:

  • Be conservative on APIs and liberal with implementations
  • When designing APIs, write code for one implementation; plan actively for the second implementation; and hope/pray that things will work for a third implementation.
  • Anything that can’t be measured easily (e.g., consistency) is often forgotten; pay particular attention to attributes that are difficult to measure
  • Make your project robust to re-orgs. 

The Surprising Impact of Medium-Size Texts on PostgreSQL Performance – Link

Amazing read. I was not aware that Postgres maintains a separate table(toast) to store text columns. This way it keeps table size in check and performance of queries that don’t read text columns perform fine. But, as explained in the article there is a catch. Postgres only writes to the toast tables when the size of text is greater than the value defined by toast_tuple_target storage parameter. The default value of this parameter is 2K. This means if your text column values are less than 2k then they will be stored inline. The good part is that you can configure this value. Keep this in mind next time you use a column with text type.

Process People – Link

A post I can relate to. It is frustrating to work with process people who have no software development experience. From the post

First, I can’t help but notice that so many of these process people have never performed either the maker role or the manager role in a strong product company.  They have more enthusiasm than experience or knowledge.

Second … A process person is a very poor substitute for a strong manager with the necessary expertise.

Third, the process is a lot like religion.  People get fanatic about their favorite processes, and it’s very difficult to reason with a fanatic.

8 Steps for Migrating Existing Applications to Microservices – Link

Practical advice on how to refactor monolithic applications to Microservices.

New HTTP standards for caching on the modern web – Link

This post covers two new HTTP caching headers. HTTP Caching is a black art. These two new headers help drive HTTP caching story for 2021. 

  • Cache-Status header helps you trace which cache returned the response and why. There are multiple caches in most web applications. Cache-Status will be a useful traceability tool. The format of this header is also very readable
    • Cache-Status: CacheName; param; param=value; param…, CacheName2; param; param…
  • <Targeted>-Cache-Control header allows you to set cache directives that target specific caches or classes of caches.

Why you can have millions of Goroutines but only thousands of Java Threads – Link

I enjoyed reading this post. There are two main reasons:

  • JVM uses default stack size of 1MB
  • JVM uses operating system threads. There is a context switching cost you pay that limits the number of threads.

If you use a library like Akka in JVM then you can achieve the same concurrency levels as available in Golang. Keep in mind Akka and Golang use different concurrency models.

Talk: How Google Backs Up the Internet – Link

It is an old talk but still very relevant. Notes from this talk:

  • Backups are useless. It’s the restore you care about.
  • Redundancy is not the same as recoverability. Google stuff fails all the time.
  • Take humans out of the loop
  • Availability and integrity are an organization wide characteristic
  • Backups are a tax you pay for the luxury of a restore.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: