DEV Community: Hemant Govekar

10 Habits of a Budding Programmer

Hemant Govekar — Tue, 03 Mar 2026 00:17:05 +0000

Habits that strongly predict long-term success, regardless of language or domain.

1. 🖊️ Writes Code Regularly

Consistency matters more than intensity. Even short daily coding sessions build fluency and muscle memory.

2. 📖 Reads Other People's Code

Studying open-source projects, libraries, or teammate's code exposes patterns, idioms, and real-world problem-solving.

3. 🐛 Debugs Before Asking for Help

They reproduce the bug, read error messages carefully, use a debugger or logs, and form a hypothesis before seeking answers.

4. 🧩 Breaks Problems into Smaller Pieces

Large problems are decomposed into functions, steps, or sub-tasks before writing any serious code.

5. 🔀 Uses Version Control Early

They commit often, write meaningful commit messages, and aren't afraid to experiment — because they can always roll back.

6. 📚 Looks Up Documentation Instead of Guessing

Official docs, READMEs, and API references are the first stop — not random trial and error alone.

7. ♻️ Refactors Code After It Works

Getting it working is step one; improving clarity, naming, and structure comes next.

8. 🧠 Learns Core Concepts, Not Just Syntax

They focus on fundamentals like data structures, control flow, scope, and complexity rather than memorizing keywords.

9. 🏗️ Builds Small, Complete Projects

Finished projects — even simple ones — teach more than half-done tutorials and boost confidence.

10. 🌀 Embraces Confusion as Part of Learning

They expect not to understand everything immediately and persist through uncertainty instead of getting discouraged.

The best programmers aren't the ones who know everything — they're the ones who keep showing up.

Google ADK

Hemant Govekar — Wed, 05 Nov 2025 16:25:17 +0000

Folder-wise ADK Python project structure to build your AI agent assistant for Azure DevOps integration. It includes all prompts, scripts, and test data needed to simulate and evaluate the agent’s capabilities.

🗂️ Folder Structure Overview

azure_sprint_assistant/
├── agents/
│   ├── planner_agent.py
│   ├── retrospective_agent.py
│   ├── ceremony_evaluator_agent.py
│   └── notifier_agent.py
├── workflows/
│   └── sprint_workflow.py
├── prompts/
│   ├── planner_prompts.yaml
│   ├── retrospective_prompts.yaml
│   ├── ceremony_prompts.yaml
│   └── notification_prompts.yaml
├── connectors/
│   ├── azure_devops.py
│   ├── confluence_api.py
│   └── teams_webhook.py
├── data/
│   └── test_data.json
├── utils/
│   └── security.py
├── main.py
└── README.md

🧠 agents/

`planner_agent.py`

from adk import LlmAgent
from prompts.planner_prompts import PROMPTS
from connectors.azure_devops import get_sprint_data, get_team_availability

class PlannerAgent(LlmAgent):
    def run(self, context):
        sprint_data = sanitize_input(get_sprint_data())
        availability = sanitize_input(get_team_availability())
        prompt = PROMPTS["capacity_prediction"].format(data=sprint_data, availability=availability)
        return self.llm(prompt)

`retrospective_agent.py`

from adk import LlmAgent
from prompts.retrospective_prompts import PROMPTS
from connectors.confluence_api import get_retrospective_notes

class RetrospectiveAgent(LlmAgent):
    def run(self, context):
        notes = sanitize_input(get_retrospective_notes())
        prompt = PROMPTS["summary"].format(notes=notes)
        return self.llm(prompt)

`ceremony_evaluator_agent.py`

from adk import LlmAgent
from prompts.ceremony_prompts import PROMPTS
from connectors.azure_devops import get_scrum_event_records

class CeremonyEvaluatorAgent(LlmAgent):
    def run(self, context):
        records = sanitize_input(get_scrum_event_records())
        prompt = PROMPTS["evaluate"].format(records=records)
        return self.llm(prompt)

`notifier_agent.py`

from adk import LlmAgent
from prompts.notification_prompts import PROMPTS
from connectors.teams_webhook import send_notification

class NotifierAgent(LlmAgent):
    def run(self, context):
        message = PROMPTS["reminder"].format(context=sanitize_input(context))
        send_notification(message)

🔁 workflows/

`sprint_workflow.py`

from adk import SequentialWorkflow
from agents.planner_agent import PlannerAgent
from agents.retrospective_agent import RetrospectiveAgent
from agents.ceremony_evaluator_agent import CeremonyEvaluatorAgent
from agents.notifier_agent import NotifierAgent

workflow = SequentialWorkflow([
    PlannerAgent(),
    RetrospectiveAgent(),
    CeremonyEvaluatorAgent(),
    NotifierAgent()
])

📝 prompts/

`planner_prompts.yaml`

capacity_prediction: |
  Based on the following sprint history and team availability:
  {data}
  {availability}
  Predict team capacity and recommend optimal story scope.

`retrospective_prompts.yaml`

summary: |
  Summarize the following retrospective notes and highlight key action items:
  {notes}

`ceremony_prompts.yaml`

evaluate: |
  Evaluate the effectiveness of the following Scrum ceremonies:
  {records}
  Suggest improvements based on team maturity and feedback.

`notification_prompts.yaml`

reminder: |
  Reminder: {context}
  Please review and take necessary actions.

🔌 connectors/

`azure_devops.py`

def get_sprint_data():
    # Simulated secure API call
    return {"velocity": 45, "story_points": [5, 8, 13], "dependencies": ["API", "UI"]}

def get_team_availability():
    return {"Alice": "80%", "Bob": "60%", "Carol": "100%"}

def get_scrum_event_records():
    return {"planning": "low engagement", "review": "positive feedback", "retro": "mixed"}

`confluence_api.py`

def get_retrospective_notes():
    return "Team struggled with API integration. Suggested better pre-sprint alignment."

`teams_webhook.py`

def send_notification(message):
    print(f"Sending to Teams: {message}")

🧪 data/

`test_data.json`

{
  "sprint_history": [{"sprint": "Sprint 1", "velocity": 40}, {"sprint": "Sprint 2", "velocity": 45}],
  "availability": {"Alice": "80%", "Bob": "60%", "Carol": "100%"},
  "story_points": {"estimated": 50, "actual": 45},
  "dependencies": ["API", "UI", "Database"],
  "team_changes": ["Carol joined Sprint 2"],
  "scrum_events": ["planning", "review", "retro"],
  "meeting_transcripts": ["Transcript 1", "Transcript 2"],
  "retrospective_notes": ["Improve API alignment", "Better story breakdown"],
  "planning_goals": ["Deliver login module", "Refactor dashboard"],
  "action_items": ["Assign API lead", "Schedule UI review"],
  "scrum_board": ["Story A", "Story B", "Bug C"]
}

🔐 utils/

`security.py`

def sanitize_input(data):
    # Remove PII and sensitive tokens
    return {k: v for k, v in data.items() if "password" not in k and "token" not in k}

🚀 main.py

from workflows.sprint_workflow import workflow

if __name__ == "__main__":
    result = workflow.run({})
    print(result)

📘 README.md

# Azure Sprint Assistant (ADK)

An AI-powered agent assistant built using Google's Agent Development Kit (ADK) to optimize sprint planning, evaluate Scrum ceremonies, and automate team notifications.

## Features
- Predict team capacity and recommend story scope
- Evaluate and improve Scrum ceremonies
- Summarize retrospectives and planning goals
- Send reminders via Teams

## Setup

bash
pip install google-adk
python main.py


## Security
All inputs are sanitized to prevent exposure of confidential data.

## Test Coverage
Includes simulated test data for all scenarios.

✅ Updated Folder Structure (with ADK conventions)

azure_sprint_assistant/
├── agents/
│   ├── __init__.py
│   ├── agent.py          ◀️ Root agent defined here
│   ├── planner_agent.py
│   ├── retrospective_agent.py
│   ├── ceremony_evaluator_agent.py
│   └── notifier_agent.py
├── workflows/
│   ├── __init__.py
│   └── sprint_workflow.py
├── prompts/
│   ├── __init__.py
│   ├── planner_prompts.yaml
│   ├── retrospective_prompts.yaml
│   ├── ceremony_prompts.yaml
│   └── notification_prompts.yaml
├── connectors/
│   ├── __init__.py
│   ├── azure_devops.py
│   ├── confluence_api.py
│   └── teams_webhook.py
├── utils/
│   ├── __init__.py
│   └── security.py
├── data/
│   └── test_data.json
├── .env                  ◀️ Environment variables (tokens, endpoints)
├── main.py               ◀️ Entry point
└── README.md

🧠 `agent.py` — Root Agent Definition

This is where you define the root agent that orchestrates the workflow.

from adk import Agent
from workflows.sprint_workflow import workflow

root_agent = Agent(
    id="azure-sprint-assistant",
    name="Sprint Assistant",
    description="AI agent that predicts sprint capacity, evaluates ceremonies, and automates Scrum workflows.",
    workflow=workflow
)

🛠️ `init.py` Files

These make each folder a Python package. They can be empty or used to expose key components:

Example: `agents/init.py`

from .agent import root_agent

🔐 `.env` — Environment Configuration

This file stores secrets and config values securely:

AZURE_DEVOPS_TOKEN=your_token_here
CONFLUENCE_API_KEY=your_key_here
TEAMS_WEBHOOK_URL=https://...

You can load these in your Python code using os.environ or dotenv:

from dotenv import load_dotenv
import os

load_dotenv()
token = os.getenv("AZURE_DEVOPS_TOKEN")

🚀 `main.py` — Run the Root Agent

from agents import root_agent

if __name__ == "__main__":
    result = root_agent.run({})
    print(result)

🧩 Summary

File	Purpose
`agent.py`	Defines `root_agent = Agent(...)`
`__init__.py`	Enables package imports
`.env`	Stores secrets securely
`main.py`	Runs the root agent

"Predict our team capacity for next sprint."
• "Recommend stories based on past velocity and dependencies."
• "Summarize last retrospective and suggest improvements."
• "Notify team about planning meeting tomorrow."
• "How engaged was the team in last sprint ceremonies?"
• "Store these notes in Confluence: [meeting transcript]"

useEffect() in ReactJs

Hemant Govekar — Wed, 21 May 2025 13:01:30 +0000

The useEffect hook in React is essential for handling side effects in functional components. It allows you to perform operations like fetching data, listening for events, updating the DOM, and cleaning up resources.

🔹 Key Features of `useEffect`

1️⃣ Runs on every render (by default)

2️⃣ Runs only once on mount (with [] dependency array)

3️⃣ Runs when dependencies change ([dependency])

4️⃣ Cleanup function to avoid memory leaks

🚀 Comprehensive Example Covering All Features

import { useState, useEffect } from "react";

const UseEffectDemo = () => {
  const [count, setCount] = useState(0);
  const [message, setMessage] = useState("Hello");

  // 🟢 1️⃣ Runs on every render (default)
  useEffect(() => {
    console.log("Component re-rendered!");
  });

  // 🔵 2️⃣ Runs only once on mount
  useEffect(() => {
    console.log("Mounted! Fetching data...");
  }, []);

  // 🟠 3️⃣ Runs when `count` changes
  useEffect(() => {
    console.log(`Count changed: ${count}`);
  }, [count]);

  // 🟣 4️⃣ Cleanup function for event listeners or subscriptions
  useEffect(() => {
    console.log("Adding event listener...");
    window.addEventListener("resize", () => console.log("Window resized"));

    return () => {
      console.log("Cleanup: Removing event listener...");
      window.removeEventListener("resize", () => console.log("Window resized"));
    };
  }, []);

  return (
    <div>
      <h2>useEffect Demo</h2>
      <p>Count: {count}</p>
      <p>Message: {message}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <button onClick={() => setMessage("React is awesome!")}>
        Update Message
      </button>
    </div>
  );
};

export default UseEffectDemo;

📌 Explanation

✅ Runs on Every Render – First useEffect() logs on each render.

✅ Runs Only Once on Mount – Second useEffect() fetches data when the component mounts.

✅ Runs on Dependency Change – Third useEffect() logs updates only when count changes.

✅ Cleanup on Unmount – Last useEffect() adds a listener and removes it when the component unmounts.

🔥 When to Use `useEffect`?

✅ Fetching data (API calls)

✅ Subscribing to events (resize, scroll)

✅ Managing intervals (setTimeout, setInterval)

✅ Cleaning up resources (event listeners, subscriptions)

Difference between call(), apply(), and bind() with example

Hemant Govekar — Tue, 20 May 2025 02:26:11 +0000

call(), apply(), and bind() are methods that allow you to change the this context in JavaScript.

🔹 Differences & Examples

1️⃣ `call()`

Calls a function immediately with a specified this value.
Arguments are passed individually.

function greet(language) {
  console.log(`${this.name} speaks ${language}`);
}

const person = { name: "Hemant" };
greet.call(person, "JavaScript"); 
// Output: Hemant speaks JavaScript

2️⃣ `apply()`

Works like call(), but arguments are passed as an array.

greet.apply(person, ["ReactJS"]); 
// Output: Hemant speaks ReactJS

3️⃣ `bind()`

Does NOT call the function immediately.
Returns a new function with the this value fixed.

const greetPerson = greet.bind(person);
greetPerson("TypeScript"); 
// Output: Hemant speaks TypeScript

📌 Summary

Method	Calls Function Immediately?	Arguments
`call()`	✅ Yes	Passed individually
`apply()`	✅ Yes	Passed as an array
`bind()`	❌ No (Returns new function)	Passed individually

✅ Use call() when passing individual arguments.

✅ Use apply() when passing an array of arguments.

✅ Use bind() when you need a reusable function with a fixed this.

Closures in JavaScript

Hemant Govekar — Tue, 20 May 2025 00:58:26 +0000

Closures in JavaScript occur when a function retains access to variables from its lexical scope, even after the outer function has finished execution. This allows functions to "remember" values and maintain state.

🔹 Simple Example:

function outerFunction() {
  let counter = 0; // Local variable

  return function innerFunction() {
    counter++; // Inner function remembers 'counter'
    console.log(counter);
  };
}

const increment = outerFunction(); // Returns innerFunction
increment(); // 1
increment(); // 2
increment(); // 3

🔹 Explanation:

outerFunction() defines a local variable (counter).
innerFunction() modifies counter, but the outer function has already executed!
However, innerFunction() retains access to counter due to closure behavior.
Each call to increment() updates the retained counter, demonstrating persistent state.

Closures are useful for encapsulation, maintaining private variables, and creating efficient event handlers. 🚀

map, foreach and reduce difference in javascript

Hemant Govekar — Mon, 19 May 2025 02:31:16 +0000

map(), forEach(), and reduce() are array methods in JavaScript, each serving a distinct purpose.

1️⃣ map()

Creates a new array by transforming each element.
Returns a modified array without changing the original.

Example:

const numbers = [1, 2, 3, 4];
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8]

2️⃣ forEach()

Iterates over an array but does not return anything.
Used when you need to execute a function on each element (like logging data).

Example:

const numbers = [1, 2, 3, 4];
numbers.forEach(num => console.log(num * 2)); 
// Logs: 2, 4, 6, 8

Unlike map(), there’s no new array—forEach() just loops.

3️⃣ reduce()

Reduces the array into a single value (sum, product, etc.).
Takes an accumulator and a current value to compute a result.

Example: Sum of array elements

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, num) => acc + num, 0);
console.log(sum); // 10

Here, reduce() accumulates values (acc) and returns the final sum.

🚀 Key Differences

Method	Purpose	Returns New Array?
`map()`	Transform each item	✅ Yes
`forEach()`	Execute a function on each item	❌ No
`reduce()`	Condense array into a single value	❌ No

If you're manipulating data (map()), looping for side effects (forEach()), or computing a single result (reduce()), each method has its place!

Types of dependencies in package.json file

Hemant Govekar — Sun, 18 May 2025 01:38:59 +0000

Let’s break down each type of dependency in package.json in detail:

1. Dependencies (`"dependencies"`)

These are the essential packages required for your project to run in production.
They are installed automatically when you run npm install or yarn install.
Example: If you're building a React application, react and react-dom would be dependencies.
Defined like this in package.json:

  "dependencies": {
    "react": "^18.0.0",
    "redux": "^4.1.0"
  }

When you deploy your application, these packages are included.

2. DevDependencies (`"devDependencies"`)

These packages are only needed during development (e.g., testing tools, linters, build tools).
They won’t be included in the production build.
Example: Testing frameworks like jest or bundlers like webpack.
Installed with:

  npm install --save-dev jest

Defined in package.json like this:

  "devDependencies": {
    "jest": "^29.0.0",
    "eslint": "^8.0.0"
  }

3. PeerDependencies (`"peerDependencies"`)

These are dependencies that the package expects to exist in the user's environment.
They don’t get installed automatically but must be provided by the host project.
Example: A UI library might list react as a peer dependency so users can use their own version.
Defined like this:

  "peerDependencies": {
    "react": "^18.0.0"
  }

If a required peer dependency isn’t installed, a warning will be displayed.

4. OptionalDependencies (`"optionalDependencies"`)

These dependencies are not mandatory but can enhance functionality.
If an optional dependency fails to install, the package manager won’t break the installation process.
Example: A package might include a database driver as an optional dependency that users can choose to install.
Defined like this:

  "optionalDependencies": {
    "sqlite3": "^5.0.0"
  }

5. BundledDependencies (`"bundledDependencies"`)

These dependencies are packaged together when distributing the application.
Useful when creating a CLI tool or library that should bundle certain dependencies for consistency.
Example:

  "bundledDependencies": ["lodash", "moment"]

Ensures that these dependencies are always included.

Each type of dependency serves a different purpose in managing the project’s requirements effectively.

Improving the performance of your .NET Core API

Hemant Govekar — Thu, 24 Apr 2025 23:58:05 +0000

Improving the performance of your .NET Core API can significantly enhance scalability and user experience. Here are some key strategies:

1. Use the Latest .NET Version

Each new version brings performance improvements and optimizations.

2. Optimize Asynchronous Operations

Use async/await to prevent blocking calls and improve responsiveness.

3. Implement Caching

Use Redis for backend caching.
Consider MemoryCache or DistributedCache for frequently accessed data.

4. Enable Response Compression

Use Gzip or Brotli compression to reduce payload size and improve transfer speed.

5. Efficient Pagination

Instead of loading all records, fetch data in manageable chunks to reduce memory usage.

6. Minimize Exceptions

Avoid excessive exception handling in performance-critical paths, as they can slow down execution.

7. Optimize Database Queries

Use Indexing, Stored Procedures, and Lazy Loading to reduce query execution time.

8. Use a CDN for Static Content

Offload static assets like images and scripts to a Content Delivery Network (CDN).

9. Profile and Monitor Performance

Use Application Insights or Prometheus to track API performance and identify bottlenecks.

10. Reduce Unnecessary Middleware

Only include essential middleware components to minimize overhead.

Debouncing and Throttling with examples javascript

Hemant Govekar — Thu, 24 Apr 2025 01:23:40 +0000

Debouncing and throttling are two techniques used in JavaScript to optimize the execution of functions that are triggered frequently, especially in response to user interactions like scrolling, resizing, or typing.

Debouncing

Debouncing ensures that a function runs only after a specified delay following the last trigger event. This prevents excessive function calls when an event fires repeatedly.

Real-world Example: Typing in a Search Bar

Imagine a user typing into a search bar. Without debouncing, every keystroke would trigger an API request, potentially overwhelming the server. Instead, with debouncing, the function waits until the user stops typing for a short period before making the request.

JavaScript Example (Debouncing a Search Input):

function debounce(func, delay) {
  let timer;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => func.apply(this, args), delay);
  };
}

const searchAPI = (query) => {
  console.log("Fetching search results for:", query);
};

const debouncedSearch = debounce(searchAPI, 500);

document.getElementById("searchBox").addEventListener("input", (event) => {
  debouncedSearch(event.target.value);
});

🔹 Effect: The searchAPI function executes only after the user stops typing for 500ms.

Throttling

Throttling ensures that a function executes at most once within a specific interval, even if it's triggered multiple times. This is useful for performance-intensive tasks like scrolling.

Real-world Example: Scroll Event Handling

Imagine a user scrolling through a website. Without throttling, the event listener could trigger dozens of times per second, potentially causing performance issues. Throttling ensures the function runs at a controlled rate.

JavaScript Example (Throttling a Scroll Event):

function throttle(func, limit) {
  let lastCall = 0;
  return function (...args) {
    const now = Date.now();
    if (now - lastCall >= limit) {
      lastCall = now;
      func.apply(this, args);
    }
  };
}

const logScrollPosition = () => {
  console.log("Scroll position:", window.scrollY);
};

const throttledScroll = throttle(logScrollPosition, 1000);

window.addEventListener("scroll", throttledScroll);

🔹 Effect: The logScrollPosition function executes at most once per second, preventing excessive calls while scrolling.

Key Differences

Aspect	Debouncing	Throttling
Execution Timing	After a delay following the last trigger	At most once within a fixed time interval
Use Case	Search inputs, button clicks	Scroll events, resize events
Prevents	Rapid consecutive calls	Excessive function execution

Both techniques improve performance by reducing unnecessary function calls, keeping your application smooth and efficient. Since you work with ReactJS, you might use debouncing for search inputs and throttling for window resize handlers inside React components.

Async, Await, Promises ... in javascript

Hemant Govekar — Wed, 23 Apr 2025 00:53:41 +0000

Video of the explaination :

JavaScript provides several mechanisms for handling asynchronous operations, with async and await being the most modern and widely used. Let's break them down along with other asynchronous keywords.

1. Async & Await

These keywords allow you to write asynchronous code that looks synchronous, making it easier to read and manage.

Async Function

Declaring a function as async means it always returns a Promise.
Inside an async function, you can use the await keyword to pause execution until a Promise resolves.

Example:

async function fetchData() {
  return "Hello, Async!";
}

fetchData().then(console.log); // Output: "Hello, Async!"

Await Keyword

The await keyword pauses the execution inside an async function until the Promise resolves, avoiding the need for .then().
Helps keep the code more readable compared to chaining .then() callbacks.

Example:

async function fetchData() {
  const data = await fetch("https://jsonplaceholder.typicode.com/todos/1");
  const json = await data.json();
  console.log(json);
}

fetchData();

2. Promises

Before async/await, JavaScript used Promises for handling asynchronous operations. A Promise represents a value that may be available now, or later, or never.

Example:

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => resolve("Promise Resolved!"), 2000);
});

myPromise.then(console.log); // Output after 2 seconds: "Promise Resolved!"

3. Callback Functions

Older JavaScript code often relied on callbacks, but they led to "callback hell" when too many nested functions were used.

Example:

function fetchData(callback) {
  setTimeout(() => {
    callback("Data received!");
  }, 2000);
}

fetchData(console.log); // Output after 2 seconds: "Data received!"

This approach became harder to maintain, leading to the rise of Promises and async/await.

4. Other Asynchronous Keywords

Promise.all()

Runs multiple Promises in parallel and waits for all of them to resolve.

const p1 = Promise.resolve("First");
const p2 = new Promise(resolve => setTimeout(() => resolve("Second"), 1000));

Promise.all([p1, p2]).then(console.log); // ["First", "Second"] after 1 sec

Promise.race()

Resolves as soon as one Promise resolves.

const p1 = new Promise(resolve => setTimeout(() => resolve("First"), 3000));
const p2 = new Promise(resolve => setTimeout(() => resolve("Second"), 1000));

Promise.race([p1, p2]).then(console.log); // Output: "Second" (fastest one wins)

When to Use Each Method?

Use async/await for cleaner and more readable asynchronous code.
Use Promises when working with APIs and chaining multiple async operations.
Use Promise.all() for running async tasks in parallel.
Use Promise.race() when only the first resolved result matters.

Securing APIs

Hemant Govekar — Sat, 05 Apr 2025 01:07:17 +0000

Securing APIs is crucial to protect data and maintain the integrity of applications. Here are 10 simple yet effective measures:

Use HTTPS: Ensure all API communications occur over HTTPS to encrypt data during transmission.
Authenticate API Calls: Implement strong authentication mechanisms like OAuth, JWT, or API keys.
Control Access: Use role-based access control (RBAC) to restrict API usage based on user roles and permissions.
Validate Input: Sanitize and validate all user inputs to prevent attacks like SQL injection or command injection.
Rate Limiting: Apply rate limiting to prevent abuse, such as excessive calls from a single source.
Monitor and Audit Activity: Track API usage with logs and analytics to identify suspicious behavior and potential breaches.
Use CORS: Enable Cross-Origin Resource Sharing (CORS) policies to restrict which domains can access the API.
Encrypt Data: Store sensitive data securely and ensure it’s encrypted at rest and in transit.
Implement API Gateway: Use an API gateway to manage traffic, enforce security policies, and provide a central point for monitoring.
Keep APIs Updated: Regularly patch and update APIs to mitigate vulnerabilities and stay secure against new threats.

These measures provide a strong foundation for API security while maintaining accessibility and functionality.

Explain PUT POST and PATCH

Hemant Govekar — Sat, 05 Apr 2025 01:05:41 +0000

In HTTPS, the HTTP methods PUT, POST, and PATCH are used to perform operations on resources. Here's a differentiation of their purposes and behavior:

POST:

Purpose: Used to create new resources or submit data to a server. It appends the resource to an existing collection.
Idempotency: Not idempotent; multiple identical POST requests will create multiple resources.
Example: Submitting a registration form to create a new user.
Response: Usually returns 201 Created and a URI pointing to the newly created resource.

PUT:

Purpose: Used to create or completely replace a resource at a specific URI. If the resource exists, it is updated; if it doesn't, it is created.
Idempotency: Idempotent; multiple identical PUT requests will produce the same result (i.e., the same resource state).
Example: Updating an entire profile with a new set of data.
Response: Typically returns 200 OK (if updated) or 201 Created (if new resource is created).

PATCH:
- Purpose: Used to partially update an existing resource. Only the fields provided in the request will be updated, leaving the rest unchanged.
- Idempotency: Idempotent; multiple identical PATCH requests will result in the same resource state.
- Example: Updating just the email address of a user profile without altering other fields.
- Response: Commonly returns 200 OK or 204 No Content.

Key Differences

Method	Action	Idempotency	Typical Use Case
POST	Create new resource	No	Submitting forms or adding records to a database
PUT	Replace entire resource	Yes	Overwriting or creating a resource at a specific URI
PATCH	Update part of a resource	Yes	Modifying specific fields in a resource

Each method is designed for specific operations, ensuring clarity and proper organization of HTTP operations.

DEV Community: Hemant Govekar

10 Habits of a Budding Programmer

1. 🖊️ Writes Code Regularly

2. 📖 Reads Other People's Code

3. 🐛 Debugs Before Asking for Help

4. 🧩 Breaks Problems into Smaller Pieces

5. 🔀 Uses Version Control Early

6. 📚 Looks Up Documentation Instead of Guessing

7. ♻️ Refactors Code After It Works

8. 🧠 Learns Core Concepts, Not Just Syntax

9. 🏗️ Builds Small, Complete Projects

10. 🌀 Embraces Confusion as Part of Learning

Google ADK

🗂️ Folder Structure Overview

🧠 agents/

planner_agent.py

retrospective_agent.py

ceremony_evaluator_agent.py

notifier_agent.py

🔁 workflows/

sprint_workflow.py

📝 prompts/

planner_prompts.yaml

retrospective_prompts.yaml

ceremony_prompts.yaml

notification_prompts.yaml

🔌 connectors/

azure_devops.py

confluence_api.py

teams_webhook.py

🧪 data/

test_data.json

🔐 utils/

security.py

🚀 main.py

📘 README.md

✅ Updated Folder Structure (with ADK conventions)

🧠 agent.py — Root Agent Definition

🛠️ __init__.py Files

Example: agents/__init__.py

🔐 .env — Environment Configuration

🚀 main.py — Run the Root Agent

🧩 Summary

useEffect() in ReactJs

🔹 Key Features of useEffect

🚀 Comprehensive Example Covering All Features

📌 Explanation

🔥 When to Use useEffect?

Difference between call(), apply(), and bind() with example

🔹 Differences & Examples

1️⃣ call()

2️⃣ apply()

3️⃣ bind()

📌 Summary

Closures in JavaScript

🔹 Simple Example:

🔹 Explanation:

map, foreach and reduce difference in javascript

1️⃣ map()

2️⃣ forEach()

3️⃣ reduce()

🚀 Key Differences

Types of dependencies in package.json file

1. Dependencies ("dependencies")

2. DevDependencies ("devDependencies")

3. PeerDependencies ("peerDependencies")

4. OptionalDependencies ("optionalDependencies")

5. BundledDependencies ("bundledDependencies")

Improving the performance of your .NET Core API

1. Use the Latest .NET Version

2. Optimize Asynchronous Operations

3. Implement Caching

4. Enable Response Compression

5. Efficient Pagination

6. Minimize Exceptions

7. Optimize Database Queries

8. Use a CDN for Static Content

9. Profile and Monitor Performance

10. Reduce Unnecessary Middleware

Debouncing and Throttling with examples javascript

`planner_agent.py`

`retrospective_agent.py`

`ceremony_evaluator_agent.py`

`notifier_agent.py`

`sprint_workflow.py`

`planner_prompts.yaml`

`retrospective_prompts.yaml`

`ceremony_prompts.yaml`

`notification_prompts.yaml`

`azure_devops.py`

`confluence_api.py`

`teams_webhook.py`

`test_data.json`

`security.py`

🧠 `agent.py` — Root Agent Definition

🛠️ `init.py` Files

Example: `agents/init.py`

🔐 `.env` — Environment Configuration

🚀 `main.py` — Run the Root Agent

🔹 Key Features of `useEffect`

🔥 When to Use `useEffect`?

1️⃣ `call()`

2️⃣ `apply()`

3️⃣ `bind()`

1. Dependencies (`"dependencies"`)

2. DevDependencies (`"devDependencies"`)

3. PeerDependencies (`"peerDependencies"`)

4. OptionalDependencies (`"optionalDependencies"`)

5. BundledDependencies (`"bundledDependencies"`)