For NASA, redundancy is all-important. (Why send a single server beyond the stratosphere when you can send five?) | Continue reading
The former lead architect of Apple’s iCloud Photo Library talks infrastructure, privacy, and system design. | Continue reading
Enough is enough with that thicket of code impeding nearby work, trapping the unwary, discouraging the inexperienced, and exhausting veteran developers! | Continue reading
Approachable ideas and best practices to help engineering teams apply the principles of functional programming to high-level design and architecture. | Continue reading
How Buffer, ThoughtWorks, N26, and Zapier have shifted their software to respond to new contexts and met new needs. | Continue reading
This issue of Increment offers structural, organizational, and personal approaches to building empathy, fostering collaboration, and growing productivity. | Continue reading
And what do we even mean when we say “technical”? | Continue reading
A disastrous IT migration corrupted 1.3 billion customer records. The culprit was insufficient testing. | Continue reading
Advice for when you’re starting from scratch and designing for growth. | Continue reading
Though they run on a mixture of paper and lore, effective editorial organizations ship like clockwork. Can engineering teams learn from their enduring processes? | Continue reading
A short treatise on rewarding value over volume. | Continue reading
How thoughtful systems (and lots of emoji) make for happy, efficient teams—whether your desks are distributed across floors, cities, or continents. | Continue reading
Studies show that human factors most influence the quality of our work. So why do we put so much stake in technical solutions? | Continue reading
How a group of university students transformed a school project into a media-player mainstay. | Continue reading
A story of how filmmaking, graphic design, and copywriting all improved a software project—and how similarly diverse skill sets might improve others. | Continue reading
A disastrous IT migration corrupted 1.3 billion customer records. The culprit was insufficient testing. | Continue reading
Knowing when and how to use this sometimes controversial (but often beneficial) technique is key. | Continue reading
This issue of Increment looks at how software testing impacts our collaboration, innovation, and code. | Continue reading
Testing in production is a superpower. It’s our inability to acknowledge it that’s the trouble. | Continue reading
Two experiments—small changes, instantly deployed; and automatically committing code that passes its tests, while deleting what fails—should have gone horribly wrong. They didn’t. | Continue reading
Example-based tests hinge on a single scenario. Property-based tests get to the root of software behavior across multiple parameters. | Continue reading
A conversation with the chairwoman of the Mozilla Foundation about her transition from corporate law to tech leadership, the power of a written document, and a more humane internet. | Continue reading
When—and why—should a business release an open-source project? | Continue reading
Making your documentation work for users with vastly different needs is a challenge. Here’s how spaCy, an open-source library for natural language processing, did it. | Continue reading
A maintainer of Babel navigates the boundaries of open source and self. | Continue reading
What can cities teach open source about governance, funding, and managing limited resources? | Continue reading
As casual contributions—coordinated by a handful of maintainers—become ever more prevalent, how should we reset our expectations for OSS? | Continue reading
A consideration of how human-oriented investments are vital to a project’s long-term health. | Continue reading
Tips for acquiring Git super powers. | Continue reading
How Donald Knuth’s 1978 typesetting program became one of the oldest still-active open-source projects and revolutionized technical publishing along the way. | Continue reading
When—and why—should a business release an open-source project? | Continue reading
What can cities teach open source about governance, funding, and managing limited resources? | Continue reading
This issue of Increment explores the inner workings and wide-reaching impact of open-source software—and the communities that build it. | Continue reading
Modern, nefarious interpretations of the age-old technique of covert communication have stoked the fires of curiosity—but is steganography really a major security concern? | Continue reading
The JavaScript ecosystem is inventive, incremental, messy, and ubiquitous. Here’s how we can make it more approachable. | Continue reading
In this tale of two threat models, we explore how pairing our existing knowledge and experience with a few simple questions can help us build better systems and keep them safe. | Continue reading
When BuzzFeed’s microservice ecosystem began to outgrow their existing auth patterns, they faced a common conundrum: Build or buy a solution? They chose the former—and to share it with the world. | Continue reading
Whether mitigating active privacy concerns or protecting communications on principle, for many in journalism and tech, Signal is the go-to for secure messaging. Here’s a look at its history, use cases, and how it fits into the messaging ecosystem. | Continue reading
No matter how lean your team, or how fast-moving your startup, you can—and should, and must—enact privacy principles. Here we discuss the difference between privacy and security, and what you can do to make good privacy practices the default. | Continue reading
To fully encrypt the web, you need to make certificates free and easy to obtain. Enter Let’s Encrypt. | Continue reading
From broken password change pages to conflicting best practices, users face a host of challenges when making password decisions. How can we remove the obstacles and help them use the systems we build securely? | Continue reading
How we can better protect users by considering the impact of our technical and product decisions on their privacy—and safety. | Continue reading
This issue of Increment explores technical, tactical, and empathetic ways to make the systems we build more secure. | Continue reading
Diving deeper into program language theory is a great way to grow as a developer. Here, we go through the essentials of using compilers in language design. | Continue reading
Good internal documentation leads to more stable and innovative development, and a better experience for users and developers alike. Here’s a look at some best practices, and how engineering orgs can make documentation a part of their culture. | Continue reading
Tips for developing and maintaining staging environments that will help you build more stable software systems. | Continue reading
Migrating your codebase to a new programming language can have some big advantages, but the process can be daunting—and risky. | Continue reading
COBOL has been a mainstay of government, business, and banking operations for nearly 60 years—but how long can it be maintained? | Continue reading