Works on My Machine by Joe Karlsson

tl;dr in tech - Issue #106

Tue, 30 Jan 2024 00:00:00 GMT

Unicode Is Harder Than You Think

By: Marco Cilloni

tl;dr: “This article attempts to briefly summarize and clarify some of the most common misconceptions I’ve seen people struggle with, and some of the pitfalls that tend to recur in codebases that have to deal with non-ASCII text.”

Should I Change Job?

By: James Stanier

tl;dr: “At every job, you should either learn or earn. Either is fine. Both are best. But if it’s neither, quit.” The article elaborates on this idea, explaining the symbiotic relationship between learning and earning. Learning increases earning potential by opening doors to bigger roles and opportunities. Earning more money can enable one to take financial risks for further learning, such as accepting a pay cut for a more senior position at a start-up.

Attention Is All A Manager Needs

By: Phil Calçado

tl;dr: “All this talk about managing information at scale makes me think of challenges faced by engineering managers and directors as they have to deal with both information overload and scarcity simultaneously. This is a recurring major topic when coaching new managers or folks who made the transition to senior management. In this article, I am going to discuss the challenges and offer a few practical tools that have worked for me in my own journey.”

Square’s Updated Growth Framework For Engineers And Engineering Managers

By: [Author Unknown]

tl;dr: Square has updated its Growth Framework for Engineers and Engineering Managers, reflecting significant changes over the past four years. The revised levels guide hiring, promotion, and encode the company’s values, with a focus on clarity, consistency, and adaptability.

How We Built The Canva Apps SDK

By: Martin Cronjé

tl;dr: Martin’s article outlines the development of the Canva Apps SDK, transitioning from a plugin model to a more flexible app-building platform. The process involved building a secure sandboxed environment, creating a new build-and-deploy pipeline, and designing APIs with a focus on simplicity, safety, evolvability, and consistency. Iterative development, continuous feedback, and a balance between alignment and empowerment were key technical strategies in the SDK’s creation.

A Few Weird Ways Of Displaying Git Hashes

By: [Author Unknown]

tl;dr: The author explores alternative ways to represent Git hashes beyond the conventional hexadecimal format, experimenting with three unconventional methods: emoji, word and color representation of hashes. The author provides examples of these representations using recent commits from one of their repositories. The post emphasizes the experimental nature of these ideas.

Enabling Good Work Habits Through Reflective Goal-Setting

By: Abi Noda

tl;dr: Abi highlights a study on developers’ productivity, revealing that reflective goal-setting leads to improvements. 84% of participants identified concrete goals through reflection, 80% saw positive behavior change, and 92% planned to maintain new habits. The key takeaway is that reflective goal-setting not only enhances awareness and productivity but also encourages lasting behavioral changes, empowering developers to gain control over their work.

Bottleneck #04: Cost Efficiency

By: Stefania Stefansdottir, Sofia Tania

tl;dr: This post discusses cost optimization for scale-ups by emphasizing the importance of a cross-functional team to analyze and execute cost-saving measures. It outlines strategies like rightsizing resources, using ephemeral infrastructure, and consolidating tools. A key takeaway is the need for a detailed analysis of cost drivers, such as compute vs storage vs network, to identify specific levers for cost reduction, ensuring alignment with the company’s unique needs as it scales.

My Problem With The Four-Document Model

By: Hillel Wayne

tl;dr: Hillel critiques the 4doc model for user documentation, highlighting that it’s not universal or comprehensive. While effective for tools, it may not suit frameworks and languages. The key takeaway is that relying solely on the 4doc model can limit documentation effectiveness, and a more flexible approach that considers the specific subject being documented is encouraged.

Some Tactics For Writing In Public

By: Julia Evans

tl;dr: Julia discusses various strategies and tactics to engage with comments and feedback on her writing, especially in the context of technical blogging. Key points include: (1) Talking about facts leads to fact-based comments and discussions. (2) Sharing personal stories encourages good discussions and helps in understanding the context and different perspectives. (3) Asking technical questions or mentioning uncertainties invites answers and makes the comments section more valuable, among other strategies.

tl;dr in tech - Issue #105

Tue, 23 Jan 2024 00:00:00 GMT

A Few Words On Taking Notes

By: Werner Vogels

tl;dr: Werner, the CTO at Amazon, explores note-taking. He values the Cornell Method for its structure and analog approach: each notebook page has 4 sections: (1) Title. (2) Notes. (3) Keywords and questions. (4) Summary. Werner discusses potential AI enhancements and believes handwritten note-taking increases comprehension and retention.

Making Software With 4,999 Other People

By: Brandon Willett

tl;dr: Brandon shares what he learned from his time at Datadog, broken into 3 sections: software, projects and people. Takeaways include: (1) Keeping the development cycle near-instantaneous with features like microservices and feature flags is both productive and enjoyable. (2) Take advantage of recency bias to solve problems right after incidents. (3) Prefer projects with small organizational scopes to avoid communication breakdowns and motivate the team.

Is This An Emoji?

tl;dr: The author faced challenges with data validation while implementing emoji tags in their app. They needed to ensure that the tags entered by users were valid emojis and not just arbitrary text. They tried various approaches like regex and Unicode character ranges, but each had its limitations and drawbacks.

Manage Your Priorities And Energy

By: Will Larson

tl;dr: Will reflect on his shift from a ‘company, team, self’ framework to an eventual ‘quid pro quo’ approach during his management tenure at Uber. His ‘quid pro quo’ approach is: (1) Generally, prioritize company and team priorities over your own. (2) If you are getting de-energized, artificially prioritize some energizing work. Increase the quantity until equilibrium is restored. (3) If the long-term balance between energy and proper priorities can’t be balanced for more than a year, stop everything else and work on solving this issue e.g. change your role or quit. Will emphasizes the importance of remaining flexible and curious.

Throw Away Your First Draft Of Your Code

By: Nicole Tietz-Sokolskaya

tl;dr: Software teams should prototype or create a “first draft” of code for new features and then discard it. Prototyping allows teams to anticipate issues and understand the full complexity of a new feature. Despite seeming wasteful, this approach actually saves time by preventing unforeseen problems during the development process. However, it’s essential to discard the prototype code to keep the process efficient and the codebase clean.

Stopping At 90%

By: Austin Henley

tl;dr: It’s common to stop at 90% of a project’s completion since the project has concrete deliverables that can be measured. The remaining 10% is more difficult to track. Austin discusses common activities to get from 90% to 100%: (1) Present the work to other teams. (2) Broadcast an email with the takeaways so that the rest of your organization knows about it. (3) Put the code somewhere that your coworkers can make use of later. (4) Write a blog post about it. Post it on Twitter, HN, and Reddit. (5) Sketch out a next-steps document, even if you have no plans to continue, that explains what you would do next and why. (6) Look for adjacent projects that could benefit. (7) Find someone that can poke holes in your work, then go address them.

Building And Operating A Pretty Big Storage System Called S3

By: Werner Vogels

tl;dr: A repost of an article by Andy Warfield, VP of S3, reflects on the vast complexity and operational scale of Amazon’s storage software system. Andy discusses the significance of recognizing and mitigating organizational scaling issues, similar to optimizing systems. He also discusses management’s approach to foster team ownership for problem-solving instead of dispensing solutions has led to more engaged and successful engineering outcomes.

What Is A Senior Software Engineer At Wise And Amazon?

By: Gergely Orosz

tl;dr: Gergely delves into senior software engineer roles at Wise and Amazon. At Wise, senior engineers lead significant projects, contribute to feature planning, and require good communication and problem-solving skills. At Amazon, the equivalent role deals with ambiguity, leads projects, communicates technical ideas efficiently, and ensures that the team’s success doesn’t solely rely on them. While definitions of ‘senior’ vary across the two companies, clear expectations across companies include project leadership, problem-solving skills, and effective communication.

By: Max Levchin

tl;dr: “This is the story of a catastrophic software bug I briefly introduced into the PayPal codebase that almost cost us the company (or so it seemed, in the moment.) I’ve told this story a handful of times, always swearing the listeners to secrecy, and surprisingly it does not appear to have ever been written down before. 20+ years since the incident, it now appears instructive and a little funny, rather than merely extremely embarrassing.”

tl;dr in tech - Issue #104

Tue, 16 Jan 2024 00:00:00 GMT

Accidentally Load Bearing

By: Jeff Kaufman

tl;dr: Jeff uses the principle of Chesterton’s Fence to emphasize that understanding the original and current roles of a system component is crucial before making changes. The author illustrates this through their experiences in home renovation and complex computer systems.

Everything That Uses Configuration Files Should Report Where They’re Located

By: Chris Siebenmann

tl;dr: Chris regularly interacts with various programs, each of which has its configuration files in different locations, sometimes system-wide, other times user-specific. Given the variability and their infrequent interaction with some programs, they struggle to remember the configuration file locations, which can lead to time-consuming searches through manuals or documentation. Their proposed solution is for programs to offer an easy method, preferably via command line, to report the location of their configuration files.

Allergic To Waiting

By: Thorsten Ball

tl;dr: Thorsten believes programmers may be tolerating longer-than-necessary wait times due to a lack of understanding about what computers are capable of, what is a reasonable time for a given task, and how internet-based work might be skewing their perceptions of acceptable speeds. The author encourages developers to question and understand the cause of long wait times instead of passively accepting them, as many of these delays can be optimized or eliminated.

Why Even Let Users Set Their Own Passwords?

By: Hugo Landau

tl;dr: Hugo argues for a rethink of the way we handle passwords, pointing out the contradictions and shortcomings of current practices. They suggest that issuing high-entropy, randomly generated passwords to users, similar to API keys or TOTP, may be more secure than the current standard of user-created passwords.

Emotions: A Code Book

By: Kent Beck

tl;dr: Kent shares a personal journey of understanding emotions using an established framework. He views emotions as envelopes containing important messages, encouraging readers to decode these messages instead of suppressing emotions, giving a “cheat sheet” that defines what kind of message each emotion brings, e.g., Fear as a call to focus, Anger as a call to enforce boundaries, and Guilt as a call to change. This self-understanding helps navigate life’s challenges and fosters personal growth.

Frameworks

By: Mike Fisher

tl;dr: The user shared three frameworks to understand growth phases of companies: Kent Beck’s 3X (Explore, Expand, Extract), Wardley’s PST (Pioneer, Settler, Town Planner), and Thiel’s Zero to One. They found these useful for identifying their personal fit within a company’s growth journey, thriving best in the scaling phase. Understanding one’s optimal growth phase can guide career choices.

12 Debugging Tools I Wish I Knew Earlier

By: Jordan Cutler

tl;dr: The first 2 are: (1) Git bisect: Run you through a binary search process between the “good commit” and the “bad commit” until it finds the commit the bug started happening. (2) “Binary search commenting”: Commenting out sections of the code and replacing it with a hardcoded value to narrow in on where the problem is.

Consistency Patterns

By: [Author Unknown]

tl;dr: This article explores the role of consistency patterns such as strong, eventual, and weak consistency in maintaining reliability, system state, and user experience in distributed systems. It delves into the intricacies of these patterns, weighing their benefits and drawbacks, and discussing their real-world applications.

Before You Try To Do Something, Make Sure You Can Do Nothing

By: Raymond Chen

tl;dr: Raymond advises starting software projects with a ‘do-nothing’ component to establish a good foundation. The step-by-step approach lets developers debug and validate at each stage, making problem-solving easier. He encourages incremental complexity to keep projects manageable and on track.

tl;dr in tech - Issue #103

Tue, 09 Jan 2024 00:00:00 GMT

Fresh Work 80/15/5

By: Kent Beck

tl;dr: “How do you balance risk, novelty, production, growth, short-term certainty, and long-term viability? I learned a simple rule that has been useful to me and is often cited by my students as a key lesson from coaching: (1) 80% of your time goes to low-risk / reasonable-reward work, (2) 15% of your time goes to related high-risk / high-reward work and (3) 5% of your time goes to satisfying your own curiosity with no thought of reward.

Interesting Learnings From Outages

By: Gergely Orosz

tl;dr: The article discusses the importance of investigating and learning from outages in the industry. It explores the different types of postmortems, including internal, customer-only, and public postmortems. The article dives into 3 case studies: (1) Adevinta experienced a significant impact due to a DNS outage, (2) GitHub experienced an outage due to a network configuration issue at their secondary site, (3) Reddit experienced an issue with a Kubernetes cluster upgrade gone wrong.”

More Software Projects Need Defenses Of Design

By: Hillel Wayne

tl;dr: Hillel argues why a well-documented “Defense of Design” is an invaluable resource for understanding a project’s history, design decisions, and constraints that shaped it. It provides insights into the thought process of the creators, developers, and maintainers, thus fostering a greater level of understanding and appreciation for the software.

Developer Workflow Tips No One Tells You About

By: Justin Joyce

tl;dr: “These are the tools, tips and advice I wish I had internalized when I was just starting out. Many of the details below are specific to macOS, but similar tips and tricks apply on other systems. I’ve broken it down very roughly into the following categories: (1) Computer setup. (2) Command-line-related things. (3) Technical but non-CS advice. (4) Potpourri.

New Study Finds An Unstructured 5-Minute Break Can Help Restore Attention

By: Paul Ginns

tl;dr: “Researchers found a 5-minute break from thinking is all you need to get your concentration back. There is no need for a walk along a river, or a lengthy video of bamboo forests swaying in the wind. A five-minute total break will do the trick.”

What We Don’t Talk About When We Talk About Building AI Apps

By: Vicki Boykis

tl;dr: Vicki shares her experience and pain points when building AI applications, highlighting several aspects often not discussed in conversations: (1) Slow iteration times, (2) Build times, (3) Docker images, and more.

On Becoming A VP Of Engineering: Doing The Job

By: Emily Nakashima

tl;dr: “I said at the beginning of this post that the most important thing I deliver is alignment. It’s not the hardest thing I have to deliver though: that is focus.” Emily also discusses what a VP’s day to day looks like, unlearning, compensation, giving yourself more slack time, and more.

Briefly: The Value Of Meetings, And Some Alternatives

By: Kellan Elliott-McCrea

tl;dr: Shopify’s meeting cost calculator stirs debate; are meetings wasted time or vital? Alternatives emerge such as Dropbox’s “Core Collaboration Hours” and Frame.io’s “Huddle Days”, which foster spontaneous discussions, encouraging productive work and respecting individual work rhythms.

How Platform Teams Get Stuff Done

By: Pete Hodgson

tl;dr: “Platform teams have a unique reliance on other teams to ensure adoption of their platform - getting code changes into other teams’ codebase is critical to their success. There are a variety of patterns for that cross-team collaboration, and selecting the right ones depends on both the phase of platform adoption

tl;dr in tech - Issue #102

Tue, 02 Jan 2024 00:00:00 GMT

I hope you’re all enjoying a well-deserved break this holiday season! It’s always great to step away from the keyboard, recharge, and spend time with loved ones. But let’s be honest, how many of you tried to make it look like you were giving that last-minute push to wrap up Q4? 😉 No judgment here, we’ve all been there. Now, as we prepare to dive back in, I want to extend my best wishes to each of you for a restful and rejuvenating break.

Tech Landscape Predictions for 2024

As we look ahead to 2024, the tech landscape is poised for some exciting and, at times, challenging trends. Here’s what I foresee:

The Return of Hiring: Anticipating a strong comeback in tech hiring in Q1 of this year, signaling a vibrant start.
The Continued AI Hype Cycle: Much like the journey of IBM’s Watson, we’ll see the AI hype persist, than normalize. Expect a plethora of half-hearted, patchwork AI applications. But, as with all technology cycles, expect normalization as the year progresses.
Cost-Conscious Engineering: Software engineers, brace yourselves for a continued focus on cost-efficiency. Cloud costs, in particular, will remain a crucial concern.
The Rising Demand for Engineers: The fields of AI, big data, and real-time analytics are growing, significantly expanding the scope and demand for skilled engineers.
Pivot in Data Teams’ Focus: Data teams will likely shift from primarily setting up infrastructure and collecting data to analyzing and extracting actionable insights from the accumulated data.
The Role of Data Engineers: Despite the advancements in AI, data engineers will remain irreplaceable in 2024. Their role in managing and interpreting complex datasets is something AI isn’t poised to take over just yet.

As software engineers, staying ahead of these trends will be key. Let’s embrace the challenges and opportunities 2024 has in store for us!

Beautiful Branchless Binary Search

By: Malte Skarupke

tl;dr: Malte Skarupke stumbled upon Shar’s algorithm, a branchless binary search. This discovery led to an exploration of its mechanics, showcasing the efficiency and elegance of branchless algorithms. A fascinating read for software engineers interested in optimizing search algorithms.

Writing Javascript Without A Build System

By: Julia Evans

tl;dr: Julia Evans discusses the appeal and frustrations of build systems in JavaScript development. She shares her perspective on why some prefer not using build systems and the challenges posed by frontend libraries that require them. A relatable piece for those grappling with the complexities of modern JavaScript development.

The Future Of Programming: Research At CHI 2023

By: Austin Henley

tl;dr: Austin Henley dives into the CHI 2023 conference proceedings, focusing on papers related to programming and AI. This roundup provides software engineers a glimpse into the latest research and trends in programming, particularly the growing influence of AI.

Theory Of Mind

By: Andrew Bosworth

tl;dr: “Theory of mind is a concept I first learned in a class on psychology. It describes our capacity to understand the mental states of others.” Andrew explains why this concept is the reason why its so important for leaders to communicate the context around their decisions.

CLI Tricks Every Developer Should Know

By: Kedasha Kerr

Avoiding The Rewrite Trap

By: Camille Fournier

How eBay Modernized The Most Important Page On Our Platform

By: [eBay Tech Blog]

Database Fundamentals

By: Tony Solomonik

tl;dr: Tony Solomonik delves into the essentials of database engineering, inspired by key literature in the field. He reflects on the fundamental challenges and his journey in creating a basic database program. This article is a valuable resource for understanding the core concepts of database design and implementation.

tl;dr in tech - Issue #101

Tue, 05 Dec 2023 00:00:00 GMT

Joins 13 Ways

By: Justin Jaffray

tl;dr: Justin dives deep into “relational inner joins.” If SQL joins are your bread and butter, then this is the Nutella spread! From “they’re not without redundancy” to different perspectives, this article offers a comprehensive look you don’t want to miss.

Readability: Google’s Temple To Engineering Excellence

By: Brian Kihoon Lee

tl;dr: Readability is the yin to your engineering yang, folks! Brian sheds light on Google’s approach to readability, but also proposes a ‘Readability Lite’ for the rest of us mortals. Useful for anyone tired of squinting at indecipherable code.

Data Management at Scale

By: Piethein Strengholt

tl;dr: Decentralized data management? Yes, please! Piethein tackles the concept of Data Mesh, explaining how to manage data at scale in a decentralized manner. For data aficionados who love organizing as much as crunching.

Names Should Be As Short As Possible While Still Being Clear

By: Ben Hoyt

tl;dr: “Some developers do use names that are too short.” Naming variables? You’ll find this piece by Ben enlightening. He talks about striking the right balance between conciseness and clarity. isThisNameTooLongOrIsItJustVerboseEnough might wanna read this.

Generating Code Without Generating Technical Debt?

By: Reka Horvath

tl;dr: Reka breaks down how GPT and other language models can help speed up prototyping but also create messier code. For software engineers dealing with the never-ending battle against technical debt, this one’s for you.

Build Times And Developer Productivity

By: Abi Noda

tl;dr: Speed is king, especially in build times. Abi talks about how even small improvements can yield big productivity gains. So the next time you’re daydreaming while your code compiles, remember, speed matters.

Gelling Your Engineering Leadership Team

By: Will Larson

tl;dr: For all the engineering leaders out there, Will shares his playbook on creating a well-gelled leadership team. He covers everything from diagnosing conflict to setting expectations, a must-read if you’re playing 4D chess with team dynamics.

Embracing Failure

By: Mike Fisher

tl;dr: “Frame failures like a video game.” Mike’s unique perspective on failure offers a mental model shift. Good for engineers who sometimes (or often, no judgment here) fail and want to turn it into a learning curve.

Finding A Buddy When You’re A Team Of One

By: Lara Hogan

tl;dr: Lone wolf devs, this one’s for you. Lara outlines ways to mitigate isolation. Peer groups, cross-team collabs, and mentorship programs are among her arsenal for fighting off the lonely blues.

Right-Sizing Your Technology Team

No Author

tl;dr: Team size questions keeping you up? This article tackles the essentials: Do we have enough devs? Are we overpaying? Is our software delivering? Good stuff for anyone puzzled about how to size a tech team effectively.

tl;dr in tech - Issue #100

Tue, 28 Nov 2023 00:00:00 GMT

If you can believe it, we’re at the 100th issue of this newsletter! A massive shout-out to all of you who’ve stuck around, and essentially turned this into a distributed think tank. Couldn’t have debugged this journey without ya. 🚀 Alright, let’s do this 100th issue justice by diving in.

Estimation Isn’t For Everyone

By: NYTimes Open Team

tl;dr: The NYTimes team says ditch story points. Instead, count work items your team completes per week. The goal is throughput, not how well you can guess your future workload. It’s like measuring the speed of your car, not the time spent guessing how fast you can go.

Amir’s 10 Laws Of Tech

By: Amir Shevat

tl;dr: “These are my personal observations working in tech for more than 20 years”. Amir covers a mix of moral, practical, and downright comical truths in tech. Think of it as Newton’s laws but for the tech universe.

Building Personal And Organizational Prestige

By: Will Larson

tl;dr: Your brand isn’t just your logo on a hoodie. Will Larson discusses the playbook for building prestige through high-quality content. And yes, you should care about prestige if you want to play in the big leagues.

2023 Engineering Salary Expectations Trends Report

By: Sam Graham

tl;dr: Engineers are lowering salary expectations due to market conditions and valuing non-monetary benefits more. Watch out for the gender pay gap; it’s still a monster we need to debug.

Compensation Heuristics

By: Saasy Management

tl;dr: Money can’t buy happiness, but lack of it can cause drama. The article outlines heuristics for thinking about compensation strategically. Let’s call it the psychology of salary in code comments.

Bottlenecks vs Bandpass

By: Andrew Bosworth

tl;dr: Stop the bottlenecking madness. Horizontal teams should set up guidelines so that vertical teams can sail smoothly. It’s like cleaning up your codebase so your future self doesn’t hate you.

How To Make Hard Decisions: Even / Over Statements

By: Lara Hogan

tl;dr: Decisions, decisions. Hogan’s “even / over” tool is like a GPS for tough choices, forcing you to articulate trade-offs for clarity. Debugging your decision-making, one choice at a time.

How To Do Great Work

By: Paul Graham

tl;dr: Want to innovate? Choose crazy good ideas and break some rules. If you always solve “fashionable” problems, you’re following trends, not setting them.

Executive Compensation

By: a16z

tl;dr: Late-stage companies, listen up. This post talks about balancing base, bonus, and equity in executive compensation. Executive compensation: the Ferrari of pay packages.

tl;dr in tech - Issue #99

Tue, 21 Nov 2023 00:00:00 GMT

Hashing

By: Sam Rose

tl;dr: A 101 on hash functions. The article explains how to test hash functions and real-world use-cases like hash maps. Knowing how hashing works is fundamental for database management, data retrieval, and security.

An Explosion In Software Engineers Using AI Coding Tools?

By: Gergely Orosz

tl;dr: AI coding tools can be your Yoda - they help you learn languages (57%), increase productivity (53%), and reduce repetitive tasks (51%). Engineers are increasingly using these tools to leverage productivity and skill-building.

Failure

By: Mike Fisher

tl;dr: “Embracing failure, dissecting it, and learning from it not only builds stronger systems but also fosters an environment of psychological safety, creativity, and continuous improvement.” A culture shift to understanding failures as systemic rather than personal can be transformative.

How Google Measures And Manages Tech Debt

By: Abi Noda

tl;dr: Technical debt isn’t just messy code - it’s a multi-headed beast. Google measures and categorizes tech debt to manage it effectively. Understanding the types of tech debt your team struggles with can guide debt reduction strategies.

The Surprising Power Of Documentation

By: Vadim Kravcenko

tl;dr: “Start small, but start today. Don’t wait for a grand strategy or a perfect tool.” Documentation isn’t just an afterthought - it’s an ongoing part of your engineering workflow. Makes handovers easier and troubleshooting quicker.

Some Blogging Myths

By: Julia Evans

tl;dr: Busting myths around blogging. You don’t need to be a guru, you don’t need the perfect post, and you certainly don’t need everyone to read it. Just start writing!

Get It Done

By: Andrew Bosworth

tl;dr: “I relate strongly to the instinct many of us have to do things ourselves rather than involve others.” Not involving others can be counterproductive. Leadership trusts those who openly discuss challenges rather than suffering in silence.

How Canva Saves Millions Annually In Amazon S3 Costs

By: Josh Smith

tl;dr: Canva saved ~$3.6M p.a. by migrating user-generated data to S3 Glacier Instant Retrieval storage. Understanding data usage patterns and applying appropriate storage classes can result in substantial savings.

Self-Healing Code Is The Future Of Software Development

By: Ben Popper

tl;dr: The future is now, almost. Self-healing code with generative AI is in development. This technology has the potential to revolutionize software maintenance and create more robust systems.

Helicopter Management And Other Mistakes

By: Charity Majors

tl;dr: “The message is simply that it took me years and years to learn that there is more to being a great manager than caring about my team.” Avoid rookie manager mistakes like over-identifying with your team and not considering organizational context.

Accountability For Effective Teams

By: Jessica Kerr

tl;dr: Accountability should focus on behavior rather than just metrics. Courageous conversations and collective goal alignment are crucial for long-term team effectiveness.

How Platform Engineering Works

By: Chad McElligott

tl;dr: “I feel confident you will have a solid foundation upon which to build an effective Platform Engineering team if you follow these four principles.” Platform engineering is not just about tools; it’s about understanding and solving for your customer.

What Drives Adoption Of Internal Developer Tools?

By: Abi Noda

tl;dr: Adoption of internal tools is driven by various factors like configurability, tech compatibility, visibility, and workflow alignment. Knowing these can guide your tool development strategy.

How To Make Difficult Technical Decisions You And Your Team Won’t Regret

By: Jordan Cutler

tl;dr: Decision paralysis? Use Jordan’s methods to evaluate technical decisions. Considering reversibility, consulting team members, and viewing from end-user perspective can provide valuable insights.

The Modern Way Of Serving Images

By: Jacob Groß

tl;dr: “The following article will guide you through responsive image techniques.” A comprehensive guide on new techniques to make your image tags more effective and resource-efficient.

Linking Modular Architecture To Development Teams

By: Matthew Foster

tl;dr: “This article charts the journey of an enterprise who set out to shift their architecture to a more modular one.” Modularity extends beyond code - it affects team structure, communication lines, and overall delivery performance.

tl;dr in tech - Issue #98

Tue, 14 Nov 2023 00:00:00 GMT

The Modern Way Of Serving Images

By: Jacob Groß

tl;dr: Your <img> tag is old news. In 2023, it’s all about making your <img> work like <picture> tags. This trick is an old dog’s dream - it helps in migrating existing codebases without pulling your hair out. As Jacob puts it, “the following article will guide you through responsive image techniques, and introduce a novel technique that aims to make <img> tags work (almost) like <picture> tags, making migration in existing codebases easier. With the reduced engineering effort, this hopefully helps you improve the images on your website in 2023.”

Get It Done

By: Andrew Bosworth

tl;dr: Worried about involving others in your project? Don’t be. Trust is earned by tackling issues as a team. Bosworth nails it, “I relate strongly to the instinct many of us have to do things ourselves rather than involve others. We don’t want to bother them. If we’re being honest, we don’t want to have to. We may worry how it reflects on us. We may worry it means we are failing. But my experience in leadership tells me the exact opposite is true. Someone who tells me when things are going poorly is someone I am going to trust relative to someone who struggles in silence.”

Some Blogging Myths

By: Julia Evans

tl;dr: Want to blog but holding yourself back? Julia calls out the myths you might be buying into: you don’t have to be a savant, originality is overrated, and not every post has to be a Pulitzer contender. Forget page views; just write.

An Explosion In Software Engineers Using AI Coding Tools?

By: Gergely Orosz

tl;dr: AI coding tools aren’t Skynet. They’re here to help you learn (57%), be more productive (53%), and focus (51%). Gergely dives into the stats and insights that show how software engineers are leaning on AI to level up.

How Google Measures And Manages Tech Debt

By: Abi Noda

tl;dr: Abi uncovers how Google puts tech debt into neat categories, measures it, and then employs tactics to tackle it. This is essential for understanding how your team may be buried under tech debt and offers some escape routes.

Linking Modular Architecture To Development Teams

By: Matthew Foster

tl;dr: Matthew explains the holistic role modularity plays in an enterprise. It’s not just about architecture; it affects team topologies and business communication. He emphasizes, “This article charts the journey of an enterprise who set out to shift their architecture to a more modular one in order to ease their growing pains. They found that modularity is a multifaceted solution that extends beyond architecture, into business lines of communication, team topologies and effective developer experience. By paying close attention to these factors, the enterprise was able to achieve significant uplifts in the delivery performance of their mobile applications.”

The Surprising Power Of Documentation

By: Vadim Kravcenko

tl;dr: Listen to Vadim, folks - “Start small, but start today. Don’t wait for a grand strategy or a perfect tool. Start by documenting your code, your decisions, and your learnings. Make it a part of your daily workflow, not an end-of-the-day chore. And as you move forward, imbibe this culture of documentation into your teams, your projects, and your organization. Create systems and processes that encourage and facilitate documentation.”

tl;dr in tech - Issue #97

Tue, 07 Nov 2023 00:00:00 GMT

You Don’t Always Need Indexes

By: Jeff Kaufman

tl;dr: In a world where data is more abundant than air, you might think you need indexes to breathe easier. But Jeff Kaufman says, “Hold on! Not so fast!”. Jeff talks about the threshold for indexing and instances where a full database scan might just be your knight in shining armor, rather than a costly indexing quest. Database engineers, you might wanna bookmark this one.

Should You Optimize For All-Cash Compensation, If Possible?

By: Gergely Orosz

tl;dr: Money, money, money, it’s always sunny, but should it all be cash, honey? Gergely discusses companies like Netflix and Shopify that let employees choose their compensation structure. To stock or not to stock, that is the question!

Email Addresses Are Not Primary User Identities

tl;dr: An email address may seem like a solid rock in the ever-changing world of user identities, but surprise, surprise, it’s more like shifting sand! This post tells you why, and offers better ways to handle user identities in your code.

To Build A Top Performing Team, Ask For 85% Effort

By: Greg McKeown

tl;dr: Want a top-performing team? Don’t ask for a 110% effort, Greg McKeown suggests. Instead, aim for an 85% effort to avoid burnout and maximize results. This one’s a golden nugget for managers and team leads out there. And hey, if you’re coding at 100%, maybe it’s time to chill a little? 😎

What Is A Vector Database?

By: Roie Schwaber-Cohen

tl;dr: This post reviews key aspects of a vector database - how it works, algorithms it uses, and the additional features that make it operationally ready for production scenarios. Remember: knowing your data structures and algorithms isn’t just for acing technical interviews, it’s for acing your actual job too! 😅

Live Comment System Design

tl;dr: Ah, the live comment feature, a crowd favorite in system design interviews. This post discusses how to build a real-time platform for publishing live comments, and also to display Facebook reactions, likes, viewer counts, user presence status, online polls, or seen receipts. If you have a system design interview coming up, you don’t want to miss this one.

Be Plainspoken

By: Andrew Bosworth

tl;dr: What’s more powerful than a superhero? A plainspoken software engineer, Andrew Bosworth says! Your desire to impress, maintain harmony, or influence can make you use more language than necessary. Simplify, be straightforward, a risend watch your communication become a superpower.

tl;dr in tech - Issue #95

Tue, 31 Oct 2023 00:00:00 GMT

Beautiful Branchless Binary Search

By: Malte Skarupke

tl;dr: “I read a blog post that describes a binary search called ‘Shar’s algorithm.’ I’d never heard of it and it’s impossible to google, but looking at the algorithm I couldn’t help but think ‘this is branchless.’ And who knew that there could be a branchless binary search?” Malte takes us on a journey through the mechanics of this elegant and efficient branchless binary search algorithm. Prepare to have your mind blown!

CLI Tricks Every Developer Should Know

By: Kedasha Kerr

tl;dr: “We’ve compiled some important tricks and commands that every developer should know from GitHub’s own engineers. By mastering these basic techniques, developers can become more efficient at working with the command line and gain a deeper understanding of how the underlying operating system and programs work.” Join us as we unlock the secrets of the command line and discover the CLI tricks that will level up your development game. Get ready to unleash the power of the terminal!

Avoiding The Rewrite Trap

By: Camille Fournier

tl;dr: “Year after year, engineers convince themselves and their leadership that a rewrite will solve all their problems. And then they or their leadership get fired, because most rewrites fail to deliver anything at all. Avoid the trap: don’t go into this exercise unless it is the only way forward, and if you absolutely must, plan accordingly.” Camille shares invaluable insights on how to navigate the treacherous waters of rewriting code. Learn from the mistakes of others and save yourself from the perils of the rewrite trap.

The Future Of Programming: Research At CHI 2023

By: Austin Henley

tl;dr: “The esteemed CHI conference is happening this week, and I’m jealous that I can’t be there. Instead, I’m going through the proceedings and reading all of the papers related to programming, of which many involve AI.” Join Austin as he takes us on a virtual tour of the exciting research presented at the CHI 2023 conference. Discover the future of programming and how AI is shaping the landscape of software engineering. It’s like peering into a crystal ball!

Writing Javascript Without A Build System

By: Julia Evans

tl;dr: “I want to talk about what’s appealing to me about build systems, why I still don’t use them, and why I find it frustrating that some frontend Javascript libraries require that you use a build system.” Julia delves into the world of JavaScript and build systems. Join the conversation as we explore the pros and cons of using build systems and discover alternative approaches to writing JavaScript without the hassle of build configurations. It’s time to simplify our workflows and unleash the power of JavaScript!

Theory Of Mind

By: Andrew Bosworth

tl;dr: “Theory of mind is a concept I first learned in a class on psychology. It describes our capacity to understand the mental states of others.” Andrew enlightens us on the importance of theory of mind for leaders in the tech industry. Learn why effective communication, providing context, and understanding the mental states of your team members are crucial for successful leadership. It’s time to level up your interpersonal skills and become a master of human interaction!

How eBay Modernized The Most Important Page On Our Platform

tl;dr: “eBay’s View Item page lives at the center of our e-commerce platform. Our customers load this page over 250 million times each day, and stringent budgets on site speed and availability guarantee the quality of their experience. And yet, this page had its last intentional rewrite ten years ago.” Explore the fascinating journey of how eBay tackled the modernization of their crucial View Item page. Discover the challenges they faced, the innovative solutions they implemented, and the lessons learned along the way. It’s a story of continuous improvement and delivering top-notch user experiences!

That’s a wrap for this week’s Byte Bazaar! Stay curious, keep coding, and remember to have fun along the way. We’ll be back next week with more thrilling tech tales. Happy coding, everyone! 🚀💻

tl;dr in tech - Issue #93

Tue, 24 Oct 2023 00:00:00 GMT

From Assumption To Next Step

By: John Cutler

tl;dr: John shares the struggle of dealing with the assumptions and uncertainties in a team setting. He talks about the theory and practice of addressing risky assumptions and planning to reduce uncertainty. This one’s a must-read for anyone trying to navigate the murky waters of project assumptions and uncertainties.

Real Time Presence Platform System Design

By: No Author

tl;dr: Ever wondered how LinkedIn, Facebook, and Slack manage to tell you if your buddy is online or not? This post does a deep dive into real-time presence platforms and their system design. Get ready to uncover the secrets behind the “online” and “offline” statuses.

Understanding Database Types

By: Alex Xu

tl;dr: “Choosing databases for various components of our application” is a sentence that gives even seasoned engineers chills. Fear not, because Alex is here to arm us with knowledge about different database types, performance factors, and cost considerations. Keep this one bookmarked for your next DB-selection showdown.

Is Critical Thinking The Most Important Skill For Software Engineers?

By: Gergely Orosz

tl;dr: “If someone cannot explain a concept without jargon, I now doubt they truly understand what they are talking about.” Preach, Gergely! This piece provides four tips on how to improve our critical thinking skills. Remember, the true test of understanding a topic is if you can explain it to someone else (without all the fancy tech lingo).

Spinning Diagrams With CSS

By: Harold Cooper

tl;dr: “Several people expressed surprise that the spinning diagrams don’t use any JavaScript or animated image formats, just HTML and CSS.” Harold explains the secret sauce behind his spinning diagrams using only HTML and CSS. It’s like magic, but with code!

By: Mitchell Hashimoto

tl;dr: Mitchell is here to make the case that prompt engineering is a real skill that can be honed based on experimental methodologies. This one’s a bit of a deep dive but well worth the effort, especially for anyone trying to add another string to their software engineering bow.

Rescuing A Project In Progress

By: Jason Fried

tl;dr: “This isn’t about calling in reinforcements or adding more resources.” Jason discusses the importance of establishing “completion discipline” in projects. It’s about slowing down, focusing, and driving the project to completion. Like Jason, we’ve all been there, desperately trying to rescue a project in progress. And like Jason, we all know it’s more about precision than firepower.

tl;dr in tech - Issue #94

Tue, 17 Oct 2023 00:00:00 GMT

An Example Of LLM Prompting For Programming

By: Martin Fowler

tl;dr: Martin takes us on an exciting journey into the world of ChatGPT and self-tested code. By priming the LLM with an implementation strategy, rather than code, Martin shows us how powerful and useful self-generated code can be. So, let the LLM do the heavy lifting and generate those code snippets for you!

I Finally Figured Out How To Take Notes!

By: Sam Rose

tl;dr: Sam had some epic requirements for note-taking:

Tagging notes, tracking dates, attendees, and key topics for easy searching.
Creating action items and staying on top of them.
Super-easy accessibility for those quick meeting note sessions.

Join Sam on his note-taking adventure and discover the secrets to efficient and organized note-taking.

Tracing Notifications

No Author

tl;dr: The engineering wizards at Slack embarked on a mission to improve debugging notifications. With different logging pipelines and data formats in play, debugging became a challenging endeavor. But fear not! This post unveils the solutions they implemented to streamline the process and save valuable time. Debug like a pro with the power of efficient notification tracing.

90% Of My Skills Are Now Worth $0…But The Other 10% Are Worth 1000x

By: Kent Beck

tl;dr: Kent Beck drops some truth bombs about the value of our software development skills in the age of AI. While routine tasks can be automated, our human creativity and expertise remain unparalleled. Embrace the unique qualities that make you an exceptional software engineer. Your skills are more valuable than ever!

The Inner Workings Of Distributed Databases

By: Alex Pelagenko

tl;dr: Join Alex as he takes us on a journey through the fascinating world of distributed databases. Dive deep into the inner workings and explore how popular time-series and OLAP databases implement high availability. Learn about the pros and cons of different approaches and gain a solid understanding of the fundamentals behind these distributed powerhouses.

Measuring Developer Productivity And Happiness At LinkedIn

By: Viktoras Truchanovicius

tl;dr: LinkedIn unveils their secret weapon for measuring developer productivity and happiness - the Developer Insights Hub. This internal product visualizes key metrics related to developer activities, code building, reviewing, publishing, and even the sentiment towards the tools being used. Gain insights into how LinkedIn approached metric selection, system architecture, and the key features of this developer happiness oasis.

The Silent Killer Of Your Operating Practice: Fear

By: Amanda Schwartz Ramirez

tl;dr: Amanda shines a light on the silent killer lurking in our operating practice - fear. Through relatable scenarios, she tackles five common fears faced by software engineers:

Fear of failure.
Fear of losing control.
Fear of conflict.
Fear of losing credibility.
Fear of missing something.

Take control and mitigate these fears to unlock your true potential as a software engineer.

That’s a wrap for this week’s edition of our epic tech digest! Remember, the path to coding greatness is paved with curiosity, learning, and a touch of humor. Stay tuned for more tech adventures next week. Happy coding! 💻✨

tl;dr in tech - Issue #96

Tue, 10 Oct 2023 00:00:00 GMT

Promoted From Dev To Team Lead: 8 Things They Didn’t Tell Me

tl;dr: Ever felt like a deer in headlights? That’s how most of us feel when stepping into a leadership role. Among the unspoken truths: many of your skills don’t translate, culture is a real thing (and you’re responsible for it), and you better get good at explaining “why” more than “what” and “how.” You got this, skipper!

The Work Is Never Just “The Work”

By: Dave Stewart

tl;dr: To all the overly optimistic project estimators (you know who you are), this one’s for you. Dave’s got strategies for improving contract work estimations, from running postmortems to timing future work. It’s time to do some work on “the work”.

Tech Debt Metaphor Maximalism

By: Avery Pennarun

tl;dr: Just like financial debt, tech debt can either be a high-interest shortcut or a low-interest strategic decision. As long as you manage it within defined limits and evaluate its impact, you’re all set. It’s time to become the finance guru of the coding world!

On Wielding Influence

By: Charity Majors

tl;dr: Charity answers the million-dollar questions:

How to drive change when you have no power or influence?
How to drive change when you are a tech lead on a new team? It’s time to go from coder to influencer!

Should You Optimize For All-Cash Compensation, If Possible?

By: Gergely Orosz

tl;dr: With companies like Netflix and Shopify allowing employees to decide how much of their total compensation is stock, Gergely investigates various approaches to this choice. More cash or more company pie? That’s the question!

Slack Architecture

By: Unknown

tl;dr: Want to know how Slack keeps those messages flying and the emojis rolling? This post guides us through the design of a system where users can send real-time messages to each other and within channels, all kept in chronological order.

Be Plainspoken

By: Andrew Bosworth

tl;dr: Andrew Bosworth talks about the superpower of being plainspoken in the workplace, discussing the pitfalls of trying to maintain harmony, influence, and impress with language.

My Approach To Building Large Technical Projects

By: Mitchell Hashimoto

tl;dr: Big project got you down? Mitchell Hashimoto suggests breaking it down into chunks to maintain excitement and motivation. And don’t forget the power of a good demo - nothing sparks joy like seeing your code come to life!

To Build A Top Performing Team, Ask For 85% Effort

By: Greg McKeown

tl;dr: The secret to a high-performance team isn’t a constant full throttle. Research suggests aiming for 85% effort to avoid burnout and achieve optimal results. Time to take your foot off the gas, just a little!

tl;dr in tech - Issue #92

Tue, 29 Aug 2023 00:00:00 GMT

Sources Of Complexity: Constraints

By: Hillel Wayne

tl;dr: “While people like coming up with grand theories of complexity, there’s very little info out there on the nitty-gritty specific sources of complexity… I think a lot about the different sources of complexity. This article is about one particular source.” So, buckle up software engineers, let’s get down to the complex world of complexity! 🚀

Engineering Maturity Model

By: Mike Fisher

tl;dr: “It’s all about layering. The reason I can build a house is because I know what goes first, second, third, and fourth…” Mike shares his secret sauce to a mature engineering organization: a scrumptious layering recipe! 🏡👷‍♂️

The Case Against Measuring Cycle Time

By: Abi Noda

tl;dr: “There are cases in which individual teams may find cycle time useful. However, using cycle time as a top-level performance measure that is pushed onto all teams is counterproductive. To actually improve performance, leaders should focus on measuring the friction experienced by developers and removing the bottlenecks that slow them down.” Think of cycle time like the cherry on top, useful but not the main ingredient in your productivity sundae! 🍒⏱️

Uber’s Engineering Level Changes

By: Gergely Orosz

tl;dr: “Uber addressed this inconsistency in levels by updating engineering levels to be more in-line with the rest of the industry. The company pretty much renamed senior 2 engineer as staff engineer, and updated the titles from L6. They also added a new level 9.” I guess Uber finally learned to ride along with the industry trends. New levels, who dis? 🚖📶

Using ChatGPT As A Technical Writing Assistant

By: Mike Mason

tl;dr: Our tech author pal, Mike, took ChatGPT out for a writing spin. While it provided some time-saving drafts and prompts, it also threw in some overly optimistic ideas. Our advice: take it in small, iterative bites with carefully crafted prompts. And always, always remember to supervise your AI buddy! 🤖✍️

Factors To Consider In Database Selection

By: Alex Xu

tl;dr: Your friendly neighborhood DB admin, Alex, breaks down the key factors influencing database selection, including scalability, performance, and data consistency. Next time you’re up for a DB selection conundrum, remember these pearls of wisdom. 🗂️💎

tl;dr in tech - Issue #91

Tue, 22 Aug 2023 00:00:00 GMT

How LinkedIn Adopted A GraphQL Architecture For Product Development

By: Arun Sethuramalingam

tl;dr: LinkedIn has gone full GraphQL, folks. No half measures here. In their blog, they dig deep into the architectural choices unique to them and why they made those choices. In Arun’s words, “In this blog post, we will cover how the GraphQL layer is architected for use by our internal engineers to build member and customer facing applications.” Useful insight for those of us wrangling API’s and data.

Contrafreeloading

By: Mike Fish

tl;dr: Not just for the birds, “contrafreeloading” is about working for rewards and taking pride in it. Mike underscores the importance of having “something to do, someone to love, and something to hope for” in your career. As software engineers, we’ve got the “something to do” part covered… multiple times over. 😅

A Beginner’s Guide To Prompt Engineering With GitHub Copilot

By: Rizel Scarlett

tl;dr: Struggling to get the most out of GitHub Copilot? Rizel’s been there. She improved her communication with the tool by providing context, examples, and clear instructions, and in her post, she spills the beans on how to do it too. “After more experimentation, I improved my communication methods with GitHub Copilot.” Must-read for those in the copilot’s seat. 👨‍✈️👩‍✈️

Rules Of Thumb For Software Development Estimations

By: Vadim Kravcenko

tl;dr: Vadim shares his wisdom on the ‘dark art’ of project estimations. He might not be a know-it-all, but he does share some handy rules of thumb that could make your life easier. He says, “Who am I to tell you how to estimate projects? I can only give you some pointers…” Estimations may always be a shot in the dark, but Vadim gives us a flashlight.

How To Survive Your Project’s First 100,000 Lines

By: Evan Ovadia

tl;dr: Evan takes us on a journey through 100,000 lines of code and how his project didn’t collapse under the weight. He credits techniques from his time at Google and game development. He says, “Some of these software engineering techniques came from my time at Google, though ironically most came from my work on the Vale compiler and game development.” This is a survival guide every budding engineer needs. 🏕️

That’s all for this week, folks! Keep on coding and remember - the best error message is the one you never see.

Catch you on the flippity flip!

tl;dr in tech - Issue #90

Tue, 15 Aug 2023 00:00:00 GMT

The Best Managers Don’t Fix, They Coach - Four Tools To Add to Your Toolkit

By: First Round Review

tl;dr: Learn how to coach - not “fix” - team members in various situations like: (1) Outcome shift: assisting a team member who is spinning on a problem. (2) Options exploration: understanding a team member’s challenge and desired outcome. (3) Acknowledging strengths: helping team members overcome imposter syndrome or a lack of confidence. (4) Identifying unconscious assumptions that might be holding a team member back.

Two Types Of Software Engineers

By: Thorsten Ball

tl;dr: Thorsten presents two types of engineers: Type 1 thinks a problem is “easy, people can just do X,” while Type 2 considers it “very hard, because it requires people to do X.” Understanding this subtle difference is important in problem-solving.

Junior To Senior: An Action Plan For Engineering Career Success

By: Jerome Hardaway

tl;dr: This guide covers: (1) Key technical competencies managers prioritize for career advancement. (2) Essential communication skills expected from senior developers. (3) How to approach code development with a focus on addressing business requirements.

Unit Testing Analytics Code

By: Matt Kaye

tl;dr: Matt discusses the pushback he often faces when discussing unit testing in analytics code, focusing on the lack of understanding behind its value and importance.

Taming The Nested Beast

By: Eliran Turgeman

tl;dr: Eliran acknowledges the downsides of overly nested code but focuses on techniques for flattening nested code when needed. Note that flattening isn’t always the answer.

The Free Software Foundation Is Dying

By: Drew DeVault

tl;dr: Drew discusses the decline of the Free Software Foundation, acknowledging its past achievements and the continued importance of software freedom principles.

6 CSS Snippets Every Front-End Developer Should Know In 2023

By: Adam Argyle

tl;dr: Handy CSS snippets for front-end developers include: (1) A container query. (2) Scroll snap. (3) Grid pile. (4) Quick circle. (5) Control variants with @layer. (6) Logical properties for memorizing less and reaching more.

Fast-Forwarding Decision Making

By: James Stanier

tl;dr: James advises to hold yourself accountable for making decisions and progressing discussions as quickly as possible. Dead time is your enemy, so be creative about ways to shave minutes, hours, and days from a decision point.

Slack

By: Martin Fowler

tl;dr: Martin discusses the concept of “slack” in timeboxed iterations, where time isn’t allocated for user stories but rather for unplanned work. Though it may seem inefficient, it often leads to significant improvements in a team’s productivity.

Time Is Emphasis: Planning Your Calendar As A Leader

By: Molly Graham

tl;dr: Molly shares insights from a study analyzing the calendars of 27 CEOs, highlighting the importance of having explicit priorities and structure for your calendar. She offers templates and examples to help you allocate time for strategic priorities effectively.

Real-time Messaging

By: Sameera Thangudu

tl;dr: The engineering team at Slack takes us through the architecture used to send real-time messages at scale, focusing on the services that send chat messages and events to online users in real time.

Semantic Search In iMessage, iMessage Wrapped, And AI Conversations

By: JonLuca DeCaro

tl;dr: JonLuca explores iMessage’s local SQLite database and builds an alternate UI for searching, along with interesting features like (1) Semantic Search, (2) Wrapped: stats about life on iMessage, (3) AI conversations with friends, and more.

Load Balancing

By: Sam Rose

tl;dr: Sam dives into the ways a single load balancer might distribute HTTP requests to a set of servers, starting from basic methods and moving up to modern load balancing algorithms.

A List Of Programming Playgrounds

By: Julia Evans

tl;dr: Julia shares her extensive list of programming playgrounds across multiple categories, perfect for those who love to experiment and learn in interactive environments.

tl;dr in tech - Issue #89

Tue, 08 Aug 2023 00:00:00 GMT

Be A Thermostat, Not A Thermometer

By: Lara Hogan

tl;dr: Lara explains how we can easily be influenced by others’ moods and how leaders should act as thermostats, setting the temperature of the room positively. For software engineers, this means being aware of negative mood shifts and actively working to create a healthy environment.

Accountability Is Not Blame

By: Kent Beck

tl;dr: Kent dives into the difference between accountability and blame, pointing out that blame is often used as a “relationship decaying” strategy. As software engineers, it’s important to foster a culture of responsibility rather than blame.So I

System Design Interview Cheat Sheet

tl;dr: This cheat sheet covers various topics like databases, API design, capacity planning, and high-level design, all based on the author’s research. It’s a work in progress but a helpful resource for software engineers preparing for system design interviews.

Clocks And Causality - Ordering Events In DistribuSo I tookted Systems

By: Giridhar Manepalli

tl;dr: Giridhar discusses the role of logical clocks in distributed systems and how they help order system events. A great read for software engineers working with or interested in distributed systems.

How To Plan As An Engineering Executive

By: Will Larson

tl;dr: Will shares valuable insights on planning as an engineering executive, including approaching planning as an infinite process, decomposing it into financial plans, functional portfolio allocations, and roadmaps. Useful for both engineers and engineering managers.

A Problem Vs The Problem

By: John Cutler

tl;dr: John highlights how conversations about problems and their causes are often negotiations involving identity, reputation, and control. As software engineers, understanding this can help navigate and address problems more effectively.

Dropbox Engineering Career Framework

tl;dr: This framework helps engineers understand how to achieve impact in their roles and grow in their careers. Managers can use it to set expectations and hold their teams accountable.

Writing Tips for Improving Your Pull Requests

By: Jeff Mueller

tl;dr: Jeff shares tips on how to write better pull requests by making them scannable, speaking plainly, avoiding adverbs, simplifying sentences, and avoiding passive voice. Excellent advice for software engineers looking to improve their PR communication.

Cohesion In Simple Terms - Software Modularity

By: Eliran Turgeman

tl;dr: Eliran discusses the importance of modularity in software design and how it contributes to extensibility

tl;dr in tech - Issue #88

Tue, 01 Aug 2023 00:00:00 GMT

The Ultimate Guide To Software Architecture Documentation

By: Patrick Roos

tl;dr: This guide provides a comprehensive approach to software architecture documentation, covering everything from how to write, structure, and visualize it, to which tools to use. As software engineers, it’s important to understand the importance of documenting our work to ensure effective communication and collaboration with our teams and stakeholders.

I Failed 3 Job Applications, Here’s What I Learned

By: Alex Ewerlöf

tl;dr: Alex shares his experiences and insights from failed job applications at Datadog, Spotify, and Shopify. He emphasizes the long and painful learning curve he faced as an introvert and offers valuable tips for others going through the job application process.

Examples Of Problems With Integers

By: Julia Evans

tl;dr: This article highlights the potential issues that can arise with integer problems, such as integer overflow/underflow, decoding binary formats in Java, and misinterpreting IP addresses or strings as integers. As software engineers, it’s important to understand the limitations and vulnerabilities of integers and to be aware of potential pitfalls that can negatively impact our code.

Don’t Yell At The Weather

By: Paulo André

tl;dr: Paulo discusses how senior leadership in many companies try to “fix” complex systems, often like “yelling at the weather.” He provides a recipe for addressing such situations, focusing on understanding that failure is “the price of admission to discover the path to success” and promoting a culture of rapid experimentation.

How To Debug

By: Phil Booth

tl;dr: Debugging is an essential part of software engineering, and this article provides a step-by-step guide to effective debugging. From reproducing the bug to understanding the code and observing the state, Phil covers everything you need to know to debug like a pro.

Improving Firefox Stability With This One Weird Trick

By: Gabriele Svelto

tl;dr: Firefox was experiencing stability issues due to failed memory allocations, and this article explores a potential solution using the Windows swap file. By automatically resizing the swap file when it’s almost full, Firefox can recover from memory allocation errors and improve stability. As software engineers, it’s important to be creative and explore innovative solutions to common problems.

The Heisenbug Server

By: Oren Eini

tl;dr: The Heisenbug Server was experiencing issues with nodes in the cluster going dark and stopping communication with the rest of the cluster. Despite internal and external metrics appearing fine, the server would stop responding to anything over the network. The solution was to restart the service, but the problem would reoccur every few days. As software engineers, it’s important to be diligent in diagnosing and solving complex issues that may arise in our code.

A Framework For Prioritizing Tech Debt

By: Max Countryman

tl;dr: Tech debt can be a major obstacle in software development, and this article provides a framework for prioritizing and addressing it effectively. By evaluating the impact of each issue and considering factors such as whether it will become worse, how quickly it will degrade, and how much disruption it’s causing today, software engineers can prioritize and address tech debt to optimize their code and improve efficiency.

How DoorDash Secures Data Transfer Between Cloud And On-Premise Data Centers

By: Roger Zeng

tl;dr: DoorDash has established a secure, stable, and resilient private network connection between their microservices and on-premise data centers by leveraging the network facilities from their cloud provider, AWS. As software engineers, it’s important to prioritize data security and understand how to establish secure connections between different systems

tl;dr in tech - Issue #87

Tue, 25 Jul 2023 00:00:00 GMT

Architects, Anti-Patterns, and Organizational Fuckery

By: Charity Majors

tl;dr: Charity Majors asserts that “only the people responsible for building software systems get to make decisions about how those systems get built.” The presence of an architect can cause decision-making to become “someone else’s problem,” leading to weaker engineers and worse systems. Charity discusses how to effectively utilize architects in your organization.

Lessons From A Pessimist: Make Your Pessimism Productive

By: Armin Ronacher

tl;dr: Armin Ronacher distinguishes between pragmatic pessimism and destructive pessimism. While pragmatic pessimism can be useful, assuming things are more difficult than they really are, destructive pessimism wants or expects things to fail and can be harmful. Embrace the former and avoid the latter for a healthier engineering mindset.

Keeping The Cloudflare API ‘All Green’ Using Python-Based Testing

By: Elie Mitrani

tl;dr: Elie Mitrani presents Scout, an automated Python testing system that verifies Cloudflare’s APIs in production-like environments. Scout helps green-light production deployments and monitors API behavior. A fascinating read for software engineers interested in Python-based testing and API management.

Eight Graphs That Explain Software Engineering Salaries In 2023

By: Tekla Perry

tl;dr: Tekla Perry analyzes 2022 data to reveal trends in software engineering salaries, including rising tech salaries (but below inflation), best-paying jobs, skills employers want, and skills by demand. A valuable resource for software engineers looking to understand the job market and plan their careers.

Why People Misuse Inheritance

By: Unknown

tl;dr: The author argues that people often misuse inheritance because it feels like less work to implement and maintain compared to composition or delegation-based approaches. However, the inheritance-based approach is often either incorrect or a “subtle bug waiting to happen.” Food for thought for software engineers striving for better design practices.

The Curious Case Of A Memory Leak In A Zig Program

By: Krut Patel

tl;dr: Krut Patel shares an unexpected “memory leak” encountered when writing a Zig program. The focus is on a simple allocation pattern that causes a “leak” when using a particular allocator from Zig’s stdlib. A captivating read for software engineers interested in memory management and Zig programming.

Commandlinefu

tl;dr: Commandlinefu is a treasure trove of command-line gems that users can record, share, comment on, discuss, and vote up or down. It’s an excellent resource for software engineers looking to expand their command-line wisdom and learn from the experience of others.

tl;dr in tech - Issue #86

Tue, 18 Jul 2023 00:00:00 GMT

Simple Explanations For Complex Phenomena

By: Paulo André

tl;dr: Paulo highlights the conflict between engineers’ desire for certainty and order, and the ever-changing scope of their work. He suggests a “momentous shift in mindset” to approach work with “less predicting & planning, more probing, sensing & responding.” A great read for software engineers dealing with complex, unknown requirements.

Getting More From Your Team Health Checks

By: Justin Kotzé, Fiona Siseman

tl;dr: Spotify leaders use team health checks as a data source to support, not judge, their teams. The checks follow a pattern of predefined questions, debrief workshops, and aggregated visualizations to observe patterns and trends. A must-read for software engineers in leadership roles looking to improve team performance.

The Case Against Relying Solely On DRY

By: Ashley Peacock

tl;dr: Ashley Peacock argues that the DRY (Don’t Repeat Yourself) principle can be overused, leading to worse code in the long run. Duplication is not always evil, and sometimes it’s okay to repeat yourself. A thought-provoking read for software engineers aiming to balance code quality and reusability.

Online Gradient Descent Written In SQL

By: Max Halford

tl;dr: Max Halford explores implementing the Online Gradient Descent ML algorithm within a relational database using SQL. Training the model directly in the database can eliminate the need for separate inference/training services. A fascinating read for software engineers interested in machine learning and database integration.

How Virtual Environments Work

By: Brett Cannon

tl;dr: Brett Cannon explains the two parts of virtual environments: directories and configuration files. He uses the example of creating a virtual environment in a Unix-based OS. A useful guide for software engineers looking to understand the inner workings of virtual environments.

Why Some GitHub Labels Illegible

By: Moritz Firsching

tl;dr: Moritz Firsching explains the issues with GitHub’s label color selection for pull requests and issues. The text color on labels depends on the brightness of the label color, leading to illegible combinations. An interesting read for software engineers who work with GitHub and want to improve their workflow.

SQL Translator

tl;dr: The SQL and Natural Language Translator is a free, open-source tool designed to translate SQL commands into natural language and vice versa. It helps non-experts understand and write SQL queries without needing deep technical knowledge. A fantastic resource for software engineers and those working with databases.

tl;dr in tech - Issue #85

Tue, 11 Jul 2023 00:00:00 GMT

Three-Bucket Framework For Engineering Metrics

By: Abi Noda

tl;dr: Abi Noda argues that engineering leaders should focus on three types of metrics: business impact, system performance, and developer effectiveness. CEOs want confidence in their engineering investments, so knowing these metrics will help you demonstrate accountability. Essential for software engineers aiming to lead teams or projects.

Using Cultural Survey Data

By: Will Larson

tl;dr: Will Larson discusses how engineering leaders can use survey data effectively by reading survey results, taking action on the data, modifying questions, and determining when to start and how frequently to run surveys. A must-read for engineers in leadership roles looking to improve their team’s culture and performance.

Naming Conventions In Programming - A Review Of Scientific Literature

By: Iwo Herka

tl;dr: Iwo Herka reviews scientific literature on naming conventions in programming, providing insights to deepen your understanding of this essential skill. He also offers practical guidelines to improve your naming choices for classes, functions, and variables. A great read for software engineers seeking to improve their code readability and maintainability.

What A Good Debugger Can Do

By: Andy Hippo

tl;dr: Andy Hippo challenges the belief that “debuggers are useless” by discussing modern tools that handle breakpoints, data visualization, express evaluation, concurrency, hot reload, and more. Software engineers can benefit from exploring these tools to increase their productivity and code quality.

Balancing Quality And Coverage With Our Data Validation Framework

By: Alexey Sanko

tl;dr: Alexey Sanko shares how Dropbox tackled their data validation problem by implementing a new quality check system for their big data pipelines. This approach balances simplicity and coverage, ensuring good quality data without being overly difficult or expensive to maintain. A fascinating read for software engineers working with big data pipelines.

Designing Good Interfaces

By: Paul Boyd

tl;dr: Paul Boyd reminds us that “An application with good code and a bad UI is still useless.” He explores software design from both the application and UI perspectives, providing examples and insights for software engineers looking to create better user experiences.

Vim Best Practices For IDE Users

By: Sebastian Carlos

tl;dr: Sebastian Carlos has sifted through the Vim User Manual for you, focusing on IDE users. He provides a deep dive into all aspects of Vim, helping software engineers who want to improve their Vim skills and productivity.

tl;dr in tech - Issue #84

Tue, 04 Jul 2023 00:00:00 GMT

Recognition And Rewards At Work

By: Lara Hogan

tl;dr: Lara Hogan emphasizes that “What we recognize is what we reward.” She provides an exercise to help us better understand how we recognize and reward our teams, highlighting the importance of reinforcing positive behaviors in the workplace. A great read for software engineers looking to improve their team dynamics.

Inside Uber’s Move To The Cloud: Part 1

By: Gergely Orosz

tl;dr: Gergely Orosz provides an in-depth look at Uber’s history of data centers, challenges of operating them, and incentives for moving to the cloud. He also offers a primer on data centers, regions, and availability zones. A must-read for software engineers interested in cloud computing and data center management.

How Discord Stores Trillions Of Messages

By: Bo Ingram

tl;dr: Bo Ingram discusses Discord’s struggles with their Cassandra cluster and their migration to ScyllaDB, a Cassandra-compatible database written in C++. A fascinating read for software engineers working with databases and seeking insights into real-world scalability problems.

Project Management For Software Engineers

By: Kevin Sookocheff

tl;dr: Kevin Sookocheff breaks down the five phases of managing an engineering project according to the Project Management Institute. This informative article covers initiation, planning, execution, monitoring and control, and closure. Essential reading for software engineers in management roles or looking to improve their project management skills.

Hired’s 2023 State Of Software Engineers

By: Hired

tl;dr: Hired’s 2023 report reveals trends such as engineer optimism, the impact of layoffs on junior and non-traditional engineers, the high demand for remote engineering talent, and shifts in the most in-demand coding skills and software engineering roles. A valuable resource for software engineers to stay updated on industry trends.

Scaling Media Machine Learning At Netflix

By: Netflix Tech Blog

tl;dr: Netflix shares their approach to building ML infrastructure to reduce time from ideation to productization, including accessing and processing media data, training large-scale models efficiently, productizing models in a self-serve fashion, and storing and serving model outputs for consumption. A captivating read for software engineers working with machine learning and media processing.

Some Possible Reasons For 8-Bit Byte

By: Julia Evans

tl;dr: Julia Evans explores the question of why the x86 architecture uses 8-bit bytes and evaluates various possible reasons, including historical accidents, optimal sizing, or a mix of both. A thought-provoking read for software engineers curious about the origins of computing architecture.

tl;dr in tech - Issue #83

Tue, 27 Jun 2023 00:00:00 GMT

Running Your Engineering Onboarding Program

By: Will Larson

tl;dr: Will Larson breaks down the essential components of engineering onboarding, the roles of executive sponsor, orchestrator, manager, and buddy, and the curriculum to consider. He also discusses why onboarding programs fail, whether to integrate with wider company onboarding, and when to prioritize onboarding. A must-read for software engineers in management roles.

Why You Should Send A Weekly Summary Email

By: Jens-Fabian Goetzmann

tl;dr: Jens-Fabian Goetzmann explains the benefits of sending a weekly summary email with sections for “Achievements This Week” and “Priorities Next Week.” Benefits include starting the week off right, ensuring progress on important tasks, enabling introspection, aligning priorities, making invisible work visible, and keeping a record of achievements. A useful practice for software engineers to stay organized and focused.

How To Approach A System Design Interview

By: interviewing.io

tl;dr: This article covers the differences between engineering and design problems, how to approach a system design interview, what to expect, what interviewers look for (and don’t), and green flags, red flags, and other signposts. A helpful read for software engineers prepping for job interviews.

The World’s Smallest Hash Table

By: Orson Peters

tl;dr: Orson Peters shares his experience optimizing an Advent of Code solution and demonstrates a technique for storing a small lookup table with small elements as a constant, indexed using shifts. A fascinating read for software engineers interested in optimizing code and learning new techniques.

Fixing The Next 10,000 Aliasing Bugs

By: polybdenum.com

tl;dr: The author presents three case studies of a common bug caused by violated invariants due to multiple aliased references to the same value. The article explores how these issues could inform future language design decisions and the emergence of alias types. Valuable insights for software engineers working with data and databases.

Which Web Frontend Architecture Fits Best?

By: Patrick Roos

tl;dr: Patrick Roos provides a guide for finding the right web frontend architecture that fits your specific quality goals and discusses various architecture styles and their rendering techniques. A great resource for software engineers working on web frontend projects.

My Hardest Bug Ever

By: Dave Baggett

tl;dr: Video game developer Dave Baggett shares his experience with the hardest bug he’s ever encountered and the process of debugging it. He spent 6 weeks debugging memory card code for Crash Bandicoot. A captivating read for software engineers interested in debugging challenges and game development.

RoomGPT

By: Nutlope

tl;dr: RoomGPT is an AI-powered tool that generates your dream room based on an uploaded photo. A fun and innovative project that demonstrates the potential of AI for software engineers and designers alike.

tl;dr in tech - Issue #82

Tue, 20 Jun 2023 00:00:00 GMT

ChatGPT Plugins: Build Your Own In Python!

By: James Briggs

tl;dr: OpenAI’s ChatGPT has launched plugins that anyone can build. James demonstrates how to create a plugin using the chatgpt-retrieval-plugin template, which could be useful for software engineers interested in building AI-powered chatbot features.

Code Ownership And Software Quality

By: Abi Noda

tl;dr: Abi Noda discusses how “Ownership is negatively correlated with the number of bugs, and the more shared the file ownership the higher the likelihood that it will contain code defects.” The post also explores how the number of contributors is positively correlated with the number of bugs, and provides 4 management recommendations for software engineers.

End of Year Pay Report 2022

By: Levels.fyi

tl;dr: Check out Levels.fyi’s annual compensation report to get a glimpse of top paying companies, locations, growing titles, and other trends for software engineers in 2022.

Twintrees, Baxter Permutations, and Floorplans

By: Donald Knuth

tl;dr: Donald Knuth’s annual lecture video connects “three fascinating concepts, which seem at first to be entirely unrelated to each other, but are in fact in one-to-one correspondence, via three beautiful algorithms.” For software engineers interested in algorithms, this is a must-watch!

Devpod: Improving Developer Productivity at Uber with Remote Development

By: Uber Engineering

tl;dr: Uber shares its experience in improving the daily edit-build-run developer experience using DevPods, their remote development environment. The blog covers initial challenges, pain points addressed, architecture, recent successes in terms of adoption and cost reduction, and thoughts about the future of remote development at Uber.

A Year Of Building For The Terminal

By: Darren Burns

tl;dr: Darren reviews a year of working on cool terminal and command line tooling projects. If you’re into terminals and command line tooling, you’ll likely find at least one thing of interest in this post!

Building A Website Like It’s 1999… In 2022

By: Sophie Koonin

tl;dr: Sophie Koonin reflects on the charm of personal websites from the 1990s and suggests that we’ve gone too far in the other direction with today’s sleek, minimalist sites. She argues that old personal websites were a true reflection of oneself, making this an interesting read for software engineers building their online presence.

How Might Generative AI Change Programming?

By: Laurence Tratt

tl;dr: Laurence dives into why he thinks Generative AI (GAI) in its current form is unlikely to fully replace programming. He explores the relationship between programming and software, how GAI differs from programming when generating software, and shares some thoughts on how ML techniques might influence programming in the future.

Comprehensive Rust

By: Google

tl;dr: Comprehensive Rust is a course used by the Android team at Google, and it’s a great resource for software engineers looking to learn Rust.

Clipboard

By: Slackadays

tl;dr: Clipboard allows you to cut, copy, and paste anything anywhere from the terminal, making it an extremely useful tool for software engineers working with command line interfaces.

Awesome ChatGPT Prompts

By: Fatih Erikli

tl;dr: This GitHub repository curates a collection of prompts to help you use ChatGPT more effectively. It’s a valuable resource for software engineers who want to get the most out of ChatGPT in their daily workflow.

Amazing AI Papers

By: Louisfb01

tl;dr: Discover the latest breakthroughs in AI research with this curated list of AI papers sorted by release date, accompanied by video explanations. This resource is perfect for software engineers and researchers interested in staying updated on cutting-edge AI developments.

tl;dr in tech - Issue #81

Tue, 13 Jun 2023 00:00:00 GMT

How To Store Your App’s Entire State In The URL

By: Scott Antipa

tl;dr: In this post, Scott Antipa discusses the benefits of storing an app’s entire state in the URL. By doing so, users can easily share and bookmark links, and have control over their data. Scott shares the steps he took to implement this feature in his app, including serializing the app state into a JSON object, encoding the JSON object in base64, and storing it in the URL. He also includes some tips and tricks for working with URL-based state, such as being mindful of URL length limits.

You Want Modules, Not Microservices

By: Ted Neward

tl;dr: Ted explores the concept of microservices, arguing that there’s a mismatch between what they promise and what they actually deliver. He suggests looking into modules instead.

Rust Is A Scalable Language

By: Alex Kladov

tl;dr: Alex highlights Rust’s vertical scalability, which allows for the creation of all kinds of software, and its horizontal scalability, which enables the easy parallelization of large software artifacts across multiple people and teams.

Logging Practices I Follow

By: Eliran Turgeman

tl;dr: Eliran shares his best practices for logging. He believes that logging is an essential part of software development, as it helps with debugging, performance monitoring, and providing insight into how users are interacting with the application. Eliran shares tips for what to log, how to log it, and how to avoid common pitfalls such as over-logging, logging sensitive information, or logging too little information. By following these practices, Eliran believes that developers can create more effective and efficient logging systems.

I Scanned Every Package On PyPi And Found 57 Live AWS Keys

By: Tom Forbes

tl;dr: Tom shares his experience of scanning PyPi to find live AWS keys. Tom built a tool that automatically scans all new PyPi releases to notify AWS of potentially leaked keys. He also shares some analysis of the keys he found and draws some conclusions at the end. Tom recommends that developers use services such as AWS IAM roles and AWS Secrets Manager to better manage their access keys.

Reverse Engineering TikTok’s VM Obfuscation (Part 1)

By: Ibiyemi Abiodun

tl;dr: Ibiyemi discusses his experience of reverse engineering TikTok’s VM obfuscation. The platform has implemented various methods to make it difficult for reverse-engineers to understand exactly what data is being collected and how it is being used. Ibiyemi analyzes the call stack of a request made on TikTok to begin to paint the picture of what data is being collected and how. This is part one of a multi-part series, and Ibiyemi plans to continue exploring this topic further.

8 Hard Truths I Learned When I Got Laid Off From My SWE Job

By: Steven Buccini

tl;dr: Steven shares eight hard truths he learned when he got laid off from his software engineering job. Steven explains that getting laid off is a profoundly lonely experience and that it can take longer than you think to find a new job. He also shares some tips on how to handle interview invites, offers for help, and honesty during the job search. Steven believes that getting laid off can be a valuable learning experience, and that you can learn more from getting laid off than you did at your job.

3D In CSS

By: Brad Woods

tl;dr: Sometimes a thing can be better communicated when shown from multiple perspectives. Brad explains how to use CSS to transform and rotate elements in 3D space to create engaging and informative visualizations.

OpenAI Cookbook

tl;dr: The OpenAI Cookbook provides examples and guides for using the OpenAI API, allowing developers to quickly and easily integrate cutting-edge AI technology into their applications.

PWL

tl;dr: Papers We Love is a collection of papers from the CS community to read and discuss, covering a wide range of topics and providing valuable insights and knowledge.

tl;dr in tech - Issue #80

Tue, 06 Jun 2023 00:00:00 GMT

Evaluating Managers: 5 Heuristics To Measure Managerial Impact

By: AbdulFattah Popoola

tl;dr: Managers have a significant impact on the success of any project. This blog post explores five heuristics to measure managerial impact: execution, people management, team development, strategic vision & organizational influence.

Directly Responsible Individuals

By: Unknown

tl;dr: GitLab assigns a “Directly Responsible Individual” (DRI) to every project to ensure accountability for its success or failure. This article highlights the characteristics of DRIs, such as being detail-oriented, calm under pressure, and skilled at asking questions.

Postgres: The Graph Database You Didn’t Know You Had

By: Dylan Paulus

tl;dr: Dylan demonstrates how to store and query graph data structures in Postgres, discussing how he used this approach to dynamically generate work instructions on a manufacturing line. Postgres can be used to generate documents based on parameters and rules defined on each edge.

Our Cloud Spend In 2022

By: Fernando Álvarez

tl;dr: “Getting this massive spend down to just $3.2 million has taken a ton of work. The ops team runs a vigilant cost-inspection program, with monthly reporting and tracking, and we’ve entered into long-term agreements on Reserved Instances and committed usage, as part of a Private Pricing Agreement. This is a highly-optimized budget.”

The Zen Of Proverbs

By: Lane Wagner

tl;dr: This blog post provides 20 rules of thumb for writing better software, such as “optimize for simplicity first” and “reading is more important than writing.” One of the most important lessons is that code should be written for humans, not computers.

Writing A Python SQL Engine From Scratch

By: Toby Mao

tl;dr: In this post, Toby Mao takes us through the process of building a Python SQL engine from scratch. He covers the steps of tokenizing, parsing, optimizing, planning, and executing, and provides a detailed explanation of each step.

State Of JS 2022

By: Sacha Greif, Eric Burel, Sarah Drasner

tl;dr: The State of JS 2022 report highlights continued innovation in performance, reactivity, and hydration. It discusses how Svelte has focused on simplicity in developer ergonomics, while Solid and Qwik have explored new approaches to reactivity.

AI Collection

tl;dr: This Github repository is a collection of generative AI applications that can help developers to explore new ways of utilizing AI. From language models to image generation, there are a variety of applications available for developers to experiment with.

Crane: Uber’s Next-Gen Infrastructure Stack

tl;dr: Uber has been on a journey to reimagine their infrastructure stack for a hybrid, multi-cloud world. In this post, they discuss the requirements they needed to satisfy, the motivation behind Crane, and key features of their implementation.

How eBay’s Notification Platform Used Fault Injection In New Ways

By: Wei Chen

tl;dr: eBay has used fault injection in new ways to improve their notification platform. They have achieved this by injecting faults through simulation in the application level by code instrumentation, a practice which they believe to be an industry first.

The Art Of Command Line

tl;dr: The command line is an often-neglected skill but can improve your flexibility and productivity as an engineer in both obvious and subtle ways. This Github repository provides a selection of notes and tips on using the command-line that can be helpful for both new and experienced

tl;dr in tech - Issue #79

Tue, 30 May 2023 00:00:00 GMT

Ordering Numbers, How Hard Can It Be?

By: Orson Peters

tl;dr: Ordering numbers may seem like an easy task, but it can be quite challenging. Even with explicit instructions and guidelines, it is difficult to get it right on the first try. The Python standard library even states that “comparison is pretty much a nightmare.” As software engineers, it’s important to understand the complexity of seemingly simple tasks and the potential challenges they can present.

Contracts You Should Never Sign

By: Vadim Kravcenko

tl;dr: As a software engineer, there are certain contracts you should avoid signing. These include non-compete clauses in employee contracts, confidentiality agreements, exclusive distribution agreements, and project-based agreements without a clear definition of scope and definition of done. It’s important to understand the terms and conditions of any contract before signing it, and to be aware of potential red flags that could negatively impact your career.

What We Look For In A Resume

By: Chip Huyen

tl;dr: When reviewing software engineering resumes, it’s important to look for demonstrated expertise, initiative and persistence, unique perspectives, and impact rather than meaningless metrics. As a hiring manager, it’s important to understand that keywords don’t necessarily indicate expertise, and to look for evidence of successful projects and meaningful contributions.

30-60 Days In A New Leadership Role: Run Experiments For Change

By: Lara Hogan

tl;dr: When starting a new leadership role, it’s important to run experiments to gather data and make informed decisions. However, it’s important to limit the number of experiments to avoid overwhelming employees, and to limit the timeline to 2-3 weeks. It’s also important to develop a communication plan and prepare to share the results of the experiments with the team.

Cursor

By: Unknown

tl;dr: Cursor is an editor specifically designed for programming with AI. It could be an interesting tool for software engineers who want to experiment with AI-assisted coding and streamline their development process.

Diagram Layout Engines: Minimizing Hierarchical Edge Crossings

By: Júlio César Batista

tl;dr: TALA is a new layout engine designed for software architecture that combines various graph visualization algorithms to produce aesthetic diagrams. In this article, the author discusses the inner workings of TALA and how it minimizes edge crossings in hierarchical layouts. As software engineers, it’s important to stay up to date on new tools and technologies that can improve our work and productivity.

A Charming Algorithm for Count-Distinct

By: Justin Jaffray

tl;dr: Count-distinct is a common problem in software engineering, and this article presents a charming algorithm to estimate the number of distinct elements in a stream. As software engineers, it’s important to understand and utilize various algorithms to optimize our code and improve performance.

Accelerating Our A/B Experiments With Machine Learning

By: Michael Wilson

tl;dr: Dropbox uses A/B experiments to compare product versions and understand what works best for their users. However, analyzing these experiments can be complex, especially for a subscription-based model. This article discusses how Dropbox uses machine learning to accelerate their A/B experiments and improve

tl;dr in tech - Issue #78

Tue, 23 May 2023 00:00:00 GMT

Removing Uncertainty: The Tip Of The Iceberg

By: James Stanier

tl;dr: James advises that when facing a huge, challenging project, align your team around reducing uncertainty. Focus on the most uncertain parts, get answers proving it’s possible or finding another path, and repeat the process. This approach builds momentum and trust within and outside the team. ❄️🧊

How DoorDash Designed A Successful Write-Heavy Scalable And Reliable Inventory Platform

By: Chuanpin Zhu, Debalin Das

tl;dr: DoorDash’s move into the Convenience and Grocery business posed a huge inventory management problem. The team built a write-heavy inventory platform to handle the scale, and this article outlines the challenges and solutions they discovered through iterations of experimentation and analysis. 🚪🛒

Developer With ADHD? You’re Not Alone

By: Eira May

tl;dr: Eira explores the possible connection between programming and ADHD, discussing the importance of neurodiversity among teams. Embrace your unique mind! 🧠🌈

What Complex Systems Can Teach Us About Building Software

By: Kevin Sookocheff

tl;dr: Kevin Sookocheff suggests three key strategies for building successful complex software systems: (1) define and enforce quality architecture principles, (2) develop information aggregation systems for monitoring compliance, and (3) encourage experimentation and diversity in team building and software development. A thought-provoking read for software engineers.

Database Sharding Explained

By: Mahdi Yusuf

tl;dr: Mahdi Yusuf delves into database sharding, discussing when to use it, how to set it up, why we shard data stores, and various alternatives to sharding. This article is essential for software engineers working with databases and looking to optimize performance.

Common Pitfalls Of GitHub Actions

By: Ashish Bhatia

tl;dr: Ashish Bhatia critiques GitHub’s Actions template, pointing out its lack of dependency caching, cancelation of stale executions, path filtering, and timeouts. He also provides solutions for each issue. Software engineers working with GitHub Actions should take note of these potential pitfalls and suggested improvements.

PSQL Tips

tl;dr: Feast your eyes on 43 psql tips, like using the -c flag for single line commands, combining multiple -c flags, and displaying results as a CSV file with the —csv flag. PostgreSQL game strong! 💪

My Favourite 3 Lines Of CSS

By: Andy Bell

tl;dr: Andy shares his favorite CSS Custom Properties, revealing their power and versatility. Impress your friends with your CSS wizardry! 🧙‍♂️

Squeezing A Sokoban Game Into 10 Lines Of Code

By: Cole Kurashige

tl;dr: Cole shares his fun journey of code golfing a Sokoban game into 10 lines of code. Although it’s a frivolous endeavor, it showcases creativity and perseverance in problem-solving. Game on! 🕹️

That’s it for this week, my friends! Keep learning, stay curious, and remember to enjoy the ride. See you next time! 🎉

tl;dr in tech - Issue #77

Tue, 16 May 2023 00:00:00 GMT

Setting Engineering Org Values

Will Larson

tl;dr: Will tackles the great engineering org value debate like a pro, answering the big questions and sharing his secrets to success. Discover how to create a values-based engineering team that’s more powerful than a mustang in full gallop! 🐴

Corporate Legibility for Software Engineers

Matt Blewitt

tl;dr: “Corporate legibility is the art of making tasks, and their outcomes, easier to understand for those not directly involved.” Matt shows you how to become a corporate legibility master and boost your career faster than a tumbleweed in a windstorm. 🌪️

Start Coding At The Point Of Least Certainty

Swizec Teller

tl;dr: Swizec reminds us that “you know you can get a monkey” but challenges us to think about whether we can “train the monkey to jump through the hoop?” Don’t just code the easy parts, partners - tackle the tough stuff head-on! 🐒

Numbers To Know For Managing (Software Teams)

By: Unknown

tl;dr: The authors provide a list of numbers for managing software teams, covering topics like minimum number of direct reports, candidates to interview before deciding, days before a new hire should merge a pull request, and days before a small support issue becomes a large one. These insights may help software engineers better understand team management.

Pull The Andon Cord

By: Taylor Pearson

tl;dr: Taylor Pearson discusses Toyota’s Andon Cord, which could halt the assembly line when pulled by a worker who spotted an issue. The worker then had to propose a solution. This process had two benefits: (1) it made workers feel trusted and involved, and (2) it increased quality by tapping into workers’ tacit knowledge. A valuable lesson for software engineers on empowering team members.

Automating Safe, Hands-Off Deployments

By: Clare Liguori

tl;dr: Clare Liguori outlines the steps a code change goes through in an Amazon pipeline on its way to production, detailing the four major phases: source, build, test, and production. This article offers software engineers valuable insights into continuous delivery pipelines and how a typical AWS service team might set one up.

Tag Systems

Daniel Stenberg

tl;dr: Daniel throws caution to the wind and shares his “non-comprehensive, poorly-researched thoughts on tag systems.” It’s like a wild west saloon chat about tag systems without worrying about the nitty-gritty. 🍻

Python’s “Disappointing” Superpowers

Luke Plant

tl;dr: Luke laments the potential loss of Python’s dynamic features, fearing a future where Python is just another C# or Java. Don’t let Python’s superpowers go to waste, folks! 💥

Rust’s Ugly Syntax

Alex Kladov

tl;dr: Alex boldly claims that “most of the time when people think they have an issue with Rust’s syntax, they actually object to Rust’s semantics.” Dive into this mind-bending exploration of syntax vs. semantics and emerge a Rust aficionado. 🦀

Various Ways Of Sending Mail Via SMTP

Charles Ulrich

tl;dr: Charles proves that SMTP ain’t all that bad, showing us how to send emails with minimal fuss. It’s like having your own personal Pony Express rider delivering your messages! 💌

tl;dr in tech - Issue #76

Tue, 09 May 2023 00:00:00 GMT

Cynefin For Developers

By: Liz Keogh

tl;dr: Liz Keogh introduces the Cynefin framework, which categorizes problems into 4 domains (obvious, complicated, complex, and chaotic) and a fifth domain, disorder, for unclear situations. Software engineers can use this framework to better understand and approach problem-solving.

ICER Image Compression Algorithm

By: Unknown

tl;dr: This GitHub repository offers a C library implementation of NASA’s ICER image compression algorithm. ICER is a progressive, wavelet-based algorithm designed for data loss resistance, making it suitable for encoding images transmitted over unreliable channels like satellite radio communications. A valuable resource for software engineers working with image compression or communication systems.

Demand And ETR Forecasting At Airports

By: Uber Engineering

tl;dr: Uber’s engineering team tackles the challenge of balancing supply and demand at airports by building new models for demand forecasting and effective queue length on the Michelangelo platform. They integrate these models with the Driver app to optimize resource allocation. A fascinating read for software engineers interested in demand prediction and resource management.

GitHub Copilot X: The AI-Powered Developer Experience

By: Thomas Dohmke

tl;dr: Thomas Dohmke introduces the evolution of GitHub Copilot into an AI assistant with chat and voice capabilities. Copilot will also be integrated into pull requests, the command line, and docs to answer questions about your projects. A must-read for software engineers excited about AI-enhanced development experiences.

Building A Great Relationship With Your Boss

By: Paulo André

tl;dr: Paulo says, “If I could pick one skill, and one skill only, this would be it,” emphasizing the importance of understanding your manager’s challenges and needs. So go ahead, learn to read your boss’s mind (or just ask them questions).

Uptime, Status Pages, And Transparency Calculus

By: Lawrence Jones

tl;dr: Lawrence believes that transparent communication in past incidents is more valuable than just focusing on uptime. Let’s face it, incidents happen, so let’s be honest about them and work together for a brighter future. 🌤️

Cleaner Unit Tests With Custom Matchers

By: Jamie King

tl;dr: Jamie reminds us that “using custom matchers in your tests can help make your assertions cleaner and less ambiguous.” Level up your unit testing game and make your code shine like a diamond. 💎

I’m Now A Full-Time Professional Open Source Maintainer

By: Filippo Valsorda

tl;dr: Filippo shares his journey to becoming a full-time open source maintainer, earning an income competitive with senior software engineers. Although he’s not ready to recommend everyone follow suit, he hopes his story can inspire and inform others. 🚀

Reversing UK Mobile Rail Tickets

By: Anonymous

tl;dr: Ever wondered what’s inside your mobile rail ticket’s barcode? This author delves into the data and discovers that it can reveal a surprising amount of detailed tracking info about your train travels. 🚂

Asynchronous Computing At Meta: Overview And Learnings

By: Sayak Kundu, Artem Denisov

tl;dr: The Meta team has built a platform for serverless asynchronous computing that provides a wide range of capabilities, including load balancing, rate limiting, and quota management. Learn how they make async computing as easy as pie. 🥧

SQL Should Be Your Default Choice For Data Engineering Pipelines

By: Robin Linacre

tl;dr: Robin argues that “SQL should be the first option considered for new data engineering work.” With its robustness, speed, and readability, SQL is the go-to choice for data pipelines, whether they’re big or small. 🗃️

That’s it for this week! Keep learning, stay curious, and don’t forget to have fun. See you next time! 🎈

tl;dr in tech - Issue #75

Tue, 02 May 2023 00:00:00 GMT

Welcome back to your favorite weekly newsletter, where we dish out the latest, greatest, and sometimes weirdest happenings in the world of software engineering. Let’s dive right in! 🏊‍♂️

Real-time Databases: What developers need to know

By: Joe Karlsson

I just published my first blog post on the Tinybird blog, where I talk about the benefits and challenges of real-time databases!

tl;dr: Real-time databases process and analyze data as it is generated, providing businesses with real-time insights that can inform decision-making. However, these databases can also pose scalability and consistency challenges. To choose the right real-time database, developers need to consider factors such as the volume of data, desired latency, and level of consistency required.

Being Right Doesn’t Matter

By: Roy Rapoport

tl;dr: Roy emphasizes that being right isn’t enough; you must also be effective in persuading others that you’re right. “There’s no partial credit for ‘I was right, but nobody listened to me.’” This is a critical lesson for software engineers who want to be influential leaders.

The Ambiguous Zone

By: Ben Northrop

tl;dr: Ben Northrop discusses the ambiguous zone that lies between following specs and using your own judgment as an engineer. Effective developers navigate this zone with curiosity, asking good questions and tactfully pushing back when things don’t make sense. A must-read for engineers looking to improve their decision-making skills.

Is There A Drop In Software Engineer Job Openings, Globally?

By: Gergely Orosz

tl;dr: Gergely Orosz investigates data from Indeed and Hacker News, concluding that (1) there was a peak in software developer job postings between mid-2021 and mid-2022, (2) the US, Canada, and UK currently have some of the lowest numbers of developer job listings since Feb 2020, and (3) Germany, France, and Australia still have significantly more jobs than in February 2020. An insightful analysis for software engineers monitoring the job market.

Real-world Engineering Challenges #8: Breaking Up A Monolith

By: Gergely Orosz

tl;dr: Dive into the massive migration project by Khan Academy, where they moved a whopping one million lines of Python code across more than 40 services (mostly in Go) over 3.5 years. Talk about a break-up! 💔

Focus

By: Andrew Bosworth

tl;dr: Andrew, the CTO at Meta, reminisces about the good ol’ days of intense focus, where resources and time were so tight that you just knew the thing you were doing was the most important thing. Stay sharp, engineers! 🎯

The Technology Behind GitHub’s New Code Search

By: Timothy Clem

tl;dr: Timothy reveals GitHub’s motivation for building their own code search solution, fueled by the vision of a new user experience, understanding that code search is different from text search, and the challenge of GitHub’s massive scale. 🕵️‍♀️

By: Charlie Andrews

tl;dr: To reach the next level in your engineering skills, Charlie suggests adding new “minigames” to your arsenal and improving existing ones with shorter feedback cycles. Time to level up! 📈

Password Strength Explained

By: Wladimir Palant

tl;dr: Wladimir delves into the complexities of password strength and helps clarify what makes a password strong (and when strong is strong enough). Time to rethink your “12345” password! 🔐

Why Does 0.1 + 0.2 = 0.30000000000000004?

By: Julia Evans

tl;dr: Julia demystifies the peculiarities of floating point addition by explaining how it works and why 0.1 + 0.2 equals that pesky 0.30000000000000004. It’s a mathematical adventure! 🧮

Magical Fibonacci Formulae

By: Orson Peters

tl;dr: Orson unravels the magic behind the simple expression x/(1−x−x2) that contains the entire Fibonacci sequence. Prepare to be amazed! 🪄

That’s all for this week, folks! Stay curious, keep coding, and see you next week for another round of coding adventures. 🚀

tl;dr in tech - Issue #74

Tue, 25 Apr 2023 00:00:00 GMT

Hey there 😎 Welcome back to another weekly newsletter, packed with juicy knowledge nuggets and served with a side of humor. This week, we’re diving into database cryptography, executive networking, mushroom computers, and more.

Database Cryptography Fur The Rest Of Us - Soatok Dreamseeker

tl;dr: This pawsitively awesome 🐾 article defines database cryptography and explains how it manifests in both relational and NoSQL databases. It also explores searchable encryption and offers a case study of MongoDB’s Client-Side encryption. Perfect for when you need to keep your data purrivate. 🐈‍⬛

Inside The Lab That’s Growing Mushroom Computers - Charlotte Hu

tl;dr: This fungi-tastic article takes us inside the lab where mushroom computers are a thing. Researchers are using mycelium to create binary systems, gates, and even memory. Who knew shrooms could be so brainy? 🍄💡

Introducing Service Weaver: A Framework For Writing Distributed Applications - Srdjan Petrovic, Garv Sawhney

tl;dr: Google’s engineering team brings us Service Weaver, an open-source framework for building and deploying distributed applications. Write your app as a modular monolith and deploy it as a set of microservices - like a code transformer! 🤖

No-Code Has No Future In A World Of AI - Ravi Parikh

tl;dr: Ravi Parikh, CEO of Airplane, takes a flight of fancy ✈️ by discussing how AI-driven software development will dwarf no-code tools’ capabilities and eventually make no-code go the way of the dodo. Sorry, no-code enthusiasts, looks like AI is taking the pilot’s seat!

Zig And Rust

By: Alex Kladov

tl;dr: Alex Kladov, who has spent seven years working with Rust, now writes Zig full-time. In this post, he shares his personal reasons for the switch. A captivating read for software engineers curious about the Rust-Zig dynamic.

Web Stable Diffusion

By: Unknown

tl;dr: This GitHub repository features a web-based implementation of the stable diffusion algorithm that runs entirely inside the browser with no server support

Move Past Incident Response To Reliability

tl;dr: This guide will help you (1) understand the current standard for incident response and analysis, (2) identify where some teams get themselves in trouble with the current standard, and (3) find your own path through the innovation and dogma of leading a company’s approach to reliability. Sounds reliable, doesn’t it? 😉

How To Contribute To A Project You Have No Idea About - Michal Warda

tl;dr: In this article, Michal outlines a 5-step process for contributing to a project, even when you’re clueless. It’s a great reminder that you don’t need to know everything to make an impact - just dive in, learn as you go, and make the codebase a better place for everyone. 🏊‍♂️

Building Your Executive Network - Will Larson

tl;dr: Will shares tactics for engineers to build their executive network, emphasizing the importance of cultivating relationships before you need them. Set a small goal like meeting one new person each month - it’s like networking on easy mode! 🎮

That’s all for this week, folks! Stay curious and keep coding. Until next week.

tl;dr in tech is emailed once a week on Tuesdays @ noon CST.

tl;dr in tech - Issue #73

Tue, 18 Apr 2023 00:00:00 GMT

How to Get Started with Home Assistant in 2023 🏡 - Joe Karlsson

tl;dr: I’ve got you covered with a beginner’s guide to Home Assistant in 2023. Say goodbye to chaos and hello to smart home automation bliss. Get the lowdown on installation, configuration, and integration with other devices. Your home just got a whole lot smarter! 🤖🏠

Code With Swearing Is Better Code 😈 - Jamie Zawinski

tl;dr: You heard it here first, folks! Swearing in your code actually improves its quality. Who knew?! Next time your manager tells you to keep it clean, just remind them that a little profanity goes a long way in achieving programming excellence. 💩💻

5 Tips To Creating A (Good) Pull Request 🚀 - Danijela Vrzan

tl;dr: The secret sauce to a perfect pull request is short and sweet. Add details, screenshots, and in-line comments. Assign reviewers, and tell your teammates it’s ready. Boom! PR magic. 🧙‍♀️

What Is ChatGPT Doing… and Why Does It Work? 🤖 - Stephen Wolfram

tl;dr: ChatGPT is all the rage, but how the heck does it work? Stephen Wolfram breaks down the magic behind this AI wizard, without diving too deep into the engineering weeds. Great news for all you non-engineer readers out there! 🧪

10 Web Development Trends In 2023 🌐 - Robin Wieruch

tl;dr: What’s hot in web dev? Meta frameworks, application and rendering patterns, serverless at the edge, database renaissance, and JavaScript runtimes, to name a few. Stay ahead of the curve, and hop on these trends like a champ! 🏄‍♂️

Against Overwhelm 😌 - Paolo André

tl;dr: Engineering managers, are you drowning and feeling overwhelmed? Take a deep breath and follow Paolo’s advice on setting goals, auditing your energy, focusing on leverage, designing your ideal week, and giving each task your full attention. Zen out, my friends! 🧘‍♀️

Content Delivery Network (CDN): Explained In Simple Words 🌍 - Animesh Gaitonde

tl;dr: CDN, WTF? Animesh gives you the lowdown on what a CDN is, why it’s necessary, and how it makes your website as speedy as a cheetah. 🐆

Big Data Is Dead 💀 - Jordan Tigani

tl;dr: RIP, Big Data. It’s time to stop worrying about data size and start focusing on how we can use it to make better decisions. Don’t let the hand-drawn graphs fool you - this post is legit. 📉

🌟 Cool GitHub Repos

AI Commits - A CLI that writes your git commit messages for you with AI. Never write a commit message again.
Pandas - The Pandas library is a must-have for any data enthusiast. It provides high-performance, easy-to-use data structures and data analysis tools for Python. Think of it as Excel on steroids! 🐼
Apache Arrow - Apache Arrow is a cross-language development platform for in-memory data. It provides a standard way to represent and manipulate data in different languages and accelerates analytical processing by minimizing data serialization and deserialization.

tl;dr in tech is emailed once a week on Tuesdays @ noon CST.

tl;dr in tech - Issue #72

Tue, 11 Apr 2023 00:00:00 GMT

It’s time for another episode of “tl;dr in tech”! Get ready for a wild ride through the world of software engineering, where we’ll dive into some hilariously helpful articles that you definitely don’t want to miss. So, grab your favorite caffeinated beverage, and let’s get this party started! 🎉

- Joe Karlsson [joekarlsson.com, @JoeKarlsson1]

🚀 Developer Advocacy in 2023 - Joe Karlsson

tl;dr: Techpocalypse, anyone? 🌋 I’ve got the lowdown on how developer advocacy can adapt and survive in these tumultuous times. Get ready for some serious internal collaboration, ROI magic, and proving that DevRel is more than just nerdy hype-machines.

🚫 Retrospectives Antipatterns - Aino Corry

tl;dr: Are your retrospectives more like retro-spectacles? 😅 Aino tackles common pitfalls that can make these meetings a total drag. Remember, folks: don’t skip on insights, avoid wallowing in the unchangeable, and don’t let loudmouths steal the show.

🍯 How We Manage Incident Response At Honeycomb - Fred Herbert

tl;dr: Fred dishes on the sweet, sweet nectar of incident response at Honeycomb 🐝. Get the buzz on managing unknowns, cognitive bandwidth, coordination, psychological safety, and feeding info back into your organization. Don’t let incidents sting you! 🐝

🎨 The Art Of Knowing When To Quit - Jim Nielsen

tl;dr: It ain’t quittin’ time yet, but Jim shows us how there’s a fine art to knowing when to say “I’m done” in software engineering. Sometimes, being done is the best thing you can do! So, remember to draw the line, folks. 🖌️

📱 Image Stacks And iPhone Racks - Building An Internet Scale Meme Search Engine - Matthew Bryant

tl;dr: Are you tired of losing your meme game mid-conversation? 😢 Matthew was too, so he built an internet-scale meme search engine! This article is a meme-tastic journey into the world of niche humor and finding the perfect meme to send to your buddies. 😂

🏗️ Writing Javascript Without A Build System - Julia Evans

tl;dr: Julia is kicking it old-school with JavaScript sans build systems. 🕺 Who needs ‘em, anyway? Learn why some folks like Julia are still rocking simple, small projects without the extra baggage. Less is sometimes more! 💼

🌐 A Gentle Introduction To CRDTs

tl;dr: Get a gentle intro to these magical data structures that guarantee eventual consistency across your networked applications. It’s like a warm hug from your favorite distributed system. 🤗

🎥 React.js: The Documentary

tl;dr: Grab some popcorn and join us for React.js: The Documentary 🍿. Learn the untold story of React’s early days, featuring an all-star cast of developers who brought this groundbreaking library to the masses.

🌟 Cool GitHub Repos

DVC - Data Version Control: Think Git, but for data and ML projects! Manage your data, models, and experiments with ease.
streamlit - Create beautiful, interactive web apps for machine learning and data science with just a few lines of Python code.
fastAPI - A modern, high-performance web framework for building APIs with Python 3.7+ based on standard Python type hints.

tl;dr in tech is emailed once a week on Tuesdays @ noon CST.

tl;dr in tech - Issue #71

Tue, 04 Apr 2023 00:00:00 GMT

Hey there, software engineering pals! 🤓

Welcome to this week’s edition of tl;dr in tech! Buckle up, grab a cup of coffee (or tea, we don’t judge), and let’s dive into this week’s smorgasbord of code content.

- Joe Karlsson [joekarlsson.com, @JoeKarlsson1]

📚 Treat Content Development for Your Open Source Project Like Your Open Source Project - Joe Karlsson

tl;dr: Content development is crucial for your open source project, so get your community involved! Gather feedback on what they want, be transparent about your content timeline, and let them contribute like they do with code. It’s a win-win: you get great content and your community feels valued. 🤝

Now, go forth and create some awesome content! 🤓

🏗️ Let It Fail - Max Countryman

tl;dr: Max shows us the beauty of letting things go kaput. Sometimes, we gotta let a situation implode to find the real gold underneath. Don’t just put a Band-Aid on it; embrace the chaos and watch your business flourish! 🚀

When life gives you lemons, make lemonade… or let them rot and make some sweet lemonade later? 🍋

🧹 The 25 Percent Rule For Tackling Technical Debt - John DeWyze

tl;dr: Shopify’s got a tidy little secret for keeping their codebase in check: 25% of their time goes toward paying off that pesky tech debt. Divide and conquer, friends! 10% for daily debt, 10% for weekly debt, and 5% for the big, scary, future debt. ⏰

You can run, but you can’t hide from technical debt! 🏃‍♂️

🧪 Testing Practices I Follow - Eliran Turgeman

tl;dr: Eliran shares his testing practices, and let’s be honest, they’re probably not gonna blow your mind. But for you testing newbies out there, it’s a great primer! And, hey, even seasoned devs might learn a thing or two. 🧐

🔍 Improve Your Debugging By Asking Broad Questions - Hillel Wayne

tl;dr: Hillel Wayne thinks we need to think big when it comes to debugging. Quit asking those narrow questions and start with broader ones! You might not learn as much from a “yes,” but you’ll get a lot more out of a “no.” 💡

Narrow questions are so last year. It’s time to go wide! 🌐

😤 Software And Its Discontents, Part 1 - Kellan Elliott-McCrea

tl;dr: Why are we all so grumpy? Kellan dives into the world of software engineering woes, from exploding complexity to talent prices soaring higher than a SpaceX rocket. We’ve lost that loving feeling, but maybe it’s time for a change? 🌈

Discontent? In tech? It’s more likely than you think. 😏

🕵️ Reverse Engineering A Mysterious UDP Stream In My Hotel - Gokberk Yaltiraklileo

tl;dr: Gokberk’s curiosity led him to discover a mysterious UDP stream at his hotel, and we’re all invited to tag along for the ride. From smart TVs to Wireshark, let’s snoop around and see what we can uncover! 🔍

Secret hotel streams? Now that’s what I call a vacation! 🏨

🌟 Cool GitHub Repos

Faker - A Python library for creating fake data. Perfect for generating test data, anonymizing databases, or just having fun with some creative nonsense! 🎭
Hugging Face Transformers - State-of-the-art Natural Language Processing for TensorFlow 2.0 and PyTorch. Write, train, and deploy transformers models with ease. 🤖

tl;dr in tech is emailed once a week on Tuesdays @ noon CST.

tl;dr in tech - Issue #70

Tue, 28 Mar 2023 00:00:00 GMT

Welcome back to my weekly newsletter, where I bring you the latest and greatest insights to keep your software engineering game strong. This week, I’m shining the spotlight on the data and database space, as we unravel some trends that are defining the landscape in 2023. So, let’s dive in and see what’s shaping the future of data management! 💾

Automated data management: AI and machine learning are revolutionizing database management. Expect to see more automation in tasks such as indexing, tuning, and schema optimization, as intelligent systems learn to optimize databases with minimal human intervention.
Real-time data processing: With the rapid increase in data generation, real-time data processing is becoming a necessity. Stream processing technologies, such as Apache Kafka and Flink, are gaining momentum as they enable organizations to analyze and act upon data as it’s generated, providing a competitive edge.
Multi-model databases: Versatility is the name of the game in 2023, and multi-model databases are leading the charge. These powerhouses support various data models within a single, integrated backend, making it easier than ever to manage diverse data types and sources.
Data mesh architecture: As data silos become a thing of the past, data mesh architecture is gaining popularity. This approach emphasizes decentralized, domain-oriented data ownership and product thinking. By treating data as a product, organizations can enable cross-functional collaboration, improve data discoverability, and drive innovation.

Measuring An Engineering Organization
- Will Larson
tl;dr: “There is no one solution to engineering measurement, rather there are many modes of engineering measurement, each of which is appropriate for a given scenario. Becoming an effective engineering executive is adding more approaches to your toolkit and remaining flexible about which to deploy for any given request.” Will provides a template to work off of.

The Worst-Selling Microsoft Software Product Of All Time: OS/2 For The Mach 20
- Raymond Chen

tl;dr: “Because I’m not here to ridicule the lackluster sales of the Mach 20 hardware. I’m here to ridicule the lackluster sales of the Mach 20 software… That leaves three customers who purchased a copy and didn’t return it. And the support specialist had personally spoken with two of them.”

Which Meetings Should You Kill?
- Camille Fournier
tl;dr: “I fear that the culprit is a surprising new factor, one that started before the pandemic but has gotten even more out of hand in the world of remote work: 1:1s.” Camille discusses how group discussion topics have turned into 1:1 topics in the remote work era.

A Guide To Fixing Developer Posture
- Gayle Laakmann McDowell

tl;dr: “This post is about anterior pelvic tilt, the most common posture dysfunction… How do you know if you have an anterior pelvic tilt? Look at your belt. If you belt points towards the floor, you have an anterior pelvic tilt. Or, look sideways in the mirror. does your butt stick out? Chances are that you have an anterior pelvic tilt. I’m gonna break bad posture in 2 sections, lower body and upper body. The lower body influences the upper body, but upper body doesn’t always influence the lower body.”

There Is No Secure Software Supply-Chain
- John McBride
tl;dr: “The security of open source software is under threat and we’re running out of people to reliably maintain those projects. And as our stacks get deeper, our dependencies become more interlinked, leading to terrifying compromises in the secure software supply-chain. For a perfect example of what’s happening in the open source world right now, we don’t need to look much further than the extremely popular Gorilla toolkit for Go.”

Microfeatures I’d Like To See In More Languages
- Hillel Wayne
tl;dr: “Since I spend a lot of time in niche obscure languages, I also encounter a lot of cool QoL features that most people might not have seen before. Here’s a few of them!” Hillel discusses:

Number representations.
Balanced string literals.
Generalized update syntax.
The Chapel power hour. And more.

How GPT3 Works - Visualizations And Animations
- Jay Alammar

tl;dr: “The dataset of 300 billion tokens of text is used to generate training examples for the model. For example, these are three training examples generated from the one sentence at the top. You can see how you can slide a window across all the text and make lots of examples.”

tl;dr in tech - Issue #69

Tue, 07 Mar 2023 00:00:00 GMT

Ahoy, mateys! Avast ye and hoist the mainsail, because we’re setting course for uncharted digital waters. Here are three tips to help you build a site that’ll shiver the timbers of even the toughest recruiters:

Keep it simple: No need to hoard all the gold and silver doubloons in your portfolio. Keep things streamlined and easy to navigate, just like the sleek lines of a well-crafted vessel.
Highlight your strengths: Just like a captain boasting of their voyages, make sure to showcase your most impressive projects and accomplishments. It’ll make you stand out in a sea of bland resumes and profiles.
Show off your personality: Aye, there be no need to be a dry landlubber! Let your unique voice and character shine through on your site, whether it be through witty quips or clever design.

So, polish your eyepatches and hoist your colors high, because with these tips, you’ll be well on your way to a top-notch portfolio website!

HTTP/3 Prioritization Demystified
- Robin Marx
tl;dr: “What exactly does prioritization mean? How does it work under the hood? Why is it important to have some control over it? and, crucially, do all browsers agree on which resources are most important?”

Overcoming The Resistance
- Paulo André

tl;dr: Paolo discusses hesitating due to one’s imposter syndrome: “How can we create the conditions to just start? How can we feel the fear… and do it anyway?”

Create a process… and then trust in it.
Use the Procrastination Pomodoro.
80% is good enough.
Feed your own feedback loop.
Don’t seek to make the right decision. Make the decision right.

Animated terminal typing out a let statement

What If Writing Tests Was A Joyful Experience?
- James Somers
tl;dr: “At Jane Street we use a pattern / library called “expect tests” that makes test-writing feel like a REPL session, or like exploratory programming in a Jupyter notebook - with feedback cycles so fast and joyful that it feels almost tactile. Having used them for some time now this is the only way I’d ever want to write tests.”

McDonald’s Event-Driven Architecture: The Data Journey And How It Works
- Vamshi Krishna Komuravalli, Damian Sullivan

tl;dr: Here is a typical data flow of how events are reliably produced and consumed from the platform:

Initially, an event schema is defined and registered in the schema registry.
Applications that need to produce events leverage producer SDK to publish events.
When an application starts up, an event schema is cached in the producing application for high performance. The authors continue to discuss how data flows through the system.

Architecture Diagrams Should Be Code
- Brian McKenna

tl;dr: “Architecture code can be versioned with the code which implements it. We can write algorithms to check our architecture. I’d like to see more tools available to describe architecture as part of code, allowing us to generate as many diagrams as we want, for accurate and easy communication.”

Data Engineering Zoomcamp
Free Data Engineering course.

What Happens When A CPU Starts

tl;dr: “Generally, when a CPU chip first receives power, it must be reset by receiving a pulse on its RESET (or RST) pin. This is because when the power supply is first powering up, even if it only takes a second or two, the CPU has already received “dirty” power, because the power supply was building up a steady stream of electricity.”

The Ugliest Pattern In React
- Sebastian Carlos
tl;dr: “Maybe the ugliness is a virtue, since it encourages us to completely change the code to enable some of the better alternatives mentioned above - After all, “adjusting state in response to rendering” will always result in code that’s difficult to understand.”

tl;dr in tech - Issue #68

Tue, 28 Feb 2023 00:00:00 GMT

Ahoy, fellow software pirates! As the tech industry continues to evolve, it’s important to consider the benefits of unionizing to protect our collective power and work towards a more ethical future. Here are three potential reasons why unionizing in tech is important:

Protecting worker rights: Unionizing provides software engineers with a collective voice to advocate for their rights and interests. This can include better pay, benefits, and working conditions. A 2018 survey by the Communications Workers of America (CWA) found that 74% of tech workers would be interested in joining a union to improve their working conditions.
Building more ethical products: Unions can help push for more ethical product development by advocating for data privacy, transparency, and fair labor practices. According to a 2019 report by the Tech Workers Coalition, unionizing can provide a counterbalance to the power of large tech companies and help ensure that workers have a say in how their products are developed.
Addressing power imbalances: The tech industry is known for its stark power imbalances, with a few large companies controlling a significant share of the market. By unionizing, software engineers can help level the playing field and negotiate on more equal terms with their employers. A 2018 survey by the International Brotherhood of Electrical Workers (IBEW) found that 71% of tech workers believed that unions were necessary to balance the power between employers and employees.

So, while unionizing may not be right for everyone, there are good reasons to consider it as we navigate the changing waters of the tech industry. Let’s remember that by working together, we can build a more equitable and just future for all.”

Sources:

“Unions and America’s Changing Workforce: Results from a Survey of Workers in the Gig Economy and Other Non-Traditional Jobs” (CWA, 2018)
“Building Power in Tech: A Guide to the Tech Industry” (Tech Workers Coalition, 2019)
“The Future of Work in Tech: A Labor Perspective” (IBEW, 2018)

We Invested 10% To Pay Back Tech Debt; Here’s What Happened
- Alex Ewerlöf

tl;dr: Alex discusses how “Tech Debt Friday” started at his org, what was learned and how it’s executed: (1) We spend 10% of our time to deal with tech debt. (2) The first rule is not to create debt in the first place. (3) The PR that creates tech debt should come paired with the issue to deal with it. And more.

How We Improved DNS Record Build Speed By More Than 4,000x
- Alex Fattouche
tl;dr: “Our network now spans over 270 cities in over 100 countries, interconnecting with more than 10,000 networks globally. According to w3 stats, “Cloudflare is used as a DNS server provider by 15.3% of all the websites.” This means we have an enormous responsibility to serve DNS in the fastest and most reliable way possible.”

Resilience And Waste In Software Teams
- Jessica Kerr

tl;dr: Jessica explains resiliency in the context of the Southwest Airlines software failure. “When software is brittle, it falls over in production, and that falls to people to fix. While software can be robust to anticipated conditions, only people handle unexpected events. When software can’t even handle stuff that happens all the time, then people suffer the strain.”

Examples Of Floating Point Problems - Julia Evans

tl;dr: Julia wanted specific examples of floating point bugs in real-world programs and asked folks for “examples of how floating point has gone wrong for them in real programs.” This post shares 8 examples of such problems. Julia writes programs to highlight the problems and ways to solve them.

Git Commands You Probably Do Not Need
- Martin Myrset
tl;dr:

The empty commit.
Pushing locally.
Commit ranking.Cat file.
Orphan commits.
Filter branch.
Octopus merge.
Rounding off.

tl;dr in tech - Issue #67

Tue, 21 Feb 2023 00:00:00 GMT

This week, I wanted to talk a little bit about the things that I think are commonly skipped, because they didn’t have time to cover in dev boot camp. Because let’s be real, they were too busy teaching you how to make a to-do list app to teach you the important stuff. But don’t worry, we’ve got your back. Think of us as your boot camp BFF (Bootcamp Best Friend Forever). These are are some:

Proper software development methodologies, such as Agile or Scrum. Be sure to seek out additional training or resources on software development methodologies, such as online tutorials or workshops.
Understanding of data structures and algorithms, which are crucial for solving complex problems and optimizing code performance. You can practice solving problems and implementing algorithms on websites like Leetcode or HackerRank.
Security best practices, including how to protect against common vulnerabilities and attacks. A great way to learn is by reading articles and taking online courses.
In-depth knowledge of the underlying architecture and operating systems of the technologies being used. TBH - reading the docs is a great way to jump in. They frequently have a “getting started” section for you newbies.

-Joe Karlsson

Subscribe now

AI Commits

tl;dr: A CLI that writes your git commit messages for you with AI. Never write a commit message again.

Hello, PNG!

- David Buchanan

tl;dr: Davi discusses the mechanics of how PNGs functions:” I’m writing this article to fulfil my role as a PNG evangelist, spreading the joy of good-enough lossless image compression to every corner of the internet… I’ll be referencing the Working Draft of the PNG Specification released in October 2022, but every feature I mention here should still be present in the 1.0 spec.”

Meetings For An Effective Eng Organization
- Will Larson

tl;dr: “I’d like to recommend 6 core meetings that I recommend every organization start with, and that I’ve found can go a surprisingly long way. These six are split across three operational meetings, two developmental meetings and finally a monthly engineering Q&A to learn what the organization is really thinking about.” Will discusses each in depth.

What Big Tech Layoffs Suggest For The Industry
- Gergely Orosz

tl;dr: Gergely discusses rapid shifts in the engineering job market. “It’s certain we’ll see a correction of 2021-22’s hiring frenzy and it’s a given that Big Tech will hire much less this year than in 2022, while the question remains whether other large tech companies will follow suit and announce layoffs in the coming months.”

Let’s Build GPT: From Scratch, In Code, Spelled Out
- Andrej Karpathy

tl;dr: “We build a GPT, following the paper “Attention is All You Need” and OpenAI’s GPT-2 / GPT-3. We talk about connections to ChatGPT, which has taken the world by storm. We watch GitHub Copilot, itself a GPT, help us write a GPT.”

How To Completely Own An Airline In 3 Easy Steps

- Maia Arson Crimew

tl;dr: “I had trip sheets for every flight, the potential to access every flight plan ever, a whole bunch of image attachments to bookings for reimbursement flights containing yet again more PII, airplane maintenance data, you name it. I had owned them completely in less than a day, with pretty much no skill required besides the patience to sift through hundreds of results”.

GitHub Readme Stats
Dynamically generated GitHub stats on your READMEs!

tl;dr in tech - Issue #66

Tue, 07 Feb 2023 00:00:00 GMT

Hello, coding comrades!

Are you ready to level up your personal brand in the tech world? Look no further, because your trusty newsletter has got you covered. This week, we’re dishing out three hot tips for building your brand and making a name for yourself in the tech industry. So, grab your favorite caffeinated beverage, sit back, and get ready to become a branding pro!

Tip #1: Build a strong online presence. Showcase your skills and experience on professional networking sites like LinkedIn, GitHub, and Stack Overflow.

Tip #2: Network, Network, Network. Attend meetups, conferences and industry events to connect with other professionals and build a strong network.

Tip #3: Be an active community member. Share your knowledge, and experiences and be an active member in online communities, forums, and groups related to your field. This will not only help you stay up to date on industry trends but also demonstrate your expertise and thought leadership.

And remember, building a personal brand takes time and effort, but it’s worth it in the long run.

tl;dr: 4 principles are DevEx at scale:

1) Keep squads fast by keeping them small, capable, and aligned.

Make engineering excellence and quality an everyday practice.
The best solutions come from the bottom up, so empower the teams doing the work.
Our fellow developers are our customers, so build with empathy.

Via: Shipping Spotify’s Culture: 5 Plugins (And 4 Principles) For Supercharging Developer Experience At Scale - Tyson Singer

tl;dr: “Not only have they come up during job interviews, but learning them changed how I think about problems.”

Topological sort.
Recursive descent parsing.
Myers string difference.
Bloom filter.
Piece table.
Splay tree.

Via: Challenging Algorithms And Data Structures Every Programmer Should Try - Austin Henley

tl;dr: “In this post, I try to answer specific questions about the internals of Copilot, while also describing some interesting observations I made as I combed through the code. I will provide pointers to the relevant code for almost everything I talk about, so that interested folks can take a look at the code themselves.”

Via: Copilot Internals - Parth Thakkar

tl;dr in tech - Issue #65

Tue, 31 Jan 2023 00:00:00 GMT

Greetings, fellow nerds 🤓!

It’s been a tough week in the tech world, with layoffs happening left and right. But don’t despair! Remember, a layoff is just a temporary setback, not a permanent defeat. Just think of it as a bug in your code: it can be fixed.

So, take a deep breath, dust yourself off, and keep calm. And check out my tips:

Keep your skills up to date: Regularly update your skills by learning new technologies and programming languages. This will make you more valuable to potential employers and increase your chances of finding a new job quickly.
Network: Attend meetups and industry events, and connect with other professionals in your field. Building a strong network of contacts can open doors to new job opportunities and provide valuable support during difficult times.
Create a strong online presence: Maintain a professional online presence through sites like LinkedIn, GitHub, and Stack Overflow. This will help potential employers find you and see your skills and experience.
Be open to different opportunities: A layoff can be a good opportunity to explore different career paths or industries. Don’t limit yourself to just one type of job or company, be open to opportunities that may not be exactly what you want but may lead you to something better.
Stay positive and keep a good attitude: A positive attitude can help you stay motivated during a difficult time. Remember that layoffs are a part of the tech industry and it’s not personal, keep your head high and stay focused on the future.

Keep up the good work and let’s keep coding together!

tl;dr: “There are so many brilliant posts on GPT-3, demonstrating what it can do, pondering its consequences, visualizing how it works. With all these out there, it still took a crawl through several papers and blogs before I was confident that I had grasped the architecture. So the goal for this page is humble, but simple: help others build an as detailed as possible understanding of the GPT-3 architecture.”

Via: The GPT-3 Architecture, On A Napkin - Daniel Dugas

tl;dr: Julia discusses the attitude and approach to take when debugging, explaining the following:

Inspect, don’t squash.
Being stuck is temporary.
Trust nobody and nothing.
It’s probably your code.
Don’t go it alone.
There’s always a reason.
Build your toolkit.
It can be an adventure.

Via: A Debugging Manifesto - Julia Evans

tl;dr: “I’ve read a lot of comparisons of these two protocols and wanted to write one that is comprehensive and impartial… I was inspired by the release of connect-web (a TypeScript gRPC client that can be used in the browser) and a popular HN post entitled GraphQL kinda sucks.” Loren writes a thorough comparison.

Via: When To Use gRPC vs GraphQL - Loren Sands-Ramshaw

tl;dr: “In this post, I decided to write down my definition of what a good OKR looks like. My thinking has evolved from what I first learned long ago in half-remembered talks, blog posts, and books, and is now based on my experience using them to set team goals over the past ten or so years.”

Via: OKRs Are Hard - Camille Fournier

tl;dr in tech - Issue #64

Tue, 24 Jan 2023 00:00:00 GMT

Hello loyal subscribers!

As you may have noticed, Revue has gone the way of the dodo bird and closed its doors (Thanks, Elon 😤). But fear not! Your trusty newsletter has found a new home on Substack, where it will continue to bring you the same great content with a fresh new look and feel. Just think of it as upgrading from a flip phone to an iPhone. So, say goodbye to Revue and hello to Substack! (And remember, if you’re still using a flip phone, it’s time for an upgrade!)

tl;dr: Lorin recently gave a lecture in a graduate software engineering course on the value of technical writing for software engineers. There are 3 goals when writing:

Building shared understanding.
A tool for your own thinking.

3) Influence in a larger org when you’re at the bottom of the hierarchy. Lorin also advises on how to improve technical writing.

Via: Writing Docs Well: Why Should A Software Engineer Care? - Lorin Hochstein

tl;dr: “The Uber Eats system handles several hundred million product images and millions of image updates are performed every hour. We have implemented a content-addressable caching layer that very effectively detects duplicates and thereby reduces download times, processing times, and storage costs.”

Via: Deduping And Storing Images At Uber Eats

tl;dr: Senior Solutions Engineer at GitHub conducted an experiment to understand tradeoffs between productivity and hardware. “When you ask a developer whether they’d prefer more or less powerful hardware, the answer is almost always more powerful hardware. More powerful hardware means less time waiting on builds - and that means more time to build the next feature or fix a bug. But even if the upfront cost is higher for higher-powered hardware, what’s the actual cost when you consider the impact on productivity?”

Via: Experiment: The Hidden Costs Of Waiting On Slow Build Times - Natalie Somersall

tl;dr: The CTO at Amazon elaborates on the following:

Cloud technologies will redefine sports as we know them.
Simulated worlds will reinvent the way we experiment.
A surge of innovation in smart energy.
The upcoming supply chain transformation.
Custom silicon goes mainstream.

Via: Tech Predictions For 2023 And Beyond - Werner Vogels

tl;dr: “Balancing these opposing principles is what makes good naming so hard. The amount of knowledge conveyed in a single word is what makes good naming so powerful. The exact balance will depend on the size of the codebase and developer team, the domain complexity, frequency of use and many other factors.”

Via: Taming Names In Software Development - Joseph Glass

tl;dr: 14 useful tips including the following:

Search for the request’s ID - often log lines will include a request ID and searching for the request ID of a failed request will show all the log lines for that request.
Build a timeline - keeping all of the information straight in your head can get confusing, so keeping a debugging document where I copy and paste bits of information.

Via: Tips For Analyzing Logs - Julia Evans

tl;dr: Broken down into 3 categories. Tips for:

Assessing a startup’s trajectory.
Assessing your fit with the role and the team.
Assessing your startup readiness & shifting to a scrappier startup mindset.

Via: From BigCo To Startup: 20 Tips For Evaluating Early-Stage Companies & Making The Leap

tl;dr in tech by Joe Karlsson - Issue #63

Tue, 03 Jan 2023 00:00:00 GMT

Photo by Mike Dorner on Unsplash

tl;dr: “The most important lesson I have taught developers over the years is that programming is fun. If you are programming, and you are not having fun, then you may be doing it wrong. It may not be your fault. Ask for help. We are at our most creative when programming is fun. Creativity is play. We need to be creative to solve the complex problems we are faced with today.”

tl;dr: A holistic framework for productivity can be summarized by the acronym SPACE:

1) Satisfaction and well-being.

2) Performance

3) Activity.

4) Communication and collaboration.

5) Efficiency.

Nicole provides 3 insights: Finding flow is key and interruptions are a drag, meetings are both awesome and terrible, and a two-minute daily reflection can help improve your days.

tl;dr: “We need young people in the software development industry. Because of their vigour and inexperience, they’ll push the envelope… We need old people because they’re in a position to speak truth to the world.” Mark points to the fact that older people have less to lose and “many are in the unique position to reveal truths no-one else dare speak.”

tl;dr: “JavaScript is a very hard language to optimize, especially as a compilation target. Since Elm compiles to JavaScript and I occasionally like to try out optimization ideas, optimizing JavaScript is a problem I’m then confronted with.” Jeroen discusses these challenges here.

tl;dr: “When the paywall was launched, the meter limit was the same for all users. However, as The Times has transformed into a data-driven digital company, we are now successfully using a causal machine learning model called the Dynamic Meter to set personalized meter limits and to make the paywall smarter.”

tl;dr: “I’ve learned that getting some particular data during an initial 1:1 can be really helpful, as I can refer back to the answers as I need to give a person feedback, recognize them, and find creative ways to support them.” Lara discusses her template for initial 1-1s with questions around “grumpiness”, feedback and recognition, goals and support, and the most important question - what’s your favorite way to treat yourself?

tl;dr in tech by Joe Karlsson - Issue #64

Tue, 27 Dec 2022 00:00:00 GMT

Photo by Volodymyr Hryshchenko on Unsplash

tl;dr: “Hybrid work only works when all employees are treated as remote employees. To do this, companies need to do five things: embrace asynchronous communication, make communication boundaries clear, champion documentation and the production of artifacts, share information widely, and provide the right tools for employees to succeed.” Each are discussed in this post.

tl;dr: “We were releasing breaking changes almost monthly with different sunset dates - making it hard for developers to test and plan their roadmap without a predictable release schedule. Unversioned APIs also blocked customers from accessing the latest features and caused internal challenges with new feature development.” Nihit’s discusses how his team set out to build API versioning for LinkedIn Marketing APIs.

tl;dr: “Having a smaller website makes it load faster - that’s not surprising. What is surprising is that a 14kB page can load much faster than a 15kB page - maybe 612ms faster - while the difference between a 15kB and a ;16kB page is trivial. This is because of the TCP slow start algorithm. This article will cover what that is, how it works, and why you should care. But first we’ll quickly go over some of the basics.”

tl;dr: “Dealing with money in software is difficult and dangerous. This post contains an overview of the problems you will run into eventually when writing software that deals with money. It describes potential representations, relevant trade-offs, and recommends ways of correctly implementing common operations. The post is prescriptive, so that you can use it to write your own library for dealing with amounts of money.”

tl;dr: “Terminology matters and we can do better than 10x. We can be specific. Skills are not homogeneous, and people can quickly improve their craft as long as we don’t treat talent like some mythical quality.”

tl;dr: “We’ve got distributions of a Go package that includes entirely unlicensed code. We’ve got a host of Go packages that may not be complying with the terms of the license, when the distributions can even agree what the license is. And it’s apparently not limited to just go. Is this normal? Is this legal? I don’t really know.”

tl;dr: The bill is designed to further support engineering managers at Honeycomb, with the following guidelines:

1) Create a culture of respect for both management and IC work, due to the increasing “disdain” managers are facing.

2) Provide a career path within management with multiple ways to advance.

3) Be straight with teams about what managers are there to do.

4) Cultivate the flow of feedback in both directions, between managers and IC.

5) Allow manager & IC compensation to move independently with the market.

tl;dr: “Imagine two people - Person A acknowledges the complex problem, and focuses. Person B doesn’t see the complex problem, and simplifies.” Both approaches may seem very similar at first glance. “Focus looks like simplification. Simplification looks like focus.” But when things go wrong, as they tend to do, Person B will make bad decisions. They’ll pick bad strategies and tactics and spread the lack of context awareness to their team.

tl;dr in tech by Joe Karlsson - Issue #24

Tue, 20 Dec 2022 00:00:00 GMT

Photo by Etienne Girardet on Unsplash

I’d like to introduce you all to my friend and coworker, Bailey Hayes, Principal Software Engineer here at SingleStore.

tl;dr: “This is the story of CVE-2022-0847, a vulnerability in the Linux kernel since 5.8 which allows overwriting data in arbitrary read-only files. This leads to privilege escalation because unprivileged processes can inject code into root processes.”

tl;dr: “This is an upcoming high performance computing book. Its intended audience is everyone from performance engineers and practical algorithm researchers to undergraduate computer science students who have just finished an advanced algorithms course and want to learn more practical ways to speed up a program.”

tl;dr: Coinbase’s Director of Eng:

1) Shape your org chart so your product reflects what you want to ship.

2) Push part of the strategic decision-making process down the org to gain speed and flexibility.

3) Think in 3D to visualize what’s missing i.e, think about how the work gets done, not just who does it.

4) Put people over org structures and leverage emerging leaders.

tl;dr: “Trying to generalize across many problems is a fraught endeavor. What’s better is getting to know a specific problem by working collaboratively and embedding with the people who have the most tacit knowledge of the problem.”

tl;dr: “Today we’ll look at how 3 high performance engineering companies handle their technical documentation” starting with Google and their g3docs system, which “made documentation radically simpler for engineers.” It

1) presented one way to document things, removing decisions.

2) Hosted docs next to the code so engineers can stay in their IDE.

3) Automatically rendered docs into designed HTML pages on commits.

tl;dr: “There is so much to learn, to experiment with, to experience. There are thousands of languages out there, each with their own story to tell, and their own way of telling that story. We should never settle for just one language or one way of doing something, because new languages and new approaches change how we view the world.”

tl;dr: “Here are a few examples of small personal programming projects I’ve done. I’m not going to talk about “learning projects” where my goal was to learn something specific because I’ve already written a billion blog posts about that. These are more about just doing something fun with no specific learning goal.”

tl;dr: “An open-source initiative that subjects popular web browsers to a suite of automated tests. These tests are designed to audit web browsers’ privacy properties in an unbiased manner. The results of the tests are made public to help users make an informed choice about which browser to use, and to encourage browser makers to fix leaks of private user data.”

tl;dr in tech by Joe Karlsson - Issue #55

Tue, 13 Dec 2022 00:00:00 GMT

Photo by charlesdeluvio on Unsplash

tl;dr: “Yet as companies far and wide try to use technology to solve the world’s ills, they grapple with an inviolable truth: there always will be more problems than engineers… that has consequences,” which Matt discusses here.

tl;dr: “My thesis is that the tooling and developer experience for programming languages is improving over time, but mainly in new languages. It goes like this: Tooling innovation happens, new languages adopt and standardize on it, and end up incrementally better than existing languages. If you add up enough of these increments, the older languages, which may have pioneered some of these innovations, seem painful and antiquated.”

tl;dr: “Visa, Mastercard, and American Express act as card networks for clearing and settling funds. The card acquiring bank and the card issuing bank can be - and often are - different. If banks were to settle transactions one by one without an intermediary, each bank would have to settle the transactions with all the other banks. This is quite inefficient.”

tl;dr: In this article, “remote development environments” refer to AWS EC2 instances where engineers make code changes and can see a running Slack application with those changes.

tl;dr: Algorithm Visualizer is an interactive online platform that visualizes algorithms from code.

tl;dr: GPU architectures are critical to machine learning, and seem to be becoming even more important every day. However you can be an expert in machine learning without ever touching GPU code. It is a bit weird to be work always through abstraction.

tl;dr in tech by Joe Karlsson - Issue #56

Tue, 06 Dec 2022 00:00:00 GMT

Photo by Desola Lanre-Ologun on Unsplash

tl;dr:

1) Tackle tech debt to keep morale up.

2) Create processes for fan-out work, where multiple engineering teams are involved in tackling a project.

3) Use design guidance to simplify design reviews.

4) Use council meetings to make aligned technical decisions.

5) Assign DRIs for effective decision making.

6) Create a developer satisfaction survey.

tl;dr: Will recalls one the best architecture interviews he’s been in, “where the candidate was able to significantly narrow down the possible solutions by asking for a few details: queries per second, expected number of rows, and necessary columns.” Will demonstrates how he would approach this question.

tl;dr: A year ago, the company had the typical hiring problems of a hyper-growth stage startup. “If you formed a new team, hiring could eat up all your time. On the other hand, managers on stable teams did not participate in hiring, and we had an organizational bias.” Maksim describes how the company instrumented a new process to reduce steps, create feedback loops, develop a “pull”, vs push system, and more.

tl;dr: “REST must be the most broadly misused technical term in computer programming history. I can’t think of anything else that comes close. Today, when someone uses the term REST, they are nearly always discussing a JSON-based API using HTTP.”

tl;dr: “The concept behind soft deletion is to make deletion safer, and reversible. Once a record’s been hit by a hard DELETE, it may technically still be recoverable by digging down into the storage layer, but suffice it to say that it’s really hard to get back.”

tl;dr: “I thought to ask a pretty basic question: when you press a key on your keyboard in a terminal (like Delete, or Escape, or a), which bytes get sent? As usual we’ll answer that question by doing some experiments and seeing what happens.”

tl;dr: “To enable users to find more relevant content with less effort, we started investigating a technique called Natural Language Search, also known as Semantic Search. In a nutshell, Natural Language Search matches a query and a textual document that are semantically correlated instead of needing exact word matches. It matches synonyms, paraphrases, etc., and any variation of natural language that express the same meaning.”

tl;dr: “It may not be obvious, but it’s one of the most common issues in product & engineering teams: different people are solving different problems, whether they realize it or not. And that is the root of much anxiety, frustration, and disappointment.” Paulo advises us on how to reconcile such a situation.

tl;dr: “All change has good and bad downstream effects. The broad-based adoption of remote work is allowing people to balance work and home life in ways that are extremely beneficial to them. But team morale and the broader cultural needs of companies have suffered and we need to recognize that… A hybrid model that provides continued flexibility while creating a lot more face time is the long-term answer.”

tl;dr in tech by Joe Karlsson - Issue #57

Tue, 29 Nov 2022 00:00:00 GMT

Photo by Alex Knight on Unsplash

tl;dr: “A new wave of robots is arriving - and, in a world short of workers, business leaders are more eager to welcome them than ever… This new generation of robots have mobility and vision, and are capable of flexibility in their behavior that simply hasn’t been possible with the kinds of industrial robots that have been in use in manufacturing since the 1960s.”

tl;dr: “For the past two years, I’ve been building and breaking recommender systems at Wordpress and Tumblr. I’m starting a new adventure soon, but this scope of work has been the most meaningful and fun of my career so far, and I wanted to reflect on a few things I’m taking away.” Vicki discusses her takeaways about ML, people, culture, communication, and the joys of engineering.

While the statistical underpinnings of A/B testing are a century old, building a correct and reliable A/B testing platform and culture at a large scale is still a massive challenge. Mirroring Fisher’s observation above, carefully constructing the building blocks of an A/B platform and ensuring the data collected is correct is critical to guaranteeing correctness of experiment results, but it’s easy to get wrong. Uber went through a similar journey and this blog post describes why and how we rebuilt the A/B testing platform we had at Uber.

tl;dr: “The practice of breaking up a large change into smaller, individually reviewable PRs which can depend on each other, forming a DAG.” Ben discusses advantages, including that stacked PRs are easier & quicker to review, since there are fewer changes to sign-off on, and easier to rollback if they cause breakage.

tl;dr: “The time estimate went from a bit over an hour, to multiple hours, to over a day, to almost a week. After giving it some time, and after failing to find anything helpful through Google, I decided that learning the tar file format and making my own tar extractor would probably be faster than waiting for tar. And I was right; before the day was over, I had a working tar extractor, and I had successfully extracted my 1.1TiB tarball.”

tl;dr:

1) Get a standing desk.

2) Get a good keyboard.

3) Setup shortcuts or learn Vim the author shows us his AutoHotkey setting.

4) Ergonomic chairs don’t really work.

5) Big monitor and big text. And more.

tl;dr: Simulating shitty network connections so you can build better systems.

tl;dr: 3 steps:

1) State what happened. The most important step is initiating the conversation. It’s common to downplay bad news or share the bare minimum.

2) Provide an explanation for the cause. This may be embarrassing, particularly if your action or inaction was a contributing factor but trying to avoid acknowledging your embarrassment often makes it worse.

3) Here’s what you’re planning to do: this gives the other parties the benefit of your thinking while signaling your openness to theirs.

tl;dr in tech by Joe Karlsson - Issue #58

Tue, 22 Nov 2022 00:00:00 GMT

Photo by Lorenzo Herrera on Unsplash

tl;dr: My friend, Wesley Faulkner, tells us his tips for starting a new role:

1) Practical tools to help your visibility and help you put your best foot forward

2) Steps to define and find the right match when looking for the next opportunity

3) How to best position yourself and set yourself up for success in your next role

tl;dr:

1) How to get better at taking your own pulse.

2) How to get better at delegating.

3) How to make your strategy more clear.

4) How to speak less and become a better detective during 1:1s.

5) How to get better at listening - by paying more attention to yourself. And more.

tl;dr: “After getting locked in for almost 2 years due to COVID-19, I wanted to spend time with nature, away from busy city life, and breath fresh air. My parents own a farm, so it felt like a perfect place to spend a few weeks. The only issue is that I don’t have wired internet connectivity in the Farm.”

tl;dr: “If you have experience writing applications using sockets, all of this information should be obvious to you. It wasn’t obvious to me as an absolute beginner, so I’m trying to make it more explicit in the hopes of shortening another beginner’s time getting their feet wet with sockets.”

tl;dr: “Large data-hungry corporations dominate the digital world but with little, or no respect for your privacy. Migrating to open-source applications with a strong emphasis on security will help stop corporations, governments, and hackers from logging, storing or selling your personal data.” This is a curated list of privacy & security-focused apps, software, and providers 🔐

tl;dr: Gergely dives into:

1) Oncall philosophies across the industry.

2) Companies which pay and those that don’t.

3) How much do companies pay?

4) Companies that don’t pay.

5) Poor on call cultures.

tl;dr: Molly warns us of black hole words, which “are commonplace in a given industry but everyone has a slightly different definition of them. You can have a whole meeting and if you don’t define the word, you just wasted an hour of everyone’s time.” Molly gives us examples, such as “values”, “work-life balance”, “impact” and “fast.”

tl;dr: “That’s a lot of functionality that can be built with labels. As an example, I’ll show how to add labels automatically depending on which area of a codebase has changed. This is what I use in every project I work on as it allows maintainers oversight and awareness of the impacts of changes. It does not depend on the language or types of files - it’s based on the git diff and paths.”

tl;dr in tech by Joe Karlsson - Issue #59

Tue, 15 Nov 2022 00:00:00 GMT

tl;dr: Top 5 in order are JS, Python, Java, PHP and C#, with the following trends to note:

1) Despite its meteoric rise, TypeScript has stalled in the rankings holding its ground at eighth.

2) Go has also stalled, never placing higher than 14th and having dropped into 16 for the last three runs.

tl;dr: “Very few hashing algorithms are usable in more than a couple of situations. Even worse, using the wrong algorithm will lead in the best case scenario to performance problems, but in the worst case scenario to security issues and even financial loss. Thus, knowing which algorithm to pick for which application is crucial.”

tl;dr: “In the rest of this post you’ll see where I started, what I went through, what I learned along the way, and how it slowly evolved into the finally chosen image. I will only show the mostly happy path here. I will also only show images that were fairly ok (discarding the other 70+% that were terrible).”

tl;dr: “Progressing, in general, is a two-stage problem: you need to discover where it is that you’d like to go, and then you need to take positive action to work towards it. In my experience, many people over index on the prescriptive “how” before spending enough time on the “what”. The search space of possibilities for your career trajectory is effectively unbounded, and can rarely be predicted over long enough periods of time. This is a feature, not a bug, and should be embraced.”

tl;dr: “My best explanation for this is that most people learn a tool through searching, not browsing. When you search, you’re trying to find information that solves your specific need. When you browse, you’re systematically going through information for learning or later lookup.”

tl;dr: “You need to develop skills that give you the leverage to show bigger value to the company. These could be interpersonal skills that make you more trusted and valued, execution skills that let you drive complex projects to success, strategic skills that give you bigger ideas and the ability to sell them, or, occasionally, expert skills that make you very hard to replace.”

tl;dr: “Earlier this year I created Password Purgatory with the singular goal of putting spammers through the hellscape that is attempting to satisfy really nasty password complexity criteria.”

tl;dr in tech by Joe Karlsson - Issue #61

Tue, 08 Nov 2022 00:00:00 GMT

tl;dr: “A computer scientist was writing a column about Literate Programming - one of Knuth’s ideas on how documentation and code should live side-by-side. So he asked both Knuth and McIlroy to write a program: “Given a text file and integer k, print the k most common words in the file - and the number of their occurrences - in decreasing frequency.”

tl;dr: “I created Papers, Please in 2013 specifically for desktop computers with mouse control. Now, here, in 2022, desktop computers no longer exist and all computing is done via handheld mobile telephone. Time to update this dinosaur.”

tl;dr: “In this blog post, we discuss the rideshare pricing system architectural design, modeling approaches and potential future iterations of Lyft’s pricing engine to illustrate how we tackle price optimization to achieve Lyft’s long-term mission.”

tl;dr: “With luck you shouldn’t have to build or maintain a streaming system yourself. Your company should have infrastructure to help you with this. However, understanding where streaming is useful and why streaming is hard could help you evaluate the right tools and allocate sufficient resources for your needs.”

tl;dr: “The thing that grabbed me here is that rituals create a sense of belonging. You show that you belong to the group by participating in the ritual… It seems especially relevant these days when so many of us are atomized and physically separated from our teammates. That ineffable sense of belonging can make all the difference between a job that you do and a role that feeds your soul.” Charity provides examples from various teams.

tl;dr: “In this post we will share our approach to building out KPI trees for our platform engineering teams… Starting with the product development process, we will explain how we shaped our platform vision, resulting in a set of actionable KPIs that we use to identify our biggest problems and continuously measure our platform’s performance.”

tl;dr: “This website is dedicated to cataloguing types of linguistic antipatterns and discussing the deeper reasons they cause problems and how to fix them.”

tl;dr: Julia’s goal is to spend approximately 0% of time on ongoing operations for “tiny unimportant websites,” writing a program that does 3 things:

1) An uptime checker.

2) An end-to-end healthcheck.

3) Automatically restart if the healthcheck fails.

tl;dr in tech by Joe Karlsson - Issue #60

Tue, 01 Nov 2022 00:00:00 GMT

tl;dr: “Your language isn’t broken, it’s doing floating point math. Computers can only natively store integers, so they need some way of representing decimal numbers. This representation is not perfectly accurate. This is why, more often than not, 0.1 + 0.2 != 0.3.”

tl;dr: “Ever had hiring manager’s remorse? It’s where you regret hiring someone immediately after they start. It could be that you don’t like their face, or just want to see the world burn. Worse, they might have mentioned they like jazz. Whatever the reason, this post is here to help you make them quit on their own by picking the worst starter project for them.”

tl;dr: “As the system evolves to solve more and more use cases, we have expanded its scope to handle not only the CDC use cases but also more general data movement and processing use cases:”

1) Events can be sourced from more generic applications.

2) Catalog of available DB connectors is growing.

3) More processing patterns such as filter, projection, union, join, etc…

tldr: Amir gives tips for how to assign great first projects to your new teammates:

1) Starter tasks, not starter projects

2) Let them work on the core business, the bread-and-butter for your team

3) Tasks should be as self-contained as possible

4) Learn from past mistakes

5) Pick a mentor, but make sure everyone on the team is approachable

6) Proactively offer help

tldr: Daily curated list of jobs that allow working from anywhere.

tl;dr: “You don’t touch an unknown switch on a computer without knowing what it does, because you might crash the computer. The switch was labeled in a most unhelpful way. It had two positions, and scrawled in pencil on the metal switch body were the words ‘magic’ and ‘more magic’. The switch was in the ‘more magic’ position.”

tl;dr: “It is absolutely possible to return after a few years away. And yeah, you could come back as a principal or staff engineer. Someone will definitely hire you. However, I suggest otherwise. I suggest you come back as a senior engineer, writing software every day, for a good 6-9 months. Your grounding in the technical challenges and solution space will be much deeper and richer if you come back hands on than if you came in at a higher level…”

tl;dr: “At some point in your career you stop looking for jobs and start looking for holes that are shaped like you.” Molly discusses 4 tools that can help guide decision-making

1) A love-good-hate-bad venn diagram.

2) The stool analogy.

3) The dating metaphor.

4) Imagining your day, each discussed here.

tl;dr in tech by Joe Karlsson - Issue #30

Tue, 25 Oct 2022 00:00:00 GMT

Photo by Eric Krull on Unsplash

Following a $30 million Series A, Viam Robotics is introducing a beta of its cloud-based tools designed to develop and deploy robots.

tl;dr: “All the language features in the examples above - classes, advanced types, and the borrow checker - have an important trait in common: They all feel like they emerge spontaneously from existing code independently of whether the language designer has thought about them. In that sense, they are the best kind of feature; instead of adding new things to worry about, they merely provide a vocabulary and tooling for dealing with already existing problems.”

tl;dr: “This article continues the long-lost series on how to migrate away from terminal protocols as the main building block for command-line and text-dominant user interfaces.” The value proposition and motivation is still that “such a critical part of computing should not be limited to device restrictions set in place some 50-70 years ago.”

tl;dr: At Kent’s company Gusto, the engineering team switched from private to public engineering levels and, as part of the transition, Kent wanted to emphasize to senior engineers and managers that power should not be misused. Here is Kent’s ways in which to exercise “power advantages” & experience power disadvantages.

tl;dr: “I am covering details from the vantage point of software engineers and engineering managers.” Gergely covers how Fast was able to hire engineers competing with the big tech companies, warning signs within the company as seen from an engineering perspective, the current situation within the company, and more.

tl;dr: Figma’s Head of Security is often asked how to approach security. Here he covers topics such as ransomware, cloud misconfigurations, credential stuffing, and more.

tl;dr: “Recently, though, some signs are emerging that Agile’s power may be fading. A new moment of reckoning is in the making, one that may end up knocking Agile off its perch.” Miriam discusses the negative impact and aspects of agile development on eng teams.

tl;dr: “If you can see the lotus flower emoji on your browser, then congratulations! You’re on a browser or operating system that supports Emoji 14.0, released in September 2021. If not, you might see something that looks like the scoreboard on an old 80’s arcade game.” Nolan discusses the flaws of native emojis.

tl;dr: “I’d like to show you some awesome web browser hacks to aid your web development workflow and how to convert those hacks into time-saving bookmarklets.”

tl;dr: “Allegedly, an 18 year old spammed an employee with 2FA via push notifications on an employee with a known password. They got into the VPN and scanned for servers, found a file share without any access controls, and a script that could access break-the-glass credentials. With the highest level of credentials available, they then got effective root access to Slack, AWS, Google Suite, and active directory at Uber.”

tl;dr in tech by Joe Karlsson - Issue #32

Tue, 18 Oct 2022 00:00:00 GMT

Photo by Billy Huynh on Unsplash

tl;dr: “Mike talks to Eliot Horowitz, founder and CEO of Viam Inc. Viam launched the open beta of its new robotics platform. Viam provides an open-source robot architecture that turns complex functionality into simple APIs, with an integrated cloud service to orchestrate production deployments.”

tl;dr: “This article contains some learnings that have helped me (and others) to become better and more productive as a writer over the past 15 years. I am sharing them in the hope, that you find them useful.” Heinrich covers how to prepare for the topic you want to write about, confusing writing and learning, and much more.

tl;dr: “Programming in Go, is the most in-demand skill; the cybersecurity talent shortage continues to intensify; and Silicon Valley companies continue to offer the highest salaries, even to their remote workers.” And more.

tl;dr: “CSS tips and tricks you won’t see in most of the tutorials,” such as creating the typing effect with no JS, using the drop-shadow filter function, smooth scrolling with one line of CSS and no JS. And more.

tl;dr: Specifically for engineering directors, Will provides book recommendations and answers the following: “how do you foster execution on teams you indirectly manage?” Will cites 3 interesting pieces to consider:

1) Understand what’s happening on indirectly managed teams.

2) Adding things necessary for execution.

3) Remove things getting in the way of execution.

tl;dr: Brie provides 10 personal templates for “more efficient progress towards your goals and make the experience of getting there more satisfying.” Examples include Ongoing Stack Rank (OSR), “It’s Only The Weekend When” Post-It, “What I’m Proud Of” Scrapbook.

tl;dr: “FAANG and other top tech companies have independently converged on a common architecture for production grade recommendation systems.” This architecture is domain / vertical agnostic and can power all sorts of applications - from e-commerce and feeds to search, notifications, etc… Nikhil starts from the basics, explains nuances and describes this universal architecture.

Running an engineering meeting is always challenging. Running an engineering meeting over Zoom when everyone is working from home poses new challenges and exacerbates old ones. Here are 10 tips on…

tl;dr in tech by Joe Karlsson - Issue #34

Tue, 11 Oct 2022 00:00:00 GMT

Photo by Jess Bailey on Unsplash

I was in the park with my son and his best friend. I saw 2 missed calls from a number I didn’t recognise. I Googled it - it was my bank. I told the other adults that I should call back in case it was important.

tl;dr: “While DALL-E 2 can perform a variety of tasks, including image manipulation and interpolation as mentioned above, we will focus on the task of image generation in this article.”

tl;dr: A URI is a string that identifies a resource. From a syntactical point of view, a URI string mostly follows the same format as the URL. A URN identifies resources in a permanent way, even after that resource does not exist anymore.

tl;dr: “The purpose of a software team is to provide valued capabilities to customers, internal or external. To do that, our software has to be up, it has to be fast enough, usable enough - a whole slew of properties that don’t show up in JIRA.” Jessica discusses 5 key properties - Availability, Security, Flow, Delight and Value - their measures, and questions they prompt.

tl;dr: “Use feature requests as a breeding ground for the next generation of the system’s architecture. By continuously evaluating what we are being asked to change, we can jump the gun and get to the next level faster and often more safely.”

As we emerge from the pandemic, employees are looking for more substantial offers that drive real value at the workplace. Will tech companies step up?

tl;dr: “Imagine discovering a serious bug in production immediately after releasing your game. Imagine this bug hurts only your paying customers. Imagine it freezes the game immediately after players complete in-app purchases… This is the worst bug I have ever dealt with in 30 years of programming. This is a story of how we tracked it down and worked with Unity to fix it.”

tl;dr: “No one argues that, when trying to improve something, we don’t often subtract. We pile on “to-dos” when we really need “to-stops,” or create incentives for good behavior … but don’t get rid of obstacles to it.” People think first about adding and, as a result, systematically overlook subtractive changes.

tl;dr in tech by Joe Karlsson - Issue #36

Tue, 04 Oct 2022 00:00:00 GMT

Photo by David Kovalenko on Unsplash

tl;dr: Underrated traits of the best engineers:

1) Crisp writers and communicators.

2) Aim for the broadest impact.

In this post, Amber “guides other engineers up and down the org chart as they weigh their next career moves, leaning on the frameworks and lessons she’s pulled from in her own career.”

Strategies for working with people you don’t like

tl;dr: “They called it the “group test”; around 8 of us were led to a room and asked to solve a puzzle together. Each of us was given an information pack, there was a white board, and a timer ticking down from 60 minutes.”

tl;dr: “The bad news is that this was on Friday, and we needed to have the videos back up at most for Tuesday morning. We had to upload ~8TB of data with a 30MB/s connection. Not ideal, and I had to think about something fast.”

tl;dr: “Shibboleths are historically a word that indicate membership in a particular group or culture… I have only studied and worked in the field for around a decade, but in that time I believe I have learned to recognize some key “distsys shibboleths” that help me recognize when I can trust what a vendor or other engineer is telling me.”

Showcasing a quality-oriented process for achieving higher reliability in microservices acting together to improve the platform.

tl;dr: “Today is my birthday. I turn 70… I’ve jotted down bits of unsolicited advice each year…”:

1) About 99% of the time, the right time is right now.

2) No one is as impressed with your possessions as you are.

3) Don’t ever work for someone you don’t want to become.

4) Cultivate 12 people who love you, because they are worth more than 12 million people who like you.

5) Don’t keep making the same mistakes; try to make new mistakes.

tl;dr in tech by Joe Karlsson - Issue #46

Tue, 27 Sep 2022 00:00:00 GMT

Photo by Michael Dziedzic on Unsplash

Today I will share some of the software engineering soft skills I have learned from my first 10 years on Google Chrome, where I am a Senior Staff Engineering…

tl;dr:

1) Fork this template.

2) If there are any sections that don’t resonate with you, remove or edit them.

3) Fill in the sections. Feel free to jump around to answer the parts that you have the most energy for.

4) Revisit a few days later: is there anything you want to change?

5) If possible, find peers to discuss each others checkups together.

6) Review a year from now.

tl;dr: Recommendations include:

1) Onboard as fast as possible.

2) Make upgrading easy: “when making a major version change, limit the blast radius of changes to make it easy for folks to update dependencies.”

3) Helpful error messages: “when applicable, include hyperlinks in error messages to provide more context on how to solve the error.” And more.

tl;dr: “The 26M rps DDoS attack originated from a small but powerful botnet of 5,067 devices. On average, each node generated approximately 5,200 rps at peak. To contrast the size of this botnet, we’ve been tracking another much larger but less powerful botnet of over 730,000 devices.”

tl;dr: “There are two projects, both deemed important by the business, and both need a UI developer. Unfortunately, only one UI developer is available. Why not let the UI developer split time across both projects?” Ben explains why this doesn’t work using the equation: Productive Time = Total Time - Overhead.

tl;dr: I would discover a bug or something would break my workflow with a new release and I would head to GitHub to report it… What I didn’t consider was that my interactions were taking time & attention from the project. User support is a cost. If you take anything away from this post I hope it is that these costs need to be paid by someone, the maintainer.”

tl;dr in tech by Joe Karlsson - Issue #47

Tue, 20 Sep 2022 00:00:00 GMT

Photo by Jordan Harrison on Unsplash

tl;dr: “Total Cookie Protection works by creating a separate “cookie jar” for each website you visit. Instead of allowing trackers to link up your behavior on multiple sites, they just get to see behavior on individual sites. Any time a website, or third-party content embedded in a website, deposits a cookie in your browser, that cookie is confined to the cookie jar assigned to only that website.”

tl;dr: Generate images from a text prompt.

tl;dr: Tools to help coach are:

1) Outcome shift - help your report shift from the problem to solution.

2) Options exploration - ask clarifying questions that help make options more concrete.

3) Acknowledging strengths - increase confidence by bringing awareness to their gifts.

4) Uncovering limiting beliefs - make unconscious assumptions conscious and shift to productive beliefs.

tl;dr: “This post proposes a systems-based model for diagnosing, detecting, and fixing the fundamental issues that plague engineering teams. It is a distillation of lessons acquired from identifying and implementing high-leverage strategic remedies across multiple products.”

tl;dr: “Add features one at a time - not as a series, but on alternate timelines. With version control, we have this superpower.” Jessica believes this is a superior process for learning new frameworks, programming style, and more.

tl;dr: “As files, datasets and configurations grow, it gets increasingly difficult to navigate them. There are however many tools out there, that can help you to be more productive when dealing with large JSON and YAML files, complicated regular expressions, confusing SQL database relationships, complex development environments and many others.”

tl;dr: Assumptions are:

1) Countries have simple shapes.

2) Everything is a country.

3) Assuming administrative divisions are homogeneous.

4) Addressing schemes follow a simple rule.

5) Time zones follow a logical system. And more.

tl;dr: “If I’m right and conservatively, we have 99% wastage on our PCS, we are wasting 99% of the computer energy consumption too. This is beyond criminal. And to do what? I have no idea, but a quick look at task manager on my PC shows a metric fuckton of bloated crap doing god knows what.”

tl;dr in tech by Joe Karlsson - Issue #41

Tue, 13 Sep 2022 00:00:00 GMT

Photo by Markus Spiske on Unsplash

tl;dr: When building cloud application leveraging more and more SaaS services like Lambda, SQS, and DynamoDB we are faced with an interesting dilemma: should we still try to develop locally or should we just embrace the cloud as a development environment? This article offers an interesting take on this question.

tl;dr: “Trailing dots on host names in URLs is the gift that keeps on giving. Let me take you through a dwindling story of how the dot is handled differently in different places through the stack of an Internet client. The evil trailing dot.”

tl;dr: “I can’t tell if the author was being clever or if it was a particularly lucky typo. Either way, I will continue putting - at the beginning: [-,.]. But if you feel the need to send someone down a rabbit trail [,-.] is an option for you.” Paul discusses how arrived at this conclusion.

tl;dr: “This is a partial story of what went wrong with the process and how it permanently damaged me. My hope is that this story will help people recognize toxic cultures in their own workplaces, or help new hires have a better career at Google.”

A Collection of application ideas which can be used to improve your coding skills. - GitHub - florinpop17/app-ideas: A Collection of application ideas which can be used to improve your coding skills.

tl;dr: App ideas which can be used to improve coding skills.

tl;dr: ‘“What if it changes?” isn’t just a question. It’s a powerful heuristic for software design that can be used to justify almost anything. Everyone should use it more. It’s great precisely because it’s rooted in pure speculation.’ Chris provides a guide for how to navigate this thinking.

tl;dr in tech by Joe Karlsson - Issue #42

Tue, 06 Sep 2022 00:00:00 GMT

Photo by Greg Rakozy on Unsplash

tl;dr: “I want to share how my team at Etsy recovered from failing really slowly. We launched a high-profile product that didn’t meet customer needs after doing a nine-month waterfall buildout, and senior leadership decided that we needed to rethink our approach from the ground up. We didn’t know exactly what the end result would be, but we agreed to pivot the product over a three-month timeline.”

tl;dr: “There’s no point in going into details about what exactly led to it, but I have to assure you that it wasn’t anyone’s fault. It was more about the direction that my role drifted in. In other words, I was no longer doing the work that I wanted to, and that made me unhappy. It was not fun.”

tl;dr: “To achieve this rapid release cadence, we’ve optimised our engineering culture, tooling, and architecture to make the path from idea to production as frictionless as possible, all without sacrificing safety. We believe our approach gets us the best of both worlds: less friction encourages smaller changes, and smaller changes are less risky.”

tl;dr: “Bob is a sleek and compact countertop dishwasher requiring no plumbing and minimal space.” One of the features is the Bob Cassette, “an all-in-one detergent cartridge… no need to manually measure and add detergent to each wash.” It’s very convenient and outrageously priced. The author explains how they engineered these cassettes to preserve convenience at a fraction of the cost.

tl;dr: A formula to work on any aspect of your own self-improvement. All steps work in parallel, in a continuous loop.

1) Awareness: Being aware of a problem is not enough, you have to accept it, believe it is worth fixing, and now is the time.

2) Understanding: Asking and understanding why you act in this way.

3) Overcoming: realizing when and how your behavior is in conflict with your values and goals.

tl;dr: “Somebody once described balance to me as three buckets filled with water. One for career, a second for physical health, and a third for social and family life. At any point, one bucket might be running low. But as long as the overall water level is high enough, things should be fine,” Scott discusses how the events in his life, in this context, guided him to leave Google.

tl;dr: “Executives are evaluated based on their perceived outcomes rather than actual outcomes.” Will discusses this common issue and how it’s hard to force a poorly run company to become better run, but easy to make local improvements on your team. It’s a bit harder to allow those local improvements to spread organically.

tl;dr: “Many leaders mould the organization in their image or the image of the past workplace. Engineering leaders brought into embattled organizations tasked with stabilizing the chaos are often heavily incentivized to do this. Many a time these folks, in my experience, tend to fail harder and more often than those who try to learn the organizational ropes and tailor their leadership style to fit the organizational culture.”

tl;dr in tech by Joe Karlsson - Issue #43

Tue, 30 Aug 2022 00:00:00 GMT

Photo by Umberto on Unsplash

tl;dr: Airbnb went through this process by implementing the following practices:

1) Provide infrastructure as code to improve developer’s productivity.

2) Clarify ownership and improve with tooling & observability.

3) Define a new architecture supported by organization & methods.

4) Lead a deprecation working group to accelerate the migration. Antoine discusses how each was solved.

tl;dr: “If I didn’t have something like Heroku in my life I doubt that my career would be the same or even I would be the same person I am today. It’s really hard to describe what having access to a platform that lets you turn ideas into production quality code does to your output ability. ” The author also worked on the product at Salesforce. “I ended up working there and when I did I understood why Heroku had fallen so much.”

tl;dr: Murat committed to asking “crazier” left-field questions in each post he wrote. After 70 posts, he learned that these:

1) Are useful as they took him out of “default mode.”

2) Keep the brain more engaged. We tend to ask easier questions. Harder ones feel uncomfortable or seem impolite.

3) By calling them “MAD” questions, they give him the license to be more uninhibited.

tl;dr:

1) Launch a bounty program so any employee that encounters a policy or process hindering their ability to deliver value can submit it with a recommendation.

2) Practice continuous governance so individuals have the power to recommend changes to their own roles.

3) Don’t rush to a policy and process for everything as there can be an efficiency cost to keeping things open-ended.

tl;dr: “Have you ever wondered how real-time games can keep multiple clients in sync even when there are large latencies between users? How can you see other players reacting to your actions near instantly, in spite of the fact that the communication between your computer and the server is not instant?

tl;dr: “We are going to ask our employees to be in the office a maximum of 25% of their time. For the balance of that time, employees can be wherever they want, either in or out of the office. We really want to earn employee’s in-office time and be incredibly intentional about when we ask folks to travel.”

tl;dr: “I didn’t really care what the area code was, so removing the params should make it easier to find a number I liked. I wrote a quick script to repeatedly call the API and try and find a number with at least 3 consecutive numbers.”

tl;dr in tech by Joe Karlsson - Issue #44

Tue, 23 Aug 2022 00:00:00 GMT

In dumb personal news - I posted a video of me singing a song about corn in my car over the weekend on TikTok and it got 1.2 MILLION views.

tl;dr: “Based on our findings above, the least viewed articles on Wikipedia are not going to be merely about topics with little popular interest - they must also be “unlucky” in the sense of having very small random gaps… Of these 600,000 least lucky articles, all received at least a few views in 2021. The booby prize for least popular article of 2021 is shared by two articles which received exactly 3 probably-human pageviews.”

tl;dr: “When an army has the force of momentum, even the timid become brave; when it loses the force of momentum, even the brave become timid.” Building momentum is about increasing velocity - speed and direction. Leading is about increasing: 1) confidence in the direction i.e. vision, planning, strategy. 2) speed at which you’re moving i.e. execution. Paulo discusses practical ways to achieve momentum.

tl;dr: Reasons include:

1) It removes redundancy because the function name should already be in the call stack.

2) It is falsifiable i.e. a person reviewing the test can decide to which degree the name agrees with the actual test.

3) Encourages testing one property of the function per test.

tl;dr: “If positive engineering is taken to mean the day-to-day work that engineers do to deliver productive, expected outcomes, then negative engineering is the insurance that protects those outcomes by defending them from an infinity of possible failures.” Jeremiah discusses the impact on productivity.

tl;dr:

1) The network is reliable

2) Latency is zero

3) Bandwidth is infinite

4) The network is secure

5) Topology doesn’t change

6) There is one administrator

7) Transport cost is zero

8) The network is homogeneous.

tl;dr: “I was 6-months into my first real developer job, trying to fix a bug. Our application would sometimes insert rows with an invalid “foreign key.” Of course, the bug was only seen in production, so I had a production MySQL shell open to see the bad rows.”

tl;dr: You want to “check that this person has internalized the feedback and will begin to make changes.”

1) Ask them if they understand the feedback and urgency.

2) Intentionally create space and pauses to give them time to respond.

3) Ask them to reflect back what they heard.

4) Ask open coaching questions e.g. “okay, given this feedback, what are you planning on changing to be able to meet these expectations?”

5) Identify next steps.

tl;dr: The impulse to pretend that nothing has happened is understandable, it carries a cost: You may actually heighten your embarrassment and distress. Instead, by acknowledging and addressing your embarrassment, you:

1) Diminish your embarrassment and the resulting distress.

2) Clarify the situation, restore consistency to your self-presentation, and reduce others’ anxiety.

3) Role model a productive response to unwelcome events.

tl;dr: “While not commenting event calls is usually not a big deal, it may be a problem in situations like mine where I had to go over many ambiguous use cases at once. This resulted in a lot of wasted time that could be otherwise avoided if the original author added a comment.”

tl;dr in tech by Joe Karlsson - Issue #39

Tue, 16 Aug 2022 00:00:00 GMT

tl;dr: “Note that the code should be taken as a twisted joke, or as an exercise in minimalism, or as both, probably a joke. Because of the aforementioned limitations, we are going to write some nasty macros to perform bitwise operations, use global variables, reuse the same counter, etc. This is not a good example of readable or elegant code.”

tl;dr: “I find the absolute best way to understand a concept is to visualize it. I’ve built a regex engine using Python and Graphviz that animates what actually goes on when a regex is searching through a body of text. If you want to try out your own examples, the project is publicly available on GitHub.”

tl;dr: “The moral of the story is that the best way to avoid bugs is to make them difficult to write. Ideally make bugs harder to write than correct code. defer and try-with-resources are “wrong by default” and require explicit work on behalf of the programmer to become correct.”

tl;dr: “Two years ago, frustrated with a long list of unfulfilled project ideas in my phone notes, I decided to start trying one idea each week in its tiniest form. I never kept to a weekly schedule, but I’ve kept plodding along since then and launched 8 things. In this post I want to update you on everything I’ve launched, and share what I’ve learnt about building lots of these tiny internet projects.”

tl;dr: A set of attitudes leaders display while enacting these two roles. A warrior’s “purpose is overcoming resistance, where life is a series of battles,” where a Sage’s purpose is “learning and helping others learn, where, life is a series of mysteries to be studied.” Ed notes that the Warrior’s mindset becomes less useful as leaders grow more senior, and the Sage mindset increasingly important.

tl;dr:

1) Make time to be curious e.g. schedule 30 mins to jot down questions that spark curiosity.

2) Imagine you were the CEO and ask yourself how the business would work, and let your mind guide you through the web of questions a founder might ask.

3) Frame your career as a series of questions to create a sense of ownership of your career.

4) Try something new.

tl;dr: “Imagine there’s a city in a valley. On either side of the valley, there’s an army commanded by a general. On one side stands General Alice and her army. On the other, General Bob and his army. Alice and Bob want to capture the city, but neither has an army large enough to do so alone. Alice and Bob must attack at the same time, but Alice and Bob can only communicate by sending messengers through the valley, who have a chance of being captured by the city’s army. How do Alice and Bob coordinate their attack?”

tl;dr in tech by Joe Karlsson - Issue #40

Tue, 09 Aug 2022 00:00:00 GMT

tl;dr: “In this article, I will present a new puzzle game and demonstrate techniques I used to write a fast, practical solver for it. Topics covered will include breadth-first/A* search, memoization, optimization, and strategies specific to NP-hard and NP-complete puzzle games.”

tl;dr: “Everything I know and learned about running and maintaining OS projects for three decades. I have been actively involved in OS development since the early 1990s when I discovered the phenomenon of people writing source code they give away freely for others to use and modify under a certain license.”

tl;dr: “One of the fun examples among all the copyright fuss is the extreme example of copyright claims made by AT&T some time in the 1980s. It’s the /bin/true program. This is a “dummy” program whose function is to make it easy to write infinite loops in shells scripts. The program does nothing; it merely exits with a zero exit status… But AT&T’s lawyers decided that this was worthy of copyright protection.”

tl;dr: Lara lists recently published resources for managing in a time of crises, including “Managering through terrible times,” “Handling the emotional weight of 1:1s” and “When your manager isn’t supporting you, build a Voltron.” Additionally listed are resources to build resilience and tactical templates.

tl;dr: “When faced with a choice, always pick the simplest thing that solves your immediate problem. Then make sure you can change your mind later. By the simplest thing I mean the solution that is easiest to reason about.”

tl;dr: Adam discusses the difference between line and staff software engineers, where a line engineer is core to the mission and staff is a supporting role. Although roles can be similar in either context, this variable is important to consider as it will directly impact your experience. Adam outlines how, as well as pros and cons of both.

tl;dr in tech by Joe Karlsson - Issue #38

Wed, 27 Jul 2022 00:00:00 GMT

tl;dr:

1) You don’t need hundreds of engineers to build a great product.

2) Simple Outperformed Smart.

3) Our highest impact findings would always come within the first and last few hours of the audit.

4) Writing secure software has gotten remarkably easier in the last 10 years.

5) All the really bad security vulnerabilities were obvious. And more.

tl;dr: “I offer the following argument that restarting from the initial state is a deeply principled technique for repairing a stateful system - whether that system is a program, or an entire computer, or a collection of computers.”

tl;dr: Nikolay covers 18 mistakes, categorized into three big categories of DB schema migration mistakes:

1) Concurrency-related mistakes.

3) Miscellaneous - mistakes related to the implementation of some specific database feature or the configuration of a particular database.”

tl;dr: The first version of Go has evolved significantly: The compiler rewrite in Go, modules, context package and Generics. “Releasing ‘Go 2’ has become a philosophical and political challenge due to the forces that be… This is a look back at the huge progress that has been made since Go 1 released and what I’d consider to be the headline features of Go 2.”

tl;dr: Broken into 5 categories:

1) Questions for gauging morale e.g. Who haven’t I heard from in my team?

2) Tracking team performance e.g. is each member on the team overperforming, on track or underperforming?

3) Measuring effectiveness as a manager e.g. What more can I say no to? And more.

tl;dr: “The following is a loose, unordered collection of thoughts that come up when I look back on the past 10 years:”

1) Fearlessness is undervalued.

2) You can’t predict the future; try and you might end up in trouble.

3) Nothing really matters, except bringing value to the customer.

4) Perfection is unachievable. And more.

tl;dr: Andreas discusses and addresses how we handle the 3 main issues when hiring remotely:

1) More people applying to job postings.

2) Team is in multiple locations.

gg3) Interviewing people with different cultural backgrounds.

tl;dr in tech by Joe Karlsson - Issue #36

Wed, 20 Jul 2022 00:00:00 GMT

tl;dr: 12 strategies, including:

1) Encourage time off, prompting employees to take some if they don’t have any planned.

2) Lower the pressure by lowering expectations on OKRs and asking about them less frequently.

3) Be more positive about teams, and reports.

tl;dr: 3 tests:

1) Balance: how much time does the team spend in meetings vs free time?

2) Flow: how much free time is uninterrupted?

3) Effectiveness: how effective does your team feel meetings are? Shishir also provides steps to improve meetings.

tl;dr:

1) Create the new empty table.

2) Write to both old and new table.

3) Copy data (in chunks) from old to new.

4) Validate consistency.

5) Switch reads to new table.

6) Stop writes to the old table.

7) Cleanup old table. This guide will go through the step-by-step process of migrating tables in PostgreSQL.

These days software is subject to an ever-changing threat landscape. Check out the many ways you can keep your projects secure on GitHub today.

tl;dr: Tips of how to help your team…

1) Work through uncertainty - tips include acknowledging what’s happening, and investing in collective rituals.

2) Push back against perfectionism - tips include identifying different work styles, and sharing at 80%.

3) Beating burnout - tips include looking for warning signs, and protecting your teams time.

tl;dr: “In this issue we cover:

1) The extremes of shipping to production.

2) Typical processes at different types of companies.

3) Principles and tools for shipping to production responsibly.

4) Additional verification layers and advanced tools.

5) Taking pragmatic risks to move faster.

6) Deciding which approach to take.

7) Other things to incorporate into the deployment process.

tl;dr: The Stack Overflow memes are true: 60% of senior engineers commit 10-100 lines/week of copied and pasted code. And there is more: read the report to learn how 600 engineers (ICs and managers) spend time, from wrangling machines to wrangling people.

tl;dr in tech by Joe Karlsson - Issue #35

Tue, 12 Jul 2022 00:00:00 GMT

tl;dr: Questions worth asking when considering if a team is achieving full potential: What kind of team we are? Are the right people here? Does everyone know their role? How do we make decisions? Have we built a sense of cohesiveness? Do we know what effectiveness looks like? What happens when we disagree?

tl;dr: Frameworks are “frames of reference that help people concentrate on what truly matters.” Without discipline, the best frameworks are useless. This is the essence of leadership, and Paulo provides examples of how to develop such frameworks.

tl;dr: Shekar provides 3 reasons:

1) Developers don’t re-read their code often enough.

2) Lack of business domain understanding.

3) Undervalue good naming. Also, helpful questions to ask: “which business concept is this functionality related to? How can I map business terms to code? What can I learn from API contracts and / or documentation of competitors?”

tl;dr: This podcast discusses the following questions: 1) What does it mean to truly treat developers as creatives within an organization? 2) What does it mean to be “developer first”? 3) How does this affect customers, product, go-to-market?

tl;dr: “My main site received about 34M requests over 72h - in three spikes.” The author discusses how this DDoS attack was executed, why, and the consequences.

tl;dr: “One way of communicating our preparedness to our customers is through a metric called Recovery Time Objective (RTO). RTO measures the amount of time we promise it will take to recover from a catastrophic event.” Dropbox reduced its RTO by “more than an order of magnitude,” as discussed in this post.

tl;dr: “Being a niche programmer is not bad at all. Pay is great, competition is low and the interview processes for the most part very humane.’ Asko discusses his relevant experience with Clojure.

tl;dr: hashcat is the world’s fastest and most advanced password recovery utility, supporting five unique modes of attack for over 300 highly-optimized hashing algorithms. hashcat currently supports CPUs, GPUs, and other hardware accelerators on Linux, Windows, and macOS, and has facilities to help enable distributed password cracking.

tl;dr in tech by Joe Karlsson - Issue #33

Wed, 06 Jul 2022 00:00:00 GMT

tl;dr:

The goal of testing code is both

It’s very common to find test that do (2) but neglect (1).

If tests are hard to read, it has the same effect as code that’s hard to read. The harder something is to understand, the harder it is to trust. The less you trust code, the harder it is to change.”

tl;dr: “Modern front-end frameworks like React, Angular, and Vue rely heavily on the terminal. If you’re not comfortable with command line interfaces, you’ll struggle to run a local development server or build your application!”

tl;dr: “While this targets primarily VPs of Engineering, the principles and practices are entirely applicable at all levels of the org. They will help you develop solid working relationships with any non-technical stakeholders.” Paulo breaks this post into:

1) Importance of starting with the end in mind.

2) Your role as a leader.

3) The mindset of an effective VP of Engineering.

4) Learn, adapt and improve.

tl;dr: Principles include:

1) Managing comes first, “stay out of the critical path of execution, wherever possible.”

2) Facilitate wellbeing so “personal safety, dignity, and wellbeing of everyone is paramount.” Make sure the quiet voices are heard.

3) Practice integrity. “Be transparent with information you can share. Be transparent about when you cannot do something. Keep your commitments. Own up to your mistakes.” And more.

tl;dr: Vadim splits the topics into four categories:

1) Onboarding.

2) Day-to-day business, discussing methods that make life easier when you don’t see your employees every day. “Small things that may seem unimportant but have a huge impact.”

3) Culture, people feel happy and engaged.

4) Results, making sure the team delivers and pushes the company forward.

tl;dr: “If we conservatively estimate that 40,000 searches occur per second, that would be equivalent to 12 kWh of energy, enough to run a ceiling fan continuously for a month. The end result is that a single data center consumes more energy per year than 20,000 homes.”

tl;dr in tech by Joe Karlsson - Issue #31

Tue, 28 Jun 2022 00:00:00 GMT

tl;dr: “You start realizing that everything comes back to a relatively small number of principles, universally applicable.” Paulo’s 20 principles include:

1) Don’t fool yourself. Self-awareness is the foundation without which nothing else works.

2) Lead yourself first. Manage emotions, don’t suppress them.

3) Focus on what you can control. Attempting to control the uncontrollable is a waste of time and energy. And more.

tl;dr: “The compass is a popular metaphor for leadership - we value its steadfastness and reliability. The weathervane symbolizes bad leadership - we’re skeptical of leaders too easily swayed.” The most effective leaders integrate aspects of both so the question isn’t “what kind of leader should I be?” but “what kind of leadership is called for at this moment - and am I capable of summoning it?” Ed provides us with 30 questions to navigate this.

tl;dr: Gergely covers a timeline of events, cause of the outage, what customers are saying, the impact of the outage on Atlassian’s business, learnings from this outage, and more.

tl;dr: “My favourites of these that I use already are entr, ripgrep, git-delta, httpie, plocate, and jq.” Julia breaks this list into replacements for standard tools, new inventions, and less-new tools.

tl;dr: “I don’t need to burn any of my limited focus on something menial anymore. It matters even more when automating something I don’t know by heart, like my Zoom URL or my EIN. Then it takes focus to find it ;and then copy it over.”

tl;dr: “I hear the misconception that a server can only accept 65K connections or a server consumes a port for each accepted connection all the time.” Joseph wrote this article to dispel this myth from 3 angles.

tl;dr: Typical white-boarding interviews are suboptimal. A better method is to have “the candidate read existing code and talk about what it does and how it works.” Reading code is: 1) Probably 95% of what a developer does in their job. 2) Way more efficient than writing. 3) Puts the candidates at ease compared to writing code. The author shows us how to put this is into practice.

tl;dr: Ask yourself why you need documentation e.g. making better decisions across the org, helping people get the right information, making onboarding more self-service. “If we’re deciding whether to write something, we should ask whether writing it will help us with one of those objectives.” Paulo suggests pointing your team towards the “why” and also provides tips for maintaining the practice.

tl;dr: “In my ongoing quest to explore the problems that are endemic to modern software development, I decided to focus in particular on estimation and the disaster that is “story pointing."" Lloyd discusses the antipatterns experienced when estimating, including failing to realize story points are an estimate, coercing developers into choosing a lower number, discounting high or low numbers, and more.

tl;dr: “Did you know there is a type of compiler backdoor attack that is impossible to defend against? In this post I’ll show you how to implement such an attack in less than 100 lines of code.”

tl;dr in tech by Joe Karlsson - Issue #29

Wed, 22 Jun 2022 00:00:00 GMT

Want to find out why I joined There are a lot of reasons I joined the team at Viam? Be sure to check out my new blog post where I walk through all the reasons why.

tl;dr: Varies on whether the company is early-stage, prioritizing growth or profitability.

1) Early stage: If you reduce your infrastructure costs to $0, and it doesn’t increase your runway by at least two months, it’s not worth focusing on.

2) Growth: “The fundamental question is whether infrastructure’s share of cost of goods sold are increasing as a percentage of revenue?”

3) Profitability: Align with the business on dollars spent on infrastructure overhead per engineer.

tl;dr: “WebCore is part of a strategy to re-imagine BBC Online and create a single website for all the digital services.” Graeme covers how the engineering team: 1) Went about re-organizing for success. 2) Viewed the team topologies and interaction modes between teams. 3) Viewed the role of the platform in enabling teams to interact with one another.

tl;dr: Julien highlights some of the challenges: “Weird” album names, albums without names, confusing names, long tracks up to 23 hours, tracks with different versions and more. Julien also links to the DB schema to show how to “tame this madness.”

tl;dr: “Something I found hilarious is that a variable might be used on lines 200-210 and then again on line 8544. No where else.”

tl;dr: “If you have a teammate coming to you questioning their worth and effectiveness, I want to equip you with a framework that will help this teammate recognize their successes and impact.” Lara discusses the BICEPS framework that covers: Improvement, Choice, Equality / Fairness, Predictability and Significance. As well as some questions you can ask your teammate e.g. In the last year, where have you created more clarity or predictability for people?

tl;dr: “One of the things that I catch myself doing more and more as a staff engineer is to help individuals, teams or sometimes the organization reach clarity. I’m no oracle and this is not rocket science but in this article I’d like to go meta and clarify the process of reaching clarity with some examples.”

tl;dr: “After reaching a certain level of seniority, it’s expected that a worker can self-direct in service of the organizational goals. This creates a situation that can be difficult to navigage: is it really self-direction if the organization decides what are the “right” and “wrong” choices in the end?”

Why I Joined Viam 🤖

Wed, 15 Jun 2022 00:00:00 GMT

Hello Friends I am excited to announce that I have joined Viam as a Developer Advocate where I will be working to help developers make cool robots. At Viam, we are building a software platform to enable users to create, configure and control any robotics project.

There are a lot of reasons I switched over to Viam, but here are the biggest:

I get to help make the future of robotics more accessible to everyone.

Robot balancing on one foot while doing the flying crane pose from Karate Kid.

Robot balancing on one foot while doing the flying crane pose from Karate Kid.

I think we all know that robotics has the potential to do so much good, but progress has been slowed by complicated hardware and software integrations, long development cycles, and people’s fear of tripping over a robot on their way to work. At Viam, I am helping make the developer experience of building robots even easier.

Our goal at Viam is to make building and programming a robot as simple as assembling web services. To this end, we are developing a series of core hardware abstractions and software components, such as object recognition, navigation, and gripping. To make building and programming robots as simple as assembling a set of legos.

The team understands the importance of developers.

Cartoon of a person typing at a computer.

The team here at Viam is made up of a diverse team of developers, robotics engineers, and executives that have a history of building and scaling companies that understand how crucial developers are to succeed. I think this is most clear in Viam’s CEO, Eliot Horowitz, who was the co-founder of MongoDB. In my humble opinion, MongoDB’s success was directly tied to Eliot’s commitment to making a database that software developers loved through developer support, and features that developers were actually asking for.

The team Eliot has assembled here at Viam is equally committed to building a robotics platform that makes robots as easy to build as it was to deploy a MongoDB database. Personally, I am humbled and honored to be asked to join a team as committed to building tools for nerds.

Robots are just super fun.

I don’t think it’s a secret that I love exploring technology projects that blur the line between art and tech. Folks might also know that I have a special love in my heart for projects that walk the razor-thin line between genius and dumb as hell (i.e. see my IoT Kitty Litter Box). The fact is making a robot is really fun. It’s concrete and tangible in a way that software can’t be. It’s a blast making a robot that solves a real-life problem or is just fun to show off to my friends. I can’t believe it’s my job to be able to help all developers find this joy while I get to make and show off my own fun demo robots.

Wrap up:

Viam is currently in stealth but we are building something really cool that we will be sharing with the world later this year. So if you want to keep updated on the very latest developer news from me and Viam, be sure to follow @ViamRobotics on Twitter, TikTok, and Instagram.

We are also hiring! If you want to work with robots (or with me ), be sure to check out all of our open positions at https://www.viam.com/careers.

You can also follow me on my personal social accounts, it’s where I post about tech, leadership, and community. Oh, and I also post silly videos about programming. See you there!

Follow Viam to stay up to date on the latest:

Website: https://www.viam.com/
Twitter: https://twitter.com/viamrobotics
Instagram: https://www.instagram.com/viamrobotics/
TikTok: https://www.tiktok.com/@viamrobotics
LinkedIn: https://www.linkedin.com/company/viaminc/about/

Viam in the news:

MongoDB’s co-founder is trying to universalize robotic deployment - TechCrunch

Email address (required)

https://www.getrevue.co/profile/joekarlsson

Subscription received!

Please check your email to confirm your newsletter subscription.

Follow Joe Karlsson

Twitter
LinkedIn
Instagram
TikTok
YouTube
Why I joined SingleStore
August 5, 2021
How to Query from Multiple MongoDB Databases
June 30, 2021

The post Why I Joined Viam 🤖 appeared first on Joe Karlsson.

tl;dr in tech by Joe Karlsson - Issue #23

Tue, 14 Jun 2022 00:00:00 GMT

tl;dr: Here are the steps I take when I’m stumped. No huge revelations here, just hard-earned advice. First 3 steps:

1) Think hard about the problem for a few weeks before typing any code.

2) Type in a function or write a class that has the inputs and outputs you need.

3) Break the function down into multiple steps with clear objectives. You may not know how to achieve those objectives, but that’s a problem for your future self. Right now, you’re just trying to write out the high-level algorithm.

Frank guides us through another 6 steps in this post.

tl;dr: Sally provides examples of both general and code specific questions: Are building features a painless process? What’s your level of confidence merging PRs into main? How do you feel about code readability and consistency? What initiatives should we be prioritizing? Are there any technologies we should consider using? What topics would you like to learn more about in our regular engineering talks?

tl;dr: “This is the story of a bug we recently put to rest; a bug which, from our very first inklings of its existence, I repeatedly described as “cursed.” Now that we understand it, I want to share just how delightfully cursed it was.”

tl;dr:

1) SSL certificates, with Let’s Encrypt

2) Concurrency, with async/await (in several languages)

3) Centering in CSS, with flexbox / grid.

4) Building fast programs with Go, and many more.

tl;dr: Early on in your company’s lifetime, you’ll form your infrastructure organization: a small team of 4-8 engineers. Later on, you’ll have 70 engineers across 8-10 teams. Those are both stable organizational configurations. The transition between the small to the large team can be difficult and unstable, and Will provides us with a playbook on how to execute it.

tl;dr: Lara provides a “delegation template” that prompts the manager to describe, in one sentence, the outcome they want to see, as well as 3 phrases to complete when delegating:

1) “I will support you by…” - aim for 2-5 actions on how to provide support.

2) “You should reach out to me when…” - how and when the report should connect with you.

3) “This will be a success when…” - make this measurable and time-boxed.

tl;dr: “DX is about developer feelings - it is a sociotechnical system which should consider every touchpoint a developer interacts with to plan and produce software, from learning a platform to the very first line of code all the way through its promotion into production.”

tl;dr: “Cypto-mania is not really about technology. If you want to understand what is going on, you need to understand it at the level of economics, culture and human nature.” Luke asks the following 3 questions to evaluate cryptocurrencies: what problem does this try to solve? Does it actually solve it? What costs does it bring with it?

tl;dr in tech by Joe Karlsson - Issue #22

Tue, 10 May 2022 00:00:00 GMT

tl;dr: No joke. This article has made me more money than anything else I have ever read. Haseeb explains each of the following in detail:

1) Get everything in writing.

2) Always keep the door open.

3) Information is power.

4) Always be positive.

5) Don’t be the decision maker.

6) Have alternatives.

7) Proclaim reasons for everything.

8) Be motivated by more than just money.

9) Understand what they value.

10) Be winnable.

tl;dr: “I split the emotions into good vs. bad to get a clearer read of my mood. The overall score swings between -1 (very bad) and 1 (very good). I don’t want to be spammed with cats every time I itch my nose and trigger a frame of video that’s interpreted as negative so I added a three-second trailing average to look for prolonged periods of negative emotion.”

tl;dr: “Reach out to the maintainers and offer them generous speaking fees for remote talks to your engineering team.” Simon believes that companies are more likely to spend on a one-off paid speaking opportunities than pay a monthly donation. If the maintainer is not an experienced speaker, find a member of your team to act as a host and gather questions from your engineers in advance to run the session as a Q&A.

Empowering everyone to build reliable and efficient software.

tl;dr: “I have nothing against process but startups generally implement them way too early and way too often.” Ravi’s advice to those thinking about instituting a new process is to answer this question: “If you could only get one thing done this year, what would it be?” Whatever the answer is, don’t waste your time on anything else. “Take your best person, make them responsible for solving that problem, and give them everything and everyone they need to make it happen.”

tl;dr: If anyone gets stuck on something for more than 30 minutes, they should ask for help. Why?

1) Simply formulating the question to ask allows us to answer the problem ourselves.

2) We are stuck because of something we don’t know, making it impossible to proceed.

3) We don’t get frustrated.

4) Reduces costs.

tl;dr: Being data-driven has been a priority for companies but many have seen mixed results. According to a survey of executives, company culture is a harder hurdle to clear than any technical problem, and the explosion of the amount of data, privacy concerns and data ownership keep making the task harder. Randy offers three principles:

1) Think different and be creative.

2) Fail fast, learn faster.

3) Focus on the long-term.

tl;dr: “Infrastructure Platform teams enable organizations to scale delivery by solving common product and non-functional requirements with resilient solutions.” The 7 key principles that can help you build the right thing are discussed.

tl;dr: Seth discusses the steps he’s taken to ensure that the packages he’s developed, notably urllib3, are secure. “I hope that some of the knowledge I’ve gained along the way can help you secure your own packages as well as inspiring some adversarial security-minded thinking.”

tl;dr: “If you want to become a manager, be aware that you’ll have to forgo some of what you probably like most about your field,” such as:

1) Focus time

2) Short feedback cycles - “management doesn’t yield instantaneous results.”

3) Conflict avoidance - as a manager you have to deliver the bad news.

4) Making technical decisions.

5) Learning new technical skills.

tl;dr in tech by Joe Karlsson - Issue #20

Thu, 28 Apr 2022 00:00:00 GMT

tl;dr: The ML model takes into account spatial and temporal features, such as the origin, destination and time of the request, as well information about real-time traffic and the nature of the request, such as whether it is a delivery dropoff or rideshare pickup.”

tl;dr: “If you agree with the notion that you need to be able to tell the difference between the absence of a value and a value itself, then this has some impacts on the code you write. If you want to keep ‘em separated (so they can come out and play), then it gets you looking at your API designs in certain ways.” The author shares her reactions to some of the ways a value can be returned.

tl;dr: Markdown in all its flavors, interpretations, and forks won’t go away. However, it’s important to look at emerging content formats that try to encompass modern needs. In this article, Knut shares his advice against Markdown by looking back on why it was introduced in the first place, and by going through some of the major developments of content on the web.

tl;dr: Start experimenting with ten mental models you can use to get unstuck, look at difficult problems from new angles, verify your assumptions, and understand systems more deeply.

tl;dr: A growing body of evidence is showing that employees who feel comfortable and psychologically safe are more engaged and creative team members.

tl;dr:

1) Imagine you’re telling your story at a bar. How would that change the way you related information?

2) Use the art of persuasion to tell stories that change minds and rally teams - “stick to a very short, simple message that you repeat in different ways again and again.”

3) The best leaders know how to tell stories about failure - “being vulnerable doesn’t weaken your authority. It strengthens everyone else around you.” And more.

tl;dr: “This blog post is for top-of-mind technologies that are improving my life at the moment.” Jowanza provides insight into how he’s leveraging:

1) Docker.

2) Httpie, a CLI tool for HTTP calls.

3) OpenAPI 3, a specification for describing RESTFUL APIs.

4) TypeScript.

tl;dr: “I hope this post will help platform engineers develop their cloud-native, self-serve streaming data platforms and scale use cases across many business functions (not necessarily from our success but maybe more from our failures).”

tl;dr in tech by Joe Karlsson - Issue #19

Tue, 19 Apr 2022 00:00:00 GMT

New Blog Alert! tl;dr: Databases are frequently left out of the DevOps discussion. In this post, I talk about best practices for setting up a database in your DevOps pipeline and then show you how to do it using GitHub Actions.

tl;dr: “As the founder of a developer tools startup, I’ve talked with hundreds, if not thousands, of software developers in the course of routine user research.” Jean presents the “truths” about building enterprise software for “99% developers,” the ones working outside of “hip companies and frameworks”:

1) Smaller companies attempt to the imitate tooling of FAANG companies despite different resources.

2) There is no gold standard development environment.

3) The goal is progress, not perfection, and more.

tl;dr: “A deep dive with five Technical Program Managers (TPM) on what the role is, how it evolved, and how engineers and managers can benefit from working with TPMs.” Gergely concludes that senior engineers already do lots of the things that TPMs do full-time. 1) Fast-growing tech companies rely heavily on TPMs to scale engineering efficiency. 2) The TPM role is spreading steadily across the industry.

tl;dr: “Discussion with Mitchell Hashimoto, co-founder of HashiCorp, who recently returned to the role of independent contributor after stints as both CEO and CTO. We talk about his journey learning to write software, how he came up with the idea for Terraform, and why he prefers slinging code to executive roles.”

tl;dr: “We’ll start by creating a positioning system that can tell us where we are. Our initial approach will be quite simple, but we’ll step-by-step improve upon it to build an understanding of the positioning method used by GPS.”

tl;dr: Co-founder and CEO at Coda’s to-do list philosophy:

1) Start every new day fresh with no weight from the previous day’s list of things to do, just a new sheet of paper with a new set of priorities, don’t compound from the previous day.

2) Do the hardest task first.

3) Have a column with next action so you can see which tasks are missing a next step.

4) Know whether it’s on your plate or someone else’s.

tl;dr: Despite saying 2021, the survey took place this January, so the results are up to date and represent the answers given by the 16,085 respondents. As with any survey or poll, be careful in how you interpret the results (many folks have noted problems around diversity or methodology). Highlights:

* esbuild was the tool with the largest year on year satisfaction growth. 5.6% of respondents are using Deno.

* Long standing libraries Axios, Lodash and Moment remain the most popular.

* Syntax is by far the most popular podcast but there are 24 others in the list to check out.

* TypeScript is by far the most common alternative ‘flavor’ of JavaScript, with Elm a distant second place.

tl;dr: “Your phone’s ability to identify any song it listens to is pure technological magic. In this article, I’ll show you how one of the most popular apps, Shazam, does it.”

tl;dr: 1) Don’t swerve around a debate. 2) Be generous with your ideas. 3) Think of yourself as the team captain, not the head coach. 4) Set the tone with cross-functional partners. 5) Write down what makes you tick. 6) Shine a light on failure. 7) Pull back the curtain. And more.

tl;dr: Charity presents strategies, such as backchanneling with contacts, effective D&I practices, and also maintains that how the interview is organized is telling

1) Was the interview conducted in a timely fashion? Were you given detailed information about what to expect?

2) Were you compensated for your any take-home projects.

3) Did they get back to you swiftly at each step of the way to let you know where you stand and what comes next?

tl;dr: What is a low-friction small thing that most will not notice, but that when they do, is a sign of craftsmanship, expertise, and pride in one’s work? Vicki has created a list relevant for ML and Data Science:

1) Python code has type annotations.

2) Accurate documentation of a repo and an easy, reproducible way to run the project.

3) Formatted and linted SQL statements. And more.

tl;dr: How do we best divvy up responsibilities in an engineering team, given the complexities of modern day technology stacks. Ben argues there are 4 things to consider:

1) Optimizing for productivity

2) Code quality

3) Risk of a developer leaving

4) Developer happiness.

Once we know how to weigh each, there are several models to consider: ownership, free-for-all, stewardship, and conservatorship, all discussed here.

tl;dr: “If you’re here because you want to fix your GIF and want the quick answer, the solution is: set your frame delay to 20ms instead of 10ms. If you want to learn a bit more about GIFs, exactly why this edge case happens, and some thoughts on how to improve things, keep reading!”

tl;dr in tech by Joe Karlsson - Issue #18

Tue, 12 Apr 2022 00:00:00 GMT

tl;dr: “Defining requirements for an April Fools’ project is extremely important because it will launch with zero ramp-up and be available immediately to all of Reddit’s users. If it doesn’t work perfectly out of the gate, it’s unlikely to attract enough users to make for an interesting experience.”

tl;dr: “You’re the CEO of yourself - a one-person enterprise - act like one.” Subbu realized that “managing yourself includes managing your internal state” i.e. how you feel about yourself and others, your emotions, time, relations, etc… yet most are not aware of their internal state. A CEO rarely runs the company based on that morning’s news, social media chatter, or the stock ticker.

tl;dr: People hate regexes for 2 reasons:

1) They’re hard to read, so it’s hard to tell what a regex does.

2) They’re fragile an a slight change to the input can break it and making them more robust is tough.

Hillel argues that the best use cases for regexes is in “interactive use” - when you’re trying to substitute in a single file you have open, or grep a folder. “Readability doesn’t matter because you’re writing a one-off throwaway, and fragility is fine because you’re a human-in-the-loop.”

tl;dr: “I recently learned how UTF-8 works and felt that the definition lended itself perfectly to creating diagrams explaining the implementation. I created these diagrams for my own enjoyment and wanted to share them. Hopefully this will inspire you to learn how other low-level protocols work too!”

tl;dr: “With help of Ergodox keyboard and Colemak layout I changed my typing habits and saved my wrists from severe pain.”

tl;dr: This is the mac app version of the Windows app DevToys.

tl;dr: “A great meeting has three key elements: the desired outcome of the meeting is clear ahead of time; the various options are clear, ideally ahead of time; and the roles of the participants are clear at the time.” Daniel, founder and CEO of Spotify, also discusses time management, common mistakes with time management, delegating decisions, and more.

tl;dr:

1) Writing open source software can be very rewarding in ways you can’t predict e.g gratitude from users, improvement as an engineer, etc…

2) Be in it for the long haul. “If you are consistently working on improving the project, it will get noticed and used over the flash-in-a-pan software that appears and eventually gets abandoned.”

3) Ship it and ship regularly. And more.

tl;dr:

1) How would you like to grow within this organization?

2) Do you feel a sense of purpose in your job?

3) What do you need from me to do your best work?

4) What are we currently not doing as a company that you feel we should do?

5) Do you have the opportunity to do what you do best every day?

tl;dr: Each time Dan lost focus and tried to login to Twitter he updated a spreadsheet called “Twitter Attempts,” where he would note what he was doing right before. This taught Dan he lost focus due to the following:

1) A shift between pragmatic and intuitive modes of thought.

2) Emotional shift.

3) Beginning of an interval of waiting.

4) Completion of a task.

tl;dr: “Right. So the operating system must have, like, a hash map from a port and IP pair to a socket, for each combination of TCP or UDP, IPv4 or IPv6.” Paul explains what’s happening under the hood.

tl;dr in tech by Joe Karlsson - Issue #17

Tue, 05 Apr 2022 00:00:00 GMT

tl;dr: “As a leader… if you spend all your time trying to stamp out fires, you’ll never be able to look ahead, strategize, or actually grow and evolve.” Lara walks us through the Eisenhower Matrix, which maps importance and urgency, and how that defines which tasks to delegate.

tl;dr: Ankit shows us how to architect an Instagram scale photo-sharing application where users can upload photos and view those photos, follow other users, view feeds containing posts of the users they follow, like, and comment on posts.

tl;dr: Deployment is a contentious issue. Some folks will believe that “teams have to be able to deploy from commit to global production in minutes” and “others will point out that their industry has multi-year product cycles.” Marc highlights the trade-offs, provides his perspective and his advice navigating the tension between speed and safety.

tl;dr: “To do something together, build shared understanding and then everyone can make compatible decisions. The old style of imposing a single person’s mental model on the group doesn’t work in complexity (and also it’s mean).”

tl;dr: Advice around optimizing workspace includes:

1) Screen should be at least to nose level.

2) Bringing your visual to a narrow space enhances focus.

3) Make sure that whatever you are looking at is straight in front of your eyes.

4) For every 45 minutes focused on something narrow, get 5 minutes of relaxation. And more.

tl;dr: “As the name might suggest, this is how you connect to a database using CSS. It only works in Chrome, unfortunately, but you can provide any SQLite database you like and query it via CSS.”

tl;dr: “This is a new option that basically works as an alias, or shortcut, to sending JSON to an endpoint.”

tl;dr: “Your job is not to manage people, but to manage processes and lead people.” The CTO at OnDeck provides advice on all management topics in short, bullet, form ranging from creating trust through transparency, avoiding “drive-by management,” how to give feedback, and more.

tl;dr: Ankit guides us through the architecture plan for a Netflix style application, planning for the following scale: 100 million active users registered, 2500 MB uploaded every minute, 10 combinations of resolution and codec formats supported, 3 videos watched daily.

tl;dr in tech by Joe Karlsson - Issue #16

Tue, 29 Mar 2022 00:00:00 GMT

tl;dr: “I enjoy collecting rare and vintage programming books. There’s just something quaint about pre-internet computer books, with their dead-tree print editions and crude typesetting.” Tiemo shares 3 favorites and sumarizes the backdrop of each.

tl;dr: “The proposal introduces a new operator. This operator is an idea borrowed from functional programming that makes applying functions more convenient in many cases. This post describes how the pipe operator works and what its use cases are (there are more than you might expect!).”

tl;dr: “I was curious to know if the functionality of VSCode can catch up with the native speed of some editors, such as Sublime. That led me to seek out where some bottlenecks may be and where time is being spent. In this post, I look at both the internals and extensions.”

tl;dr: “In this post I’ll run through a whistlestop tour of the concept of leadership, and share some of the prompts that I’ve used to help people navigate this tricky topic.” Sally provides us with 5 prompts to help us hone in on what our personal leadership style.

tl;dr: A company’s core values are important to consider when hiring but, how do you develop an interview question that measures those values? Jacob outlines 3 things:

1) Describe how the value influences action.

2) Figure out what behaviors are behind the value.

3) Find a situation where this value would influence behavior.

tl;dr: “What looks like a technical debt in a software solution, might be the most efficient way for people to deliver business value in a given situation. There is a beauty in that, if observed from a distance.”

tl;dr: “This post describes how the Netflix TVUI team implemented a robust strategy to quickly and easily detect performance anomalies before they are released - and often before they are even committed to the codebase.”

tl;dr: “Researchers from MIT, Purdue, and Yale demonstrated that turning off the camera during a Zoom meeting shrinks the environmental footprint by 96%.” This inspired Noah to think about a mobile app’s carbon footprint and he shows us how adding or removing 1MB in app size can have a surprisingly large impact.

tl;dr:

1) Hybrid working is here to stay but key questions remain e.g. how many days a week should we be in the office?

2) Companies that have been effective at developing loosely coupled systems - often with a microservices architecture - were better set up to work remotely and using a distributed approach.

3) Three interesting developments in the data engineering and AI/ML space in 2021, outlined here, and more.

tl;dr in tech by Joe Karlsson - Issue #15

Wed, 23 Mar 2022 00:00:00 GMT

tl;dr: “It’s been a while since I was on the receiving end of a software engineering interview. But I still remember my favorite interview question. It was at [SingleStore] circa 2013… Since [SingleStore is] a database company, this is a database challenge.”

tl;dr:

1) We’re not answering the user’s needs, notably around performance and accessibility.

2) We’re overusing JS: Both in our dependencies and in our own code.

3) We’re underusing HTML and CSS, partly due to IE support, but now that we don’t need to support IE there are many features that become usable.

TL;DR:

tl;dr: “A good plan would result in strong execution and a successful outcome” but this approach failed Scott when managing larger projects. His advice: “make plans that bend and adapt with the changing world around you. I built a habit of forming rough, directional plans, testing them with small bets, and using quick production feedback to reorient myself and start the cycle again.”

tl;dr: Ankit shows us how to design the architecture for a global Tinder-like service where users can create profiles, view recommendations of other users in geographically nearby regions, like or dislike other recommended users, get notifications when matched and be able to move to a different location and still get recommendations of nearby users.

tl;dr: “You’ve probably seen web editors based on the idea of blocks. I’m typing this in WordPress, which has a little + button that brings up a long list of potential blocks that you can insert into this page.” Joel thought it would be cool if blocks were interchangeable and reusable across the web, and is creating the Block Protocol doing just that, discussed here.

tl;dr:

1) There are enough “known knowns” in the project i.e. things you’re aware of and understand.

2) There are no more “known unknowns” i.e. things you’re aware of but don’t understand.

3) There are too many “known unknowns” - this might be a good indication that you need more info, and a prototype can focus your efforts.

4) You stop learning new things.

5) Falling down the rabbit hole.

tl;dr: “I can’t count how many times I’ve heard programmers talking about writing some new piece of code to work around the behavior of some other code which they don’t want to change. You are a programmer - you are allowed to change code! In fact, it’s your job! Just change the code to do what you want! Fix the bug! Change the behavior! Add the feature!” Spenser illustrates this with common excuses people give.

tl;dr: “The biggest mistake I see engineers make is doing too much work on their own before looping in others.” This costs time and creates the risk of going down the wrong path. Managers can help:

1) Encourage engineers to show work as quickly as possible.

2) Help them decide what to show that provides meaningful feedback.

3) Encourage launching something end-to-end internally, quickly.

4) Encourage constructive feedback & watch for toxic feedback, which discourages iterative development.

tl;dr: Ankit shows us how to design architecture similar to Uber’s: Riders are able to view available drivers in nearby locations, request rides from source to destination, notify nearby drivers of the ride and allow one of them to confirm the ride, show pickup ETA to customers when a ride is dispatched.

tl;dr in tech by Joe Karlsson - Issue #14

Wed, 16 Mar 2022 00:00:00 GMT

tl;dr: “Scientists keep logbooks for their findings. Why don’t computer scientists?” Conor shares an example of one and cites these benefits:

1) Enumerate where you are in the bug fixing journey.

2) Keeps you rooted when you have a stack of issues.

3) Makes your future steps clearer.

4) Documents the time and effort spent, helpful to show your team the energy you put in.

5) Documents your eventual success and how it happened.

tl;dr: “This post describes a very casual code review of a few cryptography functions used by MetaMask. It does not describe any vulnerabilities. If you’re the kind of person who likes a meandering and amateurish code review that goes absolutely nowhere, you’ll enjoy this post.”

tl;dr: Swiss Army knife for developers. An offline Windows app that helps developers in daily tasks.

tl;dr: Ankit shows us how to design such a system factoring in such scale: 1 Billion users on the application per month, 650,000 active users per second at peak, 40m messages per second at peak. “The entire application will comprise of several microservices each performing a specific task.”

tl;dr: The survival zone is when your energy is high, but negative at work. People in this zone are anxious, impatient, and self-critical. Tony shares 6 observations to avoid falling here:

1) Become a sprinter, not a marathoner.

2) Substitute self-observation for judgment.

3) When you feel bad, remember that’s not the whole story.

4) Create a safe space for yourself within yourself.

5) Take up something you enjoy doing just for its own sake.

6) Make someone else’s life better.

tl;dr: “I left Facebook (Meta) in 2021 to join a small startup called Replit. Leaving wasn’t easy, and during the process I’ve talked to half a dozen friends who were in the similar situation. I hope this post would be useful to senior engineers who are looking to leave.”

tl;dr: “Your salary negotiation - which routinely takes less than 5 minutes to conclude - has an outsized influence on what your compensation is… That makes your negotiation five very important minutes.”

tl;dr: “I guess I’m looking at this a bit like the last time I lost data due to a hard disk failure. I always knew there was a risk but until it actually happened, I didn’t take the necessary steps to protect against that risk doing actual damage. But hey, it could have been so much worse; that number could have been 10x higher and I wouldn’t have known any earlier.” Troy dives into the 17.3GB data spikes that caused his Azure bill to rocket.

tl;dr in tech by Joe Karlsson - Issue #13

Tue, 01 Mar 2022 00:00:00 GMT

tl;dr: Engineering managers are “attracted to formulas, algorithms, and structures” and this kind of thinking can create too much structure when applied to team management. Camille gives an example: Engineering managers do not scale well beyond 7 - 8 direct reports, and teams can also downsize quickly i.e. people quit. Therefore, “the temptation is to create a clean tree structure for your organization” to rebalance numbers, but this can have adverse consequences quickly. Camille advises “to nudge it back into shape over time, or very occasionally, reorganize into something more appropriate.”

tl;dr: Coleman recommends the following management style: having a “hard outer boundary for work with soft requirements on approach.” This requires trust in the product and engineering teams to choose approach trade-offs wisely, and allows for some freedom, but the team knows that freedom is not infinite. “The team can explore and experiment to a point, but doesn’t have forever to mess around.”

tl;dr: “The stay interview is essentially the opposite of an exit interview.” Examples of question: What’s your favorite and least favorite thing about working here? What might tempt you to leave? If you could change something about your job, what would it be? What talents are not being used in your current role? What would you like to learn in your current role?

tl;dr: “We want to share how we decided to work with technical debt and how Evolutionary architecture and SRE help us balance innovation and quality in mobile development.” Maksim provides several examples, such as how each team can dedicate up to 20% of their capacity to technical improvements.

tl;dr: “By collecting data from thousands of developers, the annual State of JavaScript survey is able to identify current and upcoming trends in the ecosystem.”

tl;dr: “I finally managed to get my hands on some DDR5 RAM to complete my Intel i9-12900 high-end PC build! This article contains the exact component list if you’re interested in doing a similar build.”

tl;dr: Attention all Senior Devs! “Use your privilege. As privileged tech community members, it’s your job to help fight the gatekeepers on your teams. It is your job to make space at the table for those who have been kept out.

tl;dr: This video really puts a lot of things into perspective about how ‘easy’ I have it as a cis white man in tech. Bree does a great job of breaking down how discrimination happens in the tech hiring pipeline.

tl;dr: “Attracting new talent starts with having an honest look inward at your current culture. How are you growing and developing your team now? Who is rising up the ranks? Who is represented in leadership (and in the succession plans for leadership?) Who is choosing to leave and why? You need to do an honest look inward before you identify external places to post a job ad.”

tl;dr in tech by Joe Karlsson - Issue #12

Tue, 15 Feb 2022 00:00:00 GMT

tl;dr: Knowing how your org works can be:

1) Knowing what technical skill you need to invest effort into that will actually be rewarded.

2) How to build lasting relationships with other people on your team or organization that will ultimately dictate the success of a project.

3) How to effectively pitch projects or improvements and see these through to completion.

4) How to navigate ambiguity and more.

tl;dr: As Daniel transitioned into a new role of managing managers, he sought wisdom from several, experienced executives, asking them 4 questions:

1) What worked for you and helped you succeed?

2) Have you experienced failure? What would you have done differently?

3) Were there any resources you found helpful as you grew into the role.

4) What piece of advice would you give your past self before entering the role?

tl;dr: “The types of problems organizations have are heavily influenced by their incentive structure.” Marianne describes the types of problems you’ll find in various org structures i.e. in engineering led orgs, orgs where engineering reports to product, or security, or in flat orgs. She concludes “the best organizations at managing technical debt tend to be the ones that have a thoughtful process in place to adjudicate competing incentives.”

tl;dr: Independent, cross-functional meetings at Squarespace e.g. Infrastructure Council, Backend Council and Data Council create a “sense of togetherness across an ever-growing engineering organization.” Dan started the Engineering Manager Forum and shares his blueprint for how it’s run.

tl;dr: Three pieces of information should be conveyed by an error message:

1) Context: What led to the error? What was the code trying to do when it failed?

2) The error itself: What exactly failed?

3) Mitigation: What needs to be done in order to overcome the error?

Gunnar also highlights best practices: having a uniform voice and style, consistency in terminology, and more.

tl;dr: The first 3 are:

1) Observability: covers the spectrum of logging, metrics, distributed tracing, telemetry, alerting, etc.

2) Estimate how long it takes your team to go through the CBTD (code-build-test-debug) loop and ask yourself what that numbers tell you.

3) Flaky tests erode trust and breed learned helplessness.

tl;dr: “The median data to engineers ratio for the US companies I looked at is 1:7 compared to 1:4 for European companies. And the design to engineers ratio is 1:9 for both groups. This post gives some answers to why this is but also leaves some questions unanswered.”

tl;dr: Earth’s rotation, relative to the fixed stars, has sped up and is predicted to continue to do so. Although there are no immediate implications, if it continues over a sustained period of time, we might find ourselves having to consider a negative leap second, as explained here.

tl;dr: A mental model for how a neural network works by building one from scratch. “The hardest part is acquiring the conceptual understanding of a system to come up with an equation for its performance.”

tl;dr in tech by Joe Karlsson - Issue #11

Wed, 02 Feb 2022 00:00:00 GMT

tl;dr: “A truly great leader is someone that can not only figure out the impact of a potential decision, they can fully understand the impact of that decision on all the people who will be touched by it.” Evan Cooke, former Twilio CTO, outlines the two significant issues faced by CTOs of later stage startups

1) Not knowing fellow leaders well enough

2) Misunderstanding the needs of the company - and how to navigate them.

tl;dr: “Repeating the conclusion isn’t useful. The question that reached that conclusion is useful over and over.” Yet, Jessica points to the fact that we tend to replicate team structures of successful companies without asking the right questions. Instead of “what do successful teams do?” ask “how did that team that worked well reach its way of working?”

tl;dr: “Engineering Enablement teams’ main goal is to reduce complexity and improve development velocity and time to market by providing self-service solutions, engineering standards, and best practices. The team aims to enable developers to focus on business logic and puts an emphasis on developer experience and product quality.” Tal discusses this team’s role in detail, who they are and their purpose.

tl;dr: “Quantization reduces the number of bits required to store a number. In other words, it reduces the precision of the number. The basis behind it is to divide our number by a quantum and then round to the nearest integer.” Bilal talks us through each step taken for JPEG compression to happen.

tl;dr: “This quick ‘n dirty hack that I wrote in a couple of minutes replaced two weeks’ worth of work in 1987 and ran almost two million times faster.” Curtis shows us the BASIC code he wrote 35 years ago and its contemporary counterpart.

tl;dr: “If you speed up your website by 2 seconds, everyone agrees that that’s a good thing with a visible user impact. If you reduce your website’s memory leak by 2 MB, can we still agree it was worth it? Maybe not.” Nolan discusses the unique characteristics of memory leaks:

1) Low-impact until critical.

2) Hard to diagnose.

3) Trivial to fix once diagnosed.

tl;dr: “When you operate at this type of scale, centralization is the enemy of efficiency. This is a paradox. Being efficient on a macro level requires being (very) inefficient at the micro level.” Ben discusses the implications of this in - documentation is essential, teams are fragile and suffer from churn, everything is urgent and takes forever, everything is built in house.

tl;dr in tech by Joe Karlsson - Issue #9

Tue, 18 Jan 2022 00:00:00 GMT

tl;dr: “The goal of this post is to help remind you to reflect on your current development process. Is there some piece of your pipeline taking longer than it needs to? Is there a way to create some debug tools that makes it easier to test a change? Would unit testing bring benefits, but you keep avoiding it because you think there’s a big upfront cost to it?”

tl;dr: “At Twitter, most CPU bound services start falling over at around 50% reserved container CPU utilization and almost all services start falling over at not much more CPU utilization even though CPU bound services should, theoretically, be able to get higher CPU utilizations.” This document describes potential solutions.

tl;dr: This article gives an overview of engineering milestones that will happen in 2022. The technologies include Wi-Fi 6E, electric planes, 3-nanometer chips, cryogenic energy storage, and more.

tl;dr: “This year in review is a no-nonsense write-up of some great things that happened, a bit of drama, and some things we did poorly… We figured we could use SingleStore for everything, and that’s what we did. This move saved us a huge chunk of cash.”

tl;dr: “This article explicitly focuses on senior leadership roles, which were what I was looking for.”

1) It will likely take longer than you expect.

2) Independent headhunters and recruiters are a valuable resource.

3) Use your project management skills to keep your sanity.

4) Be strategic around your interviews and chats.

5) Do not waste your time, but part as friends with everyone in the process.

tl;dr: Mentorship conversations are quite different from coaching conversations. “When someone comes to me, they’re usually asking bigger question not tied to our day-to-day work and these conversations fall into three categories:”

1) Goals - figuring out what they really want.

2) Situations - handling the unfamiliar or difficult.

3) Skills - getting promoted. David discusses how to mentor each.

tl;dr: Candost sees decision-making as a spectrum - or pendulum - between authority and consensus: “On one side, we have the authority, and on the other side, we have the consensus. This pendulum requires leaders to go back and forth. Having flexibility in decision-making is crucial and more persuasive than sticking to only one.”

tl;dr: “How Liberty Mutual implemented a high-performing DevOps culture to increase stability, shorten release cycles, and deliver value faster.”

tl;dr: “The prospect for another federated, Internet wide communication system seem very remote at this point in time, so email is it.” Email is our only reliable communication method between different organizations and, at this point, companies have something to lose if companies try to replace email.

tl;dr: Laws, Theories, Principles and Patterns that developers will find useful.

tl;dr in tech by Joe Karlsson - Issue #8

Wed, 12 Jan 2022 00:00:00 GMT

tl;dr: New blog post alert! Key-value stores (like Redis) are perhaps one of the most popular databases on the market today - and with good reason! And in this post, I will show you how you can create a scalable key-value store in using just SQL.

tl;dr:

1) Engineering: How are things being built?

2) Execution: How are things getting built on time and within budget?

3) Operations: Is the built thing going to keep running?

4) People: Are people motivated taking part in what is being built?

5) Product: Are customers satisfied by what is being built?

6) Partners: Do all my partners understand and agree with all the above?

7) Company: How do I get the company to align with all these answers?

tl;dr: Agile is not achieving a sustainable speed in an optimal direction; “it is being able to change both speed and direction, and to do so easily. It is the second derivative of position with respect to time, not just the first: agility relates both to velocity and to the ability to change it, revising direction and pace as circumstances demand.”

tl;dr: “Incentives are never perfect because management always has a limited understanding of the system it manages.” Therefore, unrewarded work is often carried out to keep the system in place. However, Milosz argues, this results in management avoiding or ignoring issues and, in order, for change to happen, we must be open to failure on a personal level and culturally, as a company, for these issues to be tackled.

tl;dr: “I thought it might be fun sharing a few nitty-gritty details of how this “biggest innovation in human communication since the invention of the letter” works under the hood.” Nikita shows us the various ways in which emojis can be encoded.

tl;dr: “I built a site where you can do experiments with DNS called Mess With DNS. It has examples of experiments you can try, and you’ve very encouraged to come up with your own experiments. In this post I’ll talk about why I made this, how it works, and give you probably more details than you want to know about how I built it (design, testing, security, writing an authoritative nameserver, live streaming updates, etc).”

tl;dr: Ivan compiled a new data set for his model to train on: 3800 images of Lego faces. “The end product can be used for interesting applications including generating new Lego faces and morphing smoothly between Lego faces.”

tl;dr: As a leader, you must trust your team. However, trusting your team can, at times, be at odds with helping them succeed. Human error or bad processes can come into play. Will uses “inspected trust:” when someone “brings a problem or a concern to you, trust them that there is a problem, but give yourself space to independently verify their interpretation of the problem.” He highlights various ways of doing this.

tl;dr: For a leader to enable her team to be more effective, 3 conditions must be met:

1) Mutual trust amongst members.

2) A group identity i.e. members belong to a unique and worthwhile group.

3) Sense of group efficacy i.e. the belief that group members are more effective working together.

At the heart of these is the ability to create awareness of emotions and regulate them, and Ed presents a framework of 14 questions and a step-by-step process that allows a group to assess where they are collectively.

tl;dr: Seth shares a few scripts written by the engineering manager of the infrastructure team at Gitlab, who is tasked with coordinating large-scale infrastructure and code improvements. The scripts parse issues and epics in order to gain better visibility into the work that needs to be done.

tl;dr in tech by Joe Karlsson - Best of 2021 Special Edition

Thu, 06 Jan 2022 00:00:00 GMT

Podcasts

Behind the Bastards dives in past the Cliffs Notes of the worst humans in history and exposes the bizarre realities of their lives.

How did 9/11 the day become 9/11 the idea? That question drives Pineapple Street Studios and award-winning host Dan Taberski.

Just listened to a really interesting Podcast. Unread is a four-episode nonfiction piece built on a personal tragedy wrapped in a mystery that comes with a hell of a hook. It’s about a guy who gets a suicide note from a friend. But the message also contained link to audio files containing conversations between him and a woman that sounds exactly like Britney. It’s about internet stan culture, suicide, and depression. I loved it!

Forever is a Long Time is a five episode series that weaves reflection and original music through Ian’s conversations with his wife and divorced family members - a look at love with people who have made mistakes.

Cathy, the iconic and much-maligned comic strip by Cathy Guisewite, chronicled the day-to-day tribulations of its titular working woman for 35 years, met with equal praise and derision. In this podcast, Jamie Loftus (Lolita Podcast, My Year in Mensa) weaves between reporting and fiction, putting a cruelly treated cartoon everywoman in context.

In August of 1619, a ship carrying more than 20 enslaved Africans arrived in the English colony of Virginia. America was not yet America, but this was the moment it began. No aspect of the country that would be formed here has been untouched by the 250 years of slavery that followed. On the 400th anniversary of this fateful moment, it is time to tell the story.

If you’ve heard of Bladen County, N.C., it’s probably because it was home to one of the few cases of election fraud in modern American history. Is there really rampant election fraud? Who exactly is making the accusations? And in small-town politics, where rumors and allegations abound, how can you be sure who is telling the truth?

In the 1980s the “male exotic dancers” of Chippendales were everywhere, selling the promise of women’s liberation for the price of a few dollars in a g-string. But behind the powerful mullets, oiled pecs, and non-stop parties lies a much darker story of greed, corruption and murder. Historian Natalia Petrzela exposes one of the great, sordid, unexamined stories in American culture.

How a military officer and a faked refugee identity were part of an alleged far-right plot to bring down the German government.

Films

Charismatic rancher Phil Burbank inspires fear and awe in those around him. When his brother brings home a new wife and her son, Phil torments them until he finds himself exposed to the possibility of love.

Feature adaptation of Frank Herbert’s science fiction novel about the son of a noble family entrusted with the protection of the most valuable asset and most vital element in the galaxy.

A quirky, dysfunctional family’s road trip is upended when they find themselves in the middle of the robot apocalypse and suddenly become humanity’s unlikeliest last hope.

Offered a plea deal by the FBI, William O’Neal infiltrates the Illinois chapter of the Black Panther Party to gather intelligence on Chairman Fred Hampton.

A truffle hunter who lives alone in the Oregonian wilderness must return to his past in Portland in search of his beloved foraging pig after she is kidnapped.

Television

The Roy family is known for controlling the biggest media and entertainment company in the world. However, their world changes when their father steps down from the company.

An isolated island community experiences miraculous events - and frightening omens - after the arrival of a charismatic, mysterious young priest.

Joe, beloved choir teacher, discusses topics of interest. First up, iron!

Joe Pera Talks with You: Created by Joe Pera. With Joe Pera, Jo Firestone, Gene Kelly, Jo Scott. Joe, beloved choir teacher, discusses topics of interest. First up, iron!

Inside: Directed by Bo Burnham. With Bo Burnham. A musical comedy special shot and performed by Bo Burnham, alone, over the course of a very unusual year.

Albums

Bo Burnham · Album · 2021 · 20 songs.

Listen to Valentine on Spotify. Snail Mail · Album · 2021 · 10 songs.

Listen to SOUR on Spotify. Olivia Rodrigo · Album · 2021 · 11 songs.

Listen to Welfare Jazz on Spotify. Viagra Boys · Album · 2021 · 13 songs.

Listen to HEY WHAT on Spotify. Low · Album · 2021 · 10 songs.

tl;dr in tech by Joe Karlsson - Issue #7

Tue, 04 Jan 2022 00:00:00 GMT

tl;dr: “Easter eggs are unexpected or undocumented feature in a piece of computer software, included as a joke or bonus” and, among the enthusiast community, “people seem to generally like this concept in software and devices.” Dan explains why he’s against adding them into Curl.

Cloud security is a shared responsibility and a big challenge. Here are the basic rules to have in mind to set up efficient guardrails.

tl;dr: “It’s a lot harder to notice the magic of particular phrases or approaches when you see someone do it.” Lara suggests developing this skill by noticing how other leaders speak. What do they say? How do they say it? Watch how they change the direction of the conversation, pause the conversation, decrease tension, create clarity, push back, etc… Lara suggests sitting in on meetings you normally wouldn’t e.g. product or sales to pinpoint 3 new techniques or phrases that you can then start experimenting with.

tl;dr: The first major input in any kind of fair evaluation is based on the work the employee needed to accomplish, and the work they did accomplish. Camille breaks this down into “must be achieved, stretch goals, and moonshot goals” elaborating on each. She also discusses identifying management characteristics essential to the role so you can score the candidate against each, while also giving leeway for your own judgment.

tl;dr: “Besides the fact that people like me get extremely stressed implementing a new algorithm in a time limit without being able to exercise the code, while someone is watching and asking questions, there are diminishing returns to spending the 30th or 40th minute on the same topic, and this is such a tiny part of your job anyway.” Kevin believes it would be better to ask a larger number of “easily gradable” questions and provides examples.

tl;dr: The recent vulnerability discovered in log4j2 is a “perfect microcosm of all of the major ecosystem problems with “Open Source.” It is “a culture of taking from open source without giving anything back.” This software is used by the largest of companies while the maintainer of log4j2 describes his work as “a spare time passion project,” with a total of 3 people funding it prior to the vulnerability being discovered. Christine believes it’s an obligation for companies to donate in return for using OS software.

tl;dr: Annual deck that covers “the transformative visions for 2025 or 2030: crypto, web3, VR, metaverse… and then everything else. Meanwhile, hundreds of start-ups take ideas from the last decade and deploy them over and over in one industry after another.”

tl;dr: “While the Internet was designed and founded as a decentralized network-of-networks, it is continuously subjected to forces that encourage its centralization.” This document attempts to identify different types of centralization, catalogs some limitations to common approaches to controlling it and recommends best practices for protocol designers.

tl;dr: Great engineering teams focus on milestones instead of projects Managing projects is hard. Companies contort themselves to do it well. Instead of playing chess, switch to checkers. Milestones are an easier game, and you get better results.

tldr: Why is Rust being used to replace parts of the JavaScript web ecosystem like minification (Terser), transpilation (Babel), formatting (Prettier), bundling (webpack), linting (ESLint), and more?

tl;dr in tech by Joe Karlsson - Issue #6

Tue, 28 Dec 2021 00:00:00 GMT

tl;dr: Derek shares his design review process, starting with the design doc (he shares his template) through to the in-person meeting, where he outlines specifics around planning, moderation and process. This review process helps with org-wide comms, understanding of technical infrastructure, knowledge of legacy work & current projects, better design, and saves time.

tl;dr: Jessica discusses “participatory sense-making.” In software, this is developing a shared mental model of the software we’re developing, what it’s going to be, how it works. In humanity, participatory sense-making is our shared reality of made-up concepts i.e. money, economy, justice, etc… “When we’re good at participatory sense-making, we can build conscientiously, instead of reducing everything to numbers.”

tl;dr: Operational Surprises (OOPS) is when something unexpected happened in operations and presents an opportunity to discover how the observed system behavior deviated from the mental model of how the system is supposed to behave. The template shared in this post is based on the template used at Netflix.

tl;dr: 8 best practices shared including:

1) Alerts are treated as code i.e. go through code reviews, generated from existing modules.

2) Use percentiles over averages to get a higher quality signal.

3) Use playbooks to document each alert so there is corresponding documentation that explains what is broken and how to investigate and fix it.

tl;dr: “Allow me a moment to go back through some of the most disastrous decisions or projects I ever agreed to (or even fought to do, sometimes):”

1) Don’t migrate an application from the data center to the cloud.

2) Don’t write your own secrets system.

3) Don’t run your own Kubernetes cluster and more.

tl;dr: Juliano discusses how each of the following five books helped him in his career:

1) The Passionate Programmer: Creating a Remarkable Career in Software Development.

2) The Pragmatic Programmer.

3) Unwritten Laws of Engineering.

4) Remote: Office Not Required.

5) Explain the Cloud Like I’m 10.

tl;dr: “Stories from 6 engineering leaders who succeeded in building and growing diverse teams,” with the following key takeaways:

1) Underrepresented leaders make a difference.

2) There are tactical wins you can start now e.g. bias training, partnering with organizations.

3) Use structure to drive diversity outcomes & create processes around those outcomes.

4) Tactics need a defined strategy and goals.

tl;dr: “We set out to make a simple and fast inner dev loop. The core shift that needed to be made was from the fully integrated environment of Onebox (many services), toward an isolated environment where only one service and its tests would run. This new isolated environment would be run on developer laptops. Users simply edit code and run tests with no additional steps in between.”

tl;dr: The following are elements of successful UB training detailed in this post:

1) You hold the power. Bias is often subtle and our brains are wired for change.

2) Create empathy by trying to understand where others are coming from.

3) Encourage interactions among people from different groups.

4) Encourage good practices and continued learning.

5) Set a broader strategy for more significant impact.

How we process large scale data in real time at Twitter while reducing latency and improving accuracy.

tl;dr in tech by Joe Karlsson - Issue #5

Tue, 21 Dec 2021 00:00:00 GMT

👩🏾‍💻🧑🏽‍💻 Tech Articles

tl;dr: Some call community the newest “moat” for business today. No matter the sector, a vibrant community not only serves as a defensive hedge against the competition but can also drive learning, innovation, and value.”

*NEW BLOG ALERT* There are so many databases out there today! When picking your next database, it’s vital to understand what problems you are attempting to solve, so you can pick one that will fit your needs today, and in the future. 🔮

tl;dr:

1. You’re not learning (and you want to be).

2. You’re learning coping mechanisms rather than skills.

3. You feel morally conflicted about hiring.

4. Your job is affecting your confidence.

5. Your job is affecting you physically.

Pivots, MVPs and Community: How Joseph Quan, Founder & CEO of Knoetic, got his startup back on track by making community his wedge. He shares his hard-won wisdom and his six-step guide for building a community like a product.

tl;dr: “We’ve gotten to the point that Chrome-based browsers are so common that developers just stopped to bother supporting other browsers… Soon Google are going to be in complete control of web standards, unless something drastically changes. Do you want the future of browsing to lie solely in the hands of the biggest advertising business on Earth? I’m pretty sure that I don’t.”

Read RudderStack CEO Soumyadeb Mitra’s insights on the changes ahead in the field of data as the data engineering megatrend impacts every industry.

tl;dr: “Community reframes your startup by starting with the people that you’re bringing together - not the product prototype you’re envisioning in your head.”

tl;dr: “There are 70% more open roles at companies in data engineering as compared to data science. As we train the next generation of data and machine learning practitioners, let’s place more emphasis on engineering skills.”

tl;dr:

1) Data will be discussed at the board level.

2) Dedicated data engineering support for every team.

3) An increased number of ‘unicorns’ solving data problems.

4) Technology for moving data will become commoditized.

5) Real-Time (and near real-time) infrastructure will become standard.

tl;dr: “In cryptography, zero knowledge proofs let you convince me that you know something, or have done something, without revealing to me what your secret thing was.”

tl;dr: “Why is PHP still such a critical part of the web, when other programming languages and frameworks are seemingly more suited to the modern web? Second, what are the motivations behind the companies that have formed this new foundation?”

Cool projects

Another Markdown editor? Yes please!

tl;dr in tech by Joe Karlsson - Issue #4

Tue, 14 Dec 2021 00:00:00 GMT

I recently sat down for an interview to discuss my role as a Developer Advocate at SingleStore. We talked about:

1) My mission as a Developer Advocate.

2) Making complex technical content more digestible.

3) Tips for growing technical communities and more

Wanna listen to one of the best playlists I have ever made? It’s music for boppin’ around the Christmas tree, with a mix of totally obscure and timeless Christmas classics.

tl;dr: A common challenge for a leader is expressing themselves effectively when dealing with the poor performance of an employee or team. The key is to convey the feeling, and evoke the right response, so the phrase “I’m disappointed” can be powerful. “It evokes an emotional response in employees, capturing their attention, and mobilizing them to take action, but it does not convey anger or generate distress.”

tl;dr: “Software development teams have a few key characteristics that make them efficient, even at scale:”

1) Specialization of specific roles.

2) Modularization, as problems are broken into chunks.

3) Clarity of ownership.

4) Organizational buy-in that tech debt needs management.

Bryan argues that the structure around data teams is in a different place for each of the above characteristics, and we are at a “tipping point” for this to change.

tl;dr: There are often procedures that need automating. They are focus-intensive yet require little thought. These are a “slog” and can be turned into a “do-nothing script” that “encodes the instructions of a slog, encapsulating each step (that needs to happen) in a function.” Dan provides an example and believes the value is immense

1) it’s easier to power through the slog.

2) It requires less activation energy.

3) It makes future automation easier.

tl;dr: Look at the patterns that come up in these 1:1s to identify what is proving dreadful i.e. how do you speak to each other? What topics do you cover? What’s the timing of your meetings? Which patterns bother you? Then you can reset your 1:1s by “designing your alliance” articulating what each person expects from the relationship, agreeing on how you’ll work together, and being clear about your boundaries. Lara explains in detail.

tl;dr: “How an enduring framework for knowledge-sharing and decision-making helped one team make more informed, egalitarian decisions - and how you can too.”

tl;dr: “This article is my layman’s attempt to sort the basic things out with the minimum words and maximum drawings. The primary focus will be on the Data link layer (OSI L2) of wired networks where the Ethernet is the king nowadays. But I’ll slightly touch upon its neighboring layers too.”

tl;dr: “an advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language you like.”

tl;dr: “Instead of spending your coffee break scrolling through your social feeds, how about a lovely little website instead? We came across some fantastic ones that are just too good not to be shared. But be warned, your break might take a bit longer than intended.”

tl;dr: An Engineering Fundamentals Checklist checklist by Microsoft to help you with following the most recent best practices around managing code in a software project.

tl;dr: In this post, Josh takes us on a tour of his custom CSS reset. He digs into each rule, and we learn what it does and why we might want to use it!

tl;dr in tech by Joe Karlsson - Issue #3

Tue, 07 Dec 2021 00:00:00 GMT

tl;dr: I recently joined Liesse Jones from the DevOps State of Mind podcast to talk about an often overlooked facet of DevOps, data and databases. Be sure to check out if you want to hear my best practices for how to transform how you deploy your databases.

You can check my latest podcast wherever you get your podcasts or read along with the transcript on the LogDNA blog.

tl;dr: The following behaviors help engineers avoid the trap of the manager’s schedule. Engineers should be:

1) Defensive of their time.

2) “Pay themselves first” - deciding how to allocate time in advance.

3) Defend the time of others.

4) Clearly designate interrupt-driven work and batch it.

5) Designate low-leverage work, and time-box it.

6) Communicate with candor.

7) Prioritize ruthlessly.

tl;dr: Complexity metrics are flawed but, can be “useful to isolate a part of your codebase which might be more prone to defect.” Matthieu believes it’s a combination of metrics, experience, and experiments that reveal complexity in a codebase. He explains and uses the following metrics in this order when analyzing complexity:

1) LOC.

2) Code shape.

3) Structural coupling (common and content coupling).

4) Logical coupling.

tl;dr:

1) “The greatest boost to productivity is ownership.” If you feel like you’ve lost ownership over something, one sentence (or action) can make you feel like you have regained it.

2) Build your resilience through exercise, meditation, and “subjecting yourself to extremes” e.g. cold showers.

3) Calibrate your energy using power poses and

tl;dr: “A few of the things that come to mind, this thanksgiving:”

1) Open/read/write/close.

2) Goroutines as they “breathes new life” into simple blocking I/O.

3) SQLite, as it’s an “island of stability.” David shares a handful more he’s thankful for.

tl;dr: “Collectively, the information voluntarily submitted to the IRRs (Internet Routing Registries) forms a distributed database of Internet routing instructions that helps connect a vast array of individual networks.” Brian illustrates how IRRs can be spoofed - by a simple email - to remove or alter routing entries for multiple e-commerce providers, banks and telecommunications companies at the same time.

tl;dr: “This year we’re excited to share the patterns we’ve seen across the community as well as three deeper dives:”

1) Shipping code

2) Creating documentation

3) Sustaining communities.”

tl;dr: This is a list of recurring anti-patterns that Jérôme sees when he helps folks with their container build pipelines, and he provides suggestions to avoid them or refactor them into something better.

tl;dr:

1) Treat alerts as code.

2) Use percentiles over averages.

3) Have a playbook to document each alert.

4) Use Prometheus Alertmanager PagerBeauty to show who is on-call.

5) Automate all your pages.

6) Perform routine tests.

7) Make sure you have an incident management framework

tl;dr: “With a little bit of care, [a git commit] can be something that helps us stay on top of things. It can be a container for related changes that belong to one and only one topic, and thereby make it easier for us to understand what happened.”

tl;dr in tech by Joe Karlsson - Issue #2

Tue, 30 Nov 2021 00:00:00 GMT

tl;dr: So, you want to learn how to code? Here’s What You Need To Know to get started. This is basically a list of Joe Karlsson’s favorite programming books, talks, podcasts, newsletters, websites, and general tips for learning more about programming.

tl;dr: “SingleStore holds the designation of being the world’s fastest unified database for data-intensive applications. As per the company’s management, the true north star of the company is to deal with all kinds of data without workload segmentation.”

tl;dr: We’ve all been in meetings discussing a challenge with one vocal engineer, who is opinionated and likes to share ideas. It’s wrong to assume that, because no one objects, a consensus has been reached or that one engineer’s decisions are correct. “In some cultures, people won’t speak up unless someone passes them the ball and mentions their names explicitly.”

tl;dr: “Denigma explains code in conversational English. Powered by machine learning.”

tl;dr: Managers fear under utilizing resources so they orchestrate processes to put all engineers to work, simultaneously. In practice, this creates issues as projects invariably don’t go to plan and resources cannot be reallocated easily. Jacob recommends a slacklog - “a backlog of things which can happen, but don’t need to happen.” These are ideas generated by the eng team, easily transferable between members, which can be added to the process to create resource flexibility.

tl;dr: “Step-by-step we’re going to break down a high-level task of creating the self-parking car to the straightforward low-level optimization problem of finding the optimal combination of 180 bits (finding the optimal car genome).”

tl;dr: A great analysis of the current state of the ecosystem. It is a collection of opinions from a pragmatic builder’s perspective. It is focused away from economics and the financial mechanisms of the chains themselves.

tl;dr in tech - Issue #1

Tue, 23 Nov 2021 00:00:00 GMT

tl;dr: Lenny’s framework for giving performance reviews, starts with how to prepare:

1) Gather direct feedback from your report & their coworkers.

2) Capture accomplishments.

3) Describe their “superpower.”

4) Write a short high-level summary of their performance.

5) Identify 1-2 development areas, with examples, concrete suggestions, and what success looks like.

6) Share a timeline for their next career milestone. Lenny also discusses how to deliver and follow-up the review.

tl;dr: “This is the fifth post in a multi-part series on how Netflix uses A/B tests to inform decisions and continuously innovate on our products.” This post covers helpful questions to ask when thinking through if a test is conclusive enough.

tl;dr: What companies do not consider when demanding that senior engineers know specific technologies:

1) Most of the job is unrelated to that technology e.g. databases, deployment, mentoring.

2) Experienced engineers can pick up new technologies relatively quickly.

3) You may not be using this technology in perpetuity. And more.

tl;dr: Gergely looks at 30+ compensation related data points to see how companies, across different regions, are adjusting to the rapidly changing hiring market. His advice: “if your company has not yet made off-cycle compensation changes, you’ll likely have to make a case for a larger than usual raise for the new year. Start engaging your leadership now.”

tl;dr: “This article is not an attempt to explain containers in one go. Instead, it’s a front-page for my multi-year study of the domain. It outlines the said learning path and then walks you through it, pointing to more in-depth write-ups on this same blog.”

tl;dr: “We started, like we often do, with git bisect. It helped us track down the set of changes that appeared to have introduced the issue; adding a Dark Mode to Tines. “This is bizarre,” we thought, “how could a bunch of CSS changes have slowed things down?”.”

tl;dr: “Lambda is split into a control plane and data plane. Each plane is responsible for a specific set of activities in the service. The Control Plane provides management APIs and manages integrations with all AWS services. Whilst the Data Plane is Lambda’s Invoke API that triggers Lambda function invocations, this explanation is still very abstract but things will become clearer over time.” Bruno details the underlying mechanics of AWS Lamda.

tl;dr: A complete CS study plan to become a software engineer.

tl;dr: “JSON is a popular data format today and can be extremely useful for applications that need to capture information about objects that may vary in their attributes.” Akmal describes the multi-model capabilities of SingleStore by focussing on JSON data.

Videos

Why I joined SingleStore

Wed, 04 Aug 2021 00:00:00 GMT

I am excited to share today that I’ve joined SingleStore (Formerly MemSQL) as a Developer Advocate.

First, I want to say what an honor it is to be joining the founding Community Team in order to help nurture and support the massively talented current and future SingleStore developers as their numbers grow.

But, let’s get into it, why did I join SingleStore?

Innovation.

It’s simple, SingleStore is creating the future of databases. It’s no question that the data demands in every industry are exponentially growing, and I think that SingleStore is uniquely positioned to handle current and future data workloads. Increasingly, the most valuable data workloads are those that are data-intensive. This kind of workload is not compute-bound. It’s easy to scale compute in the cloud now. This kind of workload is not storage-bound. Again, it’s easy to scale storage in the cloud. Data-intensive workloads are those where *how* you process the data becomes the bottleneck.

Take, for instance, a document database used for your SaaS app. Once you start scaling your business, you need analytics and that’s the moment when you realize your document database wasn’t built for that, so you bolt-on a special-purpose database for analytics, maybe Elasticsearch or Snowflake. Then, you build an API and need low-latency fetches. So, you bolt on another special-purpose database, like Redis or AWS ElastiCache. So on and so forth. You get the idea: folks are building data-intensive apps by stitching together lots of databases and that’s just how you had to do it in 2016, but not anymore.

There’s a better way. SingleStore is the *single* database for data-intensive applications. And, it’s pretty special. SingleStore seamlessly separates compute from storage. It’s the first operational cloud database to do this. This means you can run real-time analytics, update machine learning models on the fly using streaming and historical data without needing to spin up any other systems. SingleStore is currently the only database in the industry that addresses both analytical and transactional workloads for the multi-cloud world.

I think the winners of the great “database wars” are going to be the systems that are the easiest to use, scale/maintain, and affordable, and SingleStore checks all of those boxes.

Opportunity.

I have the chance of a lifetime to build out a Community and Developers Relations team at SingleStore with my old friend, Wesley Faulkner, and my new friends, Akmal Chaudhri and Domenic Ravita. Together, we have the opportunity to build a program that aligns with our values and to build an inclusive developer community while a company is in hyper-growth mode. I couldn’t have asked for a better crew to collaborate with

Strong team culture.

The company culture can have a huge impact on how happy you are in a job, so you want to find one that suits you. Working in a startup often means that you are able to shape the surrounding culture. If you take a quick look at the SingleStore Glassdoor reviews, you will find that I’m not the only one that thinks we have a great culture.

Wrap up.

I am so excited about the future of SingleStore and our developer community. If you want to learn more about SingleStore, the best place to do that is on our SingleStore developer’s page or by trying it out for yourself! Be sure to try out the SingleStore managed database. It’s the easiest way to get an SQL database up and running in minutes.

We’re always hiring, so if you want to work with me at SingleStore, be sure to check out our careers page. https://www.singlestore.com/careers.

Be sure to follow @SingleStoreDevs on Twitter to stay up to date on the latest developer news at SingleStore. You can also follow me on my personal social accounts, it where I post about tech, leadership, community, and I post silly videos about programming. See you there!

Twitter - https://twitter.com/JoeKarlsson1
TikTok - https://www.tiktok.com/@joekarlsson
GitHub - https://github.com/JoeKarlsson
YouTube - https://www.youtube.com/c/JoeKarlsson
Twitch - https://www.twitch.tv/joe_karlsson
Medium - https://medium.com/@joekarlsson
LinkedIn - https://www.linkedin.com/in/joekarlsson/
Reddit - www.reddit.com/user/joekarlsson
Instagram - https://www.instagram.com/joekarlsson/

Want to Learn More About Joe Karlsson?

https://www.joekarlsson.com/about/
https://www.joekarlsson.com/speaking/
How to Add Machine Learning Predictions with SingleStore and MindsDB
November 4, 2021
How to Get Started with SingleStore
November 4, 2021
How to Use SingleStore and Node.js
November 4, 2021
How to Use SingleStore as a Key-Value Store
June 22, 2022

The post Why I joined SingleStore appeared first on Joe Karlsson.

Works on My Machine by Joe Karlsson

tl;dr in tech - Issue #106

tl;dr in tech - Issue #105

tl;dr in tech - Issue #104

tl;dr in tech - Issue #103

tl;dr in tech - Issue #102

Tech Landscape Predictions for 2024#

tl;dr in tech - Issue #101

tl;dr in tech - Issue #100

tl;dr in tech - Issue #99

tl;dr in tech - Issue #98

tl;dr in tech - Issue #97

tl;dr in tech - Issue #95

tl;dr in tech - Issue #93

tl;dr in tech - Issue #94

tl;dr in tech - Issue #96

tl;dr in tech - Issue #92

tl;dr in tech - Issue #91

Tech Landscape Predictions for 2024