Author: Samay

  • The AI Workstation – Building a High-Performance Rig for AI & Machine Learning

    Since few months I was thinking of building a dedicated, no-compromise machine for Artificial Intelligence and Machine Learning. The goal was to build a workstation which can be used to have consistent throughput for hours-long training sessions, massive dataset processing, and future-proofing for the next generation of large language models (LLMs) keep a check on the budget. Every component choice was well thought through, prioritizing stability, thermal management, and raw compute power.

    With the budget constrains, I knew I had to use AMD Ryzen 9 9950X and NVIDIA GeForce RTX 5090 with the consideration to upgrade to RTX Pro 6000 in future

    Here is the component list:-

    ComponentSelection
    CPUAMD Ryzen 9 9950X 16 Cores / 32 Threads (Zen 5)
    CPU CoolerARCTIC Liquid Freezer III Pro 420
    Thermal CompoundThermal Grizzly Kryonaut Extreme
    MotherboardGigabyte X870E AORUS ELITE WIFI7
    MemoryCorsair Vengeance 96GB (2x48GB) DDR5-6000 CL30
    Storage1x4TB Samsung 9100 PRO
    Video CardZotac GAMING SOLID GeForce RTX 5090 32 GB
    CaseFractal Design Meshify 3 XL
    Power SupplyCorsair HX1500i 1500W, 80 PLUS Platinum, ATX 3.0
    Case FanARCTIC P14 PST 72.8 CFM 140 mm Fans 5-Pack

    And some benchmarks

  • Book Review: Crucial Conversations: Tools for Talking When Stakes are High

    In today’s fast-paced, high-stakes environments, technical expertise is not the only factor determining success. As a Software Engineering Leader, I’ve learned that mastering difficult conversations is equally important to achieving project goals. “Crucial Conversations: Tools for Talking When Stakes are High” by Kerry Patterson, Joseph Grenny, Ron McMillan, and Al Switzler offers practical guidance on navigating these tense moments, providing essential tools for leaders across all industries.

    The book defines crucial conversations as those instances where stakes are high, opinions differ, and emotions run strong. In our field, this could range from addressing performance issues to negotiating timelines or mediating team conflicts. The authors break down these interactions, offering a structured approach to ensure that difficult discussions lead to productive outcomes rather than frustration and division.

    Here are four key insights from the book that I found particularly valuable:

    1. Start with Heart: Before diving into a tough conversation, it’s important to reflect on your true motives. Are you entering the conversation to resolve the issue or to prove a point? In the context of managing engineering teams, this introspection helps leaders focus on the shared goal rather than personal wins. By clarifying your intent, you set the stage for a more constructive dialogue.
    2. Make it Safe: A concept that resonates deeply in software engineering is psychological safety—the idea that people should feel comfortable voicing their concerns without fear of backlash. The authors emphasize creating this safety, particularly in conversations where the stakes are high. In team settings, whether you’re discussing a missed deadline or a challenging code review, fostering an environment of mutual respect leads to more open and productive discussions.
    3. Master Your Stories: One of the most eye-opening lessons is the importance of separating facts from assumptions. As leaders, we often create narratives around why certain situations have unfolded. The book encourages us to challenge these assumptions and approach conversations by asking for the other person’s perspective. This practice is crucial in software engineering, where misunderstandings can quickly escalate and lead to poor outcomes if not addressed properly.
    4. Move to Action: A conversation without a clear resolution or action plan is often just a venting session. The authors offer concrete strategies for ensuring that discussions lead to decisive action. This is especially relevant in engineering leadership, where progress is measured not by what’s discussed but by what’s delivered. Turning difficult conversations into action-oriented plans ensures that you drive results, not just dialogue.

    Practical Application in Software Engineering Leadership:

    The lessons from Crucial Conversations are particularly relevant to the world of software engineering, where projects are often complex, deadlines are tight, and decisions carry significant financial and regulatory consequences. Whether negotiating with cross-functional teams, managing stakeholder expectations, or addressing performance issues, the tools outlined in the book provide a roadmap for navigating these difficult situations with confidence and clarity.

    Final Thoughts:

    Crucial Conversations is more than just a guide to effective communication; it’s a toolkit for leadership. The ability to lead with clarity, empathy, and purpose is essential in high-stakes environments like software engineering, where every decision can impact timelines, budgets, and outcomes. This book is a must-read for leaders looking to improve their communication skills and foster a culture of openness and collaboration.

    If you haven’t yet read this book, I highly recommend adding it to your leadership library. It provides not only the tools for improving difficult conversations but also the confidence to handle high-pressure situations with grace.

  • Book Review: “Never Split the Difference” by Chris Voss

    Just finished reading “Never Split the Difference” by Chris Voss, and I couldn’t wait to share my thoughts on this absolute gem of a book! 📖💎

    🔍 As professionals, negotiation is an integral part of our daily lives. Whether it’s closing deals, resolving conflicts, or even just navigating our career paths, mastering the art of negotiation is a must. And let me tell you, this book is a game-changer in that arena.

    🌐 Chris Voss, a former FBI hostage negotiator, takes us on a thrilling journey through his experiences, sharing valuable insights that seamlessly translate into the business world. The book is a treasure trove of strategies and techniques that go beyond the usual negotiation advice.

    🔑 One of the key takeaways is Voss’s emphasis on empathy and active listening. He introduces the concept of “tactical empathy,” which involves truly understanding your counterpart’s perspective and emotions. By putting ourselves in their shoes, we can build trust and establish rapport, leading to more successful outcomes.

    💡 “Never Split the Difference” also delves into the power of “mirroring” and “labeling.” These techniques, backed by psychological principles, help to disarm potential conflicts and create a cooperative atmosphere. Voss’s anecdotes and real-world examples illustrate how these tactics can be applied to scenarios we encounter in our professional lives.

    🚀 What truly stands out is Voss’s ability to fuse negotiation strategies with captivating storytelling. The book isn’t just a manual; it’s a riveting read that keeps you engaged from start to finish. His practical advice, combined with his engaging narrative style, makes the learning experience both enjoyable and impactful.

    📈 Whether you’re a seasoned negotiator or someone looking to enhance their communication skills, “Never Split the Difference” offers actionable insights that can be implemented immediately. The book’s relevance spans industries, roles, and even personal interactions.

    🌈 In a world where effective communication and negotiation are paramount, this book serves as a beacon of guidance. I highly recommend adding it to your reading list—it’s a resource you’ll keep coming back to.

    Have you read “Never Split the Difference”? What were your key takeaways? Let’s connect and discuss! 👇🤝

  • Setting up MacBook Pro M1 2021 – 14″ (macPro Monterey)

    After a long time I finally switched to a new MacBook Pro. Here is the list of things which I use as a developer:-

    The first thing to install on M1 Pro machine is rosetta

    softwareupdate --install-rosetta

    Install command line tools for Xcode

    xcode-select --install

    Next would be my favourite package manager Homebrew

    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

    I have been using iTerm since years and just cannot live without it.

     brew install --cask iterm2

    Install zsh and oh-my-zsh

    brew install zsh zsh-completions
    
    sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

    Install Node from nodejs.org

    Visual Studio Code

    Dot Files are available on my Github Repository

    https://github.com/samaybhavsar/dotfiles

    For those who work a lot on terminal can refer to Paul‘s repository. It is much more exhaustive.

    https://github.com/paulirish/dotfiles

    Install PHP 8

    brew install php@8.0
    brew link php

  • KISS, YAGNI & DRY

    KISS – Keep It Simple, Stupid

    The KISS principle states that most systems work best if they are kept simple rather than made complicated; therefore simplicity should be a key goal in design, and that unnecessary complexity should be avoided. Wherever possible, complexity should be avoided in a system—as simplicity guarantees the greatest levels of user acceptance and interaction. KISS is used in a variety of disciplines, such as interface design, product design, and software development.

    https://people.apache.org/~fhanik/kiss.html

    YAGNI – You aren’t gonna need it

    YAGNI is principle of extreme programming (XP). It states that a programmer should not implement functionality until deemed necessary. Ron Jeffries who is the founder of XP states that “Always implement things when you actually need them, never when you just foresee that you need them.”

    https://ronjeffries.com/xprog/articles/practices/pracnotneed/

    DRY – Don’t Repeat Yourself

    The DRY principle is principle of software development which aims to reduce repetition of code by abstraction. A simple example would to create a function for a piece of code which is repeated and replace it with the function calls.

    DRY has been formulated by Andy Hunt and Dave Thomas in their book The Pragmatic Programmer. It has been stated that “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system”.

    https://www.artima.com/intv/dry.html