May 2022 Summaries

The text discusses the importance of smooth web animations for a natural-feeling application and how to achieve this. It explains that performance is crucial for user experience, with 60 frames per second being the generally accepted target for achieving a "natural" feel. Developers are advised to limit the amount of necessary work in each frame to ensure smooth interactions. The text also covers various techniques such as using transformations and opacity changes, promoting elements to their own compositor layers, and leveraging requestAnimationFrame for performance-intensive events like resize or scroll. It emphasizes testing and iterating to fine-tune animation performance and reduce the amount of work needed in each frame.

Writing quality code that is maintainable and extendable is crucial for software companies relying on teamwork or long-term projects. Testability and loose coupling techniques can make code more maintainable, while making it composable and reusable. Integration testing checks parts of the software in isolation with real inputs and I/O systems, while unit testing tests parts of the software in isolation with dummy I/O systems and dependencies. Single Responsibility Principle (SRP) ensures that every part of the software addresses one single concern, making it easier to isolate features for testing. Dependency Injection (DI) is a powerful principle that allows control over dependency initialization outside of the code using them. Mocking dependencies enables complete control over their behavior during tests. Relying on abstract types (interfaces) to mock dependencies throughout the code produces cleaner, less coupled APIs. SRP and DI used in combination produce software with composable features and reusable code. Some dependencies might not be easily mockable due to open APIs or complex 3rd party dependencies, but these issues can be addressed through data access layers and interface segregation principles. Embracing testability design principles also helps make the code more usable in the first place.

Git `rebase` is a powerful tool that can be used for integrating and exchanging work between two branches, as well as rewriting history. It differs from `merge` in its ability to apply commits from one branch onto another, allowing users to stay in sync with the latest changes and deal with potential conflicts earlier. Interactive rebasing enables users to reorder, rename, remove, split, merge, or change commit messages directly within their own branches. Conflicts that arise during a rebase can be resolved using Git's built-in tools, and recorded resolutions can be reused for the same conflict in the future.

IT service desks are under increasing pressure due to digital transformation projects. Many support organizations struggle to provide adequate IT support to their employees. To streamline support processes and improve service levels, many service desk managers are turning to a knowledge-centered-service (KCS) approach. KCS involves sharing and refining knowledge on an ongoing basis. The benefits of KCS with customer support include faster resolution times, improved service delivery, and increased likelihood of cases being resolved the first time. Creating an effective knowledge base takes time but using the KCS method can help maintain it so that it's always up to date. Algolia's advanced search API is ready to help on both counts by providing a reliable search functionality with proven algorithms, integrations, and UI libraries.

Evaluating search engines and other online systems can be complex due to their constantly changing nature. A/B testing metrics play a crucial role in assessing the effectiveness of these systems. This article focuses on qualitative evaluation, specifically relevance, which is essential for measuring search engine quality. Relevance involves finding matching records and ordering them based on factors such as popularity, ratings, UI/UX, personalization, and merchandizing. Various business roles have different notions of what constitutes good relevance, making it challenging to define A/B testing metrics that accurately reflect measurable relevance. Directionality and sensitivity are two important aspects to consider when choosing a metric. Directionality ensures that the metric has a clear interpretation, while sensitivity allows for detecting small changes in search experience. Commonly used A/B testing metrics include increased revenue, conversion rate (CR), and click-through rate (CTR). While each of these metrics has its pros and cons, combining them can provide more reliable results. It is crucial to align the chosen metric with the specific use case and business objectives. Additionally, avoiding gaming by not relying on a single type of metric is essential for pragmatically evaluating an online system's performance during A/B testing.

Sharing sensitive information over Slack or email is a common but risky practice, as it exposes company secrets to potential security breaches. To address this issue, the author developed a self-destructing message service using Hashicorp Vault's Response Wrapping feature. The tool allows users to securely share sensitive data without compromising its safety. This solution has gained popularity within Algolia and is now available as an open-source project on GitHub.

The company balances the need for rapid innovation and feature updates with the need for reliable software by testing in production. This approach allows them to deliver new features on time while minimizing the impact on customers. The company uses a replicated infrastructure, health checks within the code, and a progressive deployment process to mitigate risks. They have also implemented a three-day partial deploy of the search engine to detect issues and ensure customer availability remains high. By leveraging different environments, replication factor, and a deployment process in twelve steps, they can efficiently release new versions while controlling risks progressively.

Upgrading the operating system and libraries can have significant impacts, often overlooked. The team upgraded to a newer version of glibc, which led to unexpected memory consumption issues due to an underlying bug in the allocator. After investigation, they found that the issue was caused by the allocator retaining large chunks of free memory, rather than reclaiming it. To mitigate this, they implemented a workaround using `malloc_trim` to periodically release free memory. The team also explored other options, including increasing arenas and using different allocators, but these did not provide a satisfactory solution. They concluded that upgrading components one by one over time, with careful monitoring of metrics, is an effective way to minimize risks associated with upgrades.

The text discusses eight key best practices for using Kubernetes effectively. These include not using root user in containers, handling graceful termination, using declarative management for manifests, linting manifests, configuring liveness and readiness probes, setting resource requests and limits, specifying pod anti-affinity, and defining a Pod Disruption Budget (PDB). These practices are crucial to ensure efficient deployment of services on Kubernetes and maintaining the health of containers.

The team implemented an internal static website on AWS S3 for employees to download technical reports, but faced issues with native authentication/authorization. They used Okta for Identity and User Management, which required a back-end check. To solve this, they learned about AWS Lambda@Edge that lets you run Lambda Functions at different stages of a request and response. They decided to trigger a Lambda at the viewer-request stage to check if the user is authorized. They faced several restrictions and caveats with Lambda@Edge, such as limitations on environment variables, package size, region creation, and IAM execution role. To resolve these issues, they used JSON Web Tokens for secure access control. The solution involved writing a middleware between AWS and Okta using Lambda@Edge and creating various AWS resources to make it work.

The company decided to standardize the user interface of their multi-application dashboard for ease of use and design process. They built an internal design system called Satellite, using Tailwind CSS as the CSS framework due to its utility-first approach and configurable class names. However, they faced readability issues with complex components in Tailwind. To mitigate this problem, they used web development techniques such as tagged literals and interpolation, and implemented ESLint for better DX. They also created a Visual Studio Code extension to provide intellisense suggestions for class names. Overall, these tools have improved the design system's implementation and enforced standards within the company.

You're staring at your code and thinking, "There's nothing wrong here," but there is - the app isn't working. Talking out loud with a colleague or rubber duck can help solve problems by pushing you to reflect on your understanding and solution. Pair programming involves two developers sharing a single screen, creating great software through discussion and teamwork. It involves switching roles, such as navigator taking over from driver, to make better use of mentor-mentee situations. Trust, candor, care, grit, and humbleness are essential values in pair programming, which can be done remotely with tools like Zoom or specialized remote pairing tools.