Best Practices for API Design
Well designed APIs = Happy Developers 😃
APIs (Application Programming Interfaces) are interfaces that allow one application to use the data and resources of another. They are critical to a product's or company's success.
Many of your favorite apps would not work today if they were not for APIs. The Google Maps API, for example, allows you to integrate Google Maps into your smartphone or web application. You would have to build and create your own maps database if you did not have it! Consider how long it would take to show a position on a map without an API.
Why should we use APIs?
APIs give other people access to your services.
APIs expand the app's capabilities.
Developers can reuse application logic thanks to APIs.
APIs are device-agnostic, meaning they provide data regardless of the requesting platform.
The majority of modern web applications expose APIs that clients can use to communicate with them. A well-designed web API should strive to support the following features:
Independent of the platform: Regardless of how the API is configured internally, every client should be able to call it. This necessitates the use of standard protocols as well as a method for the client and the web service to agree on the data format to exchange.
The evolution of the service: User programmers should not be able to evolve or add features to the web API. Established client applications can continue to work without alteration as the API evolves. All functionalities should be discoverable by client applications so that they can take full advantage of them.
This blog post explains the best practices that you should think about when creating a web API.
Characteristics of good API
Domain-specific: Call names, parameters and filters must be descriptive, with no unnecessary over-generalization and abstraction. See the SOAP as an anti-pattern.
Clear error messages. Validate client input off the bat. Report both missing and unknown parameters as equal errors. (Include warnings in responses for Web API).
As stateless as possible, but still provide lots of useful functionality per single call. Just mapping your internal data model to API gets you nowhere; you must do lots of hard work under the hood to create the illusion of things just happening.
Do not mix transport layer logic and API logic; this makes error resolution complicated: Did I get HTTP 404 because of the wrong URL or because I used the wrong parameter?
Each API call should serve a Use case that should be fulfilled with that single request. Do not split the API into smaller pieces than you absolutely have, even if it would be more difficult for you.
An API characterizes how different developers cooperate with your product. Accordingly, each person I referenced has the correct answer, yet a little cut of it. As you compose code, get some information about the client of that code. In the event that that client connects with your code through code of their own, you are fabricating an API. What is more, before you ask, indeed, that even applies to different engineers in your organization or even your group that utilizes your code.
Subsequently, understanding the properties of good APIs conveys fundamental significance for our industry. It has the effect of others expanding on your work or keeping away from it. Furthermore, let us face it — there is a sure measure of expert pride in question. So, what makes APIs great? We should think about certain qualities of good APIs.
Above all else, I would prefer to advocate for effortlessness. Software engineers will, in general, take care of complex issues, making it simple to allow that intricacy to seep through to clients of our APIs. Keeping them basic requires work, and at times presents a genuine test.
Our inclination to need to be useful adds to the trouble. Regularly, developers need to offer a few unique approaches to accomplish something. "Possibly, they need to pass these conditions in through a constructor. Yet, imagine a scenario in which they like to utilize setters. We should make both accessible." The way to intricacy can be cleared with sincere goals. Battle the desire to add unnecessary intricacy, in any event, when you figure it may help. Great APIs offer straightforwardness, and it requires a decent piece of exertion to safeguard that effortlessness.
Give Useful Abstractions
Then, think about the idea of deliberation. At the point when you effectively conceal subtleties from clients of your API, leaving just the fundamentals, you offer them reflection.
Instances of deliberation have large amounts of our reality. Gadget drivers theoretical the subtleties of managing seller equipment. Stringing models give a deliberation to agonizing overbooking execution at the OS level. The actual OS gives a reflection over the distinctions in center PC equipment. Indeed, even your programming language abstracts away the subtleties of composing machine code.
Elegantly composed code gives deliberations, and APIs are no special case. Your API should conceal the subtleties of what it does from your clients while making itself valuable to them. On the off chance that your clients need to jump into your code or execution to comprehend, you have given a helpless reflection.
Straightforwardness and great reflections will take you far. In any case, you can go significantly further when you compose a "discoverable" API. This has to do with how effectively an amateur can become profitable utilizing your code.
As a supportive equal, I will summon a non-code model. Consider what made the first iPhone progressive from a UX point of view. It had a screen and a solitary catch. Its applications left things hanging off the side of the screen to welcome and, for all intents and purposes, beseech you to find that you could propel your utilization by swiping left and right. In contrast to past gadgets, with minuscule catches and relentless setting menus, this discoverable gadget lets even the least shrewd clients get rolling rapidly.
Make progress toward this with your APIs. Comprehend that your clients will hack and examine before they at any point get a manual or call to inquire. Plan and plan in like manner, both with documentation/models and with the kind of self-portraying passages that loan themselves to discoverability. A technique called "GetLastNameFromOrder(CustomerOrder orderToQuery)" basically implores you to utilize it for its expected reason.
Reliable and Symmetrical
Accepting you have checked off the past contemplations, analyze your API for consistency and evenness. Consistency is moderately straightforward. Try not to call them "clients" here and there and "clients" on different occasions. Name exactly the same things in a similar way. Have a typical style. Make your API unsurprising.
Balance presents a somewhat more inconspicuous thought. At the point when I talk about balance, I mean a propensity to close open circles such that your clients anticipate. For instance, on the off chance that you have an API for record access that allows you to call Open(string filename), you ought to likewise offer a Close(string filename) technique. Open and close have inverse implications, so offering both make balance as worries that activity. Calling the Close technique "Annihilate" or, more awful, not having a nearby strategy would make a lot of disarrays.
You can, by and large, accomplish this trademark in your API by applying a basic eye to what you open to clients. Peruse it the manner in which an editor may, checking for consistency and balance. At that point, rename and modify on a case-by-case basis.
Follow the Principle of Least Astonishment
For the last thought in the blend, I need to acquaint you with the cunningly named "guideline of least surprise." This holds that "a framework ought to carry on in a way reliable with how clients of that part are probably going to anticipate that it should act; that is, clients ought not to be amazed at the manner in which it acts." To put it all the more gruffly, do not compose APIs that astound your clients.
My model above with respect to evenness could likewise be said to abuse this standard. However, we should transform it into a piece to make it clearer what this guideline implies. Envision that your record API had an Open(string filename) strategy, and afterward, it requested that you close documents by calling Open() without any boundaries. Likewise, at whatever point you call Close(), it sends an email to some person named Bill Smith for reasons unknown. Take your response to that recommendation, and you have the "shock" factor pleasantly caught.
Great APIs do not have properties that reason their clients to shout, "yet that has neither rhyme nor reason!" or "how might I at any point have realized that?!" I can think about no quicker method to lose the trust of your clients than to give them an API that does something distracting to or inverse of what it professes to do.
Consider Your API a Product
Basic, valuable, discoverable, reliable, and unsurprising all portray great APIs as well as great items. That is no mishap. At the point when you compose APIs, you make an item. If you consider it that way and if you really sell it, you have an item on your hands, planned for use by another person.
As designers, we can undoubtedly dismiss that. Subject to the scourge of information, we accept that our API clients, individual developers, will understand what we know and sort out what we have sorted out. We do not usually consider them our end clients or our clients.
Beating that inclination and imagining their perspective is the binding together subject behind the great API plan. So, when you compose your next API, put yourself in the shoes of your client, and envision what you would need.
Best Practices for API Design
Any API design follows something called Resource-Oriented Design It consists of three key concepts.
Resource: A resource is a piece of data; for example, a User
Collection: A group of resources is called a collection. Example: A list of users
URL: Identifies the location of the resource or collection. Example: /user
Read the complete article at -> Aviyel