Brand: Artifact vs Operating System
Compare two mental models for brand: a static artifact (logos, guidelines, centralized control) and a living operating system (values, APIs, support, trust). See which choices fit your engineering team.
Loading…
Topic
Developer Experience
448 posts about Developer Experience. Every summary links to the original.
- 448 posts
- 42 companies
- 10 explainers
See the idea
Developer Experience explainers
What an App Store Actually Is: A Contract, a Surface, and a Health Loop
An app store is a distribution surface, a versioned contract, and a health loop between a platform and its developers. Here is how those parts fit together and why each one fails loudly if ignored.
One IDE vs. the Right Tool: Android Studio's Boundary Trade-off
Android Studio keeps cross-platform Kotlin run and debug in one workspace but hands Swift editing to Xcode. This explainer maps the benefit, cost, and condition behind that boundary.
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
Posts
A Guide to Mindful Communication in Code Reviews
Code reviews are presented as both technical work and communication, teaching, and learning. The guide defines mindful communication as listening and speaking with compassion, kindness, and self-awareness, then applies that perspective to reviewers and authors. It recommends self-checking before commenting, asking open questions instead of assuming, omitting linter-detectable nits, signaling what can wait, giving example code and documentation, and ending substantial feedback with “What do you think?” Reviewers are encouraged to approve unless major problems exist, while large changes and architectural decisions should receive broader discussion. Authors should link relevant documentation, assume good intent unless feedback is hostile, keep diffs focused, and seek feedback early; these practices take time but can become a learnable habit that varies by team.
Introducing Grab-Kit: Distributed Service Design at Grab
As Grab migrated from a monolith to microservices, maintaining consistency, coordination, and code quality across rapidly expanding teams became a major engineering challenge. To address this, the Developer Experience team built Grab-Kit, a Go framework that automates service scaffolding, code generation, and distributed system design patterns. The framework uses Protocol Buffer definition files as a single source of truth to generate data transfer objects, communication bindings, and standardized middleware for logging and profiling. Grab-Kit also features declarative metrics definitions that synchronize with the DataDog API to build and update service dashboards automatically. Adopting the framework reduced development time for creating new services by up to 70% in teams such as GrabFood while improving overall system stability.
Tell Your Stories: The Benefits of Strategic Engineering Communications
Shopify created engineering communications in early 2016 as rapid growth and expansion from four to five offices made informal knowledge sharing insufficient. The program serves internal and external audiences through weekly technical talks, an internal newsletter, engineering-blog posts, conference presentations, and an editorial calendar, with Shopifolk developers treated as a primary audience. Communications staff hunt for stories by building relationships with project leads, then coach speakers and work alongside developers while preserving their voices; coaching covers narrative, breath control, body language, and calls to action. The reported effects include less risk of duplicated work or mistakes, cross-pollination of ideas, more confident speakers, increased interest in Shopify from some attendees, and a recurring pipeline in which storytelling generates further stories.
Grab's Front End Study Guide
Rapid hiring and engineering expansion created a steep learning curve for newcomers and backend engineers unfamiliar with modern web architecture. Grab created an opinionated front-end study guide to help engineers navigate JavaScript tooling, state management, and modern application practices. The guide frames client-side single-page applications as a scalable alternative to traditional server-side rendering, enabling clear client-server separation for multiple client apps hitting the same backend API. It establishes core competencies in ECMAScript 2015 via Babel and explains how component-driven interfaces in React improve maintainability and performance through virtual DOM reconciliation. Ultimately, the resource aims to ramp up developer onboarding and accelerate shipping speeds across web platforms.
Deep Dive into iOS Automation at Grab - Continuous Delivery
Grab manages continuous delivery for its iOS applications using four build configurations per target: Adhoc QA, Hot Dogfood, Dogfood, and Testflight. The engineering team moved away from Fastlane in favor of custom bash scripts under 100 lines that execute clean builds and archives via xcodebuild. To eliminate manual logins for build execution, Grab developed a server-side Swift application integrating SlackKit and a bot named Iris. Incoming Slack commands are parsed and scheduled onto a serial DispatchQueue to trigger the appropriate build scripts. Deployment and rollback of updates to Iris and its build scripts are handled through Capistrano.
Deep Dive into iOS Automation at Grab - Integration Testing
Grab replaced third-party cloud CI services with an in-house Xcode Server pipeline to run automated iOS integration tests across an expanding engineering team. Instead of performing fresh repository clones on shared cloud instances, Xcode Server pulls code incrementally and mirrors local developer configurations. The team automated testing bots through Ruby scripts and Arcanist hooks tied to Phabricator code reviews, dynamically provisioning bots on diffs and deleting them after merges. This architecture preserves step-by-step UI test execution logs and screenshots for easier failure diagnostics. To maintain stability on on-premises hardware, pre-integration scripts clear application cache states using simctl commands.
Always Be Learning
Kickstarter’s Data team describes how pair learning fits into its broader “always be learning” culture, alongside monthly reading groups open to all employees. Two team members worked through Hadley Wickham’s Advanced R by reading one chapter every two weeks, then meeting for an hour and a half to discuss the material and complete exercises. They found that a steady pace, applying concepts to Kickstarter data, explaining ideas aloud, and documenting lessons in an internal R guide supported sustained learning; the guide includes a demonstration of R’s lazy evaluation. The pair considered the format easier to schedule and harder to neglect than larger groups, while acknowledging fewer perspectives and inclusion challenges, and concluded that it strengthened job-related skills and intellectual curiosity.
Programmers Beware - UX is Not Just for Designers
Software engineers frequently overlook user experience when designing APIs, SDKs, and code-level functions. Usability issues arise across various technical interfaces, from mobile apps forced to coordinate multiple round-trip network calls to ambiguous function signatures that obscure boolean arguments. To counter this, engineers can apply a five-question discovery framework to identify user identity, core objectives, user capabilities, ways to reduce user burden, and familiar paradigms. Practical remedies include sacrificing strict RESTful separation to merge mobile endpoints, placing validation logic inside internal RPC servers, and replacing boolean arguments with explicitly named helper functions. Ultimately, treating calling systems, end users, and fellow programmers as users shifts implementation complexity from consumers to servers.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.