• Source: The pipeline starts when you push new code to a repository like GitHub, CodeCommit, or S3.
• Build: Code is compiled, and tests are run. This is where tools like AWS CodeBuild come in to do the heavy lifting of building the code and running tests.
• Deploy: Once the code is tested and verified, it’s deployed to your desired environment, be it a staging or production environment.

• Spam Detection: Classifying emails as spam or not based on labeled data.
• Medical Diagnosis: Predict diseases based on past patient data and diagnoses.
• Stock Market Prediction: Estimating future stock prices using historical data trends.

• Customer Segmentation: Grouping customers based on purchasing behavior.
• Anomaly Detection: Identifying fraudulent transactions in banking systems.
• Market Basket Analysis: Finding product purchase patterns in retail stores.

• Self-Driving Cars: Learning to navigate roads by trial and error.
• Game Playing AI: AI systems like AlphaGo learn to play board games by competing with themselves.
• Robotics: Training robots to optimize movement and complete tasks efficiently.

• The state changes when someone types in a text box.
• The state changes again when they click a button.
• And again, and again, with each tiny interaction.

const fs = require("fs");
const { getDB, closeDB } = require("./db");

(async () => {
  const initialSLPlaces = JSON.parse(
    fs.readFileSync("sl-places.json", "utf-8")
  );
  const initialSLAreas = JSON.parse(fs.readFileSync("sl-areas.json", "utf-8"));
  
  const db = await getDB();
  
  // Delete existing records to avoid duplication
  await db.collection("sl-places").deleteMany();
  
  // Insert new data into the collection
  await db
    .collection("sl-places")
    .insertMany([...initialSLPlaces, ...initialSLAreas]);
  
  // Create a 2dsphere index to enable efficient geospatial queries
  await db.collection("sl-places").createIndex({ location: "2dsphere" });
  
  // Close the database connection
  closeDB();
})();

const { getDB, closeDB } = require("./db");

(async () => {
  const db = await getDB();

  // Search near Kirinda Beach within 500m
  const places = await db
    .collection("sl-places")
    .find({
      location: {
        $near: {
          $geometry: {
            type: "Point",
            coordinates: [81.2570, 6.2155], // Coordinates for Kirinda Beach
          },
          $maxDistance: 500, // Max distance in meters
        },
      },
    })
    .toArray();

  console.log(places); // Display the found places
  closeDB(); // Close the database connection
})();

const { getDB, closeDB } = require("./db");

(async () => {
  const db = await getDB();

  const places = await db
    .collection("sl-places")
    .find({
      location: {
        $geoWithin: {
          $geometry: {
            type: "Polygon",
            coordinates: [
              [
                [81.2, 6.2], // Bottom-left corner
                [81.6, 6.2], // Bottom-right corner
                [81.6, 6.5], // Top-right corner
                [81.2, 6.5], // Top-left corner
                [81.2, 6.2], // Closing the polygon
              ],
            ],
          },
        },
      },
    })
    .toArray();

  console.log(places); // Display places within the polygon
  closeDB(); // Close the database connection
})();

const { getDB, closeDB } = require("./db");

(async () => {
  const db = await getDB("playground");

  const area = await db
    .collection("sl-places")
    .find({
      area: {
        $geoIntersects: {
          $geometry: { type: "Point", coordinates: [81.7302, 7.2801] },
        },
      },
    })
    .toArray();

  console.log(area); // Display areas that intersect with the point
  closeDB(); // Close the database connection
})();

1. Non-blocking: JavaScript runs on a single thread, meaning it can only handle one task at a time. Without asynchronous operations, long-running tasks (like waiting for your coffee) would block everything else. Async operations let JavaScript handle other tasks while waiting for things like network requests or timers.
2. Improved performance: Instead of waiting for tasks like fetching data or loading resources, the app can continue responding to user actions, making it feel faster and smoother.
3. Concurrency: Async tasks can run in parallel. For example, while you’re waiting for coffee, you can read a book, chat with friends, or check your email.
4. Efficient I/O tasks: Web development often involves tasks like fetching data from a server. Asynchronous operations allow this data fetching to happen without freezing the rest of your application.

1. Non-blocking: JavaScript runs on a single thread, meaning it can only handle one task at a time. Without asynchronous operations, long-running tasks (like waiting for your coffee) would block everything else. Async operations let JavaScript handle other tasks while waiting for things like network requests or timers.
2. Improved performance: Instead of waiting for tasks like fetching data or loading resources, the app can continue responding to user actions, making it feel faster and smoother.
3. Concurrency: Async tasks can run in parallel. For example, while you’re waiting for coffee, you can read a book, chat with friends, or check your email.
4. Efficient I/O tasks: Web development often involves tasks like fetching data from a server. Asynchronous operations allow this data fetching to happen without freezing the rest of your application.

• You place the order (“Order placed”).
• While the coffee is being brewed, you continue with other tasks.
• After 2 seconds, the callback function (`handleOrder`) runs, letting you know your coffee is ready.

1. JavaScript Thread: Where your React Native JavaScript code runs.
2. Native Modules Thread: Where the native code executes.
3. UI Thread: Responsible for rendering the user interface.

• Map Function — This Allows you to iterate over an array and modify its elements.
• Find Function — Returns the first element in the provided array that satisfies the condition of the function.
• Callback Function — Allows a function to call another function.
• Promises — This technique is used to handle asynchronous operations.
• Async / Await — This makes it easier to write promises
• De-structuring — This allows getting data from objects and arrays to set them into new variables.
• Rest Operator — Allows a function to accept an indefinite number of arguments as an array
• Spread Operator— allow a copy of all parts of the existing array into another array (object work as same)