The theme of the book is to find out what is truly essential? Focus on essential and eliminate everything else. Greg McKeown defines Essentialism as “Less but better”.
The key takeaway is that only once you give yourself the permission to stop trying to do it all, to stop saying yes to everyone, can you make your highest contribution towards the things that really matter. How often we say “yes” to everything, there is so much going on in our lives that nothing ever gets our true focus and attention. How can we give our best in any area when we’re being pulled in so many different directions? We can’t. We need to identify what is truly important, learn to say no to things that don’t fit into the “essential” category and simplify our lives. This book is an essential read for anyone who feels overcommitted, overloaded, or overworked.
Very good read. Highly recommended.
Note: My friend Rishi has done a detailed review of this book. Check this out here:
This is a quick share on git. Scenario: I want to push my local changes to git but am having a few commits which I don’t want to push now. In other words, I just want to push changes till a certain commit. Solution: $git push <remotename><commit SHA>:<remote_branch_name>
To elaborate First, fetch the SHA of the commit you want to push $ git log
Copy the SHA and use the command below (Make sure that you replace the SHA of your commit with the given in the example).
The big O notation is used to analyze runtime time complexity. big O notation provides an abstract measurement by which we can judge the performance of algorithms without using mathematical proofs. Some of the most common big O notations are:
O(1) : constant: the operation doesn’t depend on the size of its input, e.g. adding a node to the tail of a linked list where we always maintain a pointer to the tail node.
O(n): linear: the run time complexity is proportionate to the size of n.
O(log n): logarithmic: normally associated with algorithms that break the problem into similar chunks per each invocation, e.g. searching a binary search tree.
O(n log n): just n log n: usually associated with an algorithm that breaks the problem into smaller chunks per each invocation, and then takes the results of these smaller chunks and stitches them back together, e.g, quicksort.
O(n2): quadratic: e.g. bubble sort.
O(n3):cubic: very rare
O(2n):exponential: incredibly rare.
Brief explanation: Cubic and exponential algorithms should only ever be used for very small problems (if ever!); avoid them if feasibly possible. If you encounter them then this is really a signal for you to review the design of your algorithm always look for algorithm optimization particularly loops and recursive calls.
The biggest asset that big O notation gives us is that it allows us to essentially discard things like hardware means if you have two sorting algorithms, one with a quadric run time and the other with a logarithmic run time then logarithmic algorithm will always be faster than the quadratic one when the data set becomes suitably large. This applies even if the former is ran on a machine that is far faster than the latter, Why?
Because big O notation isolates a key factor in algorithm analysis: growth. An algorithm with quadratic run time grows faster than one with logarithmic run time.
Note: The above notes are for quick reference. Understanding algorithmic performance is a complex but interesting field. I would recommend picking a good book to understand the nitty-gritty of big O and other notations.