All Posts

  • Managing Humans Review

    This is my review of Managing Humans. This is a book on management written by Michael Lopp, who is a well known internet writer on the software industry.

  • The Notion Of Hierarchy

    Teams in companies don’t exist in a vacuum. Rather, they are part of a larger organization. And getting this right is just as important and hard as getting teams right.

  • The Hard Thing About Hard Things Review

    This is my review of The Hard Thing About Hard Things. Like with Accelerate or No Rules Rules I was not expecting much coming in, but was blown away by the book. There’s a lot of wisdom in here for sure.

  • The Notion Of Teams

    Teams and team formation are a fundamental part of any organization. But getting them right is far from trivial. And there are a lot of ways to mess things up. So it’s important to have a “correct” definition for them.

    In my time at Bolt, I’ve been involved with managing, bootstrapping, and reorganizing my fair share of teams. I made all the mistakes. To save others from doing so I’ve written several internal guides. Now I’m adapting and publishing them for a wider audience. I believe the lessons are theoretically sound and should apply across companies and industries. Like the previous post on reading lists, this one is geared towards a manager audience. Nevertheless, working in a badly set up team is a world of difference from working in a well set up one. Hence even as an individual contributor, this knowledge is useful. You’ll know what to look for and what to avoid!

  • Accelerate Review

    This is my review of Accelerate. I’ve long wanted to read this one. But I was procrastinating on it because in my mind I thought I’d already be familiar with its message. And to a degree that was the case. But I also found a lot of interesting information that I didn’t expect. Like the causal relationship between engineering practices and company outcomes. Both in the hard things like better financial results and accomplishing group goals. But also in the soft ones like improving team morale and job satisfaction.

  • My Suggested Reading For Managers & Tech Leads

    Folks starting out on their management career or thinking about higher-level engineering roles such as Staff have a daunting task ahead of them. While much of the specifics vary company by company, there’s some fundamentals that tend to stay the same. Luckily “there have been whole books written about this stuff”! Even more luckily I’ve compiled a big list of books I’ve found useful that made it into a sort of required reading list for folks in my group. I’m sharing it now with this wider audience.

  • Career Frameworks

    In a previous article in this series, we spoke about the types of software companies and some general strategies for your job search. Now it’s time to turn our attention to how companies organize their workforce. It turns out the tech industry has standardized the type and the scope of work engineers do to a large degree. Whether you’re outside or inside this system, knowing how it works is important when looking at a long term career in technology.

  • Building Mobile Apps At Scale Review

    This is my review of Building Mobile Apps At Scale. I wanted to read this book to better understand the challenges of building complex mobile apps. My teams have relatively recently expanded to include mobile engineers, so I primarily wanted to have enough of a grounding in this tech space so I could have a decent conversation. Turns out a lot of the complexities are the same as in backend or web development. They’re just accentuated by the distribution channel of app stores. But I believe a lot of the modern and common sense approaches to development - automated testing, CI/CD, progressive releases, etc. - carry over.

  • Three Types Of Software

    Early in my computing career, I came across a neat classification of software. It split things up into systems, applications, and scripts. Like all abstractions, it only gets you so far. But I’ve found it a useful conceptual model as an engineer and a manager. And it has interesting things to say about how software is built, how it’s used, and even who gets to write it.

  • No Rules Rules Review

    This is my review of No Rules Rules. This is a book about Netflix and the culture they’ve built over there. The main idea is that their unique culture has allowed them to achieve their extraordinary results. And that this could work for your company too. Indeed, among the FAANGM companies, Netflix the most focused, most customer driven, and arguably the one impacting the cultural zeitgeist the most these days. It’s also the smallest of the bunch, which means it punches way above it’s weight class.

  • Excellence Tokens

    A while ago I came across the concept of innovation tokens. It’s a neat and powerful idea. In short, you have a limited number of times you can innovate in any new project or company. Every time you do something new you spend one token. This can be using new technology or adopting new processes. Or it can even be how you define benefits in your company or going all-in on remote working. Of course, there’s no real limit. But innovation has a cost and you should acknowledge it and make sure you spend it in the right places. Too much innovation can thus cause a project to fail. It can overextend the capabilities of the team implementing it. Or make the project hard to understand for users.

  • A Taxonomy Of Software Companies

    The type of software company you work for has a massive impact on your career. In the last article, we saw how your approach to interviewing can hold you back in your career. Working for the wrong type of company can have a similar effect. Working for the right type of company can act as a force multiplier. It can push you further than your skills alone could. And it can also provide on-the-job training. Or an environment of constant learning and development. Or in very broad terms, it can “open up doors”.

  • The Clone Test

    You might have heard of the “Netflix Keeper Test”. This is a part of their culture where a manager asks themselves if one of their reports were to leave, would they fight for them.

  • A History Of The Ancient World Review

    This is my review of A History Of The Ancient World. I had planned on doing more history reading in 2021. But the year whizzed by and I found myself in December having read nothing. A quick search for “top history books” surfaced a number of interesting choices. I chose this one because it covered a period of history I feel I don’t have a good grasp on - pre-Roman/Greek antiquity from the start of civilisation onwards. It also tied in nicely with my study of epic poems (a great deal of which were written in ancient times, or drew inspiration from it).

  • Announcing Jupiter Release 0.8.0

    I’ve prepared a major release, namely 0.8.0. This is just the second release of the year, and the first in more than 10 months.

  • Seven Anti-Patterns For Your Developer Job Search

    Over the last year, I’ve reached out to almost 1000 engineers trying to get them to interview for Bolt. I’ve had some success and plenty of failures. But I have learned a lot about how people approach interviews and career development. And I’ve identified seven “anti-patterns” that I think are detrimental to a successful career.

    In this article, I want to share these anti-patterns with you. I also want to share my approach to effective “job searches”. I hope these will prove useful to you.

    I’m gonna work off some assumptions. You’re a software engineer with some years of experience. You want to get the most out of your career. You’re based somewhere in Europe, the US, LatAm, or so. Life is going OK for you and you want to optimize your long-term career. If this is not you, then you may or may not get something out of all this.

  • Staff Engineer Review

    This is my review of Staff Engineer: Leadership Beyond The Management Track. It is a book about being a “staff engineer”. As far as I know, it is the only book about the topic. It is by Will Larson, the author of An Elegant Puzzle, and much like that book, it is a compilation of his writing on his blog, as well as his separate staffeng.com website.

  • Thoughts On Why Software Engineers Leave Romania

    On one of the Romanian developer forums I frequent a familiar question was raised - why do developers chose to leave Romania? This is a touchy topic here. After the fall of communism in 1989, and more especially after after joining the EU in 2007, there has been an exodus of sorts of people from Romania seeking a better life elsewhere. But mostly in the EU, the USA and Canada. This has had a tremendous impact on the country, both good and bad. It’s not the place here to explore this, but it’s important to note that this discussion is not as simple as it might be for an international audience.

  • Atomic Habits Review

    This is my review of Atomic Habits. As the name implies it is a book on habits. It looks at how to effectively build good habits, and how to drop bad habits. It also makes the case that the habits one has are what determine success, rather than the goals one sets or the motivation one has.

  • Crucial Conversations Review

    This is my review of Crucial Conversations. It’s a relationships book with a lot of applicability in the workplace. It’s a nice read for managers, hence it got on my reading list.

  • Team Topologies Review

    This is my review of Team Topologies. It’s a management book (oh no, not again), which looks at some good patterns for organizing teams in larger organisations. It proposes a set of team types and team interaction modes between them which aim to maximize ownership, delivery, efficiency, etc.

  • 21 Lessons For The 21st Century Review

    This is my review of 21 Lessons For The 21st Century by Yuval Noah Harari. It’s in a way a followup to his Sapiens and Homo Deus books. The former I read, but didn’t get around to writing a review here – no shameless self-linking today! Now, Sapiens focused on humanity’s past, and Homo Deus on its distant future. But this one has a bit of both, and manages to keep the focus on the near future - what will happen in 10 or 20 or 30 years, and how one can be best prepared for that.

  • Announcing Jupiter Release 0.7.0

    I’ve prepared a major release, namely 0.7.0. Since I think I jumped some releases, I will also summarize the 0.6.x releases.

  • Help Them Grow Or Watch Them Go Review

    This is my review of Help Them Grow Or Watch Them Grow. This is a management book focused on the career growth aspects of the manager’s job. It’s a short book, and perhaps not a classic, but it is nonetheless a very worthwhile read and it’s had quite the impact on how I approach career conversations and career growth with my team.

  • The Effective Executive Review

    This is my review of The Effective Executive by Peter Drucker. This was a great read. I don’t think I’ve fully assimilated it yet, but I’ve made copious notes and will come back to them. But what I did manage to get out of it has both changed the way I see my job as a manager and solidified that some of the things I was doing were the right things.

  • Jupiter Dev Log 5 - Architecture

    Docs

  • Clean Architecture Review

    This is my review of Clean Architecture by Uncle Bob. The book is undoubtedly a classic and I feel bad for not having read it earlier. I think it might have helped with a project or three. Better late than sorry for sure, and unlike other books I read too late (SICP primarily) I did feel I got a lot out of this book, and I came out a better developer on the other side. It certainly gave me a bunch of ideas to try out in Jupiter.

  • Friday Blast #95

    Productionizing Spark streaming applications (2019) - we had to use Spark streaming for a project at Bolt, and this guide proved mighty useful for getting us in the right headspace for tackling the problem.

  • Friday Blast #94

    Why write ADRs (2020) - architecture decision records (ADRs) are a form of technical documentation. They cover the big technical decision made on a project, in a sort of syntehsized fashion. Much like a design doc, but without going into the nitty-gritty.

  • Friday Blast #93

    Taming floating point error (2020) - a brief overview of what error means in floating point and how it affects work. What I found most interesting was the discussion on error analysis and error propagation through a computation. This was one area I didn’t have a good mental model of how to approach from uni days, and it turns out that (at least conceptually) it is quite straightforward and elegant. Indeed, I have an even higher appreciaton for the design of the floating point standard now.

  • Radical Candor Review

    This is my review of Radical Candor by Kim Scott. This is a management book as you can surely surmise. The central idea is that one should practice radical candor in a work environment - a style of interacting with others where one both seeks and offers good and constructive and sometimes hard to hear feedback.

  • Announcing Jupiter Release 0.5.1

    I’ve prepared a minor release - 0.5.1 - which contains a lot of goodies for recurring tasks. This version introduces:

  • Friday Blast #92

    Why do ARM chips have instructions with JavaScript in the name (2018) - remember kids, if your programming language becomes popular enough, its primitive operations will become CPU instructions. I wonder if there’s been any analysis done on this? Like look at where a sufficient sample of programs spend their time and make that into instructions. You’d need a size/complexity heuristic to not just leave it at main but I’m sure companies such as Google or AWS which run big sever workloads would have the data.

  • Friday Blast #91

    OAuth 2.0 and OpenId Connect in plain english (2018) #video - A gentle guide to these protocols for managing authorization / identity and its delegation. It’s one of those things every developer building web applications should know about, but there’s a dearth of good material out there.

  • Friday Blast #90

    More testable code with the hexagonal architecture #video (2019) - the hexagonal architecture is the name given to an clean and interesting approach to building large “business” applications. There is essentially a core of logic, surrounded by “ports” for persistency, communication, etc. and “adapters” that allow the logic to make use of the ports.

  • Announcing Jupiter Release 0.5.0

    As promised, the 0.5.0 release comes much faster than the 0.4.2 one. It includes a single change, namely smart list. It’s a significant addition however, and the first foray outside task-planning for Jupiter.

  • Getting To Yes Review

    This is my review of Getting To Yes by Roger Fisher, William Ury, and Bruce Patton. It’s another book on negotiation, and it’s the second in the series I review, after Never Split The Difference. This is the original which started the whole trend.

  • Announcing Jupiter Release 0.4.0

    Today marks the date of the fourth “minor” release of Jupiter - version 0.4.2. It’s a massive release, and the last one I’ll make this massive! It literally has tens of big changes, and took about 5 months to deliver! Not cool for such a small project.

  • Never Split The Difference Review

    This is my review of Never Split The Difference by Chris Voss. This is a book on negotiation and it’s written by the former head negotiator of the FBI. So the credentials are quite good, and I think the author delivers.

  • Friday Blast #89

    When you should NOT use Rails (2020) - I’ve never used Ruby on Rails, but it does seem like a great tool - opinionated, powerful, flexible, etc. However, like all tools it has its place and might not be good in “all circumstances”. Folks sometimes forget this. The linked article talks a couple of such situations, and what alternatives there are.

  • Jupiter Dev Log 4 - Using ReadTheDocs For Docs Hosting

    Docs

  • Friday Blast #88

    Technology holy wars are coordination problems (2020) - a point about how and when holy-wars in technology appear. Basically when there’s multiple competing ecosystems, and choosing one will mean the others will wither and suffer.

  • Friday Blast #87

    Every Jurassic Park dinosaur illustrated with modern science (2020) - a fun and quite long article analysing what we’ve learned about dinosaurs since Jurassic Park (and what we’ve known all along, but got wrong anyway). Spoilers - velociraptors are about chicken-size.

    The end of OS X (2020) - WWDC happend and Apple announced they’re gonna drop Intel and Mac OS 11. It’s an interesting take - Mac OS X was the Unix desktop folks were clamoring for, and that’s why it was so common for developers to use it. But OS 11 seems more like iOS. How will that play out?

  • Friday Blast #86

    It’s been quite some time since one of these. It’s more like a monthly blast for a while. I’ll try to do better in the future.

  • Work Rules Review

    This is my review of “Work Rules” by Laszlo Bock. The author is the former head of HR at Google - or of people operations as they’re known there. The book aims to present what makes Google special from this point of view, such that it’s consistently considered one of the best places to work in the world, and what other companies might learn from their approach.

  • Friday Blast #85

    It’s been quite some time since one of these.

  • Announcing Jupiter Release 0.3.0

    Today marks the date of the third “minor” release of Jupiter - version 0.3.0. It’s a really big release, as it essentially moves all the recurring tasks interactions to be in the “new way”, like vacations or workspaces.

  • Jupiter Dev Log 3 - Lint All The Things

    Python

  • Announcing Jupiter Release 0.2.0

    Today marks the date of the second “minor” release of Jupiter - version 0.2.0.

  • Announcing Jupiter Release 0.1.0

    Today marks the date of the first “minor” release of Jupiter - version 0.1.0. The main improvement is a switch to a command or Notion only flow for workspace and vacations. No more mucking about in yaml files. Instead everything can be done via the jupiter CLI app or via Notion.

  • Friday Blast #84

    A successful Git branching model (2010) - the introduction of git-flow, a popular branching model for git.

  • Jupiter Dev Log 2 - Release Process With GitHub Actions And GitFlow

    This latest instalment in the Jupiter Dev Log series covers the newly added “automatic release process” in some detail. The release process was decidedly manual before this work. I ran make docker-push on my local machine, and a new Docker image replaced the one on Docker Hub. There are in fact two key improvements: having versioned releases (and a versioning process to boot), and having an automated release process which acts on some pushes to GitHub and uploads the current version to DockerHub.

  • Jupiter Dev Log 1 - Setting Up Publishing To DockerHub

    The installation instructions were bad so I had a first attempt at making a saner distribution method. Ideally Jupiter should be packaged as a Python package, a brew formula for MacOS, a deb package for Debian and derived distributions, an rpm package for RedHat and derived distributions, a docker image, etc. Once installed it should act like a regular script. So you can just jupiter upsert-tasks and it would work like cat /etc/passwd.

  • Jupiter Dev Log 0 - Intro

    I plan on blogging a bit about the bigger developments on the Jupiter project. Especially those around CI/CD, integration with various 3rd party systems, productionisation efforts, etc. The infra bits as it were. Not so much the “code itself”, cause that usually is straightforward.

  • Announcing Jupiter

    Today I’m releasing a small open source project. It’s been a while since I did so. I’m excited though because it’s something I built for myself and which I’m using heavily in my day to day life. It’s not just some academic exercise or some feel-good effort after a larger abandoned project. I am doubly excited because the project itself is quite rough, and unfinished, and stupid in many places. Fighting that perfectionism bug one crappy release at a time.

  • Friday Blast #83

    I can’t believe I haven’t posted any Friday Blast in 2020 yet! It’s been a bit of a hectic start of the year, but I’ve definitely done some reading. Time to give back!

  • High Output Management Review

    This is my review of “High Output Management” by Andy Grove. Now this book is a classic. Folks who chose to read it will read it regardless of what I say here.

  • Friday Blast #82

    What sticks in your head (2019) - musings on why it is easier to remember some stuff rather than other. John, who’s been linked on this blog many times, has a knack for remembering math, but doesn’t really remember programming topics that well. I’m opposite that. The “picking your memory battles” section was quite good from this point - if you know you don’t have a knack for something, don’t weight yourself with too many topics in that area - try to focus on the most important bits.

  • Friday Blast #81

    Meet Michelangelo: Uber’s machine learning platform (2019) - an overview of Uber’s work in “ML platforms”. I’ve seen these sort of systems for “industrial grade” model building and modelling pop-up more and more recently, and Uber’s take is quite interesting and comprehensive.

  • Friday Blast #80

    Announcing TypeScript 3.7 RC (2019) - the latest TS contains a bunch of neat features like the ?. accessor and the ?? operator for simpler interaction with undefined. I know a lot of the code I write would benefit from this. Sad that Dart has had this bit of syntactic sugar since a billion years ago tho.

  • Friday Blast #79

    Why printk() is so complicated (2019) - a deeper dive into the printk function from the Linux Kernel. Not really familiar with the kernel, except that it exists. But I had no idea something so “basic” as logging can turn into something to big. OTOH, in webapp land, it’s not exactly trivial either to have good high-performance logging.

  • Friday Blast #78

    Building and motivating engineering teams (2016) - from the author of “The Manager’s Path”, but before the book. There’s something in here for anybody - for ICs it’s a handy reminder of what you can or could expect from a company. For managers it’s more practical. While founders or higher-up types can actually influence things like salaries or purpose, line managers can work within what they can control - respect for example - to create better teams and orgs.

  • Friday Blast #77

    Marking the end of pixel trackers in Basecamp emails (2019) - pixel tracking in emails is a common technique for gathering analytics for the emails you send. They work by embedding an image url (historically a 1x1 pixel) into the email, with some unique coordinates. When the email gets rendered, the image gets requested and you know the email was seen. They’re pretty ingenious. But also a hack for tracking folks when you perhaps should not. So it’s refreshing to see Basecamp take the lead here and do something against the grain of pervasive tracking which is the norm in products nowadays.

  • An Elegant Puzzle Review

    In which An Elegant Puzzle, an engineering management book by Will Larson is reviewed and found excellent.

  • Friday Blast #76

    Algebraic geometry (2019) - John Carlos Baez is a physics and maths blogger I’ve been following for some time. Most of the stuff he writes about is way above my pay grade, including algebraic geometry. However this article is about the psychology and sociology of science, and of how to approach difficult subjects, rather than maths per se. And I found it really interesting. And perhaps you will come back to these thoughts when approaching the next hard academic challenge you’re facing.

  • Friday Blast #75

    TensorFlow.js - machine learning for web and beyond (2019) - an overview of the TensorFlow.js paper. It’s pretty impressive how this can handle both training and inference in JS via WebGL! It uses “old timey” tricks of expressing non-graphics code in terms of shaders and graphics operations and the performance is quite decent! Seems like the abstraction layers between JS and the GPU aren’t that big!

  • Friday Blast #74

    On being a pricipal engineer (2019) - many tech companies have a “Pricipal” role on the individual contributor career ladder, and it’s usually pretty high there. The author describes what it means to operate at that level in their company, but I think it translates well across the board.

  • Algorithms To Live By Review

    This is my review of Algorithms To Live By, written by Brian Christian and Tom Griffiths. The book aims to highlight with fun and pertinent examples some problems and algorithms for solving them. It is decidedly pop-science, so don’t expect any heavy math - or any math at all. But it was a fun and easy read, suitable for a vacation. And the historical framing of the problems is great no matter your technical level.

  • Friday Blast #73

    The Soviet license plate game and Kolmogorov complexity (2019) - a fistful of awesome! Won’t spoil it, but it’s also a good example of the difference between something being possible and something being possible and efficient.

  • Friday Blast #72

    Replicated data consistency explained through baseball (2019) - a first part of a series dedicated to consistency in distributed systems. This one prepares the ground and then reviews the article of the same name. Granted, I don’t know the baseball rules, but I picked up enough to get something decent out of this.

  • Language-level Dependency Injection

    I’ve recently read languages I want to write and Hull – an alternative to shell that I’ll never have time to implement and I came to the conclusion I rather like the idea of writing about some hypothetical language rather than going out and building a prototype. The latter is a lot of work after all and you should do it only for serious things, not any ol’ silly idea that pops into your head! So it’s much better to just write about the silly stuff and to get it out of my system. So what follows is my contribution to this sort of literature.

  • Friday Blast #71

    Grace Hopper - nanoseconds #video (2012) - Grace Hopper talking about communication latency. Life goals to have such nice presentation skills.

  • Friday Blast #70

    Deeply understanding JavaScript async and await (2019) - history of callbacks –> promises –> async/await in JavaScript. It’s funny that the code he highlights as callback hell I don’t find that hard to grok - been doing it at work for some time and I consider it just decent, not hellish. But yeah, async/await can’t come soon enough to all PLs and codebases.

  • Friday Blast #69

    The Netflix Problem #youtube (2019) - a Vlog type link this time, but an interesting analysis of this space. Basically every big movie producing company has been building their own streaming platform lately. Which has caused a fragmentation of content much like in the days of ‘yore when movie companies also owned the cinemas. The author posits this is not a sustainable thing and points to the increase of piracy after years of decline as an leading indicator of this thing. It’s an interesting space for me, as I’ve always had a side-interest in the media business. But also because I like Netflix as a tech company. I’ll try to write a bit more about this, cause the video itself didn’t address all that’s happening in this space IMO.

  • Peopleware Review

    Managed to finish Peopleware this last week. It’s a classic of software development, so it barely needs an introduction or review from me. But since it’s been a while since the last non-”Friday Blast” article, here we go.

  • Friday Blast #68

    Why we build CockroachDB on top of RocksDB (2019) - an insightful post from the CockroachDB team about how they use RocksDB as the storage layer for single nodes. RocksDB is a embedded KV-store in the vein of LevelDB, Sqlite etc. which uses LSM storage. For me it’s also interesting how this separation seems to be more-and-more common. Use a well known storage layer, and build only the value-added thing on top of it. Especially since said storage layer would deal with platform idiosyncrasies like fsync bugs etc. MySQL and even Postgres have been used this way, but they’re obviously more heavyweight.

  • Friday Blast #67

    Everything you need to know about networking on AWS (2018) - fun and bitesized read about how AWS organises “networks”. Since you’re dealing with IaaS (among many other things), you can set things up at the network level as well. And even if you only want to deal with managed services, you’ll be hit by this. I’m tangentially involved with this stuff, so a refresher is good. Especially one which shows “how things are in real life usually”, like this one.

  • Friday Blast #66

    On infrastructure at scale - a cascading failure of distributed systems (2019) - all the things that started failing in Target’s infrastructure. It’s a nice story of how complex systems interact. It even has oscillating behaviour.

  • Friday Blast #65

    Open sourcing TonY - native support of TensorFlow on Hadoop (2018) - an example of building an application on YARN (Hadoop’s scheduler), which is similar to what Hadoop, Hive, Spark etc. do, but with a focus on TensorFlow. Size is quite small in the examples, but it’s still a neat example.

  • Friday Blast #64

    Made it to \(2^6\) Friday blasts!

  • Friday Blast #63

    The observability pipeline (2018) - the case for treating metrics/logs/traces data as “another dataset” rather than something different. For example, sending them first to a central collection point (Kafka or equivalent) and then dispersing them to all the “targets” that need them - logging infra, metrics and alerting, even to a data lake so they’re available as business metrics. The main idea is to stop NxM problems with this data and introduce some decoupling so it’s easier to switch infra providers later down the road.

  • Friday Blast #62

    Multi-cloud is a trap (2018) - a case for avoiding the pitfall of designing a system for “multiple clouds”. This is one in a bunch of “avoid generalisation” advice. The one I hold dear is avoid designing a system to be database agnostic. Instead, use the DB you’ve selected to the maximum of it’s potential - which will push you naturally in the areas where it’s differentiated from the others.

  • Friday Blast #61

    API gateways are going through an identity crisis (2019) - I like this article especially for the nice overview of the various kinds of things which have been called “API gateways” - frontends for backends, Kubernetes access managers, API infra as a service offerings etc.

  • The Manager's Path Review

    Another month, another book review [1]. This time it’s “The Manager’s Path” by Camille Fournier. This was quite the good read and I felt like I got a lot out of it. It seem to pop up a lot on first time managers reading lists and its been recently doing the rounds at work as well. Mostly cause there’s a lot of us these days.

  • Friday Blast #60

    Your AI skills are worth less than you think (2019) - an interesting look at the value of data science/machine learning/AI skills. It’s no surprise, even to folks who’ve been tangentially aware to the whole AI developments of the past few years that the state of the art has evolved a lot. Both in models, but also in tooling. So something which might take a dedicated team one year to build in 2010, can be done by one intern in 2019 in their spare time. Therefore what it means to know and be good at AI is changing - much like it did for building software. It used to be you needed a PhD and specialized knowledge to write a computer program. This also affects how companies use AI. And to bring this back to what the article is about, if your company is just about AI, you’re probably in dangerous waters. The best setup is when you’re doing something which needs to be done, but you can use AI as a lever to make it faster/better/cheaper etc. Especially as it seems the AI tooling is concentrating in the hands of a few big companies, rather than being more evenly distributed like the software one.

  • Friday Blast #59

    Azure Cosmos DB (2018) - Murat was a CS professor who’s blog I was following for some time. Recently he’s made the jump to industry, at least for a Sabbatical, working on Microsoft’s Cosmos DB. I had some vague knowledge of it, as this sort of Spanner / Cloud Data Store type thing. But it seems it’s so much more than that. Or at least it attempts to. It’s wants to basically be a all-in-one database, with OLAP and OLTP support, distributed by default, planet scale geo-distribution by default and with all sorts of APIs for accessing it: SQL, Mongo etc. Probably fun to build against, but not so fun to depend on it, cause it’s unlikely anybody will be able to match it soon. Still, interesting read and the first of many detailing his work on the system.

  • Friday Blast #58

    Designations, levels and calibrations (2018) - thoughts of Will Larson on the way to structure career ladders as tech companies. This is common stuff for most tech orgs - several ladders, several levels on the ladder and clear guidelines for each level.

  • Friday Blast #57

    A short guide to hard problems (2018) - most folks are familiar with the P and NP complexity classes, at least via the P vs NP problem at the core of computer science. Here a bunch of extra complexity classes are covered - BPP, BQP, PH, PSPACE and EXPTIME as well as the relationships between them. Sometimes they’re clear cut, other times we have strong reasons to believe a they’re the same, and yet other times the field is open.

  • Deep Work Review

    I recently finished reading “Deep Work: Rules For Focused Success In A Distracted World”, by Cal Newport. This is an interesting book. Good for sure, and perhaps life-changing if you need and can integrate it’s advice.

  • Friday Blast #56

    16 ways to measure network effects (2018) - a company has network effects when users benefit from new users coming into the platform. Think of Facebook, Twitter or Uber as canonical examples of these sorts of businesses in the tech space. This article is a rundown of no less than 16 metrics to describe such companies. Obviously useful for insiders, though some of these are reported by public companies as well.

  • Better Angels Of Our Nature Review

    Finally finished this book. It was a long read.

  • Binary And Fuzzy Features

    Today’s topic is a bit different. We’re gonna talk about product management and a way to interact with it as an engineer. Especially one working on consumer facing Internet applications. Thing Google, Facebook or Taxify.

  • Dictator's Handbook Review

    I recently finished The Dictator’s Handbook. It was a good and quick read and definitely worth a checkout. It’s the popular version of academic works in the selectorate theory branch of political science. A branch the authors more or less started.

  • Friday Blast #55

    Thank you for your help, NoSQL, but we’ve got it from here (2018) - More and more companies are realising that SQL can handle very large scales very well and that losing ACID, Schemas, SQL etc. isn’t a price worth paying in most situations for the slight benefits a NoSQL solution offers. A nice quote “It’s not clear why schema was lost as part of the NoSQL movement.” - I’ve often wondered why myself.

  • RetroFeed Work Log #5 - User Authentication

    We’re not out of the woods yet with setting things up for RetroFeed, buy we’ve come to a very interesting point - setting up user authentication.

  • Friday Blast #54

    Timeouts and cancellations for humans (2018) - a precursor to the Trio article from last week, this one deals with a more structured way to handle timeouts and cancellations in general. Like in that one, the notion of scope is married with the cancel token of C# fame to get something really interesting. This one and the previous article have actually made me yearn for trying some of that scope based concurrency. I’ve also long had my suspicions that some of the ways in which timeouts are handled are not so great, and end up with additive timeouts if not downright incorrect code.

  • Friday Blast #53

    Notes on structure concurrency or go statement considered harmful (2018) - making the case that the go statement (or async/await or the equivalent functions from other languages) is just as good for concurrent programming as goto was for the early programming of the 50s and 60s. Which is not that good. The idea of nurseries, which the author proposes does look nice, though without language support in the form of nicer syntax I don’t really see it catch on.

  • Friday Blast #52

    Celebrating one year of posting these things! Or the 52nd post to be more precise, which is a bit over a year, on account of some major laziness.

  • Friday Blast #51

    In defence of complicated measurement systems (2018) - a really good one from John D Cook. Measurement systems are tools for humans to use - they’re as good as is needed. We have (almost) uniform and concentrated systems now, but in the past the unit for measuring nautical distance was different from the one used to measure lengths of cloth. And why not? When would one interact with both during a regular lifetime?

  • Spatial Data Analysis Review

    It’s been almost three months since I did one of these things. Not great. So this is my review of Spatial Data Analysis by Christopher Lloyd.

  • Friday Blast #50

    Distributions of zeros of the Riemann zeta (2018) - mostly for the nice view from Quanta of the various places where a certain distribution appears - zeros of Riemann’s zeta function, spaces between eigenvalues of random matrices, distances between cells in chicken cells in chicken’s eyes etc.

  • Friday Blast #49

    What do you believe now that you didn’t five years ago (2018) - interesting read about centralized vs decentralized systems. And how five years ago people believed they’d take over (I mean, more than in the case of email, the WWW etc), and that hasn’t really happened. And it’s probably never going to the way proponents would want.

  • RetroFeed Work Log #4 - Middleware, Views, Sessions, Secrets

    So far we’ve setup a NPM package and setup NestJs for normal web programming. In this instalment of the RetroFeed we’ll continue with the standard web application setup. We’ll speak about the common middleware we used, about sessions, and a we’ll close with some design thoughts.

  • Friday Blast #48

    Programming in the adult entertainment industry is broken (2018) - fun read about all the broken stuff in the adult entertainment industry. The root of the issue is that payments are hard when there is a very high percentage of refunds.

  • RetroFeed Work Log #3 - Web Serving & More Setup

    In the second part of this series we looked at the most basic things we could do - package setup, some basic scripts, common integrations etc. And we left it for this third article to cover actually setting up a real application which could do some minimal things, and for the next one to cover infrastructure and making the project public. It turns out there’s a bunch to cover here as well, and one article won’t do it justice. So I’ll only cover the initial application behaviours, a bit of testing and more integrations here, and we’ll delay things like sessions and authentication for the next part.

  • Friday Blast #47

    What I talk about when I talk about logging (2018) - there’s a lot to productionizing an Internet application which has to do with “logging”. This article is a tour of all the boxes which need to be ticked for a good setup.

  • Friday Blast #46

    Why Kubernetes is the new application server (2018) - a case for K8s as the new “enterprisey” thing to build applications against. From RedHat, makes or JBoss and other enterprisey things (and some not-so-enterprisey things as well).

  • RetroFeed Work Log #2 - Basic Package Setup

    We left off in Idea & Basic Setup with a project idea and a general tech plan. The current and next two articles will cover a bunch of foundation-level issues for any Internet application project. More precisely we’re going to:

  • Friday Blast #45

    Digg’s v4 launch: an optimism born of necessity (2018) - I love war stories like these. Digg was big in the day, before something happened and it wasn’t. The massive and borked v3.5->v4 migration was widely blamed for it’s downfall, though the story isn’t always as simple. An interesting view into why things broke. And Python’s stupid default parameters behavior.

  • RetroFeed Work Log #1 - Idea & Basic Setup

    Last month I begun an experiment in logging my work on Raynor RPC (log1 and log2). While working on a library is fun, it’s better when there’s a clearer direction. Like the one provided by a product. So with this post I’m changing gears a bit, and will start blogging about a small side-project I’d like to work on, in which I’ll integrate Raynor RPC. In any case, much like with Raynor RPC, publicly speaking about this thing will at least help with keeping myself committed to the project. Even if the audience is me and Googlebot. At best, perhaps a real thing will emerge, with users and releases and bugs and angry GitHub threads. In any case, perhaps the info here will prove useful to folks, regardless of where this goes.

  • Friday Blast #44

    High-performance rate limiting (2016) - how Smyte does rate-limiting, with a fairly custom rate-limiter. Truth be told, these usually aren’t found off-the-shelf.

  • Subscription Purgatory

    I’ve recently read Subscription Hell by TechCrunch’s Danny Crichton. I’ve also been noticing the trend for media companies to move to a subscription/paywall model, and away from the traditional advertising model. Mostly because it’s very obvious - doesn’t take a great technological seer to notice it. But it is interesting and worth elaborating on it. And I felt that the article focused on a single aspect - how much all of this is going to cost - to the detriment of other negative aspects. Some of which, if they get to play out, would really merit the title of hell.

  • Friday Blast #43

    Optimal low-rank matrix approximation (2018) - decomposing matrices into pieces is one of the workhorses of engineering and statistics (and applied math). Recommender systems, image compression, PCA etc. all can be reduced to some form of matrix decomposition. Here John Cook speaks about the optimal approximation, which is, for general matrices, the SVD (no surprise there). I really liked the expression of \(A = \sum_{i} \alpha_i u_i v_i^T\). Makes it really clear just how “small” the decomposition can be.

  • Friday Blast #42

    Reducing DRAM footprint with NVM at Facebook (2018) - Morning Paper’s review of a new paper by Facebook on their use of NVM for their MySQL databases. Pretty interesting stuff and a cool production use of non-volatile memory.

  • Friday Blast #41

    Probit regression (2018) - this is an alternative to the more famous logistic regressions. They’re both generalized linear models, and the difference lies with the link function. For the first it is the so-called probit function, while for the latter the logistic one. The probit function is the inverse of the standard normal distribution’s CDF. It looks very much like the well known logistic link-function / neural activation function, and in practice the two method are basically the same. But sometimes it’s easier to analyze with one than with another.

  • Raynor RPC Work Log #2

    Last time I sketched out Raynor RPC. A bit of code got written and put on GitHub but nothing big. In this one I’m going to polish up that thing. The main focus is on getting the annotations right.

  • Friday Blast #40

    The philosophy of computational complexity (2018) - there’s a lot of nice links from this one. The article itself deals with philosophy and what it should absorb from computational complexity. And the undercurrent is that both philosophy, and science has a whole, hasn’t really absorbed all that much from the field. Even though it offers a lot of insights and computational limits crop up in a lot of places - from biology, to economics, quantum physics etc. Also includes a nice discussion on various level of “truthyness” of the P=?NP problem, and what that would mean for cryptography and the world in general.

  • Raynor RPC Work Log #1

    I’m going to try something different with this blog post and make it a sort of work log for a small project I’m trying to build.

  • Friday Blast #39

    I’ve compiled a bunch of links of the multi-repo vs mono-repo choice. It’s been a hot topic of debate at work.

  • Friday Blast #38

    Another batch of random links.

  • Friday Blast #37

    Today’s friday links are all over the map. Can’t have all of them be themed.

  • Packages For Databases

    A common rule of thumb in internet companies when dealing with relational databases is to avoid stored procedures. There’s a bunch of reasons why this is, but it’s usually a combination of perceived performance issues and simply being hard to use.

  • Friday Blast #36

    Last week I wanted to better understand JS modules, so the bulk of the links are related to this topic. It’s a fast moving domain, so the articles cover a lot of ground.

  • Friday Blast #35

    A 2 year Stanford study shows astonishing productivity boost for working from home (2018) - I can confirm this and I’m happy it’s a trend with a positive trajectory. There’s a whole host of improvements at the individual’s, company, city and state level for more companies and people doing this.

  • Google Helped Me

    And now it’s time for a small rant.

  • Friday Blast #34

    There and back again: why PaaS is Passe (and why it’s not) (2018) - PaaS has become somewhat of a dirty word in infrastructure circles. Tyler Treat makes the case that at some point it’ll make a comeback. Most of the stuff going on when building infrastructure for a project/company aims at building some sort of PaaS in the end, and once enough things are fleshed out, folks won’t mind the loss in customization a next generation PaaS provider will offer. Kubernetes will probably be involved somehow.

  • Friday Blast #33

    Measuring transactional integrity in AirBnB’s distributed payments ecosystem (2018) - AirBnB has a whooping number of payments integrations of all sorts - APIs, redirect flows and good ol’ FTP uploads. Even in the simplest cases this is a system which takes a while to achieve consistency and some notion of “data integrity”. So the payments team have setup a number of extra monitoring systems to look at issues and produce metrics of the “health of payments subsystem”. I’ve been thinking of issues related to this a lot in the past year. In many systems, it’s not enough to have a strong type system and a battery of tests in order to be certain of a system’s correctness. You need to actively look at the system’s state and find the issues. This might mean checking that invariants which are hard to express in code or business rules which aren’t concisely expressed in code are maintained.

  • The Next 100 Years Review

    I’ve recently finished reading “The Next 100 Years” by George Friedman. This is another geopolitics-for-the-masses book, after Prisoners Of Geography, and I actually read them back to back. It was perhaps too much and some themes repeated themselves. But I guess it’s good for better remembering these things. Nevertheless, this was an interesting read.

  • Friday Blast #32

    Microservice fallacies (2016)- the usual stuff - only get them once you’re sure you need them. Which is usually not at the start of a project. There’s other ways to get the modularisation benefits.

  • Friday Blast #31

    A practical introduction to container terminology (2018) - if you’ve ever worked with Docker or other container tech, you’ve probably been a bit confused by all the names - container, repository, registry, image etc. There’s a lot to unpack and a lot of people using one name when they mean another. This is a long-ish presentation & glossary of container terms from RedHat.

  • Immigrant, Expat And Émigré

    A national sport in Romania is the mass migration towards “the west” in the last 30 years. There’s some issue to what makes up the diaspora. But about 3.4 million people have left since joining the EU in 2007. Some as students, but most of them as foreign workers. That’s about 20% of the country’s population. So it’s been happening for a while at a high rate and it’s likely to continue for a while.

  • Friday Blast #30

    Differential privacy for dummies (2016) - differential privacy is a way of working with data which doesn’t provide information about any one person / item in the data set. A neat example is asking people to identify as criminals/drug users etc. There is a protocol of adding noise to the data, which can be done by each person being asked in turn, so that (1) you don’t know if any one person is actually in the target class and (2) you can compute population queries such as total number of people in the class, proportion of people in the class etc. There’s a bunch more examples there as well as a brief theoretical overview. Interesting stuff for the age of big data and big surveillance.

  • Friday Blast #29

    The ultimate guide to progressive web applications (2017) - one of the better developments in the recent tech space has been a resurgence of websites/SPAs under the guise of progressive web applications as viable contenders to native applications. Well worth a read as an introduction, but not that many technical details.

  • Why Does The State Object Exist In React?

    Use @depiction asks on StackOverflow Why does state object exist in React?. I’ve provided a biggish answer to the question, so I figured I’d add it to the blog as well. My answer follows:

  • Friday Blast #28

    A focus on probabilistic data structures with some Bitcoin thrown in this week.

  • On The Success Of The Romanian IT Industry

    I’ve recently read The phenomena of the IT industry - too big of a success for an unprepared country . The article is in Romanian, but Google Translate should do a decent enough job of it.

  • Friday Blast #27

    Ten years in, nobody has come up with a use for blockchain (2017) - I’ve been following the blockchain/crypto thing from afar, so I don’t have enough context to judge the article. It seems to have a point though, especially when saying that many of the folks who’ve built one system or another on top of a blockchain, didn’t bother to study what they were replacing in detail. And, more importantly, whether the things they’d be giving up had any merit - which, in many cases they did (rewards programs, the ability to dispute charges etc).

  • Prisoners Of Geography Review

    I’ve just finished reading “Prisoners Of Geography - Ten Maps That Tell You Everything You Need To Know About Global Politics”. The title is a bit long, but the book isn’t and is approachable to boot. It’s an introduction into geopolitics - or how the geography of the world affects politics and the development of states. It’s follows the same vein as “Guns, Germs and Steel” or “Why Nations Fail” (my review). But where those two tried to impose a unifying theory of why the world is the way it is, this one has more modest goals, and looks at geography as one factor shaping nations today. Which is nice, because there’s no need to twist the data to fit the model.

  • Explore Bucharest -- Primaverii

    Primaverii 1

  • Friday Blast #26

    Understanding the C++ memory model (2018) - a brief discussion on atomic operations and memory barriers and what they mean in the context of C/C++ (and many other languages at the same level of abstraction - Java, C#, Rust etc). Atomics are used to guarantee that certain very basic operations happen as a unit. Things like incremeting, compare-and-swap, compare-and-test etc. The set of atomic operations for a particular object forms a total order. However, this implies nothing for other objects or for visibility of other operations. For that, memory barriers are needed. C/C++ have the notion of acquire and release barriers, which guarantee that all operations before, respectively after, won’t be reordered past the barrier. Barriers say nothing about atomicity. So you need both as a basis for concurrency primitives.

  • Friday Blast #25

    Ten year’s worth of learning about pricing (2017) - this is not a tech link. But it’s interesting none-the-less I think, for those many engineers which live next to the business side of whatever company they work for.

  • Notes On Capturing The Data Exhaust Of A Web Application

    The “classical” view of the server side part of a web application is that it consists of a bunch of web servers, database servers, caches etc. Basically, a set of components which run the application code, and a set of data storage components the application code makes use of. This is regardless of where you are on the monolith - services - microservices - serverless application architecture spectrum.

  • Friday Blast #24

    A video heavy link set today. Hope you enjoy.

  • When To Join A Company For Maximum Engineering Challenge

    Disclaimer: this is a post with a bit of career advice. I haven’t written about this at all before. And I haven’t thought about it that much to boot. So take whatever follows with a grain of salt. I do think the things I’m going to say are uncontroversial though, but if I’m off the mark I’d sure like to know. So any comments and critiques are welcome.

  • Friday Blast #23

    Threads cannot be implemented as a library (2004) #pdf - the main point is that for superior concurrency support, the language needs to step in. It’s not enough to rely on a library such as pthreads. The reasoning is both performance related - such libraries want every synchronization to go through them, and don’t really say anything about shared variables which are used without library provided synchronization. However, modern processors offer some primitives outside of locking - atomic operations, fences etc. which are required for best performance, but which can’t be expressed correctly if the compiler does reorderings or other optimizations. It is also safety related. Some optimizations, which might be unaware of the special behavior of pthreads functions may yield race conditions or other unexpected behaviors. This works comes in the wake of the seminal Java Memory Model, but addresses C/C++ and other low-level languages (Ada?). It all culminated with C and C++ having memory models in the later revisions.

  • Friday Blast #22

    Back from holidays with a shorter set of links. Still, there’s some pretty interesting stuff.

  • Explore Bucharest -- Dorobanti And Victoriei

    Dorobanti And Victoriei 1

  • Explore Bucharest -- Cismigiu

    Cismigiu 1

  • Java Concurrency In Practice Review

    This is a book review for Java Concurrency In Practice, by Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes and Doug Lea. The author’s are a who’s who of the Java world. The tl;dr is that this is a very good book and you should go out and read it[1]. I didn’t have that much experience with modern concurrent programming, past basic threads/processes and lock-based concurrency, and I feel much better informed and prepared after reading this book.

  • Friday Blast #21

    Online migrations at scale (2017) - an article from Stripe engineering about how they performed a large-scale migration of their core data structures without any downtime. Now, not all migrations are this complex, but some are. And in this particular case, in any setup you’d have - large or small - you’d be stuck doing the same dance. I found the use of Scientist to be particularly interesting. This is a Ruby library which aids in refactoring data paths - they made sure that all of their new read paths produced the same results as their old read paths, and had extensive error reporting and monitoring around it.

  • Friday Blast #20

    This week - career advice.

  • Why Nations Fail Review

    This is a book review for Why Nations Fail? by Daron Acemoglu and James Robinson. The tl;dr is that this is a good book and an easy read and you should go out and read it.

  • Explore Bucharest -- Maria Rosetti Area

    Maria-Rosetti 1

  • Friday Blast #19

    A brief history of select(2) (2016) - covers the history of the select syscall. Early Unixes were very basic.

  • Little's Law

    I was recently reading Java Concurrency In Practice and came about this little gem of a theorem called Little’s Law. It’s quite intuitive and you’ve probably used it a bunch of times already. Still, I wasn’t aware of it despite how useful and simple it is to state.

  • Friday Blast #18

    Building blocks of TCP (2016) - this is a chapter in the High Performance Browser Networking book. It deals with some of the behaviours of TCP like flow control, congestion avoidance etc and looks at both historic things as well as newer developments.

  • Software 2.0?

    Recently an article by Tesla’s Andrej Karpathy titled Software 2.0 circled the techsphere. The author was of the opinion that neural networks are a fundamental shift in how we build programs and that this is an interesting development which warrants a web 2.0 style name.

  • Friday Blast #17

    Ask HN: What language agnostic programming books should I read? (2017) - A Hacker News discussion with loads of good titles. I’d go so far as to say that most good tech books are independent of the technology itself and present timeless bits of knowledge.

  • Raynor-Chai

    This post is about raynor-chai, a nifty extension/helper for chai, the JavaScript assertions library. It allows one to use the methods of raynor to check that certain objects behave in the way you like.

  • Friday Blast #16

    Tough Cookies (2017) - the 2017 guide to making secure cookies. They should be http only, secure, have the same site attribute and use prefixes. This protects against XSS and XSRF attacks in a first instance, as well as ensure the cookies are essentially restricted to the role of association information for user state.

  • Friday Blast #15

    Practical advice for analysis of large, complex data sets (2016) - advice from the Google data scientists working on ads. Now, I think this is good advice for any software engineer working on complex projects. Many projects will involve analysis of large data sets, running experiments and A/B tests etc.

  • On Communist Subway Station Names

    Bucharest, the city where I was born, grew up and currently reside, has a medium scale subway system. One of the stranger things people complain about is the bad station names. Perennial favorites are “Precision”, “The Flatting Mill”, “Peace”, “Heroes”, “The Polytechnic”, “Writers”, “Horizon”, “Modern Times”, “Defenders Of The Country”, “Aviators”, “The Youth”, etc.

  • Friday Blast #14

    What is the effect of ordering if…else statements by probability (2017) - both theoretically and empirically, ordering the branches in decreasing probability of being taken results in better performance. Granted, you’re only likely to see it in microbenchmarks. But it’s still interesting, cause a “readability” best practice I use is have the least-likely to be taken cases in functions and loops first. Since they’re most likely error handlers rather than real code, and leave the bulk of the method for last.

  • Friday Blast #13

    This is the 13th Friday Blast post. Coincidentally[1] today is also Friday the 13th.

  • Friday Blast #12

    Clocks for software engineers (2017) - hardware design is very different from software design. And it starts from the very basic concept of the clock, which is the periodic and square-ish signal which synchronizes all the other components of the design. There’s a whole bunch of hardware design tips on the website as well.

  • Friday Blast #11

    This is the 11th installment of the Friday Blast series. More data science and career advice this time.

  • Designing Data Intensive Applications Review

    This is a book review for Designing Data-Intensive Applications, by Martin Kleppmann. The tl;dr is that this is a very good book and you should go out and read it. It’s the kind of book where you can genuinely feel a better developer at the end of it than at the start.

  • Friday Blast #10

    This is the 10th installment of the Friday Blast series. I missed last week on account of explosive health problems. So today’s dosage is a little bit larger than the usual. Enjoy!

  • Bug Report #2 - Lazy Select In C#

    This is the second in a series of articles about bugs I encounter while working. The first one was about GETUTCDATE() and how it complicates things in longer queries.

  • Explore Bucharest -- Traian Area

    Pictures taken in July. I forgot about them and finally managed to upload them.

  • Explore Bucharest -- Around The Catholic Cathedral

    Pictures taken in June. I forgot about them and finally managed to upload them.

  • Friday Blast #9

    The 9th installment of the Friday Blast series. A slight focus on physics for this week.

  • Friday Blast #8

     

  • Friday Blast #7

    A shorter week this week. Didn’t get that much reading on account of spending most of my reading time on Designing Data Intensive Applications.

  • History Tables

    Somebody recently asked on a forum I frequent what’s a way to get a history of the changes a user has made to their account. Turns out they were building their own application, with Laravel and basic PHP. This is a common product need and is a nice feature to boot. A common extension is to have this for all entities an application cares about.

  • Friday Blast #6

    This week - Norbert Baum’s claim of proof for \(P \neq NP\).

  • Friday Blast #5

    A lighter week for this issue.

  • Average Number Of Machine Failures In A Datacenter Given Just The Mean Time To Failure

    I’m currently reading Designing Data-Intensive Applications. Quite early in the book an interesting application of basic probability theory pops up. The author says “Hard disks are reported as having a mean time to failure (MTTF) of about 10 to 50 years. Thus, on a storage cluster with 10,000 disks, we should expect on average one disk to die per day”. The point they’re trying to make is that even with a component which is quite reliable, you will see a lot of issues at scale. Therefore large scale distributed systems need to acknowledge this fact and be resistant to the failures. I think there’s some neat math behind the statement itself, irrespective of its sobering effect on engineers. So let’s see how we would go about deriving it.

  • Bug Report #1 - GETUTCDATE() In Longer Queries

    This is the first in a series of articles about bugs I encounter while working[1]. It’s a new thing I’m trying for the blog, along side the Friday Blast series, which is currently at week 4. There’s a lot of bugs out there. But I want to highlight those which are generic enough so that the solution is useful to other people, and fun enough that they’ll be worthwhile to write about.

  • Friday Blast #4

    There’s a good mix of recent and older articles this week. I’d say they veer towards being longer this week, but they’re also more essay-like, so they should be easier to grok.

  • Explicit Entity State

    Many or even most of the entities we work with in typical applications have a notion of distinct states they can be in. These states correspond to the evolution of that entity though the application, and the entity is expected to move from one state to another as a result of certain events happening.

  • Friday Blast #3

    A shorter blast this week, on account of being on vacation.

  • Friday Blast #2

    In this post I’ve begun putting the year next to the link. The bias will be towards more recent articles, of course. But sometimes it’s useful to know the context of a piece to be able to judge its content/advice.

  • On Backends For Frontends

    Just read Sam Newman’s Backends For Frontends. It’s a very insightful piece and a worthwhile read. I’ve encountered the pattern several times, but I didn’t have a name for it and I feel so glad to see it more formally defined.

  • Friday Blast #1

    This is the first in what I want to be a weekly series of posts. It’s nothing fancy, just a bunch of articles I found interesting over the last week.

  • On Serverless

    If we ever were to rank technology trends by choice of bad name, then serverless would easily make it to the top. Which is unfortunate, as I think that despite the name, serverless is a very important development and possibly the last step towards a very interesting cloud vision.

  • CP For Distributed Databases

    Some distributed databases are characterized as being CP. BigTable is an example of this, and it stands in contrast in this respect with Dynamo which is AP. If you think about it, however, things are a little bit odd. If you’ve ever used BigTable or it open-source clone HBase you know that it doesn’t stop accepting writes if one node goes down. And at the scale these tools are employed, nodes go down all the time. So is the characterization wrong? Or is there something missing from the description?

  • Explore Bucharest -- Xenofon Street And Carol Park

    We set out to explore Xenofon Street, which is the only street in Bucharest which is in steps. It also leads to the highest point in Bucharest. Which is not that high in absolute terms, and there is no “view” to speak of, but it sounded intereessting.

  • Explore Bucharest -- Cernica

    Cernica 1

  • Raynor

    A little while ago I wrote and open-sourced a small TypeScript/JavaScript data validation and marshalling library called Raynor. Since it proved quite useful to use around the house, I figured I could do a little bit more with it than just dump it on GitHub. This article is a first step in that direction. It is an overview and tutorial of what Raynor is and how it operates. If you find this sort of stuff interesting I hope this will provide enough info for you to be able to try it in our own projects.

  • Some Notes On Microservices

    The hardest thing about building internet applications with microservices is the lack of transactions. While the production issues are nothing to scoff at either, they at least have solutions, either technical or cultural. However, while distributed transactions are possible in theory, in practice they impose too hefty of a performance penalty, and require the kind of deep integration and coordination between actors you aren’t likely to encounter.

  • Life - Moments Vs Processes

    Chalk this up to random musings.

  • Gradual Security Claims

    Wikileaks released the other day a treasure trove of documents describing the CIAs hacking tools. There’s a lot stuff in there, but at core it confirms the belief of many in the IT field, that most things one does on a connected device can be found out, even when the intention is not to. This includes phones and computers, but also more exotic devices such as smart TVs. Though not as cool as the CIA’s other toys, they are perhaps more fearsome.

  • Explore Bucharest -- Cotroceni

    Cotroceni 1

  • NPM Prepack And Publish

    The other day I published a small package to GitHub and NPM. This post serves as documentation and tutorial.

  • The Three Ways Of XOR

    We all know the XOR operation. It’s the cousin of NOT, AND and OR. Like AND and OR, it is a binary boolean function. Unlike them, most programming languages don’t have an explicit “logical operator” for it, but rather show only the bitewise version. Regardless, cryptographers love it and machine learning folks fear it. And for very good reasons. Despite its simplicity, there are quite interesting things to say about it, and this article presents three of them.

  • Vector Watch Sale

    Vector Watch, a Romanian startup building smart watches, has recently been acquihired by FitBit. The news is quite old by now, and all that could have been said about it has been said already. But that’s not a valid reason to not write this blog post.

  • Joins

    Joins are a perenial source of grief among web programmers, especially those who don’t interact that much directly with the database. However, they’re an indispensible and quite powerful tool.

  • Explore Bucharest -- Dorobanti

    Dorobanti 1

  • Stay In School

    I’m a big fan of our industry’s openness to people from all backgrounds. As the StackOverflow developer survey highlights, some 40% of all developers don’t have a formal CS or even technical background. There is a bias towards web development in that survey, but, even in the larger population of developers, some amount of this fact is likely to hold true.

  • Introduction To Adtech

    This is the first of a many-parts series of articles on Internet advertising technology. Or AdTech, for short. This is not an especially well covered topic online, so perhaps this will be useful to people.

  • Polyglot Libraries (And Frameworks)

    The name Polyglot Library is one I propose for those libraries which appear in more than one programming language. The most famous example of this is, perhaps, the xUnit family of testing frameworks. While all of them are written in different languages, there’s an undoubted conceptual core which is static, as well as a “tree of influence” between versions.

  • Communication Networks

    Here’s a highly simplified list of major telecommunication networks people have built, in somewhat historical order: mail service, telegraph, telephone, radio, television, the internet.

  • String Interpolation - So Hot Right Now

    One of my theories about modern programming languages is that they are all slowly converging towards two-to-five archetypes. And this happens not only on the level of features, but syntax, libraries and the whole ecosystems built around the languages.

  • Playing With CSS

    For the longest time, me and CSS were in a friend-of-a-friend type of relationship. Sure, we’d hang out when our common friend frontend development was around, but we’d never just hang out by ourselves. However, I always felt bad about this state of affairs, since it is one of the core technologies of the web. And I was sure my cargo-cult approach to it is not the proper aproach to it. There must be some logic to it.

  • SDHash

    This article talks about the SDHash package, which is a Python library for computing hashes of images which ignore perceptual differences.

  • Optimal Predictors

    This post is about a neat question I was asked many moons ago in an interview. I was quite pleased with myself for getting it right, especially under pressure. I’ve changed some bits of the problem statement in order to protect the innocent, however.

  • How Tabletest Works

    In a previous post I introduced the tabletest library. In this post I’m going to dive a little bit into its inner workings. The water is relatively shallow however, since, at less than 80 lines of commented code, the library is not that big to begin with.

  • Tabletests

    This article is an introduction and justification for tabletest and tabletest3. These are small Python and Python3 (respectively) packages I’ve written. They are used when writing so-called “tabletests” or data-driven tests.

subscribe via RSS