Is a Library just an API?
Posted by Odd-Fix-3467@reddit | learnprogramming | View on Reddit | 51 comments
Is a library just a API or a collection of API's?
When someone says using an API, does it mean that the API is some imported method from the library?
snowbirdnerd@reddit
A Library is just a bunch of functions you are loading into your project.
APIs are kind of like functions but they have a lot more rules about access and they are usually done over a network.
petroleus@reddit
That's probably the most misleading answer I've seen on this post
snowbirdnerd@reddit
How is it misleading? It's a basic answer for a basic question in a learning sub.
Should I dive into how COREs works to answer someone who doesn't know what a library is?
Come on.
deftware@reddit
An API is how you interact with a library. A library is just a collection of code. The API is how you interact with that collection of code.
Nowadays, to sound modern and different and fancy and new, for no real practical or useful reason whatsoever, JavaScript coders introduced the concept of "frameworks" which are literally just libraries.
I've noticed an accelerating rate of people coming up with new words for things that already exist over the last 10-15 years and it's starting to really look like they're just desperate to feel like they're making some kind of groundbreaking contribution - by coming up with all kinds of new terminology that is redundant and futile.
petroleus@reddit
Even though "framework" is most frequently seen with JavaScript frameworks, that's completely untrue. Borland's TurboVision was, even at the time, called a framework, literally on page 1 of the User's Guide. The book predates the existence of JavaScript by four-five years.
Una_Ungrateful_Biped@reddit
I'm still a student & learning, I may be COMPLETELY wrong, but here's how I've understood things.
To use an analogy = think of a library as a human being. It can do all the things it can do.
The API is if I gave you a document stating "this human speaks the english language. here's all the rules of that language so you know how to communicate with it, and communications to expect back from it".
In my course when I was learning programming (the main degree is data science aimed, but we had 1 year which was just programming), the professor used the terms interchangeably a lot cuz from a perspective of using the library, its not very different.
sklearn is a library ; it is a piece of software/code with a bunch of ml related capabilities.
The sklearn api is basically a ruleset for how to communicate with the sklearn library, and how it will (assuming you do things right) communicate back.
petroleus@reddit
A better way to understand it is that APIs are a language, and libraries are what speaks that language. Multiple libraries can use one API (say, three different people at the help desk who you can talk to in the same way), and a single library can implement multiple APIs (that one help desk worker who speaks English, German and Arabic).
Usually you'll have one library with one API at a time, but they're very different concepts. The API is just the interface (like, that's in the name) to whatever's going on under the hood. You, the user, should not care if the "thing" under the API is implemented in Rust, C++, Brainfuck, or actual little people enslaved inside a webserver in Zambia.
GregHullender@reddit
API is to library as recipe is to pie.
BirdUp69@reddit
This is like asking: is a house a door? No. You use a door to access a house
Technologenesis@reddit
An API is a specification; a library implements that specification. Theoretically, two different libraries could implement the same API.
escargotBleu@reddit
And then you have libraries that can be used to access several API. Like open ai python library could be used to access deepsek Api.
regular_lamp@reddit
Some examples of APIs with many implementations: OpenGL, Vulkan, MPI, BLAS
Timely_Note_1904@reddit
S3 is another.
_lazyLambda@reddit
You should view every function as an API, that another developer including your future self might use
KPS-UK77@reddit
Library A collection of pre written code, usually around a specific purpose. To save coders the time of having the write that code themselves they can just call clases/methods from the library. You effectively write your own libraries when written code anyway.
MyLibrary Product.getProduct(int id)
MyCode Import MyLibrary MyLibrary.getProduct(1)
Api A protoal to allow external sources to access your system, usually to either read data from or write data to it. These days usually written in REST format
www.mywebsite.com/api/get/productid www.mywebsite.com/api/send/messageTitle/messageBody
GlobalWatts@reddit
An API allows your program to interact with another program.
A library is external code you embed into your application.
When you interact with a library, you are using its API. When you use an API, you are not necessarily interacting with a library.
Typically when you interact with a library, the native syntax is indistinguishable from using internal code, so you may not even realize you're using an API.
Ping-In-TheNorth@reddit
Yes
Macaframa@reddit
API-> Application Programming Interface. That can mean a whole bunch of things. But it boils down to “way that I can interact with the thing” usually people mean a backend system that has data. So they make api endpoints that you can interact with to CRUD(create, read, update, delete) on that data. You can also use the term to describe how to interact a component that someone created. It’s an elastic term that is not super specific. I hope this helps
blahblahredditstuff@reddit
A library is a bunch of code that you can pull into your project, it’s suppose to save you some effort of writing functions/classes etc… - Like using a cookbook instead of trial and error creating your own recipes.
An API (application programming interface) is how 2 pieces of software can interact; send/receive data, trigger some function somewhere but i only care about the effect not how it runs. - I order a pizza from the local spot, I tell them the size and toppings I want based on what they offer. They ask pickup or delivery, payments arranged and it’s a done deal. I don’t know what temperature their oven is or the origin of the ingredients.
mr_oscy@reddit
Outstanding analogies, thank you very much :)
blahblahredditstuff@reddit
Happy to share what I know with people who are interested.
MaytagTheDryer@reddit
Think of an API as a wall outlet. Anything can get electricity out of it as long as the thing has a plug with the right shape (and voltage and amperage and such). The system has something that clients want, and the outlet provides a way to get it. The outlet does not make the electricity and it's not the electrical grid, it's just the interface to get the electricity some other system is providing. In programming terms, it could be a library, a web service, etc. providing the "electricity" (functionality and/or data), the API is the plug you need to connect to in order to get the goodies out.
So a library will have an API, but it is not an API. Anything you can connect to programmatically has an API.
neptune-jam@reddit
It’s like a bank ATM. The bank wants you deposit money, withdraw funds etc, but they don’t want you looking at the whole internal system. So they give you an ATM so they can manage what you do.
It’s the same with an API. It provides rules on what kind of information someone is happy to share with, without you poking around their entire system
peterlinddk@reddit
In later years it has been more and more common that a "webservice using a REST API" is something that can be shortened to "API", which has spread a lot of confusion.
"API" basically means "a definition on how to write software to interface this thing" - it can be a library, it can be a class, it can be a module with a collection of functions, it can be a service on the network, it can be a piece of hardware, basically, anything you can write a program to interact with, from a USB keyboard, to an application running on the computer, to the operating system itself, to something running on another machine, connected through the internet.
BchubbMemes@reddit
THIS! I was self taught on the job, and then moved to an apprenticeship, and they started teaching us about apis, the whole session was how to use a basic rest api, no mention of what it actually is. It seems an entire generation of developers are learning this way and its slightly worrying
CelKyo@reddit
An API is when you advertise to people using your program: “You can call me like that. I guarantee when you call me like that, I will do this, respecting these constraints. The ‘how’ being none of your business”
A bunch of public functions (e.g. a library?) can be an API.
Interfaces (in OOP) are APIs.
An API is nothing more than a contract that facilitates interactions between two pieces of software. It is to make sure we are on the same page regarding the functionalities I provide you (or you provide me) and how to use them.
Gishky@reddit
A Library is a bunch of code that you import to your project. Think of it as just copying someone else's code, but instead of doing that directly you import their classes and methods which you then use.
An API is another program running somewhere that you talk to.
_Alexandros_h_@reddit
An API is a "concept". Its the "general term" for all the functionality provided by a programming entity: ((any type of) library/server/...). For example, if you have a simple logging library that just prints info/warning/error/debug messages, and it has a function for each:
then the API for this library are those functions.
As mentioned before, there is no specific things that an API is, however there are some categories of APIs such as a REST API that is basically an http server serving data in JSON format
GetContented@reddit
It's two related but different things. What they have in common is they're an interface to some functionality.
People use the term very loosely, unfortunately. Often they use it to mean something very general — which is as u/Technologenesis says: an interface or specification for execution or communication.
However, quite often web (and other) developers will use it to mean just a network- or internet-connected communication protocol or specification for that and/or its running implementation, very specifically. For example, JSON:API is a specification for building such APIs, and an implemented API that conforms to JSON:API will be spoken of in this way. ("just call the API with this data" means make a request to the API endpoint of some server software that's implemented the specified API and that's running on some server)
But you'll also hear people talk about the interface to libraries as an API. ("Call this API method with these arguments")... and usually this is when the internals are hidden and versioned from the users of the API (which is good general practice anyway... this is also when you will hear people talk about "using private APIs" — it means they're calling or using the internals in a non-condoned way)
dwitman@reddit
An API is a gag reflex.
You shove your finger down it's throat, it vomits up some info...you act upon that info.
kerstop@reddit
A fun little thought is that a programming language is just a specification implement in a compiler or interpreter that you use to make that compiler or interpreter output machine code or side effects respectively. Therefore all programming languages are themselves API's. Really, the words application and programming don't contribute that much to the meaning of the acronym and you could just read API as interface instead.
wial@reddit
I like a lot of the answers here but one usage I didn't see is to call an in-house project (e.g. in C#) a library when it is not intended to be run as an application in its own right but only as an adjunct to other application projects. It might have some vestigial capabilities, its own tests (of course) etc, and might have been intended to run stand alone at some point, but now is meant to serve more than one application -- e.g. for testing and recording data quality as a separate concern by different projects running etl on different kinds of data. Such a library might use the GoF strategy pattern, for instance, when called in to support varying requirements while keeping the same basic structure.
Put another way, this is to emphasize that a project is not intended to be an application in its own right.
throwaway8u3sH0@reddit
And analogy might help. Your car is a library. The steering wheel, foot pedals, switches and buttons are the API. It's the interface that allows you to control the library.
Different cars can all agree to implement similar APIs so that a person can switch between them easily. (Once you've driven one, you can pretty much drive them all.)
Or they could be set up with differing APIs (think stick shift vs automatic). Being able to use one may not make the other ones easier.
art_is_a_scam@reddit
I am confused about what a library is. When I open them up they seem to use some sort of magic. Like if I wrote a few dozen lines that say #define _do_magic_thing, it wouldn’t do anything.
AnotherSkullcap@reddit
An API is how you use some else's code. A library is a downloaded copy of someone else's code. Not everyone uses them this way, but that's the basic idea.
Montrell1223@reddit
Explaining what an api is harder than explaining what a monad is
Far_Swordfish5729@reddit
A library is a compiled, distributable code base or part of one. It's often physically a jar, dll, or similar though it could be a source repository you build yourself. You use it at runtime and include it to do something. (e.g. "I used the image processing library to sharpen the image.").
An api (application programming interface) is a particular code interface (think logical types and methods/operations) that others on other teams are expected to use. Because of that, the publishing team will promise that changes and especially breaking changes to the interface definition will not be made without notice and time for code bases using it to adapt. When you as a programmer include someone else's library, you would be advised to interact with it through defined apis. If you don't and instead use reverse engineering techniques to find and interact with other internal points like internal methods, services, or data tables, the library publisher may change these at any point without notice and you may have unexpected emergency fixes.
Note that something being an api is about the stability and change notification promises not about a particular format, spec, or connection method. An api is often a set of service layer or business layer web services using rest/json or soap formatting, but it certainly does not have to be. There are UI layer apis, which are usually js, iframe, or css interaction points. There are apis that are simply methods you call when you add someone else's code to your project. There are plugin apis where you code an extension that implements a published interface and register it using a published json or xml config file. There are data layer apis which are usually sets of tables, views, and stored procs you are to use when extending a product's data model.
RefinedSnack@reddit
Love this so much. I do want to add that API and Library are both terms that are frequently loosely applied. So as a newer dev interacting with these terms and hearing it from others, it's best to understand what the terms are but not get caught up in the holy war that is programming terms.
On a more personal note I dislike how broadly the terms API and Library are used. I do see their merit as abstractions, and the urge to apply them broadly comes from that. But also, it's confusing for me and others.
thespike323@reddit
It took me a while to grasp an API too, but the best way to put it is it's a way for you to interact with something from a program you write. So an API could be the public functions exposed in a java library you need to download or the HTTP endpoints of a web application, just anything exposed for a programmer to use something from their program.
mxldevs@reddit
A library is just code that does stuff.
An API itself is just an interface that describes how you interact with whatever component you're dealing with.
A library typically provides an API that helps users interact with the library.
MeepleMerson@reddit
API = Application Programming Interface. It is the way that one piece of software (application) calls upon another piece of software (application, server, library, etc.) to do something. It can refer to the technical details themselves, or sometimes also the documentation of those details.
A library is not an API. It's a collection of code and data intended to incorporated into an application. The manner in which to access / use the library would be the API. There's no doubt stuff in the library that is used by the library itself and is not intended for other applications to fiddle with. Those would not be included in the API since the programmer is never intended to interact with them.
SwordsAndElectrons@reddit
A library has an API. It isn't an API.
A library is a set of reusable a code. It may be compiled as a dll, jar, etc. or it may even be distributed as source code.
An application programming interface, or API, is a method for connecting to computer programs. The program you connect to may be a library, another application, or a remote service or application on your local network or over the Internet (aka a web API).
It's a similar idea to UI. A user interface is how a user will interact with your program. An application programming interface is how someone writing a separate application will interact with your program.
WaySlayer@reddit
API is any intentionally programmed interface that gives external access to any software package which contains any functionality you can think of. Best known is web, API gives access to data or views. Other examples are games, API to build custom mods for example. I once worked on software for Autodesk Revit which is a windows CAD package. It had an API to add custom funcntionality.
Hello world example of Revit API: https://help.autodesk.com/view/RVT/2024/ENU/?guid=Revit_API_Revit_API_Developers_Guide_Introduction_Getting_Started_Walkthrough_Add_Hello_World_Ribbon_Panel_html
Febrokejtid@reddit
A library most likely has an API, and an API most likely has a library. An API is an interface you can interact with, without having to be familiar how things actually work underneath.
When driving a car, you don't need to know how the engine actually works. You use a set of tools to drive the car, such as the wheel. The car doesn't need to know how the human body works for you to be able to drive it.
Let's say you want to integrate a billing service with an e-commerce platform. You would use the API endpoints of both to communicate with each other, without having to know how each works underneath or having explicit access to their databases.
In terms of a library, the API is a set functionality that you can use, meanwhile the underlying logic is abstracted away from you.
IchLiebeKleber@reddit
A library can have an API, or implement an API, but the terms aren't synonymous. The API is about how different pieces of software communicate with each other, including your code with a library.
kschang@reddit
They are "similar", and I can see why you'd confuse the two.
A library is just a collection of "existing code" you can call to do something for you. Most UI elements require a call to a UI library of some sort.
An API, on the other hand, is similiar to a library in that you are calling some code with some parameter and they go off and do something for you. So functionally, they are quite similar.
However, an API is just a standard, a definition. The actual implementation can change underneath, but it doesn't affect the API user as long as the API doesn't change (or remain compatible).
You may have realized that an API is usually residing on a DIFFERENT server, whereas a library is local to you.
Does that help?
PeteMichaud@reddit
This is a little fuzzy, but there are 2 distinct uses for the term API. One is the interface a given program or class provides to callers, so in that sense a library provides an api.
However, generally speaking, when someone says API they are talking about an external service that you call over the network.
hrm@reddit
I agree with you, but the usage of API as in an external service has been used for a way shorter time than API as in a stable interface to some library/function. Me and many others (with hip replacements) are a bit annoyed at this…
PeteMichaud@reddit
I am with you!
beatlemaniac007@reddit
In both cases the interface aspect is what API refers to, be it for a library or a service.
Leucippus1@reddit
No.
A library is compiled or interpreted code you can load into your environment to help you accomplish things quickly. For example, the 'standard' C++ library includes things like iterators and functions for dealing with strings. CMath allows you to do mathematical functions. Without those libraries you would need to write those things yourself.
An API, whether it is one over a network or one on the same machine as you have, like Windows APIs or something, is a way of interacting with another piece of software in a standard way. Think, the directX API or an NVIDIA API. The API may have an associated library you can use, but they two are not synonymous.