BIM (Building Information Modelling) Developer with API Salary in 2024

Where is API used?

API Alternatives

Webhooks

Webhooks are user-defined HTTP callbacks that are triggered by specific events. They deliver data to other applications in real-time, unlike APIs, which require polling.

Example: GitHub webhook sending commit data to a CI tool.

# Example webhook URL setup in Python using Flask
@app.route('/webhook', methods=['POST'])
def webhook_handler():
    data = json.loads(request.data)
    # Handle webhook data here
    return 'Success', 200

• Real-time data transfer.

• Reduced server load.

• Better for specific event responses.

• Dependent on external service uptime.

• Limited by the number of triggers.

• Less control over data retrieval.

Message Queues

Message queues provide asynchronous communication between different system components, ensuring that tasks are processed at a manageable rate without loss of data.

Example: RabbitMQ managing load between microservices.

# Example of sending a message using RabbitMQ in Python
channel.basic_publish(exchange='',
                      routing_key='task_queue',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                         delivery_mode = 2, # make message persistent
                      ))

• Decouples components.

• Resilient to component failures.

• Scalable communication system.

• Complexity in setup and maintenance.

• May introduce latency.

• Monitoring of message processing needed.

Server-Sent Events (SSE)

SSEs allow servers to push data to the client over HTTP without polling. Unlike WebSockets, SSEs are unidirectional, server to client.

Example: Real-time notifications in a web application.

# A simple SSE example in JavaScript
const evtSource = new EventSource("sse");
evtSource.onmessage = function(event) {
  console.log("New message:", event.data);
}

• Simple server-side push mechanism.

• No need for a special protocol.

• Lower overhead than WebSockets.

• Only supports text data.

• Unidirectional communication.

• Not supported by all browsers.

Quick Facts about API

The Origins of SOAP

Believe it or not, SOAP – which stands for Simple Object Access Protocol – isn't about keeping your code squeaky clean! Invented in 1998 by Dave Winer and others at Microsoft, it became a groundbreaking way for programs to play nice over the internet. This envelope-wrapped messaging protocol was like Harry Potter’s owl post for computers, minus the feathers. SOAP was the first of its kind, setting the stage for web services as we know them!

REST: The Cool Kid on the Block

Fast-forward to 2000, and the world met REST (Representational State Transfer) thanks to Roy Fielding's doctoral dissertation. Unlike its SOAPy predecessor, REST was the “chill” protocol that used standard HTTP methods like GET, POST, PUT, and DELETE. It was like going from flip phone texting to instant messaging—everyone wanted to REST because it made web communications as easy as ordering pizza online.

GET /pizzas HTTP/1.1
Host: example.com

GraphQL: The New Contender

In 2015, Facebook engineers looked at REST and thought, "Hold my data," introducing GraphQL. This query language for APIs turned heads by allowing for precise and flexible data retrieval. Gone were the days of over-fetching or under-fetching data – with GraphQL, it's like telling your fridge exactly what groceries to keep chilled, ensuring you get just what you asked for, nothing more, nothing less.

{
  fridgeContents(only: ["milk", "eggs", "cheese"]) {
    items {
      name
      expiryDate
    }
  }
}

What is the difference between Junior, Middle, Senior and Expert API developer?

Top 10 API Related Tech

1. 
   

   JavaScript & Node.js

   
   

   If API development was a kitchen, JavaScript would be the multitasking chef, and Node.js would be the turbo-charged oven. Together, they whip up scrumptious server-side treats. JavaScript's ubiquity in the browser kingdom extends its reign to the server domain with Node.js, enabling developers to speak one language both client-side and server-side. Plus, being non-blocking is like always getting a green light in traffic!

   
   

   
   const express = require('express');
   const app = express();
   app.get('/api/greetings', (req, res) => {
     res.send('Hello World!');
   });
   app.listen(3000, () => {
     console.log('API is listening on port 3000');
   });
           

1. 
   

   REST & JSON

   
   

   I'll rest easy while you ingest this – REST (Representational State Transfer) is the maître d' that recommends the finest architectural style for your APIs. Meanwhile, JSON (JavaScript Object Notation) is like the popular kid that everyone understands, making data exchange in APIs smoother than a jazz symphony.

   
   

   
   GET /api/books/1 HTTP/1.1
   Host: example.com
   Accept: application/json
           

1. 
   

   OpenAPI/Swagger

   
   

   Swagger struts into API Land like it owns the place, because, essentially, it sorta does. As the blueprint master, it ensures every API's design is so slick, other developers can understand your API faster than a teenager texting back "K".

   
   

   
   swagger: "2.0"
   info:
     title: "Book API"
     description: "API for managing books"
     version: "1.0.0"
   host: "example.com"
   schemes:
     - "https"
   paths:
     /books:
       get:
         summary: "List all books"
         responses:
           200:
             description: "A list of books"
             schema:
               type: "array"
               items:
                 $ref: "#/definitions/Book"
           

1. 
   

   GraphQL

   
   

   Forget the guesswork, GraphQL lets your clients cherry-pick exactly what they need, like a sushi conveyor belt but for data. Bye-bye overfetching, adios underfetching! It's like having a personal shopper for your data who always grabs what you ask for.

   
   

   
   {
     books {
       title
       author
     }
   }
           

1. 
   

   Docker

   
   

   Imagine shipping your API in a container so sturdy, it doesn’t care where it’s run. That’s Docker – it encapsulates your API in a cozy container ensuring it works seamlessly in development or production, just like your favorite coffee that tastes the same, no matter the mug.

   
   

   
   # A minimal Dockerfile for a Node.js API
   FROM node:14
   WORKDIR /usr/src/app
   COPY package*.json ./
   RUN npm install
   COPY . .
   CMD [ "node", "server.js" ]
           

1. 
   

   OAuth 2.0

   
   

   Think of OAuth 2.0 as the bouncer at the club checking IDs. It's basically saying "Prove you have access before you can touch any of these secure resources. And no, knowing the DJ doesn't count." It’s a protocol for authorization that keeps your API as secure as Fort Knox.

1. 
   

   Postman

   
   

   Ever wish for a digital pen pal who never gets tired of your API requests? Enter Postman - the friendly GUI that makes testing your APIs as delightful as getting a letter in the mail, minus the wait. It’s like a Swiss Army knife for poking at APIs.

1. 
   

   Redis

   
   

   Need to cache or store session data at lightning speed? Redis is the hyperactive memory stash for when your API needs to remember something faster than a goldfish. Think of it like a caffeine boost for your API's memory.

1. 
   

   Apache Kafka

   
   

   If your API was at a party, Kafka would be the impeccable networker passing messages around like hot gossip. It excels at handling data streams in real-time, ensuring your API is as informed as the town crier in a bustling market square.

1. 
   

   WebSockets

   
   

   Where traditional HTTP is like sending snail mail, WebSockets let your API have live chats with the server, enabling real-time communication that’s as fast as kids on scooter boards. It keeps the line open, so you can say goodbye to constantly asking, "Are we there yet?"