Is Smalltalk Fast Enough for the Backend of Web Apps Used by Millions?

When considering the suitability of Smalltalk for the backend of web applications that millions of users rely on, it's important to take into account the specific use case and architecture. In many scenarios, the speed of the backend may not be the primary bottleneck, especially if users predominantly engage in read operations that rarely change.

The Role of Caching and CDN

If the overwhelming majority of user interactions involve reading static content, the backend doesn't need to be exceptionally fast. Content caching and the distribution to a Content Delivery Network (CDN) can significantly alleviate the load on the backend. These cached contents can be served directly from the CDN without ever hitting the backend, thereby offloading the processing to a CDN closer to the user's network. This approach is widely used and can drastically reduce latency and improve overall performance.

Handling Write Requests

Write requests, however, might require more attention. For typical read-heavy applications, Smalltalk should be more than capable of handling at least 100 requests per second (RPS), given the right workload. However, if the write requests are more frequent, scaling out and load balancing the backend becomes necessary.

Regardless of the programming language, there is always a performance ceiling. Most major web languages, such as PHP, Ruby, Python, and Node.js, perform similarly. Even Java and Go, which are significantly faster in certain scenarios, still hit a limit around 10k to 100k RPS, beyond which scaling out is essential.

Architectural Considerations

Knowing the specific access patterns and load is crucial for designing an appropriate architecture. Caching strategies play a key role in optimizing performance. Many web service providers now offer comprehensive caching solutions, further reducing the need for backend heavy lifting.

Alternative Perspectives

Some argue that when evaluating the performance of a technology, it's not just about raw compute speed but also about the costs associated with meeting certain requirements. Benchmarks are often misused and fail to measure the right performance metrics. For a web service, network-related performance can be just as critical as compute performance. Even if a Smalltalk backend handles simple tasks well, the overall performance might not be as critical as other factors like network latency and socket library performance.

Smalltalk, while traditionally perceived as heavier, has evolved into a lightweight solution. A Smalltalk development environment with all tools included can be smaller than the image files produced by modern smartphones. This makes it a compelling choice for lightweight, efficient web services.

Complex Workloads

For complex, heterogeneous, and rapidly changing workloads, Smalltalk stands out. Despite the potential benefits of languages like C for simple, buffer-based operations, the overhead of managing and scaling a C-based solution can outweigh the performance gains. In such scenarios, Smalltalk’s strengths in terms of development efficiency and ease of handling complex logic can make it a preferred choice.

In conclusion, while Smalltalk might not be the fastest language for every situation, its suitability for web applications can be validated through careful consideration of the use case, appropriate architectural design, and efficient caching strategies. Smalltalk, with its powerful yet lightweight nature, offers a compelling solution for a wide range of web applications.