March 2017 Summaries

Microservice architecture is gaining popularity as companies like Amazon and Netflix share their successful experiences with it, highlighting its suitability for managing complex systems and large-scale deployments. Although many perceive microservices as a future prospect rather than a current necessity, the article argues that recognizing the limitations of monolithic applications—such as system fragility under load, slow development cycles, and high maintenance burdens—can prompt timely transitions to microservices. It details common issues that arise in monoliths, such as single points of failure, slow CI builds, extended onboarding times, and emergency-driven task switching, which collectively hinder a team's ability to innovate and respond swiftly to market demands. By decomposing monolithic systems into smaller, manageable services, companies can alleviate these problems, improve team morale, and refocus on product development, thus enhancing their ability to deliver valuable features to users more efficiently.

Semaphore has introduced a new feature called CI Speed Insights to help users monitor and enhance their continuous integration (CI) speed, now available to all Semaphore users. This feature provides a chart on the project page displaying the runtime duration of recent builds and average CI speed, with a focus on maintaining build times under 10 minutes to ensure efficient continuous integration processes. CI speed is defined as the average time from pushing new code to receiving a build status report, considering both build runtime and any delays due to resource availability. If builds exceed optimal time, Semaphore suggests running tests in parallel, a setup that can be configured manually to reduce build times. Additionally, Semaphore is developing automatic test parallelization, initially supporting Ruby tools like RSpec and Cucumber, to further optimize testing processes. Users interested in this feature can contact Semaphore for a demo, and further discussions can be joined on their Discord channel.

Ruby and Rails are often criticized for being slow compared to languages like Node.js and Python, yet they remain widely used by various businesses due to their strengths in other areas. The primary reason for perceived slowness in applications often lies in unoptimized database queries, such as loading too much data into memory and inefficient existence checks, rather than inherent language inefficiencies. Rails provides multiple methods for checking the existence of a database record, each with different performance implications, with .exists? being the most efficient due to its use of the SELECT 1 … LIMIT 1 query. This method significantly outperforms alternatives like .present?, .any?, and .empty?, with .exists? executing in just 1.1 ms compared to 2892.7 ms for .present?. While .exists? is generally the best choice for performance, there are exceptions, such as when records are already loaded into memory, where .any? might be preferable. Semaphore emphasizes the importance of optimizing code for speed and offers tools like Semaphore Boosters to enhance continuous integration processes by automatically parallelizing test suites to reduce runtime.

Semaphore has updated its Slack notification system to provide a streamlined, single-line format that efficiently conveys vital information about builds and deployments, responding to user demand for clarity. These notifications can be easily set up to keep team members informed about project progress, emphasizing the collective achievement each deployment represents. The recommendation is to direct production deployment notifications to a shared Slack channel, such as #engineering or #general, to ensure the whole team is aware of accomplishments. Semaphore's internal settings notify users of changes in the master branch's build status and production deployments. For teams new to continuous deployment, Semaphore offers resources to help them begin automating their processes, starting with a central manual trigger and deployment history.

Rendered Text has developed a microservices architecture to create an efficient mailing system for their Semaphore product, utilizing Elixir, RabbitMQ, and Apache Thrift. This system decomposes tasks into smaller, independently functioning services, such as gathering data, processing it, and sending emails. They use RabbitMQ for asynchronous messaging, with a Ruby producer sending encoded messages to an Elixir consumer, and ex-tackle for message handling. The email composition leverages Elixir's EEx for HTML template rendering, allowing data to be inserted into HTML partials for better readability. For email delivery, the SparkPost API is employed, facilitating the sending of emails with analytics and support for multiple recipients. The entire process, from data gathering to email dispatch, is streamlined to take less than four seconds, with a preview email sent to service owners before customer reports are issued.

Continuous integration (CI) is often misunderstood and inconsistently implemented despite its core promise of enhancing software reliability. Essential to CI is an automated test suite, a complex requirement that demands expertise in test-driven development. However, long CI build times can impede productivity, leading developers to keep code branches isolated longer and complicating merges and refactoring efforts. Martin Fowler highlights that true CI involves daily commits to a shared mainline, automated builds and tests for each commit, and rapid resolution of build failures, ideally within ten minutes. Slow CI processes create defensive work habits and impact overall team performance, but solutions like parallelizing tests can significantly reduce wait times and maintain developer productivity. Semaphore, for instance, offers features like Semaphore Boosters to expedite Rails test suites, ensuring that CI remains efficient and conducive to a productive workflow.