<?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 Saiful Islam Rasel on Medium]]></title>
        <description><![CDATA[Stories by Saiful Islam Rasel on Medium]]></description>
        <link>https://medium.com/@saiful-islam-rasel?source=rss-ce0bec2f92a2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*vGB14BtvIuQkGlvnUhKYcw.png</url>
            <title>Stories by Saiful Islam Rasel on Medium</title>
            <link>https://medium.com/@saiful-islam-rasel?source=rss-ce0bec2f92a2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 09:22:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@saiful-islam-rasel/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Book Review and Takeaways: (The Art of Thinking Clearly)]]></title>
            <link>https://medium.com/@saiful-islam-rasel/book-review-and-takeaways-the-art-of-thinking-clearly-5a9a0e58c059?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a9a0e58c059</guid>
            <category><![CDATA[thinking-clearly]]></category>
            <category><![CDATA[book-review]]></category>
            <category><![CDATA[takeaways]]></category>
            <category><![CDATA[art-of-thinking-clearly]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Thu, 12 Nov 2026 00:00:45 GMT</pubDate>
            <atom:updated>2026-11-12T12:22:55.944Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/157-thinking-clearly-book-review/"><em>blog</em></a><em> on November 12, 2026. Feel free to check it out for more!</em></p><figure><img alt="The Art of Thinking Clearly Book (Photo Credit: Headway)" src="https://cdn-images-1.medium.com/max/640/0*zWdjsN4xubk2qWbL" /><figcaption>The Art of Thinking Clearly Book (Photo Credit: Headway)</figcaption></figure><h3>Book Introduction</h3><p>“ <strong>The Art of Thinking Clearly</strong>” by <strong>Rolf Dobelli</strong> is a popular psychology book that explores common <em>thinking errors</em> and <em>cognitive biases</em> that influence our everyday decisions.</p><p>Through 99 short chapters, the book explains why our minds often make irrational decisions, how we fall into logical traps, and how we can avoid these mistakes. But sometimes too many things can make you bored as well.</p><p><strong>The central message</strong>: Understand how your brain tricks you, recognize common thinking errors, and make better, more rational decisions in everyday life.</p><h3>About Author(s)</h3><p>“ <strong>Rolf Dobelli</strong> “ is a Swiss author, entrepreneur, and public intellectual best known for writing about cognitive biases, decision-making, and clear thinking. His books have been translated into many languages, and his work has reached a broad international audience through books, essays, and lectures on reasoning and psychology.</p><h3>High Level Overview</h3><p>The book is organized into short, 99 independent chapters. Each explaining a specific thinking error, why it happens, and how to avoid it.</p><p><strong>Key Areas Covered:</strong></p><ul><li><strong>Decision-Making</strong>: Why we often make irrational choices and poor judgments.</li><li><strong>Cognitive Biases</strong>: How mental shortcuts distort our thinking.</li><li><strong>Probability &amp; Risk</strong>: Why we misunderstand probabilities, risks, and uncertainty.</li><li><strong>Social Influence</strong>: How other people’s opinions, expectations, and behaviors affect our decisions.</li><li><strong>Self-Deception</strong>: How we fool ourselves through overconfidence, confirmation bias, and selective thinking.</li><li><strong>Success &amp; Failure</strong>: Why we misinterpret success, failure, and the reasons behind them.</li><li><strong>Critical Thinking</strong>: How to question assumptions, challenge beliefs, and make more rational decisions.</li></ul><h3>Key Takeaways</h3><p><strong><em>1. Be Aware of Your Thinking Biases</em></strong></p><ul><li><strong>Confirmation Bias</strong>: We tend to look for information that supports what we already believe and ignore information that challenges it.</li><li><strong>Hindsight Bias</strong>: After something happens, we convince ourselves that we knew it would happen.</li><li><strong>Overconfidence Bias</strong>: We often believe our knowledge, skills, and predictions are more accurate than they actually are.</li></ul><p><strong>Lesson</strong>: Don’t assume you’re always right. Actively look for evidence that challenges your beliefs.</p><p><strong><em>2. Don’t Follow the Crowd Blindly</em></strong></p><ul><li><strong>Social Proof</strong>: We assume something is right simply because many people are doing it.</li><li><strong>Authority Bias</strong>: We tend to trust someone’s opinion just because they have a respected position or title.</li><li><strong>Groupthink</strong>: People sometimes agree with a group to avoid disagreement, even when they have different opinions.</li></ul><p><strong>Lesson</strong>: Popularity and authority don’t always mean correctness. Think independently and evaluate the evidence.</p><p><strong><em>3. Understand the Cost of Sunk Decisions</em></strong></p><ul><li><strong>Sunk Cost Fallacy</strong>: We continue investing time, money, or effort in something simply because we’ve already invested so much.</li><li><strong>Escalation of Commitment</strong>: Instead of accepting a mistake, we keep investing in a failing decision to justify our previous choices.</li></ul><p><strong>Lesson</strong>: Past investments cannot be recovered just by continuing. Make decisions based on future benefits, not past costs.</p><p><strong><em>4. Don’t Let Emotions Control Your Decisions</em></strong></p><ul><li><strong>Loss Aversion</strong>: Losing something hurts more than gaining something of equal value feels good.</li><li><strong>Scarcity Effect</strong>: We value something more when we believe it is limited or about to disappear.</li><li><strong>Fear of Missing Out (FOMO)</strong>: We make rushed decisions because we don’t want to miss an opportunity.</li></ul><p><strong>Lesson</strong>: Avoid making important decisions under fear, excitement, or pressure. Give yourself time to think.</p><p><strong><em>5. Don’t Confuse Correlation with Causation</em></strong></p><ul><li>Two things happening together doesn’t necessarily mean one caused the other.</li><li>Sometimes both are influenced by a third factor.</li><li>We naturally look for patterns, even when those patterns are coincidental.</li></ul><p><strong>Lesson</strong>: Before accepting a conclusion, ask whether there is actual evidence of cause and effect.</p><p><strong><em>6. Be Careful with First Impressions and Comparisons</em></strong></p><ul><li><strong>Anchoring Bia</strong>s: The first piece of information we receive influences our later judgment.</li><li><strong>Contrast Effect</strong>: Something can appear better or worse depending on what we compare it with.</li><li><strong>Halo Effect</strong>: When someone has one positive quality, we tend to assume they have other positive qualities too.</li></ul><p><strong>Lesson</strong>: Don’t let the first number, impression, or comparison determine your judgment. Evaluate things independently.</p><p><strong><em>7. Don’t Judge Success by Visible Examples Alone</em></strong></p><ul><li><strong>Survivorship Bias</strong>: We focus on successful people and ignore those who tried the same thing but failed.</li><li><strong>Outcome Bias</strong>: We judge a decision based on its result rather than whether it was a good decision at the time.</li><li><strong>Availability Bias</strong>: We give more importance to information that comes easily to mind, often because it is recent or memorable.</li></ul><p><strong>Lesson</strong>: Don’t learn only from success stories. Study failures too, and evaluate decisions based on the information available when they were made.</p><p><strong><em>8. Be Realistic About Time and Planning</em></strong></p><ul><li><strong>Planning Fallacy</strong>: We consistently underestimate how much time, effort, and resources a task will require.</li><li><strong>Optimism Bias</strong>: We assume things will go better than they realistically might.</li><li><strong>Overthinking</strong>: We sometimes spend too much time analyzing options instead of making a decision.</li></ul><p><strong>Lesson</strong>: Be realistic when planning. Consider potential problems, allow extra time, and know when you have enough information to decide.</p><p><strong><em>9. Understand the Power of Incentives</em></strong></p><ul><li><strong>Incentive Super-Response</strong>: People tend to behave according to the rewards and benefits they receive.</li><li><strong>Motivation Crowding</strong>: External rewards can sometimes reduce people’s natural motivation to do something.</li><li><strong>Reciprocity</strong>: When someone does something for us, we often feel obligated to return the favor.</li></ul><p><strong>Lesson</strong>: Understand what motivates people’s behavior, including your own. Look beyond what people say and consider what incentives influence their actions.</p><p><strong><em>10. Don’t Overvalue What You Already Have</em></strong></p><ul><li><strong>Endowment Effect</strong>: We tend to value something more simply because we own it.</li><li><strong>Status Quo Bias</strong>: We prefer things to remain the way they are, even when change could be beneficial.</li><li><strong>Choice Supportive Bias</strong>: After making a decision, we tend to remember its positive aspects and overlook its disadvantages.</li></ul><p><strong>Lesson</strong>: Don’t let ownership, familiarity, or previous decisions prevent you from recognizing better alternatives.</p><p><strong><em>11. Learn to Accept Uncertainty</em></strong></p><ul><li><strong>Probability Neglect</strong>: We sometimes focus on how frightening an outcome is rather than how likely it is.</li><li><strong>Black Swan Thinking</strong>: Rare and unexpected events can have enormous consequences.</li><li><strong>Zero-Risk Bias</strong>: We sometimes prefer eliminating a small risk completely rather than significantly reducing a much larger risk.</li></ul><p><strong>Lesson</strong>: Nothing is completely predictable. Understand probabilities, prepare for unexpected events, and make decisions based on both risks and potential consequences.</p><h3>Conclusion</h3><p>The biggest lesson from this book is that our brains are not always good at making rational decisions. We often rely on emotions, assumptions, mental shortcuts, and incomplete information without even realizing it. So:</p><ol><li><strong>Question your assumptions</strong>: Your first impression isn’t necessarily correct.</li><li><strong>Think independently</strong>: Don’t blindly follow the crowd or authority figures.</li><li><strong>Control your emotions</strong>: Avoid making important decisions under fear, excitement, or pressure.</li><li><strong>Learn from failures</strong>: Don’t study only successful people and outcomes.</li><li><strong>Recognize your limitations</strong>: You don’t know everything, and you can be wrong.</li><li><strong>Focus on future value</strong>: Don’t waste resources trying to justify past decisions.</li><li><strong>Challenge your beliefs</strong>: Actively seek information that contradicts your opinions.</li><li><strong>Accept uncertainty</strong>: Make decisions using available evidence rather than expecting perfect predictions.</li><li><strong>Keep things simple</strong>: Don’t overcomplicate decisions when you already have enough information.</li><li><strong>Think before you decide</strong>: A little deliberate thinking can prevent many costly mistakes.</li></ol><p>We don’t necessarily need to become smarter to make better decisions. We need to become more aware of the ways our minds deceive us.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a9a0e58c059" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From the Vault of “Designing Data-Intensive Applications”]]></title>
            <link>https://medium.com/@saiful-islam-rasel/from-the-vault-of-designing-data-intensive-applications-b8ac34f02db2?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ac34f02db2</guid>
            <category><![CDATA[book-review]]></category>
            <category><![CDATA[data-intensive-app]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[data-intensive-system]]></category>
            <category><![CDATA[distributed-data-system]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Sun, 13 Sep 2026 00:00:35 GMT</pubDate>
            <atom:updated>2026-09-13T12:08:16.179Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/156-designing-data-intensive-applications-book-review/"><em>blog</em></a><em> on September 13, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cBfOQeNPgldq9Py9" /><figcaption>Designing Data-Intensive Applications (Photo Credit: Google)</figcaption></figure><h4>Book Introduction</h4><p><strong><em>“Designing Data-Intensive Applications</em></strong>” by Martin Kleppmann is a practical guide to building reliable, scalable, and maintainable data-intensive systems. It explores the fundamental ideas behind databases, distributed systems, replication, partitioning or sharding, transactions, consistency, messaging, consensus, batch processing, and stream processing. All the time, focusing on the trade-offs behind engineering decisions.</p><h4>About Author(s)</h4><p><strong>Martin Kleppmann</strong> is a computer scientist, author, and researcher specializing in distributed systems and data-intensive applications. He is best known for this book, which has become a widely recommended reference for software engineers and architects designing large-scale systems.</p><h3>Lessons, Tips, Tricks, and Solutions</h3><p>The most valuable part is the learning:</p><blockquote><em>How to think about systems? </em><strong><em>Good system design is less about knowing technologies and more about understanding trade-offs.</em></strong><em> So its important to know, what problem am I solving, what guarantees do I need, what can fail, and what am I willing to trade?”.</em></blockquote><p>Below are some of the lessons I keep coming back to:</p><h4>Don’t Start With the Technology</h4><p>Instead of asking questions like: “Should we use PostgreSQL or MongoDB?”</p><p><strong>Asks</strong>:</p><ul><li>What problem are we solving?</li><li>How much data?</li><li>Read/write ratio?</li><li>Expected traffic?</li><li>Latency requirements?</li><li>Consistency requirements?</li><li>Availability requirements?</li><li>What happens when things fail?</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Requirements should drive technology, not the other way around.</em></blockquote><h4>“Scalable” Is Not a Requirement</h4><p>“Millions of users” doesn’t tell us much insights.</p><p><strong>Instead define</strong>:</p><ul><li>Requests/sec</li><li>Reads/sec</li><li>Writes/sec</li><li>Data volume</li><li>Data growth</li><li>Concurrent connections</li><li>Events/sec</li><li>Network bandwidth</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Turn vague scale requirements into measurable workload characteristics.</em></blockquote><h4>Latency and Throughput are Different</h4><ul><li><strong>Latency:</strong> How long one request takes.</li><li><strong>Throughput:</strong> How much work the system handles per second.</li></ul><p>Don’t rely only on averages. Measure the percentile also.</p><p><strong>Lesson:</strong></p><blockquote><em>Always ask: “What’s the tail latency?”</em></blockquote><h4>Reliability Is About More Than Uptime</h4><p>A system isn’t reliable merely because it is “up.”</p><p><strong>Reliability includes</strong>:</p><ul><li>Correctness</li><li>Availability</li><li>Durability</li><li>Fault tolerance</li><li>Predictable behavior</li><li>Recovery from failures</li></ul><p>Does the system continue doing the correct thing when things go wrong? That’s a much stronger definition.</p><h4>Assume Everything Will Fail</h4><p>Failures aren’t exceptional.</p><p><strong>Expect</strong>:</p><ul><li>Network failures</li><li>Disk failures</li><li>Database failures</li><li>Service crashes</li><li>Slow dependencies</li><li>Cloud outages</li><li>Human mistakes</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Reliability means doing the right thing when things go wrong.</em></blockquote><h4>A Timeout Doesn’t Mean Failure</h4><p>In case long running or pending response, did the operation fail? You don’t know. It may have succeeded.</p><p><strong>That’s why:</strong></p><ul><li>Timeouts</li><li>Retries</li><li>Idempotency</li></ul><p>must be designed together.</p><h4>Retries Can Make an Outage Worse</h4><p>If the dependency is already overloaded, retries amplify the problem.</p><p><strong>Use</strong>:</p><ul><li>Limited retries</li><li>Exponential backoff</li><li>Jitter</li><li>Timeouts</li><li>Idempotency</li></ul><p><strong>Lesson:</strong></p><blockquote><em>A retry is additional load, not free insurance.</em></blockquote><h4>Idempotency Is Your Friend</h4><p>Suppose, request succeeds, but response is lost. Client retries. Without idempotency, duplicates happen. With an idempotency key, only one operation happen.</p><p><strong>Useful for</strong>:</p><ul><li>Payments</li><li>Orders</li><li>Account creation</li><li>Message processing</li><li>Job execution</li></ul><p><strong>Lesson:</strong></p><blockquote><em>If an operation can be retried, make it safe to retry.</em></blockquote><h4>Exactly-Once Is Hard</h4><p>Common delivery semantics:</p><ul><li><strong>At-most-once</strong> : may lose messages</li><li><strong>At-least-onc</strong>e : may duplicate messages</li><li><strong>Exactly-once</strong> : much harder than it sounds</li></ul><p>The message may arrive again. Often the practical solution is:</p><blockquote><em>At-least-once delivery + idempotent processing.</em></blockquote><h4>The Database Is More Than a Storage Box</h4><p>A database is doing a tremendous amount of work:</p><ul><li>Storage</li><li>Indexing</li><li>Query optimization</li><li>Concurrency control</li><li>Transactions</li><li>Crash recovery</li><li>Replication</li><li>Locking</li><li>Logging</li><li>Durability</li></ul><p>Understanding how these mechanisms work changes how you write applications.</p><h4>Indexes Are Not Free</h4><p>An index makes reads faster. But indexes have costs. Every additional index can mean:</p><ul><li>More storage</li><li>More memory usage</li><li>More write work</li><li>More maintenance</li></ul><p>Every index can increase write cost.</p><p><strong>Lesson</strong>:</p><blockquote><em>Don’t ask “Can we add an index?” Ask “What workload does this index optimize, and what does it cost us?”</em></blockquote><h4>Read Patterns Should Influence Data Modeling</h4><p>A powerful idea from DDIA:</p><blockquote><strong><em>Data models should reflect how data is used.</em></strong></blockquote><p>Don’t only model:</p><blockquote><em>“What does the business entity look like?”</em></blockquote><p>Also ask:</p><blockquote><em>“How will the application retrieve it?”</em></blockquote><h4>Your database design should make that query efficient. Data modeling is therefore closely connected to <strong>access patterns</strong>.</h4><h4>Transactions Protect Invariants</h4><p>Don’t think of transactions as just:</p><blockquote><em>“BEGIN and COMMIT.”</em></blockquote><p><strong>Think</strong>:</p><blockquote><em>What must always remain true?</em></blockquote><p>Examples:</p><ul><li>Inventory cannot become negative.</li><li>Payment must match an order.</li><li>Username must be unique.</li><li>Money shouldn’t disappear during a transfer.</li></ul><p><strong>Then use</strong>:</p><ul><li>Transactions</li><li>Constraints</li><li>Locks</li><li>Atomic operations</li></ul><p>to protect those invariants.</p><h4>Concurrency Creates Bugs</h4><p><strong>Ask</strong>:</p><blockquote><em>What happens if these two operations happen at the same time?</em></blockquote><p><strong>Possible tools</strong>:</p><ul><li>Transactions</li><li>Row locks</li><li>Optimistic concurrency</li><li>Atomic updates</li><li>Constraints</li></ul><h4>Don’t Guess About Database Performance</h4><p>When a query is slow:</p><pre>EXPLAIN</pre><p>or:</p><pre>EXPLAIN ANALYZEss</pre><p><strong>Look for</strong>:</p><ul><li>Sequential scans</li><li>Index scans</li><li>Join strategy</li><li>Row estimates</li><li>Sorting</li><li>Aggregation</li><li>Unexpected cardinality</li></ul><p><strong>Lesson:</strong></p><h4><em>Measure the query plan instead of guessing.</em></h4><h4>Replication Is Not Backup</h4><p>Replication helps with:</p><ul><li>Availability</li><li>Read scaling</li><li>Fault tolerance</li></ul><p>Backup helps with:</p><ul><li>Accidental deletion</li><li>Corruption</li><li>Historical recovery</li><li>Point-in-time recovery</li></ul><p><strong>Lesson:</strong></p><blockquote><em>You need replication </em>and<em> backups.</em></blockquote><h4>Replication Creates New Problems</h4><p>With replication you have to think about:</p><ul><li>Replication lag</li><li>Failover</li><li>Leader failure</li><li>Split brain</li><li>Stale reads</li><li>Lost writes</li><li>Promotion</li><li>Reconciliation</li></ul><p><strong>Ask:</strong></p><blockquote><em>Does this use case require read-after-write consistency?</em></blockquote><h4>Replication and Partitioning Solve Different Problems</h4><p>Replication useful for:</p><ul><li>Availability</li><li>Fault tolerance</li><li>Read scaling</li></ul><p>Partitioning useful for:</p><ul><li>Data volume</li><li>Write scalability</li><li>Storage limits</li><li>Parallelism</li></ul><p>Large systems often need both.</p><h4>Choose Partition Keys Carefully</h4><p>If we don’t choose it carefully then one partition can becomes overloaded.</p><p><strong>Watch for:</strong></p><ul><li>Hot partitions</li><li>Uneven traffic</li><li>Rebalancing cost</li><li>Cross-partition queries</li></ul><p><strong>Lesson:</strong></p><blockquote><em>A partition key is a workload-distribution decision.</em></blockquote><h4>The Network Is Not a Function Call</h4><p>A network request can:</p><ul><li>Timeout</li><li>Be lost</li><li>Be duplicated</li><li>Be delayed</li><li>Be processed but return no response</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Treat remote calls as unreliable operations.</em></blockquote><h4>Slow Is Sometimes Worse Than Down</h4><p>A completely failed dependency can be easier to handle.</p><p>A slow dependency can cause:</p><ul><li>Connection exhaustion</li><li>Thread exhaustion</li><li>Queue growth</li><li>Memory pressure</li><li>Retry storms</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Latency is a failure mode.</em></blockquote><h4>Backpressure: What Happens When Consumers Are Slower?</h4><p>Possible solutions:</p><ul><li>Scale consumers</li><li>Slow producers</li><li>Batch work</li><li>Apply backpressure</li><li>Drop low-priority work</li><li>Load shed</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Every queue needs a capacity story.</em></blockquote><h4>A Queue Doesn’t Create Infinite Capacity</h4><p>A queue can absorb temporary traffic spikes. It cannot solve slow consumer problems forever. The backlog will eventually grow without bound.</p><p><strong>Lesson:</strong></p><blockquote><em>A queue buys you time; it doesn’t create capacity.</em></blockquote><h4>Ordering Is Usually Local</h4><p>You can guarantee ordering <strong>within a partition</strong>. Not necessarily globally.</p><p><strong>So instead of asking:</strong></p><blockquote><em>“Do we need ordering?”</em></blockquote><p><strong>Ask:</strong></p><blockquote><em>“What exactly needs to be ordered?”</em></blockquote><h4>Eventual Consistency Isn’t Always Bad</h4><p>If a search index updates two seconds later, is that a problem? Maybe not.</p><p>But for bank balance it might be unacceptable.</p><p><strong>Lesson:</strong></p><blockquote><em>Consistency should be driven by business requirements.</em></blockquote><h4>CAP Is Commonly Misunderstood</h4><p>CAP isn’t:</p><blockquote><em>“Choose any two of C, A, and P.”</em></blockquote><p>The interesting situation is a <strong>network partition</strong>.</p><p>During a partition, you may have to choose between: Strong consistency vs Availability</p><p><strong>The key lesson:</strong></p><blockquote><em>You can’t make disconnected nodes instantly agree on reality.</em></blockquote><h4>Consensus Is Not Replication</h4><p>Replication:</p><blockquote><em>“How do we keep multiple copies?”</em></blockquote><p>Consensus:</p><blockquote><em>“How do multiple nodes agree on a decision despite failures?”</em></blockquote><p>Consensus algorithms such as <strong>Raft</strong> or Paxos help with:</p><ul><li>Leader election</li><li>Coordination</li><li>Cluster metadata</li><li>Agreement</li></ul><h4>Always Think About Split Brain</h4><p>Imagine two nodes both think: I am the leader. Now both accept writes and the disaster starts.</p><p>When designing leader-based systems, <strong>ask:</strong></p><blockquote><em>What prevents two leaders from acting at the same time?</em></blockquote><p><strong>Think about:</strong></p><ul><li>Quorum</li><li>Consensus</li><li>Leases</li><li>Fencing</li></ul><h4>Fencing Protects Against Zombie Leaders</h4><p>The old leader shouldn’t be allowed to keep writing. A fencing token can help rejects operations from old leader.</p><p><strong>Lesson:</strong></p><blockquote><em>Don’t just detect old leaders, also prevent them from doing damage.</em></blockquote><h4>Events Should Be Treated Like APIs</h4><p>Once other systems consume your events, so changing the event schema becomes dangerous.</p><p><strong>Think about:</strong></p><ul><li>Backward compatibility</li><li>Forward compatibility</li><li>Optional fields</li><li>Versioning</li><li>Schema governance</li></ul><p><strong>Lesson:</strong></p><blockquote><em>An event consumed by other systems is a contract.</em></blockquote><h4>Transactional Outbox Solves a Classic Problem</h4><p>Suppose you need to update database + publish event. What if one success and another failed? Now your database and event stream disagree.</p><p><strong>Outbox:</strong></p><pre>BEGIN<br>  Update order<br>  Insert event into outbox<br>COMMIT<br><br>Outbox → Kafka</pre><p>The database update and event creation become atomic.</p><h4>Source of Truth vs Derived Data</h4><p>Data that need for day to day operation and supports other analytics is source of truth. And, analytics system or any other that can reproduce using source of truth is called derived data like: cache.</p><p><strong>Lesson:</strong></p><blockquote><em>Know which data is authoritative and which data can be reconstructed.</em></blockquote><h4>Caching Creates a Second Reality</h4><p>With cache you must answer:</p><ul><li>How stale can data be?</li><li>How is invalidation handled?</li><li>What if cache disappears?</li><li>What if millions of keys expire together?</li></ul><p>Caching improves performance, but introduces consistency complexity.</p><h4>Beware Cache Stampede</h4><p>Suppose a popular cache entry expires and all the request lands to database now. It can harms overall system.</p><p><strong>Possible solutions:</strong></p><ul><li>Request coalescing</li><li>Locks</li><li>Early refresh</li><li>TTL jitter</li><li>Stale-while-revalidate</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Design for cache misses, not just cache hits.</em></blockquote><h4>Stream Processing Has Time Problems</h4><p>An event may happen at: 10:00, but arrive at: 10:05. Therefore event time is different than processing time.</p><p>This leads to:</p><ul><li>Windows</li><li>Watermarks</li><li>Late events</li><li>Out-of-order events</li></ul><p>Real-time event processing is often much harder.</p><h4>Schema Changes Need a Migration Strategy</h4><p>Avoid immediately remove old column after deploy new code. Instead, plan and evaluate the situation and migration strategy considering backward and forward compatibility.</p><p><strong>Lesson:</strong></p><blockquote><em>Database evolution is part of application deployment.</em></blockquote><h4>Microservices Move Complexity Around</h4><p>Microservices can provide:</p><ul><li>Independent deployment</li><li>Team ownership</li><li>Independent scaling</li></ul><p>But introduce:</p><ul><li>Network failures</li><li>Distributed transactions</li><li>Eventual consistency</li><li>More observability</li><li>More deployments</li><li>More operational overhead</li></ul><p><strong>Lesson:</strong></p><blockquote><em>Microservices aren’t free scalability.</em></blockquote><h4>Every New Component Creates New Failure Modes</h4><p>Before adding a component, ask:</p><blockquote><em>What problem does this solve, and what new problems does it introduce?</em></blockquote><h4>Backups Are Only Useful If You Can Restore Them</h4><p>A backup saying success doesn’t prove recovery works.</p><p><strong>Lesson:</strong></p><blockquote><em>A backup you haven’t restored is a theory and not useful.</em></blockquote><h4>Recovery Is Part of Architecture</h4><p>Don’t only design: “How does the system work?”</p><p>Also design: “How does the system recover?”</p><p><strong>Ask:</strong></p><ul><li>What if the database dies?</li><li>What if Kafka loses a node?</li><li>What if a region goes down?</li><li>What if data is corrupted?</li><li>How do we rebuild derived data?</li></ul><h4>Distributed Transactions Are Expensive</h4><p>Suppose you have 2 database and one business operation requires both databases to succeed. Now you need some form of distributed transaction or workflow.</p><p>Two-phase commit (<strong>2PC</strong>) can provide coordination, but it introduces:</p><ul><li>Coordinator dependency</li><li>Blocking scenarios</li><li>Failure complexity</li><li>Operational complexity</li><li>Performance overhead</li></ul><p>An alternative is often a <strong>Saga</strong> with compensating actions when something fails. The system should designed around compensation rather than one giant atomic transaction.</p><h4>“Distributed Transactions Are Hard” Is Not the Solution</h4><p>When a distributed transaction is difficult, don’t immediately jump to:</p><blockquote><em>“Let’s use Kafka.”</em></blockquote><p>Ask whether the business operation can be redesigned. Architecture often improves when the <strong>business process itself</strong> is modeled explicitly.</p><h4>RPO and RTO Turn “Recovery” Into Something Measurable</h4><p><strong>RPO — Recovery Point Objective</strong></p><blockquote><em>How much data can we afford to lose?</em></blockquote><p>Example:</p><pre>RPO = 5 minutes</pre><p>Means you can tolerate losing up to roughly five minutes of recent data, depending on the recovery design.</p><p><strong>RTO — Recovery Time Objective</strong></p><blockquote><em>How quickly must the service recover?</em></blockquote><p>Example:</p><pre>RTO = 30 minutes</pre><p>Means the system should be restored within roughly 30 minutes.</p><p>These requirements influence:</p><ul><li>Backup frequency</li><li>Replication</li><li>Disaster recovery</li><li>Architecture</li><li>Cost</li></ul><h4>Zero-Downtime Deployment Is Mostly About Compatibility</h4><p>People often think zero-downtime deployment means:</p><blockquote><em>“Use Kubernetes rolling deployments.”</em></blockquote><p>But the harder problem is usually:</p><pre>Can old and new versions safely coexist?</pre><p>For example:</p><pre>Old app → old schema<br>New app → new schema</pre><p>If they’re incompatible, rolling deployment doesn’t save you.</p><p>The real requirement is:</p><blockquote><strong><em>Compatible evolution.</em></strong></blockquote><h4>The DDIA Questions I Keep in My Head</h4><p>When designing a system, I find these questions more useful than memorizing technologies:</p><ol><li>What is the business requirements?</li><li>What is the workload?</li><li>What is the source of truth?</li><li>What invariants must always hold?</li><li>What consistency do we actually need?</li><li>What happens concurrently?</li><li>What happens when something is slow?</li><li>What happens when something fails?</li><li>Can requests be duplicated?</li><li>Can messages be duplicated?</li><li>Does ordering matter?</li><li>Where is the bottleneck?</li><li>How does the system scale?</li><li>How does it recover?</li><li>Can derived data be rebuilt?</li><li>What does this architecture cost?</li><li>What complexity are we introducing?</li></ol><h4>The Biggest Lesson</h4><p>After reading DDIA, I don’t think the goal is to become someone who can recite the low level details like:</p><ul><li>B-Tree</li><li>LSM Tree</li><li>MVCC</li><li>2PL</li><li>WAL</li><li>SSTables</li><li>Raft</li><li>CAP</li><li>3PC</li><li>Kafka</li><li>Replication</li><li>Partitioning</li></ul><p>The real goal is to become someone who naturally asks:</p><ul><li>What happens when this grows?</li><li>What happens when this is slow?</li><li>What happens when this fails?</li><li>What happens when the same request arrives twice?</li><li>What happens when data is stale?</li><li>What happens when two operations happen concurrently?</li><li>How do we recover?</li><li>And what trade-off are we making?</li></ul><h4>In One Sentence:</h4><blockquote><strong><em>Build systems around requirements, understand the data flow, expect failure, make correctness explicit, measure the real bottlenecks, design for recovery, and never accept complexity without understanding the trade-off.</em></strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ac34f02db2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lessons Learned in My Career (So Far): Good (Do’s) and Bad (Don’ts)]]></title>
            <link>https://medium.com/@saiful-islam-rasel/lessons-learned-in-my-career-so-far-good-dos-and-bad-don-ts-7156324fbb80?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/7156324fbb80</guid>
            <category><![CDATA[lessons]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[job-life]]></category>
            <category><![CDATA[career-guidance]]></category>
            <category><![CDATA[career-advice]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 00:00:20 GMT</pubDate>
            <atom:updated>2026-09-04T17:38:07.514Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/155-do-dont/"><em>blog</em></a><em> on September 04, 2026. Feel free to check it out for more!</em></p><figure><img alt="Career Lessons (Photo Credit: Google)" src="https://cdn-images-1.medium.com/max/675/0*RIolVSB1AO8QWqn8" /><figcaption>Career Lessons (Photo Credit: Google)</figcaption></figure><p>In February 2026, I completed <strong>5 years</strong> of my career. During these 5 years, I served responsibility for <strong>4 different designations</strong>. Started as a <strong><em>Software Engineer (Level 1)</em></strong> in March 2021. Next year, promoted to <strong>Software Engineer (Level 2)</strong>. Year after, joined as <strong>Senior Software Engineer</strong>, and currently an <strong><em>Assistant Lead Software Engineer</em></strong> after last promotion.</p><p>So I feel I should share my learnings (so far) from my career. Maybe freshers or juniors can benefit from it.</p><p><strong><em>Please note</em></strong>: all the points below are my personal opinions, and it’s completely fine to disagree. So let’s start…</p><h3>Do’s</h3><ul><li>Learn programming and write lots of code during the first 3 years of your university life.</li><li>Do problem solving and competitive programming in university life.</li><li>Do a side project at the 4th year of your university to showcase your capability.</li><li>Join a job in the final year of your university, if possible.</li><li>Do as much as work in your first 3–4 years of your career.</li><li>Be flexible about tech stack, work, and opportunity.</li><li>Gather and gain domain knowledge strongly while working on a project.</li><li>Build genuine relationships with your co-workers.</li><li>Imposter syndrome is natural. Nobody knows all the things.</li><li>Challenge yourself and push your limitations day by day.</li><li>Search for quality work after a certain time of your career.</li><li>Always keep learning.</li><li>Always take ownership and show interest in leadership.</li><li>Raise questions about anything to judge its validity before starting to do it.</li><li>Understand the business impact of your work. Make yourself product-centric.</li><li>Be good at debugging and incident handling.</li><li>Align, align, and align people with data.</li><li>Make a prototype or demo while presenting any ideas.</li><li>Office politics exist; learn to navigate them.</li><li>Act then think. Sometimes too much thinking creates an analysis paralysis situation.</li><li>Soft skills are important. So give proper attention to it.</li><li>Keep attention on work-life balance, especially when you have passed a good amount of time in your career.</li><li>Try hard even if you know you can fail.</li><li>Interview participation is important to judge your ability and upgrade your capability.</li></ul><h3>Don’ts</h3><ul><li>Don’t avoid programming, problem solving, and competitive programming.</li><li>In this competitive job market, don’t wait too long to join a job.</li><li>In your early career, don’t think too much about job-life balance.</li><li>Don’t be too biased about the tech stack.</li><li>Don’t just focus on gaining technical knowledge; focus on domain knowledge gathering too.</li><li>Don’t break trust and honest relationships with co-workers.</li><li>Don’t get stuck in your comfort zone.</li><li>Don’t get stuck in flat, regular, and not exciting work.</li><li>Never stop learning.</li><li>Don’t hesitate to take leave and break.</li><li>Don’t just do what you asked to do; judge its ROI by questioning.</li><li>Don’t try to avoid meetings because meetings will be one of the important parts of your job.</li><li>Don’t think you are always an individual contributor. You need to be a people manager some day.</li><li>Don’t lie while sharing feedback. Your sugar-coated feedback will not be helpful to others.</li><li>Never afraid to fail.</li><li>Don’t avoid the importance of soft skills.</li><li>Never stop participating in job interviews, but make sure you don’t switch jobs too often.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7156324fbb80" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Critical Thinking]]></title>
            <link>https://medium.com/@saiful-islam-rasel/critical-thinking-fdf3f783503a?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdf3f783503a</guid>
            <category><![CDATA[problem-solving-technique]]></category>
            <category><![CDATA[critical-thinking]]></category>
            <category><![CDATA[problem-solving]]></category>
            <category><![CDATA[careers]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Sat, 23 May 2026 18:35:23 GMT</pubDate>
            <atom:updated>2026-05-23T18:35:23.276Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/154-critical-thinking/"><em>blog</em></a><em> on May 22, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*Iur9T4gWmWtWFGCJ" /><figcaption>Critical Thinking (Photo Credit: eSchool News)</figcaption></figure><p>Some people think developing “<strong>critical thinking</strong>” capability is really critical. By following proper approaches and practices, it is easy to develop. In this article, we try to explore what “critical thinking” really means and how we can develop it.</p><h3>What does “Critical Thinking” mean?</h3><p>Critical thinking is the ability to:</p><ul><li>analyze information <strong>objectively</strong>,</li><li>evaluate evidence <strong>logically</strong>,</li><li>identify <strong>assumptions</strong> and <strong>biases</strong>,</li><li>and make <strong>reasoned</strong> decisions instead of reacting <strong>emotionally</strong> or <strong>blindly</strong> accepting information.</li></ul><p>In modern work and life, critical thinking matters more than memorization. It involves actively questioning assumptions, recognizing biases, and synthesizing information rather than accepting claims at face value.</p><blockquote><strong>In single word, critical thinking means: “Thinking carefully, logically, and independently before believing, deciding, or acting.”</strong></blockquote><h3>Nature of Critical Thinker</h3><p>Instead of asking: <strong><em>What should I think?</em></strong></p><p>A critical thinker asks:</p><ul><li>Why is this true?</li><li>What evidence or data supports this?</li><li>What assumptions are being made?</li><li>Are there alternative explanations?</li><li>What could go wrong?</li></ul><p>This means a critical thinker is always curious about asking questions, finding the alternatives, evaluating <strong>cause vs. consequences</strong>, and choosing the best solution possible.</p><h4>Signs of a Weak Critical Thinker</h4><ul><li>Believes everything immediately</li><li>Relies only on emotions</li><li>Avoids questioning authority</li><li>Jumps to conclusions</li><li>Cannot explain reasoning</li><li>Confuses opinion with fact</li><li>Ignores evidence</li><li>Thinks in extremes (“always”, “never”)</li></ul><h4>Signs of a Strong Critical Thinker</h4><ul><li>Curious</li><li>Calm under uncertainty</li><li>Asks good questions</li><li>Changes opinion when evidence changes</li><li>Thinks in probabilities</li><li>Evaluates trade-offs</li><li>Distinguishes facts from assumptions</li><li>Can explain reasoning clearly</li></ul><h3>Why Critical Thinking Is Important?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hAGbue1dCzcWz8h4" /><figcaption>Importance of Critical Thinking (Photo Credit: TSCFM)</figcaption></figure><ul><li>It helps to improve decision-making</li><li>Enhances problem-solving ability</li><li>Builds deeper understanding</li><li>Refine research skills</li><li>Enhances communication skills</li><li>Polishes creativity</li><li>Stimulates curiosity</li><li>Promotes independent learning</li><li>Reduces costly mistakes</li><li>Better incident handling</li></ul><h3>How Much We Can Do?</h3><p>As a human being, we can’t do everything. We have limitations of time and resources.</p><p>In reality we follow a simple rule:</p><blockquote><strong>our ability to do = (bottlenecks * problems) / limited time</strong></blockquote><p>In limited time, we can achieve more productivity, if we can reduce maximum bottlenecks and solve more problems.</p><p>To maximize this ratio:</p><ul><li><strong>Focus</strong>: Decrease the size of the denominator (Time) by doing <strong>deep, uninterrupted</strong> work blocks.</li><li><strong>Expansion</strong>: Increase the numerator by <strong>breaking large problems</strong> into sequential steps, which helps you clear multiple bottlenecks without feeling overwhelmed.</li></ul><h4>Understanding Cause Vs. Consequences</h4><ul><li><strong>causes</strong>: symptoms that problematic.</li><li><strong>consequences</strong>: new problems due to the recommendation.</li></ul><p>Identify causes, then figure out the real <strong>reason behind</strong> them. Based on the identifications, generate a <strong>recommendation</strong>. Make sure the recommendation does not create any problems further. Because if the recommendation creates new bottlenecks, then it reduces our productivity based on the above rule.</p><p>Use <strong><em>5 why techniques</em></strong> to identify causes and <strong><em>7 so-what’s techniques</em></strong> to identify consequences. It should help you identify the causes, reasons behind them, and the consequences.</p><h3>Core Components of Critical Thinking</h3><p>Mastering critical thinking relies on several key mental disciplines:</p><h4>1. Observation</h4><p>Carefully noticing facts, patterns, behaviors, and details. Challenge the existing model.</p><p><strong>Example</strong>:</p><ul><li>A server CPU suddenly spikes every night at 2 AM.</li><li>Instead of guessing, you investigate logs, jobs, and traffic patterns.</li></ul><h4>2. Analysis</h4><p>Breaking complex problems into smaller understandable parts. Analysis through <strong>high road</strong> and <strong>low road</strong> technique.</p><p><strong>Example</strong>:</p><p>In a production outage investigate:</p><ul><li>Network?</li><li>Database?</li><li>Application?</li><li>DNS?</li><li>Load balancer?</li></ul><p>You isolate the real root cause instead of panicking.</p><h4>3. Logical Reasoning</h4><p>Connecting facts logically. Use 80/20 principle.</p><p><strong>Example</strong>:</p><ul><li>High latency started after deployment.</li><li>Logs show DB connection pool exhaustion.</li><li>Therefore, deployment likely introduced inefficient queries.</li></ul><h4>4. Questioning Assumptions</h4><p>Not accepting things blindly.</p><p><strong>Example</strong>:</p><p>Instead of:</p><ul><li>“Kubernetes is always better.”</li></ul><p>Ask:</p><ul><li>Better for what?</li><li>At what scale?</li><li>What are the trade-offs?</li><li>Does the team have expertise?</li></ul><h4>5. Evidence-Based Thinking</h4><p>Using facts and data instead of opinions.</p><p><strong>Example</strong>:</p><p>Bad:</p><ul><li>“I feel this architecture is good.”</li></ul><p>Better:</p><ul><li>“Load tests show it handles 20k RPS with acceptable latency.”</li></ul><h4>6. Bias Awareness</h4><p>Understanding that humans naturally think irrationally sometimes.</p><p><strong>Examples</strong>:</p><ul><li>Confirmation bias</li><li>Ego bias</li><li>Authority bias</li><li>Emotional reasoning</li></ul><p>Critical thinkers actively challenge their own beliefs.</p><h4>7. Decision Making</h4><p>Choosing the best possible option after evaluating alternatives.</p><p><strong>Example</strong>:</p><p>Not:</p><ul><li>Perfect decisions</li></ul><p>But:</p><ul><li>Reasoned and informed decisions</li></ul><h3>Critical Thinking Framework</h3><p>A practical framework for critical thinking:</p><h4>Step 1 — Understand the Problem</h4><p><strong>Ask</strong>:</p><ul><li>What exactly is the problem? (<strong>Goal</strong>)</li><li>For whom we are going to solve the problem (<strong>Stockholders</strong>)</li><li>Do we have available data? (<strong>Metrics</strong>)</li><li>What constraints exist? How much should we address or solve the problem? (<strong>Boundaries</strong>)</li><li>What are we trying to achieve? (<strong>Success Criteria</strong>)</li></ul><h4>Step 2 — Gather Information</h4><p><strong>Collect</strong>:</p><ul><li>Facts</li><li>Data</li><li>Logs</li><li>Metrics</li><li>Evidence</li><li>Context</li></ul><h4>Step 3 — Identify Assumptions</h4><p><strong>Ask</strong>:</p><ul><li>What are we assuming?</li><li>Could those assumptions be wrong?</li></ul><h4>Step 4 — Generate Alternatives</h4><p>Avoid binary thinking.</p><p><strong>Instead of</strong>:</p><ul><li>“Should we use Docker or not?”</li></ul><p><strong>Think</strong>:</p><ul><li>Docker</li><li>VMs</li><li>Managed services</li><li>Hybrid approach</li></ul><h4>Step 5 — Evaluate Trade-offs</h4><p>Every solution <strong>has</strong>:</p><ul><li>Pros</li><li>Cons</li><li>Risks</li><li>Costs</li><li>Complexity</li></ul><h4>Step 6 — Make a Decision</h4><p>Choose the best option <strong>based on</strong>:</p><ul><li>Evidence</li><li>Constraints</li><li>Risks</li><li>Goals</li></ul><h4>Step 7 — Reflect Afterwards (Consequences)</h4><p><strong>Ask</strong>:</p><ul><li>What worked?</li><li>What failed?</li><li>What did we miss?</li><li>How can we improve?</li></ul><p>Reflection builds wisdom.</p><h3>How to Develop Critical Thinking</h3><p>There hasn’t been any definite answer. But, in general, we can follow the below:</p><h4>1. Ask Better Questions</h4><p>The quality of your thinking depends on the quality of your questions.</p><p>Useful questions:</p><ul><li>Why?</li><li>How do we know?</li><li>What evidence exists?</li><li>What assumptions are hidden?</li><li>What are alternative explanations?</li><li>What are the trade-offs?</li><li>What could fail?</li></ul><h4>2. Read Deeply, Not Just Quickly</h4><p>Read:</p><ul><li>Books</li><li>Technical blogs</li><li>Case studies</li><li>Postmortems</li><li>Research papers</li></ul><p>Then ask:</p><ul><li>Do I agree?</li><li>Why?</li><li>What are weaknesses in this argument?</li></ul><h4>3. Practice Problem Solving</h4><p>Critical thinking improves through use.</p><p>Good activities:</p><ul><li>Debugging systems</li><li>System design</li><li>Chess</li><li>Competitive programming</li><li>Architecture reviews</li><li>Incident analysis</li></ul><h4>4. Learn Logic and Reasoning</h4><p>Basic knowledge of:</p><ul><li>Deductive reasoning</li><li>Inductive reasoning</li><li>Logical fallacies</li><li>Probabilistic thinking</li></ul><p>is extremely valuable.</p><p>Example fallacies:</p><ul><li>Strawman</li><li>False dilemma</li><li>Ad hominem</li><li>Appeal to authority</li></ul><h4>5. Analyze Real Incidents</h4><p>Especially valuable for engineers.</p><p>Read:</p><ul><li>Engineering postmortems</li><li>Outage analyses</li><li>Failure reports</li></ul><p>Ask:</p><ul><li>What caused this?</li><li>What assumptions failed?</li><li>What safeguards were missing?</li></ul><p>Companies like <a href="https://sre.google/">Google SRE</a> and <a href="https://blog.cloudflare.com/">Cloudflare Blog</a> publish excellent engineering analyses.</p><h4>6. Debate Ideas, Not People</h4><p>Strong thinkers:</p><ul><li>Challenge ideas respectfully</li><li>Separate emotion from analysis</li><li>Seek truth, not victory</li></ul><h4>7. Slow Down Important Decisions</h4><p>Bad decisions often come from:</p><ul><li>Hurry</li><li>Ego</li><li>Fear</li><li>Assumptions</li></ul><p>Important decisions deserve:</p><ul><li>Reflection</li><li>Data</li><li>Alternative analysis</li></ul><h4>8. Write More</h4><p>Writing exposes weak thinking.</p><p>Try:</p><ul><li>Technical blogs</li><li>Decision documents</li><li>Architecture notes</li><li>Personal reflections</li></ul><p>If you cannot explain something clearly, you may not fully understand it.</p><h4>9. Learn From Multiple Perspectives</h4><p>Avoid echo chambers.</p><p>Read from:</p><ul><li>Different experts</li><li>Different industries</li><li>Different opinions</li></ul><p>This improves intellectual flexibility.</p><h4>10. Develop Intellectual Humility</h4><p>One of the strongest traits of critical thinkers:</p><blockquote><em>“I might be wrong.”</em></blockquote><p>This mindset accelerates learning.</p><h3>Resources:</h3><p><strong>Books</strong>:</p><ul><li>Thinking, Fast and Slow</li><li>The Demon-Haunted World</li><li>Super Thinking</li><li>Decisive</li><li>The Art of Thinking Clearly</li><li>Engineering Thinking</li><li>The Pragmatic Programmer</li></ul><p><strong>Course</strong>:</p><ul><li>LinkedIn Learning Path: <a href="https://www.linkedin.com/learning/paths/develop-critical-thinking-decision-making-and-problem-solving-skills">Develop Critical Thinking, Decision-Making, and Problem-Solving Skills</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdf3f783503a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Effective Resume/CV Writing for Software Engineers]]></title>
            <link>https://medium.com/@saiful-islam-rasel/effective-resume-cv-writing-for-software-engineers-96722d673078?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/96722d673078</guid>
            <category><![CDATA[cv]]></category>
            <category><![CDATA[resume-writing-tips]]></category>
            <category><![CDATA[resume]]></category>
            <category><![CDATA[resume-writing]]></category>
            <category><![CDATA[cv-writing]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Sat, 16 May 2026 00:00:47 GMT</pubDate>
            <atom:updated>2026-05-19T15:02:09.423Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/153-cv-writing-for-engineers/"><em>blog</em></a><em> on May 16, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rwrLp6XkOxn9HvE397kwsA.jpeg" /><figcaption>Photo Credit: Study 365</figcaption></figure><p>A software engineering CV/Resume is not just a document listing technologies and job history. It is a <strong>marketing document</strong> that should answer one core question:</p><blockquote><strong>“Why should this engineer be interviewed?”</strong></blockquote><p>So, understanding the characteristics of a effective Resume is equally important to understanding the company and role you are going to interview for.</p><h3>Why Does a Great Resume Matter?</h3><p>A great resume matters because it acts as:</p><blockquote>Your professional introduction, marketing document, and opportunity generator — all at the same time.</blockquote><p>It is usually the <strong>first impression</strong> a company has about you. Before interviews, coding rounds, technical discussions, system design evaluations, your resume decides whether you get the opportunity to express you at all.</p><p>For software engineers, a resume is not just a document — it is a professional representation of:</p><ul><li>your technical ability,</li><li>your impact,</li><li>your growth,</li><li>your ownership mindset,</li><li>your leadership capability,</li><li>your communication,</li><li>and your engineering maturity.</li></ul><p>A strong resume helps you:</p><ul><li>get interviews,</li><li>attract recruiters,</li><li>pass ATS screening,</li><li>stand out among hundreds of applicants.</li></ul><p>On the other hand, a weak resume can <strong>hide</strong> even very <strong>strong engineers</strong>.</p><h3>The Goal of a Resume</h3><p>A resume is <strong>NOT</strong>:</p><ul><li>a biography,</li><li>a technology dump,</li><li>a full career history,</li><li>a document to list everything you know.</li></ul><p>A resume <strong>IS</strong>:</p><ul><li>a concise professional story,</li><li>a proof of capability,</li><li>a demonstration of impact,</li><li>an interview invitation.</li></ul><h3>Things to Need to Consider Before Preparing a Resume:</h3><ul><li><strong>Know the target role</strong> — Your resume should align with the responsibilities and expectations of the role you are applying for.</li><li><strong>Understand your career level</strong> — Freshers, mid-level, senior, and lead engineers require different resume focus areas.</li><li><strong>Identify your strongest selling points</strong> — Highlight the skills and experiences that differentiate you from other candidates.</li><li><strong>Focus on impact, not only responsibilities</strong> — Companies care more about outcomes and business value than task lists.</li><li><strong>Collect measurable achievements</strong> — Numbers make accomplishments more credible and easier to understand.</li><li><strong>Understand the company/domain</strong> — Tailoring your resume to the company increases relevance and shortlist chances.</li><li><strong>Prioritize relevant experience</strong> — Recruiters should quickly see the most important and relevant information first.</li><li><strong>Decide the resume length early</strong> — Freshers should usually keep it to 1 page; experienced engineers to 2 pages.</li><li><strong>Choose a clean and readable format</strong> — A well-structured resume improves readability and professionalism.</li><li><strong>Organize technical skills logically</strong> — Grouped skills are easier to scan and look more professional.</li><li><strong>Think about ATS compatibility</strong> — Simple formatting and relevant keywords improve ATS screening success.</li><li><strong>Prepare a strong professional summary</strong> — The summary should quickly communicate your expertise and value.</li><li><strong>Highlight career progression clearly</strong> — Promotions and increasing responsibilities demonstrate growth and trust.</li><li><strong>Balance responsibilities and accomplishments</strong> — Strong resumes show both what you owned and what you achieved.</li><li><strong>Select only relevant projects</strong> — Projects should support the role you are targeting, not just fill space.</li><li><strong>Add leadership signals if experienced</strong> — Mentoring, ownership, and cross-team collaboration strengthen senior-level profiles.</li><li><strong>Remove outdated or weak content</strong> — Old or irrelevant information reduces resume quality and focus.</li><li><strong>Use action-oriented language</strong> — Strong verbs make accomplishments sound confident and impactful.</li><li><strong>Keep the resume concise and high-signal</strong> — Recruiters prefer resumes that are easy to scan quickly.</li><li><strong>Proofread grammar and formatting carefully</strong> — Small mistakes can reduce professionalism and credibility.</li><li><strong>Include professional links</strong> — LinkedIn, GitHub, portfolio, or blogs strengthen your technical profile.</li><li><strong>Ensure consistency everywhere</strong> — Consistent tense, formatting, and wording improve readability.</li><li><strong>Avoid technology dumping</strong> — Listing too many tools without proof weakens credibility.</li><li><strong>Think from a recruiter’s perspective</strong> — Your resume should quickly answer why you are worth interviewing.</li><li><strong>Align the resume with your long-term career direction</strong> — Your resume should position you for the role you want next, not only the role you have now.</li></ul><h3>Writing The Resume</h3><h4>1. Common</h4><ul><li><strong>Format Correctly</strong>: proper alignment, line height, space gap, underline, bold, etc.</li><li><strong>Maintain Consistency</strong>: use consistent and concise formatting throughout the full resume.</li><li><strong>Font Size</strong>: use a common font size for texts, another for sub-headers, and another for headers.</li><li><strong>Page</strong>: use 1 page for freshers or less experienced engineers and 2 pages for experienced engineers.</li><li><strong>Section Ordering</strong>: order sections based on experience level.</li><li><strong>Grammer</strong>: avoid any kind of grammer mistakes.</li><li><strong>Personal Information</strong>: avoid adding irrelevant personal information as much as possible.</li><li><strong>File Name &amp; Format</strong>: name the resume with your name and use <strong>.pdf</strong> format.</li></ul><h4>2. Resume Structure</h4><p><strong>Recommended Structure (Freshers)</strong></p><ul><li>Header + Links</li><li>Professional Summary / Objective</li><li>Education</li><li>Technical Skills</li><li>Projects</li><li>Internship / Experience</li><li>Competitive Programming / Achievements</li><li>Certifications / Additional Info</li></ul><p><strong>Recommended Structure (Experienced Engineers)</strong></p><ul><li>Header + Links</li><li>Professional Summary</li><li>Work Experience</li><li>Technical Skills</li><li>Projects</li><li>Education</li><li>Competitive Programming / Achievements</li><li>Certifications / Additional Information</li></ul><p>Let’s see how we can prepare every section effectively.</p><p><strong>Please note</strong>: the example given below is more appropriate for experienced engineers. But freshers can gather a good understanding, hopefully.</p><h4>Header</h4><p>In header you should place your full name and title, all the requeired contact info (like: address, phone, email), and links that can represent you further (like: portfolio website, LinkedIn, github).</p><p>Use a suitable font size: 11 for text, 12 for title, and 16 for full name. This section is the same for freshers and experienced engineers.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/0*WYeAExZ_4lA-u3_1" /><figcaption>Header</figcaption></figure><h4>Professional Summary</h4><p>The summary should quickly answer some of the questions, like who you are, years of experience, specialization, impact, leadership level, etc. Summarize yourself and your career/experience in brief. So that anyone feels interested to read the resume further and know you.</p><p>Freshers should emphasize their education and achievements. And experienced engineers should emphasize their career journey and impact.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*ggnht28oqzxv7lDT" /><figcaption>Summary</figcaption></figure><h4>Work Experience</h4><p>Listing your work experience in descending order. Don’t just write the jobs or responsibilities; show the impact you generate in your role. Use action-oriented verbs to make it powerful. Quantify your impact or achievement whenever possible. Mentioning the tech stack will be helpful.</p><p>For freshers, this section is naturally not relevant. But for experienced engineers, it is the section with the most meaning. If possible, list experience in a way that represents the growth or promotion nicely.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/0*91Qh1bQj0IST3xf2" /><figcaption>Experience-1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/0*BIB1M6ZfAoXNakAG" /><figcaption>Experience-2</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/0*24vkTkX4YiTBrAy_" /><figcaption>Experience-3</figcaption></figure><h4>Technical Skills</h4><p>Show the technical capability you have. List the technologies you are confident about, and avoid including anything you barely know. Group skills logically as much as possible.</p><p>Order them wisely, listing the technologies you most know first. Freshers should showcase their technical learning here.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/0*D1nivbChh6nMlv7X" /><figcaption>Skills</figcaption></figure><h4>Projects</h4><p>List highly impactful and successful projects in terms of business that you work with. Add links if possible. Order them wisely, listing the most recent and impactful one first.</p><p>For freshers, it is the section to showcase your pet projects and real-world working capability. Keep that section at the top after the education section.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/0*hMlGPUa4FEzZb0m7" /><figcaption>Projects</figcaption></figure><h4>Education</h4><p>List only the most recent 1 or 2 degrees. Show CGPA if it’s mentionable. Keep the section small and concise.</p><p>For freshers, keep that section at the top after the summary section.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/651/0*kZQsuUgPEIV7WObb" /><figcaption>Education</figcaption></figure><h4>Competitive Programming</h4><p>Programmers with contest programming or competitive programming get extra care in the community. So, if you have the competitive programming background, you should keep it on your resume.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/0*gaPdrO0_HNqIUDUH" /><figcaption>Competitive Programming</figcaption></figure><h4>Additional Info</h4><p>Showcase your personal achievements, extracurricular activities, blogging links, hobbies, etc. But all the information you provided in this section should emphasize your previously given data.</p><p><strong>Example</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/548/0*0-HadzkN-gWlEW9A" /><figcaption>Additional Info</figcaption></figure><h3>Common Resume Mistakes</h3><ul><li><strong>Using a generic resume for every job</strong> — Recruiters can tell when your resume isn’t tailored to the role.</li><li><strong>Writing a long objective statement</strong> — Hiring managers care more about your value than your career wish list.</li><li><strong>Including irrelevant experience</strong> — Unrelated details distract from your strongest qualifications.</li><li><strong>Listing duties instead of achievements</strong> — Results and impact are more impressive than task descriptions.</li><li><strong>Using vague buzzwords</strong> — Terms like “hardworking” or “team player” mean little without proof.</li><li><strong>Having spelling or grammar mistakes</strong> — Errors make you look careless and unprofessional.</li><li><strong>Making the resume too long</strong> — Recruiters often scan resumes for only a few seconds.</li><li><strong>Using poor formatting</strong> — Cluttered layouts are hard to read and may confuse ATS systems.</li><li><strong>Adding too much personal information</strong> — Details like age, religion, or marital status are unnecessary.</li><li><strong>Using an unprofessional email address</strong> — A casual email can hurt your professional image.</li><li><strong>Not including keywords from the job description</strong> — ATS software may reject resumes missing relevant terms.</li><li><strong>Including outdated skills</strong> — Old or irrelevant skills can make your profile seem outdated.</li><li><strong>Exaggerating or lying</strong> — False claims are often discovered during interviews or background checks.</li><li><strong>Using paragraphs instead of bullet points</strong> — Dense text reduces readability and quick scanning.</li><li><strong>Ignoring measurable results</strong> — Numbers help employers understand your real impact.</li><li><strong>Adding references directly on the resume</strong> — It wastes space since employers ask only if needed.</li><li><strong>Using inconsistent fonts or styles</strong> — Inconsistency makes the resume look unpolished.</li><li><strong>Leaving unexplained employment gaps</strong> — Recruiters may assume the worst without context.</li><li><strong>Submitting the wrong file format</strong> — Some formats break formatting or fail ATS compatibility.</li><li><strong>Not updating contact information</strong> — Employers can’t reach you if details are outdated.</li></ul><h3>Final Resume Checklist</h3><p>Before sending a resume, ask:</p><ul><li>Is it easy to scan quickly?</li><li>Are accomplishments measurable?</li><li>Does it show ownership?</li><li>Does it show growth?</li><li>Is formatting clean and consistent?</li><li>Is it tailored to the role?</li><li>Is grammar polished?</li><li>Is it within ideal page limit?</li><li>Does it contain strong leadership/business signals (if senior)?</li></ul><h3>Conclusion</h3><p>A strong software engineering resume should communicate:</p><blockquote>“This engineer solves meaningful problems and delivers measurable impact.”</blockquote><p>Not:</p><blockquote>“This engineer knows many technologies.”</blockquote><p>The strongest resumes balance:</p><ul><li>technical depth,</li><li>business impact,</li><li>communication,</li><li>ownership,</li><li>leadership,</li><li>engineering maturity.</li></ul><p>As engineers grow from fresher → senior → lead, the focus should gradually shift:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*fWcriBn6-b5YtQ8NIGHrRg.png" /><figcaption>Experience Vs. Focus</figcaption></figure><h4>Further Readings</h4><ul><li><strong>Book</strong>: How to Write a Good Resume by Gergely Orosz (ByteByteGo)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96722d673078" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Object Oriented Design (OOD) Interview Preparation]]></title>
            <link>https://medium.com/@saiful-islam-rasel/object-oriented-design-ood-interview-preparation-ad945482ab37?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/ad945482ab37</guid>
            <category><![CDATA[ood-interview]]></category>
            <category><![CDATA[object-oriented-design]]></category>
            <category><![CDATA[ood-interview-tips]]></category>
            <category><![CDATA[ood]]></category>
            <category><![CDATA[interview]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 15:35:14 GMT</pubDate>
            <atom:updated>2026-04-15T15:35:14.647Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/152-ood-interview-preparation/"><em>blog</em></a><em> on April 15, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GppEyCRz13zH98zG.png" /><figcaption>Object Oriented Design (Photo Credit: PrepBytes)</figcaption></figure><h3>What is OOD (Object-Oriented Design)?</h3><p><strong>Object-Oriented Design (OOD)</strong> is the process of designing a system by breaking it down into <strong>objects (classes)</strong> that interact with each other to solve a problem.</p><p>In Simple Terms, OOD is the modeling of real-world problems using <strong>objects</strong>, <strong>behaviors</strong>, and <strong>relationships</strong>.</p><h4>Key Components of OOD</h4><ol><li><strong>Objects</strong>: Represent real-world entities like: User, Car, Order</li><li><strong>Classes</strong>: Blueprint of objects</li><li><strong>Encapsulation</strong>: Hide internal data, expose behavior</li><li><strong>Relationships</strong>: How objects interact? Means is it “has-a” (composition) or “is-a” (inheritance)</li></ol><h4>Goal of OOD</h4><ul><li>Manage complexity</li><li>Improve maintainability</li><li>Make system extensible</li></ul><h3>How Are OOD Interviews Different From Other Interviews?</h3><h4>Difference Between OOD and Coding Interview</h4><p><strong>1. Coding Interview</strong></p><ul><li>Goal: Solving Problem</li><li>Focus: On Logic</li><li>Output: Code</li><li>Evaluation: Correctness</li><li>Time: Fast Solution</li></ul><p><strong>2. OOD Interview</strong></p><ul><li>Goal: Design System Objects</li><li>Focus: Structure</li><li>Output: Class + relationships</li><li>Evaluation: Design Quality</li><li>Time: Thoughtful Design</li></ul><h4>What Interviewers Look For in OOD?</h4><ul><li>Clear thinking</li><li>Proper abstraction</li><li>Clean class design</li><li>Use of principles (Like: SOLID)</li><li>Communication</li><li>Extensibility</li><li>Balance of Cohesion &amp; Coupling</li></ul><h4>Difference Between OOD and System Design</h4><p><strong>1. System Design</strong></p><ul><li>Level: High-level</li><li>Focus: Services</li><li>Scale: Distributed</li><li>Concern: Scalability and reliability</li></ul><p><strong>2. OOD</strong></p><ul><li>Level: Low-level</li><li>Focus: Classes</li><li>Scale: Single System</li><li>Concern: Code structure</li></ul><h3>How To Prepare For An OOD Interview?</h3><ul><li>Step 1: Master OOP Fundamentals</li><li>Step 2: Learn OOP Principles</li><li>Step 3: Learn Key Design Patterns</li><li>Step 4: Practice Core OOD Problems</li><li>Step 5: Add Advanced Thinking</li><li>Step 6: Practice Communication</li><li>Step 7: Do Mock Interviews</li><li>Step 8: Build Real Projects (Best ROI)</li></ul><p>Let’s discuss each step in brief.</p><h4>Step 1: Master OOP Fundamentals</h4><p>You must be very comfortable with:</p><ul><li><strong>Encapsulation</strong>: Hide internal state and expose only necessary behavior</li><li><strong>Abstraction</strong>: Focus on what, not how</li><li><strong>Inheritance</strong>: “is-a” relationship</li><li><strong>Polymorphism</strong>: Same interface, different behavior</li></ul><p>I had some detailed articles on OOP fundamentals. Please read if you are really interested.</p><ul><li><a href="https://sir-rasel.github.io/blogs/5-lets-feel-programming-part-5-programming-style/">Common Programming Style</a></li><li><a href="https://sir-rasel.github.io/blogs/32-java-part-3-oop/">Java Crash Course — Part 3 (Object Oriented Programming)</a></li></ul><h4>Step 2: Learn OOP Principles</h4><p>Design principles provide high-level guidelines to design better software applications. They do not provide implementation guidelines and are not bound to any programming language. SOLID is a well known design principle term.</p><p>I had a detailed article on OOP design principles. Please read if you are really interested.</p><ul><li><a href="https://sir-rasel.github.io/blogs/44-design-pattern-principle-intro/">Software Design Patterns and Principles — Part 1 (Introduction)</a></li></ul><h4>Step 3: Learn Key Design Patterns</h4><p>Design patterns provide low-level solutions related to the implementation of commonly occurring object-oriented problems.</p><p>I had a detailed article series on OOP design patterns. Please read if you are really interested.</p><ul><li><a href="https://sir-rasel.github.io/blogs/45-design-pattern-principle-classification/">Software Design Patterns and Principles — Part 2 (Classification and Most Used Design Patterns)</a></li></ul><h4>Step 4: Practice Core OOD Problems</h4><p>Start with:</p><ul><li>Parking Lot</li><li>Elevator System</li><li>Library Management</li><li>Ride Sharing (Uber)</li><li>ATM System</li><li>Notification System</li><li>Movie System</li><li>Vending Machine</li><li>Restaurant Management System</li></ul><h4>Step 5: Add Advanced Thinking</h4><p>Once basic design is clear:</p><ul><li>Concurrency</li><li>Scalability</li><li>Fault Tolerance &amp; Recovery</li><li>Persistence</li></ul><h4>Step 6: Practice Communication</h4><p>This is critical. Always structure your answer:</p><ul><li>Clarify requirements</li><li>Define use cases</li><li>Identify classes</li><li>Add relationships</li><li>Apply patterns</li><li>Discuss edge cases</li></ul><p>I had some detailed articles on presenting and soft skills. Please read if you are really interested.</p><ul><li><a href="https://sir-rasel.github.io/blogs/76-soft-skills-book-review/">Soft Skills</a></li><li><a href="https://sir-rasel.github.io/blogs/27-present-like-pro/">Present Like a Pro</a></li></ul><h4>Step 7: Do Mock Interviews</h4><ul><li>Speak out loud</li><li>Time yourself (30–45 mins)</li><li>Explain decisions</li></ul><h4>Step 8: Build Real Projects (Best ROI)</h4><p>Learn by doing is the best learning approach. So, practice by build real-world project.</p><h3>Common Mistakes to Avoid</h3><ul><li>Assuming requirements &amp; not asking clarification questions</li><li>Jumping into coding too early</li><li>Overengineering</li><li>Ignoring edge cases</li><li>Not explaining decisions</li><li>Using patterns blindly</li><li>Ignoring advance cases like: concurrency, scalability</li><li>Not discussing future improvement scopes of the solution</li></ul><h3>OOD Interview Framework</h3><p>Having a clear framework for the OOD interview is more important than many realize. Without structure, the interview can feel disorganized and difficult for you and the interviewer to follow.</p><h4>1. Understand &amp; Clarify the Problem (Very First Step)</h4><p><strong>Goal</strong>: Avoid wrong assumptions.</p><p><strong>Ask questions like</strong>:</p><ul><li>What are the core features?</li><li>Who are the users/actors?</li><li>What are the inputs/outputs?</li><li>Any constraints</li></ul><p><strong>Example</strong>:</p><blockquote><em>“Are we designing a parking lot for a single building or multiple locations?”</em></blockquote><p>✅ <strong>Tips</strong>:</p><ul><li>Never jump into coding/design immediately.</li><li>Repeat the problem in your own words.</li><li>Identify functional vs non-functional requirements.</li></ul><h4>2. Identify Use Cases (Behavior First)</h4><p>Think in terms of what the system does (verb), not classes (noun) yet.</p><p><strong>Example</strong> (Parking Lot):</p><ul><li>Vehicle enters</li><li>Vehicle exits</li><li>Assign parking spot</li><li>Calculate fee</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Start with happy path, then edge cases.</li><li>Mention at least 1–2 edge cases:</li><li>Full parking</li><li>Invalid ticket</li></ul><h4>3. Identify Core Entities/Objects (Nouns → Classes)</h4><p>Extract nouns from the problem.</p><p><strong>Example</strong>:</p><ul><li>ParkingLot</li><li>Vehicle</li><li>ParkingSpot</li><li>Ticket</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Don’t over-design early.</li><li>Keep it minimal and extendable.</li></ul><h4>4. Define Relationships (Linking)</h4><p>Think in terms of:</p><ul><li>Association</li><li>Composition</li><li>Inheritance</li></ul><p><strong>Example</strong>:</p><ul><li>ParkingLot has many ParkingSpots (Composition)</li><li>Vehicle → Car, Bike (Inheritance)</li></ul><p>✅ Tips:</p><ul><li>Prefer composition over inheritance unless there’s a strong “is-a” relationship.</li><li>Avoid deep inheritance chains.</li></ul><h4>5. Define Class Responsibilities (SRP)</h4><p>Each class should have one clear responsibility.</p><p><strong>Example</strong>:</p><ul><li>ParkingLot → manages spots</li><li>Ticket → stores entry/exit info</li><li>FeeCalculator → calculates cost</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Follow Single Responsibility Principle (SRP).</li><li>If a class is doing too much → split it.</li></ul><h4>6. Define Key Methods &amp; Interfaces</h4><p>Now define behavior.</p><p><strong><em>Example</em></strong>:</p><pre>class ParkingLot {<br>    ParkingSpot assignSpot(Vehicle v);<br>    void releaseSpot(Ticket t);<br>}</pre><p>✅ <strong>Tips</strong>:</p><ul><li>Keep methods high-level first, refine later.</li><li>Use interfaces for flexibility.</li></ul><h4>7. Apply Design Patterns (Only When Needed)</h4><p>Use patterns only when justified.</p><p><strong>Common OOD Patterns</strong>:</p><ul><li>Factory Pattern → Object creation</li><li>Strategy Pattern → Replace conditional logic</li><li>Singleton → Shared resource (e.g., ParkingLot instance)</li><li>Observer → Event-driven systems</li></ul><p><strong>Example</strong>:</p><ul><li>Fee calculation → Strategy Pattern</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Don’t force patterns.</li></ul><p><strong>Say</strong>:</p><blockquote><em>“We can use Strategy Pattern here to make fee calculation extensible.”</em></blockquote><h4>8. Handle Edge Cases &amp; Constraints (Deep-dive)</h4><p><strong>Think deeper</strong>:</p><ul><li>What if system scales?</li><li>What if concurrency happens?</li></ul><p><strong>Example</strong>:</p><ul><li>Two cars trying to take the same spot → need locking</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Mention thread safety</li><li>Mention data consistency</li><li>Mention failures</li></ul><h4>9. Persistence (Optional but Strong Signal)</h4><p><strong>Mention how data is stored</strong>:</p><ul><li>In-memory vs DB</li><li>Caching</li></ul><p><strong>Example</strong>:</p><ul><li>Store tickets in DB</li><li>Cache available spots</li></ul><p>✅ <strong>Tips</strong>:</p><ul><li>Keep it simple (simple language data type like map) unless interviewer pushes deeper.</li></ul><h4>10. Write Clean Code (If Asked)</h4><p><strong>Focus on</strong>:</p><ul><li>Readability</li><li>Modularity</li></ul><p><strong><em>Example</em></strong>:</p><pre>interface FeeStrategy {<br>    double calculateFee(Ticket t);<br>}</pre><h4>11. Walk Through Example</h4><p><strong>Simulate</strong>:</p><blockquote><em>“Car enters → spot assigned → ticket created → exit → fee calculated”</em></blockquote><p>✅ <strong>Tips</strong>:</p><ul><li>This shows practical correctness.</li></ul><h4>12. Discuss Trade-offs</h4><p>This is what senior engineers do.</p><p><strong>Example</strong>:</p><ul><li>Why composition over inheritance?</li><li>Why Strategy pattern?</li></ul><h4>Conclusion</h4><p>OOD interviews are not about perfection, they are about how you think, structure, and evolve a design.</p><p>So follow the 4 step rules: Learn → Practice → Explain → Improve.</p><h4>Further Readings</h4><ul><li><strong>Book</strong>: Object-Oriented Design Interview by Alex Xu (ByteByteGo)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ad945482ab37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leadership Development: S.T.E.E.R. To The Future]]></title>
            <link>https://medium.com/@saiful-islam-rasel/leadership-development-s-t-e-e-r-to-the-future-bf074953a8f6?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf074953a8f6</guid>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[leadership-development]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[leadership-coaching]]></category>
            <category><![CDATA[steer]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Tue, 14 Apr 2026 00:00:53 GMT</pubDate>
            <atom:updated>2026-04-15T13:20:28.811Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/151-leadership-steer/"><em>blog</em></a><em> on April 14, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/0*vHwnArOxqkBxQ-cr" /><figcaption>STEER Leadership Model (Photo Credit: Dallas Innovates)</figcaption></figure><p>On September 14–15, 2025, I participated in a 2-day-long workshop titled “<strong><em>bKash Leadership Excellence Program: S.T.E.E.R. to the Future</em></strong>” with Quazi M. Ahmed, organized by b-academy, and the learning partner was Quazi Consultants. I would love to share my learning and takeaways from this workshop.</p><p><strong>Please note</strong>: not all the following things were discussed in the workshop as it was presented. I am trying to present based on my own learnings and understanding. So let’s start…</p><h4>About b-academy:</h4><p><strong>b-academy</strong> is a program run by the HR department of bKash Ltd. for its full-time employees only. It offers several technical, non-technical, hard skill, and soft skill learning workshops for bKash employees.</p><h4>About Instructor:</h4><p><strong>Quazi M. Ahmed</strong> is a highly experienced and internationally recognized professional in the field of leadership development, coaching, and training. His diverse educational and training background, spanning the United States, Japan, Norway, and Bangladesh, reflects a global perspective in his approach to leadership and organizational development.</p><h3>Leadership</h3><p><strong>Leadership</strong> is the ability to influence, motivate, and enable others to contribute toward success and sustain results. Effective leaders set direction, foster a positive culture, and build trust, combining strategic thinking with empathy to guide teams.</p><h4>Core Components of Leadership</h4><ul><li><strong>Vision and Strategy</strong>: Defining a clear, inspiring direction for the future and communicating it to the team.</li><li><strong>Integrity and Ethics</strong>: Acting with honesty, authenticity, transparancy, and high moral standards to build trust.</li><li><strong>Communication Skills</strong>: Clearly conveying ideas, listening effectively, and fostering open dialogue.</li><li><strong>Emotional Intelligence (EQ)</strong>: Possessing self-awareness to manage one’s own emotions and empathy to understand others’.</li><li><strong>Influence and Motivation</strong>: Persuading and inspiring team members to take action and achieve goals.</li><li><strong>Decisiveness and Courage</strong>: Making difficult decisions and acting with conviction, even under pressure.</li><li><strong>Team Building and Empowerment</strong>: Fostering collaboration, nurturing a supportive culture, and empowering others.</li><li><strong>Learning Agility and Resilience</strong>: Adapting to change, learning from mistakes, and persisting through challenges.</li></ul><h4>Essential Leadership Qualities</h4><ul><li><strong>Self-Awareness</strong>: Understanding personal strengths and weaknesses.</li><li><strong>Passion and Grit</strong>: Displaying enthusiasm and perseverance (sometimes called “grit”) in achieving goals.</li><li><strong>Respect and Compassion</strong>: Valuing team members and acting with empathy.</li><li><strong>Adaptability</strong>: Adjusting leadership styles to fit different situations (e.g., democratic vs. situational).</li><li><strong>Trust Worthy and Honesty</strong>: Showing honesty every time. Earns respect and trust of others.</li></ul><h3>The S.T.E.E.R. Leadership Code</h3><p><strong>S.T.E.E.R.</strong> is the DNA of leadership at bKash.</p><ul><li>Strategist</li><li>Talent Developer</li><li>Enabler</li><li>Executor</li><li>Resilient</li></ul><p>These are the five dimensions of bKash leadership.</p><h4>Strategist</h4><p><strong>Definition</strong>: Sets direction and makes future-oriented decisions (with actions).</p><p><strong>Goal</strong>: Shape the future.</p><p><strong>What it means</strong>:</p><ul><li>Setting long-term vision and direction</li><li>Aligning team goals with business objectives</li><li>Making smart trade-offs (speed vs quality, cost vs reliability)</li></ul><p><strong>The Six Behaviors of a Strategist</strong>:</p><ul><li>Craft &amp; communicate vision — paint a clear future picture</li><li>Translate vision into action — break strategy into achievable steps</li><li>Inspire ownership — motivate the team to take responsibility</li><li>Listen for diverse perspectives — gather and value different viewpoints</li><li>Align team with strategy — connect daily work to organizations mission</li><li>Challenge the status quo — ask, “how can we do better?”</li></ul><p><strong>Key mindset</strong>:</p><blockquote><em>“Am I solving the right problem, not just solving it right?”</em></blockquote><h4>Talent Developer</h4><p><strong>Definition</strong>: Nurtures and empowers team members.</p><p><strong>Goal</strong>: Build talents or leader for the future.</p><p><strong>What it means</strong>:</p><ul><li>Mentoring and coaching team members</li><li>Identifying strengths and improving weaknesses</li><li>Creating future leaders</li></ul><p><strong>The Six Behaviors of a Talent Developer</strong>:</p><ul><li>Build bench/pipeline strong — prepare successors for key roles</li><li>Align growth with needs — connect personal aspirations to organizational priorities</li><li>Foster continuous learning — encourage ongoing skill-building and curiosity</li><li>Develop strategic &amp; collaborative skills — equip team members for higher-level impact</li><li>Broaden capability via challenges — stretch people with meaningful new responsibilities</li><li>Improve with feedback — coach consistently for growth and performance</li></ul><p><strong>Key mindset</strong>:</p><blockquote><em>“If my team grows, everything else grows.”</em></blockquote><h4>Enabler</h4><p><strong>Definition</strong>: Removes barriers, provides resources, and supports collaboration.</p><p><strong>Goal</strong>: Engage for impact.</p><p><strong>What it means</strong>:</p><ul><li>Providing tools, processes, and clarity</li><li>Eliminating blockers (technical, organizational, communication)</li><li>Creating a safe and productive environment</li></ul><p><strong>The Six Behaviors of a Enabler Leader</strong>:</p><ul><li>Engage &amp; energize people — motivate with enthusiasm and purpose</li><li>Foster transparency &amp; inclusivity — build trust through open communication</li><li>Enable peak performance — provide tools, resources, and clarity for success</li><li>Remove roadblocks — anticipate and eliminate obstacles</li><li>Encourage innovation &amp; adaptability — create space for new ideas</li><li>Build authentic relationships — show care, consistency, and integrity</li></ul><p><strong>Key mindset</strong>:</p><blockquote><em>“How can I make it easier for my team to succeed?”</em></blockquote><h4>Executor</h4><p><strong>Definition</strong>: Delivers on promises with discipline and speed.</p><p><strong>Goal</strong>: Ensure results.</p><p><strong>What it means</strong>:</p><ul><li>Driving delivery and accountability</li><li>Prioritizing effectively</li><li>Ensuring consistent progress</li></ul><p><strong>The Six Behaviors of a Executor Leader</strong>:</p><ul><li>Plan &amp; manage work effectively — set clear goals, timelines, and priorities</li><li>Ensure accountability — track commitments and follow through</li><li>Execute with speed — deliver results without compromising quality</li><li>Leverage team strengths — use diverse skills for stronger outcomes</li><li>Make smart trade-offs — balance risk, cost, and speed to optimize outcomes</li><li>Deliver results consistently — build trust by achieving what was promised</li></ul><p><strong>Key mindset</strong>:</p><blockquote><em>“Execution beats intention.”</em></blockquote><h4>Resilient</h4><p><strong>Definition</strong>: Stays strong in adversity, adapts quickly.</p><p><strong>Goal</strong>: Conquer challenges.</p><p><strong>What it means</strong>:</p><ul><li>Staying calm during crises</li><li>Adapting to change quickly</li><li>Learning from failures instead of blaming</li></ul><p><strong>The Six Behaviors of a Resilient Leader</strong>:</p><ul><li>Navigate change &amp; uncertainty — stay steady and guide others through transitions</li><li>Bounce back from setbacks — learn and recover quickly from difficulties</li><li>Demonstrate learning agility — adapt, experiment, and grow from experiences</li><li>Manage emotions — stay composed, model calm, and support others’ emotions</li><li>Maintain positivity — encourage optimism and focus on solutions</li><li>Stay aligned with values — keep decisions grounded in organization’s mission and principles</li></ul><p><strong>Key mindset</strong>:</p><blockquote><em>“Setbacks are part of the process — not the end of it.”</em></blockquote><h4>Key Aspects of Steering Leadership:</h4><ul><li><strong>Balancing Authority &amp; Inspiration</strong>: Effective leaders blend the structural force of authority (control) with leadership (vision and inspiration) to avoid losing direction or engagement.</li><li><strong>Adaptability</strong>: Steering leadership requires adapting to high-pressure situations by taking control when necessary.</li><li><strong>Mentorship</strong>: It focuses on growing people through active coaching and continuous development.</li><li><strong>Values-Driven</strong>: It emphasizes understanding personal and organizational values to maintain the right course.</li></ul><h4>Conclusion:</h4><p>Successful leaders need to follow all of these 5 dimensions. Without any one of these can fall behind. Because all five dimensions are interdependent:</p><ul><li>Strategy aligns with talent</li><li>Enabling empowers execution</li><li>Resilience sustains all others</li></ul><p>S.T.E.E.R. is not about being perfect in all five areas — it’s about <strong>balancing them consciously</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf074953a8f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Book Review and Takeaways: (How to Win Friends and Influence People)]]></title>
            <link>https://medium.com/@saiful-islam-rasel/book-review-and-takeaways-how-to-win-friends-and-influence-people-1780b71f807e?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/1780b71f807e</guid>
            <category><![CDATA[how-to]]></category>
            <category><![CDATA[book-review]]></category>
            <category><![CDATA[influence]]></category>
            <category><![CDATA[winfriends]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Sat, 11 Apr 2026 00:00:48 GMT</pubDate>
            <atom:updated>2026-04-12T16:32:10.893Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/150-how-to-win-friends-book-review/"><em>blog</em></a><em> on April 11, 2026. Feel free to check it out for more!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/0*uNNo5_irA8ajUqbk" /><figcaption>How to Win Friends and Influence People Book (Photo Credit: uniathena)</figcaption></figure><h4>Book Introduction</h4><p>“<strong><em>How to Win Friends and Influence People</em></strong>” by Dale Carnegie is a timeless self-help classic that teaches practical techniques for improving communication, building relationships, and influencing others positively — both in personal and professional life. Instead of theory, it focuses on human psychology and real-life social behavior.</p><h4>About Author(s)</h4><p><strong>Dale Carnegie</strong> (1888–1955) was an American writer, lecturer, and developer of self-improvement courses. He was a pioneer in personal development &amp; communication skills and was focused on public speaking, salesmanship, and interpersonal skills. He founded Dale Carnegie Training, still active globally. His teachings are based on practical observation of human behavior, not only academic theory. He also wrote <strong>How to Stop Worrying and Start Living</strong> (1948).</p><h4>High Level Overview</h4><p>The book is divided into core principles grouped into sections, each targeting a specific social skill:</p><p><strong><em>Part 1: Fundamental Techniques in Handling People</em></strong></p><ul><li>Don’t criticize, condemn, or complain</li><li>Give honest and sincere appreciation</li><li>Arouse in others an eager want</li></ul><p><strong><em>Part 2: Six Ways to Make People Like You</em></strong></p><ul><li>Become genuinely interested in others</li><li>Smile</li><li>Remember names</li><li>Be a good listener</li><li>Talk in terms of others’ interests</li><li>Make others feel important</li></ul><p><strong><em>Part 3: How to Win People to Your Way of Thinking</em></strong></p><ul><li>Avoid arguments</li><li>Show respect for others’ opinions</li><li>Admit when you’re wrong</li><li>Begin in a friendly way</li><li>Let others feel the idea is theirs</li><li>Try honestly to see things from the other person’s point of view</li><li>Be sympathetic with the other person’s ideas and desires</li><li>Appeal to the nobler motives and dramatize your ideas</li></ul><p><strong><em>Part 4: Be a Leader (Influence Without Offending)</em></strong></p><ul><li>Praise improvements and give honest appreciation</li><li>Give indirect criticism</li><li>Ask questions instead of giving orders</li><li>Let others save face</li><li>Inspire enthusiasm</li><li>Let other learn from the mistakes</li><li>Make others happy to do something you have asked of them</li></ul><h4>Key Takeaways</h4><blockquote><strong><em>1. Never Criticize, Condemn or Complain — Understand Instead</em></strong></blockquote><p>Criticism triggers defensiveness. People justify their behavior instead of improving.</p><p><strong>Replace criticism with</strong>:</p><ul><li>Curiosity</li><li>Empathy</li><li>Constructive feedback</li></ul><blockquote><strong>2. Appreciation Is a Powerful Motivator</strong></blockquote><p>People crave recognition. Honest appreciation builds trust and loyalty.</p><p><strong>Important</strong>:</p><ul><li>Must be genuine, not flattery</li><li>Focus on specific actions, not vague praise</li></ul><blockquote><strong>3. Influence = Aligning with Others’ Interests</strong></blockquote><p>You can’t force people — you must make them want to do something.</p><p><strong>Ask</strong>:</p><ul><li>“What does this person want?”</li><li>“How can I connect my goal to their desire?”</li><li>“How can I arouse in the other person an eager want?”</li></ul><blockquote><strong>4. People Love Talking About Themselves</strong></blockquote><p>Listening is more powerful than speaking.</p><p><strong>Practice</strong>:</p><ul><li>Active listening</li><li>Ask open-ended questions</li><li>Let others feel heard</li><li>Show genuine intertest in other people</li><li>Smile</li></ul><blockquote><strong>5. Names Matter More Than You Think</strong></blockquote><p>A person’s name is emotionally significant.</p><p><strong>Remembering and using names</strong>:</p><ul><li>Builds instant rapport</li><li>Shows respect and attention</li></ul><blockquote><strong>6. Avoid Arguments — They Always Backfire</strong></blockquote><p>Winning an argument often means losing a relationship.</p><p><strong>Better approach</strong>:</p><ul><li>Respect differences</li><li>Seek understanding, not victory</li></ul><blockquote><strong>7. Admit Mistakes Quickly</strong></blockquote><p>Owning mistakes builds credibility and disarms criticism.</p><p><strong>Counterintuitive truth</strong>:</p><ul><li>Admitting faults increases respect</li></ul><blockquote><strong><em>8. Make Others Feel Important (Sincerely)</em></strong></blockquote><p>This is one of the core principles of human behavior.</p><p><strong>People respond positively when</strong>:</p><ul><li>Their value is recognized</li><li>Their ego is respected</li></ul><blockquote><strong>9. Lead Through Encouragement, Not Authority</strong></blockquote><p>People resist control but respond to encouragement.</p><p><strong>Effective leadership</strong>:</p><ul><li>Praise progress</li><li>Suggest instead of command</li><li>Build confidence</li></ul><blockquote><strong>10. Change Behavior Without Offending</strong></blockquote><p>Direct criticism damages relationships.</p><p><strong>Instead</strong>:</p><ul><li>Start with praise</li><li>Give feedback indirectly</li><li>Offer hope and encouragement</li></ul><h4>Conclusion</h4><p>“<strong>How to Win Friends and Influence People</strong>” is fundamentally about emotional intelligence and human-centered communication. Its principles are simple but powerful:</p><blockquote><em>Treat people with respect, understand their perspective, and make them feel valued.</em></blockquote><p>Mastering these ideas can significantly improve your:</p><ul><li>Leadership skills</li><li>Career growth</li><li>Personal relationships</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1780b71f807e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DevOps — Step By Step Learning : Part 4 (Basic Programming Using Golang)]]></title>
            <link>https://medium.com/@saiful-islam-rasel/devops-step-by-step-learning-part-4-basic-programming-using-golang-35eb7470e140?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/35eb7470e140</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[golang-programming]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[programming-basic]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 16:13:25 GMT</pubDate>
            <atom:updated>2026-03-17T06:55:11.224Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/127-devops-basic-golang/"><em>blog</em></a><em> on February 16, 2026. Feel free to check it out for more!</em></p><blockquote><strong><em>Other Parts of This Series:</em></strong></blockquote><blockquote><strong><em>Part 3: </em></strong><a href="https://medium.com/@saiful-islam-rasel/devops-step-by-step-learning-part-3-a-simplified-roadmap-to-start-2053952dcc43">DevOps — Step By Step Learning : Part 3 (A Simplified Roadmap to Start)</a></blockquote><blockquote><strong><em>Part 5: </em></strong><a href="https://medium.com/@saiful-islam-rasel/devops-step-by-step-learning-part-5-create-a-rest-api-server-using-golang-and-gin-090e5480b05d">DevOps — Step By Step Learning : Part 5 (Create a REST API Server Using Golang and Gin)</a></blockquote><figure><img alt="DevOps Basic Golang Programming (Photo Credit: Unsplash)" src="https://cdn-images-1.medium.com/max/1024/0*gbzGzxpOAdc9r1HG" /><figcaption>DevOps Basic Golang Programming (Photo Credit: Unsplash)</figcaption></figure><h3>Story:</h3><p>The roadmap defined was done, and it’s time to start learning accordingly. The first step was learning a programming language. Though Rasel was working on C# (.NET), he decided to learn a new lightweight and faster language and picked <strong>Golang</strong>. Because Golang is lightweight, faster, and cloud-native. Many DevOps tools, like Docker and Kubernetes, are built using Golang.</p><p>As Rasel knows the programming fundamentals, it was easy to cross-check and learn it in the earliest time.</p><h3>Programming Fundamentals:</h3><p>In every programming language, basically the following <strong>fundamental things</strong> are the backbone:</p><ul><li><strong>Part 1:</strong> <a href="https://sir-rasel.github.io/blogs/1-lets-feel-programming-part-1/">Let’s Feel Programming Fundamentals — Part 1</a></li><li><strong>Part 2:</strong> <a href="https://sir-rasel.github.io/blogs/2-lets-feel-programming-part-2-variable-operator/">Let’s Feel Programming Fundamentals — Part 2 (Variable, Operator)</a></li><li><strong>Part 3:</strong> <a href="https://sir-rasel.github.io/blogs/3-lets-feel-programming-part-3-condition-loop/">Let’s Feel Programming Fundamentals — Part 3 (Condition, Loop)</a></li><li><strong>Part 4:</strong> <a href="https://sir-rasel.github.io/blogs/4-lets-feel-programming-part-4-function-pointer/">Let’s Feel Programming Fundamentals — Part 4 (Function, Pointer, Scope)</a></li><li><strong>Part 5:</strong> <a href="https://sir-rasel.github.io/blogs/5-lets-feel-programming-part-5-programming-style/">Let’s Feel Programming Fundamentals — Part 5 (Procedural, Functional, OOP Style)</a></li><li><strong>Part 6:</strong> <a href="https://sir-rasel.github.io/blogs/6-lets-feel-programming-part-6-data-structure/">Let’s Feel Programming Fundamentals — Part 6 (Data Structure)</a></li><li><strong>Part 7:</strong> <a href="https://sir-rasel.github.io/blogs/7-lets-feel-programming-part-7-algorithm/">Let’s Feel Programming Fundamentals — Part 7 (Algorithm)</a></li><li><strong>Part 8:</strong> <a href="https://sir-rasel.github.io/blogs/8-lets-feel-programming-part-8-concurrency-parallel/">Let’s Feel Programming Fundamentals — Part 8 (Threads, Async-await, Concurrency, Parallel)</a></li></ul><h4>How to these Concepts Works in Golang:</h4><p><strong><em>1. Data Types, Variables, and Constants</em></strong></p><ul><li>Data Types: Go has basic types like int, string, bool, and float64.</li><li>Variables: Declared using var or := (short-hand declaration).</li><li>Constants: Declared using const, and their values cannot change.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    var age int = 25       // Integer variable<br>    name := &quot;John&quot;         // String variable (short-hand)<br>    const pi float64 = 3.14 // Constant value<br>    fmt.Println(&quot;Age:&quot;, age)<br>    fmt.Println(&quot;Name:&quot;, name)<br>    fmt.Println(&quot;Pi:&quot;, pi)<br>}</pre><p><strong><em>2. Operators</em></strong></p><ul><li>Arithmetic Operators: +, -, *, /, %</li><li>Relational Operators: ==, !=, &lt;, &gt;, &lt;=, &gt;=</li><li>Logical Operators: &amp;&amp;, ||, !</li><li>Assignment Operators: =, +=, -=, *=, /=</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    a, b := 10, 5<br>    fmt.Println(&quot;Addition:&quot;, a+b)  // Arithmetic<br>    fmt.Println(&quot;Greater than:&quot;, a &gt; b)  // Relational<br>    fmt.Println(&quot;Logical AND:&quot;, (a &gt; 5) &amp;&amp; (b &lt; 10))  // Logical<br>}</pre><p><strong><em>3. Condition (if-else &amp; switch)</em></strong></p><ul><li>Used for decision-making.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    num := 10<br>    if num &gt; 0 {<br>        fmt.Println(&quot;Positive number&quot;)<br>    } else if num &lt; 0 {<br>        fmt.Println(&quot;Negative number&quot;)<br>    } else {<br>        fmt.Println(&quot;Zero&quot;)<br>    }<br>    // Switch case<br>    day := 3<br>    switch day {<br>    case 1:<br>        fmt.Println(&quot;Monday&quot;)<br>    case 2:<br>        fmt.Println(&quot;Tuesday&quot;)<br>    default:<br>        fmt.Println(&quot;Other day&quot;)<br>    }<br>}</pre><p><strong><em>4. Loop (for loop)</em></strong></p><ul><li>Go only has for loops (it replaces while and do-while).</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    // Standard for loop<br>    for i := 1; i &lt;= 5; i++ {<br>        fmt.Println(&quot;Iteration:&quot;, i)<br>    }<br>    // Loop through an array<br>    numbers := []int{10, 20, 30}<br>    for index, value := range numbers {<br>        fmt.Println(&quot;Index:&quot;, index, &quot;Value:&quot;, value)<br>    }<br>}</pre><p><strong><em>5. Function</em></strong></p><ul><li>Functions help organize reusable code.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>// Function with parameters and return value<br>func add(a int, b int) int {<br>    return a + b<br>}<br>func main() {<br>    sum := add(10, 5)<br>    fmt.Println(&quot;Sum:&quot;, sum)<br>}</pre><p><strong><em>6. Memory Allocation and Pointers</em></strong></p><ul><li>Pointers store memory addresses.</li><li>new() allocates memory dynamically.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    x := 10<br>    p := &amp;x  // Pointer to x<br>    fmt.Println(&quot;Value of x:&quot;, x)<br>    fmt.Println(&quot;Memory address of x:&quot;, p)<br>    fmt.Println(&quot;Value via pointer:&quot;, *p)  // Dereferencing<br>}</pre><p><strong><em>7. Variable Lifetime and Scope</em></strong></p><ul><li>Global variables exist throughout the program.</li><li>Local variables exist only inside functions.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>// Global variable<br>var globalVar = &quot;I am global&quot;<br>func main() {<br>    localVar := &quot;I am local&quot; // Local variable<br>    fmt.Println(globalVar)<br>    fmt.Println(localVar)<br>}</pre><p><strong><em>8. Object-Oriented Concepts (Structs &amp; Methods)</em></strong></p><ul><li>Structs are like objects in Go.</li><li>interfaces are the declarations of function prototypes that can implemented.</li><li>Methods are functions attached to structs.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>// Struct definition<br>type Car struct {<br>    brand string<br>    year  int<br>}<br>// Interface definition<br>type Speaker interface {<br>  Speak() string<br>}<br>// Method associated with Car struct<br>func (c Car) display() {<br>    fmt.Println(&quot;Brand:&quot;, c.brand, &quot;Year:&quot;, c.year)<br>}<br>func main() {<br>    myCar := Car{&quot;Toyota&quot;, 2022}<br>    myCar.display()  // Calling method<br>}</pre><p><strong><em>9. Data Structures</em></strong></p><ul><li>Array: Fixed size</li><li>Slice: Dynamic array</li><li>Map: Key-value pairs</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func main() {<br>    // Array<br>    var arr = [3]int{1, 2, 3}<br>    fmt.Println(&quot;Array:&quot;, arr)<br>    // Slice<br>    slice := []int{10, 20, 30}<br>    slice = append(slice, 40)  // Append new element<br>    fmt.Println(&quot;Slice:&quot;, slice)<br>    // Map (key-value pairs)<br>    person := map[string]int{&quot;Alice&quot;: 25, &quot;Bob&quot;: 30}<br>    fmt.Println(&quot;Bob&#39;s age:&quot;, person[&quot;Bob&quot;])<br>}</pre><p><strong><em>10. Algorithm (Sorting Example)</em></strong></p><ul><li>Implementing Bubble Sort algorithm.</li></ul><pre>package main<br>import &quot;fmt&quot;<br><br>func bubbleSort(arr []int) {<br>    n := len(arr)<br>    for i := 0; i &lt; n-1; i++ {<br>        for j := 0; j &lt; n-i-1; j++ {<br>            if arr[j] &gt; arr[j+1] {<br>                arr[j], arr[j+1] = arr[j+1], arr[j]<br>            }<br>        }<br>    }<br>}<br>func main() {<br>    numbers := []int{64, 25, 12, 22, 11}<br>    bubbleSort(numbers)<br>    fmt.Println(&quot;Sorted array:&quot;, numbers)<br>}</pre><p><strong><em>11. Concurrency (Goroutines &amp; Channels)</em></strong></p><ul><li>Goroutines allow parallel execution.</li><li>Channels enable safe communication.</li></ul><pre>package main<br>import (<br>    &quot;fmt&quot;<br>    &quot;time&quot;<br>)<br><br>// Goroutine function<br>func sayHello() {<br>    time.Sleep(2 * time.Second)<br>    fmt.Println(&quot;Hello from Goroutine!&quot;)<br>}<br>func main() {<br>    go sayHello()  // Runs concurrently<br>    fmt.Println(&quot;Main function execution&quot;)<br>    time.Sleep(3 * time.Second) // Wait to see goroutine output<br>   ch := make(chan int) // channel<br>   go func() {<br>      ch &lt;- 42<br>   }()<br>   fmt.Println(&lt;-ch) // receive from channel<br>}</pre><p>Besides all of this, <em>error handling, testing, generics</em> are also advanced topics should be learned.</p><h4>Summary:</h4><p>Go (Golang) is a simple and efficient programming language with strong support for concurrency and performance. It has basic data types like int, string, bool, and float64, and allows you to store values in variables or constants (which don’t change). You can perform calculations and comparisons using operators such as +, -, ==, and &amp;&amp;. To make decisions, Go provides conditional statements like if, else, and switch, while repetitive tasks can be handled using loops, mainly the for loop.</p><p>Functions help break code into reusable blocks, and Go uses structs, methods and interfaces instead of traditional classes for object-oriented programming. Go also provides pointers to store memory addresses, and variables have lifetime and scope, meaning they exist for a certain time and in a certain part of the program. Data in Go can be organized using data structures like arrays, slices, maps, and structs, while algorithms define step-by-step solutions to problems.</p><p>A standout feature of Go is concurrency, allowing multiple tasks to run at the same time using goroutines and channels. This makes Go ideal for building fast, scalable applications. Overall, Go is designed to be simple, fast, and highly efficient, making it great for web development, cloud computing, and system programming.</p><h4>Further readings:</h4><ul><li><a href="https://go.dev/doc/">https://go.dev/doc/</a></li><li><a href="https://go.dev/doc/tutorial/getting-started">https://go.dev/doc/tutorial/getting-started</a></li><li><a href="https://gobyexample.com/">https://gobyexample.com</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35eb7470e140" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DevOps — Step By Step Learning : Part 26 (Build Tools and Its Necessity)]]></title>
            <link>https://medium.com/@saiful-islam-rasel/devops-step-by-step-learning-part-26-build-tools-and-its-necessity-e9e861e5e253?source=rss-ce0bec2f92a2------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9e861e5e253</guid>
            <category><![CDATA[build-tool]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Saiful Islam Rasel]]></dc:creator>
            <pubDate>Tue, 10 Mar 2026 00:00:12 GMT</pubDate>
            <atom:updated>2026-04-09T18:33:34.036Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post was originally shared on my personal </em><a href="https://sir-rasel.github.io/blogs/149-devops-build-tool/"><em>blog</em></a><em> on March 10, 2026. Feel free to check it out for more!</em></p><blockquote><strong><em>Other Parts of This Series:</em></strong></blockquote><blockquote><strong><em>Part 25: </em></strong><a href="https://medium.com/@saiful-islam-rasel/devops-step-by-step-learning-part-25-docker-networking-with-help-of-linux-namespace-2e05f222b21b">DevOps — Step By Step Learning : Part 25 (Docker Networking With Help Of Linux Namespace)</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DtwEN_INchSanCHx" /><figcaption>DevOps Build Tools (Photo Credit: Unsplash)</figcaption></figure><h4>Story:</h4><p>Rasel observed some of his junior software developer colleagues limited to an IDE. This means they were skilled at writing code and running it with a single click of the IDE’s run button. But they didn’t know how the code was built on the server side. They should know beyond the IDE, as the server has no IDE or run buttons at all. So Rasel decided to assist them in understanding the build tools, how they work, and their importance.</p><h4>What is a Build Process?</h4><p>A <strong>build process</strong> is the sequence of automated steps to transform source code into a final executable or deployable artifact.</p><h4>Common Build Steps:</h4><ul><li><strong>Clean</strong>: Remove old build artifacts (e.g., target/, bin/)</li><li><strong>Restore/Install</strong>: Download dependencies from package managers</li><li><strong>Compile</strong>: Convert source code into machine-readable format (bytecode, binary, etc.)</li><li><strong>Test</strong>: Run automated tests (unit, integration, etc.)</li><li><strong>Package</strong>: Bundle compiled code into deployable formats like .jar, .exe, .zip</li><li><strong>Publish</strong> (Optional): Deploy or export final package to a registry or environment</li></ul><h4>Problems Build Tools Solve:</h4><ul><li><strong>Manual repetition &amp; human error</strong>: Automate every build step</li><li><strong>Dependency management complexity</strong>: Automatically resolve and install packages</li><li><strong>Inconsistent builds across developers</strong>: Ensure same results through scripts/configs</li><li><strong>Tedious testing and packaging</strong>: Integrate tests and packaging in the build process</li><li><strong>CI/CD integration</strong>: Seamlessly connect to pipelines (GitHub Actions, etc.)</li></ul><h4>Popular Build Tools for Different Cases:</h4><ul><li><strong>Java</strong>: Maven, Gradle, Ant</li><li><strong>.NET (C#)</strong>: MSBuild, dotnet CLI</li><li><strong>JavaScript</strong>: Webpack, npm scripts, Gulp</li><li><strong>Go</strong>: go build, Make</li><li><strong>Python</strong>: Poetry, setuptools, pip</li><li><strong>C/C++</strong>: Make, CMake, Ninja</li><li><strong>Rust</strong>: Cargo</li><li><strong>Android</strong>: Gradle</li><li><strong>iOS/macOS</strong>: Xcode, Fastlane</li></ul><h3>Examples of Some Build Tools</h3><h4>Java with Maven</h4><p><strong>Structure</strong>:</p><pre>myapp/<br>├── pom.xml<br>└── src/main/java/com/example/App.java</pre><p><strong>pom.xml (example)</strong>:</p><pre>&lt;project&gt;<br>  &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;<br>  &lt;groupId&gt;com.example&lt;/groupId&gt;<br>  &lt;artifactId&gt;myapp&lt;/artifactId&gt;<br>  &lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;<br>  &lt;dependencies&gt;<br>    &lt;dependency&gt;<br>      &lt;groupId&gt;junit&lt;/groupId&gt;<br>      &lt;artifactId&gt;junit&lt;/artifactId&gt;<br>      &lt;version&gt;4.13.2&lt;/version&gt;<br>      &lt;scope&gt;test&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>  &lt;/dependencies&gt;<br>&lt;/project&gt;</pre><p><strong>Commands</strong>:</p><pre>cd myapp<br>mvn clean           # Step 1: Clean previous builds<br>mvn compile         # Step 2: Compile Java source<br>mvn test            # Step 3: Run tests<br>mvn package         # Step 4: Package as JAR<br>mvn install         # Step 5: Install to local Maven repo</pre><p><strong>Output</strong>: target/myapp-1.0-SNAPSHOT.jar</p><h4>.NET (C#) with dotnet CLI / MSBuild</h4><p><strong>Structure</strong>:</p><pre>myapp/<br>├── myapp.csproj<br>└── Program.cs</pre><p><strong>Using dotnet CLI</strong>:</p><pre>dotnet new console -n myapp     # Step 1: Create project<br>cd myapp<br>dotnet restore                  # Step 2: Restore dependencies<br>dotnet build                    # Step 3: Compile<br>dotnet test                     # Step 4: Run tests (if present)<br>dotnet publish -c Release       # Step 5: Create deployable</pre><p><strong>Using MSBuild</strong>:</p><pre>msbuild myapp.csproj /p:Configuration=Release</pre><p><strong>Output</strong>:</p><ul><li>bin/Debug/net8.0/myapp.dll</li><li>bin/Release/net8.0/publish/myapp.exe (for deployment)</li></ul><h4>JavaScript with Webpack</h4><p><strong>Structure</strong>:</p><pre>myapp/<br>├── package.json<br>├── webpack.config.js<br>└── src/index.js</pre><p><strong>webpack.config.js</strong>:</p><pre>module.exports = {<br>  entry: &#39;./src/index.js&#39;,<br>  output: {<br>    filename: &#39;bundle.js&#39;,<br>    path: __dirname + &#39;/dist&#39;,<br>  },<br>};</pre><p><strong>Commands</strong>:</p><pre>npm init -y                               # Step 1: Init package.json<br>npm install webpack webpack-cli --save-dev  # Step 2: Install Webpack<br>npx webpack                               # Step 3: Run the build</pre><p><strong>Output</strong>: dist/bundle.js</p><h4>Go with go build and Make</h4><p><strong>Structure</strong>:</p><pre>myapp/<br>├── main.go<br>└── Makefile</pre><p><strong>Makefile</strong>:</p><pre>build:<br>    go build -o myapp main.go<br><br>test:<br>    go test ./...</pre><p><strong>Commands</strong>:</p><pre>make build         # Step 1: Compile Go code<br>make test          # Step 2: Run tests</pre><p><strong>Output</strong>: Binary file myapp</p><h3>Python with Poetry</h3><p><strong>Structure</strong>:</p><pre>myapp/<br>├── pyproject.toml<br>└── myapp/__init__.py</pre><p><strong>Commands</strong>:</p><pre>pip install poetry                 # Step 1: Install Poetry<br>poetry init                       # Step 2: Create pyproject.toml<br>poetry add requests               # Step 3: Add dependencies<br>poetry install                    # Step 4: Install deps<br>poetry build                      # Step 5: Build sdist and wheel</pre><p><strong>Output</strong>: dist/myapp-0.1.0.tar.gz and .whl</p><h4>C/C++ with CMake</h4><p><strong>Structure</strong>:</p><pre>myapp/<br>├── CMakeLists.txt<br>├── main.cpp<br>└── build/</pre><p><strong>CMakeLists.txt</strong>:</p><pre>cmake_minimum_required(VERSION 3.10)<br>project(MyApp)<br>add_executable(myapp main.cpp)</pre><p><strong>Commands</strong>:</p><pre>mkdir build &amp;&amp; cd build<br>cmake ..              # Step 1: Generate build system<br>make                  # Step 2: Compile the project</pre><p><strong>Output</strong>: build/myapp</p><h4>Summary:</h4><ul><li>Build tools automate the complete lifecycle from source to deployable output.</li><li>They reduce errors, save time, and integrate well with pipelines.</li><li>Learning the steps for your language’s tool helps you build faster and more reliably.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9e861e5e253" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>