What is an Anti-pattern?

Common API Anti-patterns

1. Focusing on Implementation Details Instead of Resources (RPC-style APIs)

   Remote procedure call (RPC) style APIs are a common anti-pattern in RESTful API design. These APIs expose methods that map directly to the underlying implementation, rather than focusing on resources. This makes the API rigid and difficult to evolve.

2. Over-Engineering for Unforeseen Needs

   This occurs when developers try to anticipate every possible use case and build a complex API to accommodate them. Over-engineering leads to bloated and difficult-to-use APIs, making maintenance a nightmare.

3. Tight Coupling Between Client and Server

   Tightly coupling the client and server can make the API inflexible and difficult to change. This strong dependency between implementations makes the API brittle and hard to evolve without breaking clients.

4. Lack of Versioning

   Not versioning your API can lead to issues when you need to make breaking changes. Without clear versioning, managing updates and ensuring backward compatibility becomes a significant challenge.

5. Inadequate Documentation

   Poorly documented APIs can be difficult to use and lead to confusion for developers. Good documentation provides clear descriptions of each method and the resources they return. It should help developers get started quickly rather than hunting through dense libraries of docs. Document your API well using tools like Xapi and Swagger.

6. Misusing HTTP Methods

   HTTP methods like GET, POST, PUT, and DELETE are meant to convey the intended action of a request. Overloading these methods, or using them in ways that don’t match their intended purpose, can make the API confusing and difficult to understand.

7. Lack of Error Handling

   Failing to handle errors properly can lead to a confusing and frustrating experience for developers using your API. Providing meaningful error messages and appropriate status codes is crucial for a good developer experience.

8. Tunneling Through a Single HTTP Method

   Your API is a collection of methods. Tunneling everything through a single HTTP method, like GET or POST, can make the API inefficient and difficult to manage.

   Tunneling through GET: GET should retrieve a representation of a resource identified by a URI. Misusing GET for actions like deleting or finding customers by encoding parameters in the URI is a common anti-pattern.
   Tunneling through POST: POST carries an entire body, not just a URI. Using POST for varying messages to express different intents is another common anti-pattern.
9. Ignoring Caching and Revalidation

   Preventing caches from caching everything, and not supporting efficiency and revalidation, is a missed opportunity. Proper caching is crucial in RESTful APIs, enhancing performance and efficiency. Delegate cache header generation to infrastructure like Apache HTTPD. Clients should utilize caching to avoid redundant requests, using proxies like Squid. Web caches reduce latency by serving responses faster and lower network traffic by reusing data, saving bandwidth and costs.

10. Inconsistent or Misleading Status Codes

    Misusing or failing to use proper status codes when sending responses can lead to poor communication between the client and server. While many are familiar with 200, 404, and 500, there are many more codes that, if used correctly, provide richer communication.

11. Misusing Cookies

    Using cookies to propagate a key to some server-side session state violates REST principles and can lead to security issues. It's essential to manage states appropriately without misusing cookies.

12. Overexposing Database Schema

    Exposing your database schema directly through the API makes it inflexible and difficult to evolve. An API should abstract the underlying data model to provide a stable interface for clients.

13. Missing Hypermedia Links

    The absence of links in representation means the API is not fully RESTful. Hypermedia links are essential for guiding clients through the available actions.

14. Neglecting MIME Types

    Ignoring MIME types reduces the flexibility and self-descriptiveness of the API. Proper use of MIME types is crucial for clear communication about the data formats used.

Common Code Design Anti-patterns

1. God Class/Object

   A single class or object handles too many responsibilities, violating the Single Responsibility Principle (SRP).

2. Spaghetti Code

   Unstructured and tangled code with poor separation of concerns.

3. Magic Numbers and Strings

   Using hardcoded values without meaningful names.

4. Yoda Conditions

   Reversing the normal order in conditional statements.

5. Excessive Interface Complexity

   Interfaces that are needlessly crowded and complex.

6. Excessive Use of the Singleton Pattern

   Overuse of singleton pattern across many classes.

7. Primitive Obsession

   Using primitive data types excessively instead of creating meaningful classes.

8. Copy-Paste Programming

   Reusing code by copying and pasting rather than abstracting and reusing properly.

9. Cargo Cult Programming

   Using code or patterns without understanding how they work.

10. Golden Hammer

    Over-reliance on a single tool or pattern, applying it to all problems.

11. Boat Anchor

    Keeping obsolete or unused code in the codebase.

12. Dead Code

    Code that doesn't do anything or its purpose is unclear.

13. Proliferation of Code

    Adding unnecessary layers of abstraction or objects that serve no real purpose.

Conclusion

References

1. REST API Design Patterns and Anti-Patterns: A Developer’s Guide for Young Developers

2. REST Anti-Patterns

3. Web API Design Anti-Pattern: Exposing your database model

4. Anti-patterns that every developer should know