Well folks, brace yourselves for what might just be the laziest link dump in the history of link dumps. I've got to admit, this one's a real gem of laziness, and for that, I offer my sincerest apologies. I wish I could say I had a good excuse, but the truth is, I was just too lazy to do any better. So, without further ado, here's a collection of my thoughts and ideas that may not be my finest work, but hey, we all have our lazy days, right? Thanks for sticking with me through this lazy adventure!
Good reads
Joe Armstrong, one of the creators of Erlang? He said:
The most reliable parts are not inside the system, they are outside the system. The most reliable part of a computer system is the power switch. You can always turn it off. The next most reliable part is the operating system. The least reliable part is the application
2024-02-16 The Three Virtues of a GREAT Programmer
According to Larry Wall(1), the original author of the Perl programming language, there are three great virtues of a programmer; Laziness, Impatience and Hubris
- 💎 Laziness: The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful and document what you wrote so you don't have to answer so many questions about it.
- 💎 Impatience: The anger you feel when the computer is being lazy. This makes you write programs that don't just react to your needs, but actually anticipate them. Or at least pretend to.
- 💎 Hubris: The quality that makes you write (and maintain) programs that other people won't want to say bad things about.
2024-02-06 Command Line Interface Guidelines
An open-source guide to help you write better command-line programs, taking traditional UNIX principles and updating them for the modern day.
2024-02-08 A Distributed Systems Reading List
This document, curated by Fred Hebert in 2019 and later updated, serves as a comprehensive reading list and primer on distributed systems. It provides foundational theory, practical considerations, and insights into complex topics within the field. Intended for quick reference and discovery, it outlines the basics and links to seminal papers and resources for deeper exploration.
Foundational Theory
- Models: Discusses synchronous, semi-synchronous, and asynchronous models, with explanations on message delivery bounds and their implications for system design.
- Theoretical Failure Modes: Covers fail-stop, crash, omission, performance, and Byzantine failures, highlighting the complexity of handling faults in distributed environments.
- Consensus: Focuses on the challenge of achieving agreement across nodes, introducing concepts like strong and t-resilient consensuses.
- FLP Result: An influential 1985 paper by Fischer, Lynch, and Patterson stating that achieving consensus is impossible in a purely asynchronous system with even one possible failure.
- Fault Detection: Explores strong and weak fault detectors and their importance following the FLP result.
- CAP Theorem: Explains the trade-offs between consistency, availability, and partition tolerance in distributed systems, including refinements like Yield/Harvest models and PACELC.
Practical Matters
- End-to-End Argument in System Design: Highlights the necessity of end-to-end acknowledgments for reliability.
- Fallacies of Distributed Computing: Lists common misconceptions that lead to design flaws in distributed systems.
- Common Practical Failure Modes: Provides an informal list of real-world issues, including netsplits, asymmetric netsplits, split brains, and timeouts.
- Consistency Models: Describes various levels of consistency, from linearizability to eventual consistency, and their implications for system behavior.
- Database Transaction Scopes: Discusses transaction isolation levels in popular databases like PostgreSQL, MySQL, and Oracle.
- Logical Clocks: Introduces mechanisms like Lamport timestamps and Vector Clocks for ordering messages or state transitions.
- CRDTs (Conflict-Free Replicated Data Types): Explains data structures that ensure operations can never conflict, no matter the order of execution.
Other Interesting Material
Links to reviews, protocol introductions (Raft, Paxos, ZAB), and influential papers like the Dynamo paper are provided for further exploration of distributed systems.
The document concludes with a recommendation for "Designing Data-Intensive Applications" by Martin Kleppmann, noted as a comprehensive resource that ties together various aspects of distributed systems. However, it's suggested that readers may benefit from foundational knowledge and discussions to fully grasp the material.
2024-01-05 Managing superstars can drive you crazy - by Anton Zaides
Managing Talented Developers:
- Challenge: "The most talented developers are the hardest to manage."
- Strategy: Instead of hiring multiple average engineers, consider hiring fewer top-tier engineers for better results.
Challenges with 'Superstars:
- Promotion Pressure: A team full of superstars may constantly seek promotions, creating management difficulties.
- Expectations: Superstars expect continuous challenges and significant projects.
Types of Developers:
- Low Ability + High Confidence: Difficult to work with due to overestimation of their abilities.
- High Ability + Low Confidence: Talented developers in need of mentorship.
- Low Ability + Low Confidence: May perform better in a different environment.
- High Ability + High Confidence: A positive challenge, expecting growth and opportunities.
Managing Rockstars:
- Avoid Overpromising: Don't promise promotions you can't guarantee.
- Listen to Advice: Consider their suggestions but maintain your decision-making authority.
- Avoid Micromanagement: Trust them to manage their work and approach you when needed.
Effective Strategies:
- Set Clear Goals: Define specific targets for promotion opportunities.
- Delegate Challenging Tasks: Assign visible and difficult tasks to lay the groundwork for promotion.
- Provide Unfiltered Feedback: Give honest feedback to help them grow.
dvice from Superstars:
- Jordan Cutler: Help them focus on the right things and avoid being vague in feedback.
- Raviraj Achar: Protect them from burnout and prevent them from disrespecting the team.
Crossplatform
Quickly create and run optimised Windows, macOS and Linux desktop virtual machines.
Kubernetes
Anders Jönsson's article on Medium delves into Urb-it's eight-year journey with Kubernetes, including the shift from AWS to Azure Kubernetes Service (AKS), lessons from two major cluster crashes, and various operational insights. Here's a simplified digest of the key points:
Early Adoption and Transition
- Chose Kubernetes early for scalability and container orchestration.
- Initially self-hosted on AWS, later migrated to AKS for better integration and ease of management.
Major Cluster Crashes
- First Crash: Due to expired certificates, requiring a complete rebuild.
- Second Crash: Caused by a bug in kube-aws, leading to another certificate expiration issue.
Key Learnings
- Kubernetes Complexity: Requires dedicated engineers due to its complexity.
- Updates: Keeping Kubernetes and Helm up-to-date is critical.
- Helm Charts: Adopted a centralized Helm chart approach for efficiency.
- Disaster Recovery: Importance of a reliable cluster recreation method.
- Secrets Backup: Essential strategies for backing up and storing secrets.
- Vendor Strategy: Shifted from vendor-agnostic to fully integrating with AKS for benefits in developer experience and cost.
- Observability and Security: Stressed on comprehensive monitoring, alerting, and strict security measures.
Operational Insights
- Monitoring and Alerting: Essential for maintaining cluster health.
- Logging: Consolidating logs with a robust trace ID strategy is crucial.
- Security Practices: Implementing strict access controls and security measures.
- Tooling: Utilizing tools like k9s for managing Kubernetes resources more efficiently.
Infrastructure and Tooling Setup
- AKS Adoption: Offered better integration with Azure services.
- Elastic Stack: Transitioned to ELK stack for logging.
- Azure Container Registry: Switched for better integration with Azure.
- CI/CD with Drone: Highlighted its support for container-based builds.
Golang
2024-02-09 How I write HTTP services in Go after 13 years by Mat Ryer
Mat Ryer, in his blog post on Grafana, shares his refined approach to writing HTTP services in Go after 13 years of experience. This article is an evolution of his practices influenced by discussions, the Go Time podcast, and maintenance experiences. The post is aimed at anyone planning to write HTTP services in Go, from beginners to experienced developers, highlighting the shift in Mat's practices over time and emphasizing testing, structuring, and handling services for maintainability and efficiency.
Key Takeaways and Practices:
- Server Construction with
NewServer:
- Approach: The
NewServerfunction is central, taking all dependencies as arguments to return anhttp.Handler, ensuring clear dependency management and setup of middleware for common tasks like CORS and authentication.
func NewServer(logger *Logger, config *Config, commentStore *commentStore) http.Handler {
mux := http.NewServeMux()
// Configuration and middleware setup
return handler
}
Routing with
routes.go:
- Purpose: Centralizes API route definitions, making it easy to see the service's API surface and ensuring that route setup is consistent and manageable.
- Implementation Strategy: Dependencies are explicitly passed to handlers, maintaining type safety and clarity in handler dependencies.
Simplified
mainFunction:
- Design: Encapsulates the application's entry point, focusing on setup and graceful shutdown, facilitated by a
runfunction that encapsulates starting the server and handling OS signals.
func main() {
if err := run(); err != nil {
// Handle error
}
}
Middleware and Handler Patterns:
- Middleware: Adopts the adapter pattern for middleware, allowing pre- and post-processing around handlers for concerns like authorization, without cluttering handler logic.
- Handlers: Emphasizes returning
http.Handlerfrom functions, allowing for initialization and setup to be done within the handler's closure for isolation and reusability.Error Handling and Validation:
- Strategy: Uses detailed error handling and validation within handlers and middleware, ensuring robustness and reliability of the service by catching and properly managing errors.
Testing:
- Philosophy: Prioritizes comprehensive testing, covering unit to integration tests, to ensure code reliability and ease of maintenance. The structure of the codebase, particularly the use of
runfunction, facilitates testing by mimicking real-world operation.Performance Considerations:
- Optimizations: Includes strategies for optimizing service performance, such as deferring expensive setup until necessary (using
sync.Oncefor lazily initializing components) and ensuring quick startup and graceful shutdown for better resource management.
Linux
2024-02-15 systemd by example - Part 1: Minimization - Sebastian Jambor's blog
Jambor shares his journey to understand systemd, a crucial system and service manager for Linux, by starting with the simplest setup possible and gradually adding complexity. The post encourages hands-on experimentation by running systemd in a container, avoiding risks to the host system.
The article concludes with a functioning, minimal systemd setup comprised of six unit files. This foundational knowledge serves as a platform for further exploration and understanding of systemd's more complex features.
All examples, including unit files and Docker configurations, are available on systemd-by-example.com, facilitating hands-on learning and experimentation.
The Era of AI
2024-02-21 Let's build the GPT Tokenizer - YouTube
Let's Build the GPT Tokenizer [video]
2024-02-21 Let's Build the GPT Tokenizer video | Hacker News
Let's build GPT: from scratch, in code, spelled out.
2024-02-21 Neural Networks: Zero To Hero Video Lectures
A course by Andrej Karpathy on building neural networks, from scratch, in code.
We start with the basics of backpropagation and build up to modern deep neural networks, like GPT. In my opinion language models are an excellent place to learn deep learning, even if your intention is to eventually go to other areas like computer vision because most of what you learn will be immediately transferable. This is why we dive into and focus on languade models.
Prerequisites: solid programming (Python), intro-level math (e.g. derivative, gaussian).
The spelled-out intro to neural networks and backpropagation: building micrograd
This is the most step-by-step spelled-out explanation of backpropagation and training of neural networks. It only assumes basic knowledge of Python and a vague recollection of calculus from high school.
The spelled-out intro to language modeling: building makemore
We implement a bigram character-level language model, which we will further complexify in followup videos into a modern Transformer language model, like GPT. In this video, the focus is on (1) introducing torch.Tensor and its subtleties and use in efficiently evaluating neural networks and (2) the overall framework of language modeling that includes model training, sampling, and the evaluation of a loss (e.g. the negative log likelihood for classification).
2024-01-30 Anil-matcha/Free-GPT-Actions: A listing of Free GPT actions available for public use
A listing of Free GPT actions available for public use
2024-02-15 reorproject/reor: AI note-taking app that runs models locally.
Reor is an AI-powered desktop note-taking app: it automatically links related ideas, answers questions on your notes and provides semantic search. Everything is stored locally and you can edit your notes with an Obsidian-like markdown editor.
Skill, Test, Creativity
2024-01-27 rasbt/LLMs-from-scratch: Implementing a ChatGPT-like LLM from scratch, step by step
In Build a Large Language Model (from Scratch), you'll discover how LLMs work from the inside out. In this book, I'll guide you step by step through creating your own LLM, explaining each stage with clear text, diagrams, and examples.
Lifehack
2024-02-09 ⚫ Show HN: Improve cognitive focus in 1 minute
2024-02-09 Show HN: Improve cognitive focus in 1 minute | Hacker News
Fun
2024-02-09 The sinusoidal tetris | andreinc
2024-02-12 Balancing cube – Willem Pennings
2024-02-15 Gitlab Meeting Simulator 2024
Workplace / Job Interview
The GitHub repository "SystemDesign" by kpsingh focuses on the author's learning journey regarding Design Principles (Low Level Design) and System Design (High Level Design). It aims to delve into foundational concepts such as SOLID principles and design patterns, crucial for understanding both low and high-level design aspects in software engineering. For those interested in exploring the nuances of software design, this repository could serve as a valuable resource. More details can be found on GitHub.
2024-02-09 adityadev113/Interview-Preparation-Resources: StudyGuide for Software Engineer Interview
The GitHub repository "Interview-Preparation-Resources" by adityadev113 serves as a comprehensive guide for software engineer interview preparation, containing various resources collected during the author's own SDE interview preparation journey. This repository is intended to assist others on the same path by providing a wide range of materials related to behavioral interviews, computer networks, DBMS, data structures and algorithms, mock interviews, operating systems, system design, and more. Additionally, it includes specific documents like interview questions from Microsoft, important Java questions, and a roadmap for learning the MERN stack. The repository encourages community contributions to enrich the resources available for interview preparation. For more detailed information, visit GitHub.
The document "Leetcode Patterns and Problems" in the "Interview-Preparation-Resources" repository provides a structured approach to solving Leetcode problems. It categorizes problems into specific patterns to help understand and tackle algorithmic challenges effectively, aiming to enhance problem-solving skills for technical interviews. For detailed patterns and problems, you can visit the [GitHub page](https://github.com/adityadev113/Interview-Preparation-Resources/blob/main/Understanding Data Structures and Algorithms/Leetcode Patterns and Problems.md).
2024-02-12 Finding a New Software Developer Job | Henrik Warne's blog
ne section I added now was Behavioral Questions. These are questions of the form “Tell me about a time when you disagreed with a coworker. How did you resolve it?”. Typically, you should answer them using the STAR framework: Situation, Task, Action, Result, Reflection. In the past, I have failed interviews because of these questions – I hadn’t prepared, and couldn’t come up with good examples on the spot in the interviews.
This time I went through a good list of such questions (Rock the Behavioral Interview) from Leetcode, and thought about examples to use. Once I had good examples, I wrote the question and my answer down in the document. Before an interview, I would review what I had written down, so I would be able to come up with good examples. This worked well, I didn’t fail any interviews because of behavioral questions.
In the document I also wrote down little snippets of code in both Python and Go. I tried to cover many common patterns and idioms. I did this so I could refresh my memory and quickly come up with the right syntax in a coding interview. I ran all the snippets first, to see that I hadn’t made any mistake, and included relevant output. Reviewing these snippets before an interview made me feel calmer and more prepared.
I also watched a good video by Gergely Orosz, 🚩 Confessions from a Big Tech Hiring Manager: Tips for Software Engineering Interviews, on technical interviews in general. Some takeaways: be curious and collaborative, and ask questions.
C++
2024-02-09 Playing Video Games One Frame at a Time - Ólafur Waage - Meeting C++ 2023 - YouTube
Detours is a software package for monitoring and instrumenting API calls on Windows. It is distributed in source code form.
2024-02-09 TerryCavanagh/VVVVVV: The source code to VVVVVV! http://thelettervsixtim.es/
This is the source code to VVVVVV, the 2010 indie game by Terry Cavanagh, with music by Magnus Pålsson. You can read the announcement of the source code release on Terry's blog!
2024-02-09 Playing Video Games One Frame at a Time - Ólafur Waage - Meeting C++ 2023 - YouTube
2024-02-09 VVVVVV on Steam $4.99
2024-01-06 Back to Basics: Iterators in C++ - Nicolai Josuttis - CppCon 2023 - YouTube
2024-02-18 All C++20 core language features with examples | Oleksandr Koval’s blog
2024-02-18 20 Smaller yet Handy C++20 Features - C++ Stories
Distributed Systems
Data Structures for Data-Intensive Applications: Tradeoffs and Design Guidelines
Manos Athanassoulis Stratos Idreos and Dennis Shasha Boston University, USA; mathan bu.edu Harvard University, USA; stratos seas.harvard.edu New York University, USA; shasha cs.nyu.edu
ABSTRACT
Key-value data structures constitute the core of any datadriven system. They provide the means to store, search, and modify data residing at various levels of the storage and memory hierarchy, from durable storage (spinning disks, solid state disks, and other non-volatile memories) to random access memory, caches, and registers. Designing efficient data structures for given workloads has long been a focus of research and practice in both academia and industry. This book outlines the underlying design dimensions of data structures and shows how they can be combined to support (or fail to support) various workloads. The book further shows how these design dimensions can lead to an understanding of the behavior of individual state-of-the-art data structures and their hybrids. Finally, this systematization of the design space and the accompanying guidelines will enable you to select the most fitting data structure or even to invent an entirely new data structure for a given workload.
Seattle
2024-02-09 🌎 nearbywiki Fairview Avenue North Bridge
Explore interesting places nearby listed on Wikipedia
Ideas
2024-02-24 Tommy's inclusive datepicker
2024-02-06 Kaptr.me - Capture, share and save data with live screenshots of any app or website
2024-02-07 Web based logs viewer UI for local development environment | Logdy
Dark Souls 2
2024-02-01 📌 Some more translated DS2 Kouryakubo Maps (WIP, edited for SotFS) : DarkSouls2
JP Kouryakubo Maps http://www.kouryakubo.com/darksouls2/index.html
2024-02-12 Dark Souls 2 Design Works : Free Download, Borrow, and Streaming : Internet Archive
Bigdata
CSS (Research)
2024-02-16 sass/sass: Sass makes CSS fun!
2024-02-16 💲📺 Creating a Living Style Guide with Sass and Vanilla JavaScript | Pluralsight
2024-02-16 Atomic Design Methodology | Atomic Design by Brad Frost
2024-02-20 You Might Not Need Sass: Modern CSS Techniques
2024-02-21 Stepping away from Sass
Web Dev Stuff
2024-01-28 In Loving Memory of Square Checkbox @ tonsky.me
2024-01-30 ⭐ Web Components in Earnest
Found in: 2024-01-30 JavaScript Weekly Issue 672: January 25, 2024
2024-01-30 How to start a React Project in 2024
Found in: 2024-01-30 JavaScript Weekly Issue 672: January 25, 2024
2024-01-30 pretty-ms 9.0: Convert Milliseconds to Readable Strings — 1337000000 → 15d 11h 23m 20s
Found in: 2024-01-30 JavaScript Weekly Issue 672: January 25, 2024
2024-01-30 TypeSpec
Found in: 2024-01-30 JavaScript Weekly Issue 672: January 25, 2024 A language for concisely describing cloud service APIs and generating other API description languages (e.g. OpenAPI), client and service code, docs, and more. Formerly known as CADL. – GitHub repo.
2024-02-23 JavaScript Bloat in 2024 @ tonsky.me
Json to code
Convert JSON to classes/code
Lisp
2024-01-30 Colin Woodbury - A Tour of the Lisps