Azure outage

🚨 Outage Summary

• When: The disruption started around 15:45 UTC on October 29 and was largely mitigated early on October 30, 2025.

• Cause: Microsoft traced the root cause to an "inadvertent tenant configuration change" within its Azure Front Door (AFD) service, a global content delivery network. A software defect allowed a faulty deployment to bypass safety validations, leading to an invalid configuration state.

• Impact: The outage impacted services relying on Azure Front Door for global content delivery, including:

  • Microsoft Services: Azure Portal access, Microsoft 365 services (Outlook, Teams, Admin Center), Xbox Live, and Minecraft.

  • External Customers: Airlines (like Alaska Airlines), retail companies (like Starbucks and Costco), financial institutions (like NatWest), and others, resulting in issues like website failures, login problems, and check-in disruptions.

🛠️ Resolution

• Microsoft's engineers addressed the issue by blocking all further configuration changes to AFD services and rolling back to a "last known good" configuration across their global network.

• The company has implemented additional validation and rollback controls and will conduct an internal review (Post Incident Review or PIR), which will be shared with affected customers within 14 days.

Cursor Composer

I'm thrilled to pull back the curtain on Cursor Composer, this brand-new agent model that's setting a new standard for software engineering intelligence and speed.

On their internal benchmarks, Composer doesn't just pass the test—it crushes it. We're seeing frontier coding results at a generation speed that is a stunning four times faster than comparable models. That means smarter solutions delivered in a fraction of the time.

How did they do it? They trained Composer to tackle real-world software engineering challenges within massive, complex codebases. During training, the model was equipped with a full suite of production search and editing tools, forcing it to learn how to efficiently solve a diverse range of truly difficult problems.

The final result is a powerful, large-scale model—an agent optimized for high-speed, real-world use right here in Cursor. Get ready for a massive boost to your workflow!

Today's layoff news

 

Today's news about Amazon targets as many as 30,000 corporate job cuts which is nearly 10% of its roughly 350,000 corporate employees. 

This would mark Amazon's largest job cut since late 2022, when it started to eliminate around 27,000 positions.

https://www.reuters.com/business/world-at-work/amazon-targets-many-30000-corporate-job-cuts-sources-say-2025-10-27/

API Migration Journey

On working recent api migration, it triggered me to write comprehensive and suitable journey of API design growth for a technical audience. 

SOAP

• Illustration:

  • SOAP Sender: Represents a client application initiating a request.

  • Protocol (HTTP/SMTP): The transport layer over which SOAP messages are sent. Messages are typically XML-based.

  • SOAP Message (Envelope): A structured XML document containing the message body, header, and fault information.

  • SOAP Receiver: A server-side application parsing the SOAP message, processing the request, and sending a SOAP response.

  • Key Characteristics:

    • Strictly Typed: Uses XML Schema Definition (XSD) for message structure.

    • WSDL: Web Services Description Language describes the operations a web service offers.

    • Stateless: Each request is independent.

    • Synchronous/Asynchronous: Can support both.

    • Security: Built-in WS-Security standards.

    • Reliability: WS-ReliableMessaging for guaranteed delivery.

• Use Case: Enterprise-level financial transactions, legacy system integration, highly distributed environments requiring ACID transactions and formal contracts.

• Pros: High reliability, security, ACID compliance, language independence, extensive tooling.

• Cons: Complex, verbose XML, higher overhead, steeper learning curve.

REST

• Illustration:

  • Sender (Client): Sends HTTP requests (GET, POST, PUT, DELETE) to a server.

  • HTTP Request: Contains method, URL, headers, and optional body.

  • REST Web Server: Processes requests, accesses resources, and sends back HTTP responses.

  • HTTP Response: Contains status code, headers, and resource representation (e.g., JSON, XML).

  • Key Characteristics:

    • Stateless: Server doesn't store client context between requests.

    • Cacheable: Responses can be cached to improve performance.

    • Client-Server: Clear separation of concerns.

    • Layered System: Intermediaries (proxies, load balancers) can be introduced.

    • Uniform Interface: Resources identified by URIs, standard HTTP methods.

    • Self-Descriptive Messages: Messages contain enough info to be processed.

    • HATEOAS (Hypermedia As The Engine Of Application State): Optional, but a core principle for discoverability.

• Use Case: Mobile application backend for a social networking platform, public APIs, web services requiring scalability and simplicity.

• Pros: Simple, flexible, widely adopted, efficient (JSON is light), scalable, cacheable.

• Cons: No strict contract (can lead to integration issues), lack of type safety, under/over-fetching data for complex queries.

GraphQL

• Illustration:

  • Sender (Client): Sends a single HTTP POST request to a GraphQL server.

  • GraphQL Query/Mutation: A flexible query string defining exactly what data the client needs.

  • GraphQL Server: Parses the query, resolves fields by interacting with various data sources (databases, other APIs), and constructs a single JSON response.

  • Database/Other APIs: Data sources from which the GraphQL server fetches information.

  • Key Characteristics:

    • Single Endpoint: All queries go to one URL.

    • Declarative Data Fetching: Clients specify data requirements.

    • Schema Definition Language (SDL): Defines types, fields, and relationships.

    • Resolvers: Functions that fetch data for specific fields.

    • Strongly Typed: Prevents many runtime errors.

    • No Over/Under-fetching: Clients get exactly what they ask for.

• Use Case: Real-time collaborative document editing, complex UIs needing data from multiple sources, microservices aggregation layer, mobile applications to reduce network requests.

• Pros: Efficient data fetching, strong typing, better developer experience (IDE support), versionless APIs.

• Cons: Caching complexity (due to POST requests), steeper learning curve than REST for basic use, file upload can be tricky.

gRPC

• Illustration:

  • Client (abc): Makes a remote procedure call to a server.

  • Protocol Buffers (010010): A language-neutral, platform-neutral, extensible mechanism for serializing structured data. Used for defining service interfaces and message structures.

  • gRPC Server (Database Icon): Receives the call, executes the procedure, and returns a response.

  • HTTP/2: The underlying transport layer for multiplexing, streaming, and efficient connections.

  • Key Characteristics:

    • Contract-First: Uses Protocol Buffers (or other IDLs) to define service methods and message types.

    • High Performance: Binary serialization (Protobufs) and HTTP/2 for efficient data transfer.

    • Streaming: Supports unary, server-side, client-side, and bi-directional streaming.

    • Polyglot: Code generation for many languages.

    • Strongly Typed: Ensured by Protobuf definitions.

• Use Case: Microservices communication in a distributed system, inter-service communication, high-performance computing, real-time data streaming.

• Pros: High performance, low latency, efficient serialization, strong contracts, multi-language support, built-in streaming.

• Cons: Browser support requires a proxy, not human-readable payload, steeper learning curve, limited tooling compared to REST.

Websocket

• Illustration:

  • Sender (Client): Initiates an HTTP Upgrade request to establish a WebSocket connection.

  • HTTP Upgrade: Handshake process to upgrade from HTTP to WebSocket protocol.

  • Web Server (Building): Accepts the upgrade, establishing a persistent, full-duplex connection.

  • Full Duplex: Both client and server can send and receive messages simultaneously over the same open connection.

  • Key Characteristics:

    • Persistent Connection: A single, long-lived connection.

    • Full-Duplex: Bi-directional communication.

    • Low Overhead: After the initial handshake, minimal frame overhead.

    • Real-time: Ideal for immediate data exchange.

    • Event-Driven: Messages pushed from server to client.

• Use Case: Live sports score updates, chat applications, real-time dashboards, online gaming, stock tickers.

• Pros: Real-time communication, low latency, efficient for frequent small messages, reduced server load compared to polling.

• Cons: More complex to implement than HTTP requests, requires server infrastructure to manage persistent connections, no built-in error handling/retries like HTTP.

Webhook

• Illustration:

  • Source Application (Server with Gears): An event occurs (e.g., order fulfillment).

  • Async (Red Dotted Line): The source application asynchronously sends an HTTP POST request.

  • Payload (Gear Icon in Box): The POST request contains data about the event, typically JSON.

  • Webhook Listener/Receiver (Server Stack): A designated URL (endpoint) on a different server that is configured to receive these notifications.

  • Automated Order Fulfillment: The receiving system processes the event data.

  • Key Characteristics:

    • Event-Driven: Triggered by specific events.

    • HTTP POST: Typically uses POST requests to deliver data.

    • Asynchronous: The source doesn't wait for a response from the receiver.

    • Subscription Model: The receiver "subscribes" to events from the source by providing a callback URL.

    • Payloads: Data included in the POST request.

    • Retries/Error Handling: Often implemented by the source application for reliability.

• Use Case: Automated order fulfillment notifications in e-commerce, GitHub commit notifications, payment gateway callbacks, CRM updates, CI/CD pipeline triggers.

• Pros: Real-time updates, reduced polling overhead, efficient for event propagation, simple to implement for basic use cases.

• Cons: Requires the receiver to have a publicly accessible URL, security concerns (verifying source), managing retries and failures, potential for "noisy" notifications if not filtered.

Browser workflow

Rocky wrote a simple and powerful workflow of web browser.  Here it is

When you type a URL into your browser:

• The browser breaks the URL into components like scheme (e.g., "https"), domain (e.g., "example.com"), and path (e.g., "/page").
• If the IP address isn’t cached, it queries a DNS server to resolve it.
• A connection is established with the web server using the IP and port (80 for HTTP, 443 for HTTPS).
• The browser sends an HTTP request to fetch the resource.
• The server responds with the requested data (HTML, CSS, JS) and a status code.
• The browser renders the page by processing the HTML, applying CSS, and executing JavaScript.
• Secure sites establish an SSL/TLS connection for encryption.
• Resources are cached to speed up future visits.
• Fast, secure, and seamless—all thanks to modern browsers!

Java on Cursor AI

In Java, you can set a custom cursor using the java.awt.Toolkit and java.awt.Cursor classes. This process involves loading an image file (like a PNG) and then creating a CustomCursor object from it, which can be applied to any AWT or Swing component, such as a JFrame or JPanel

Cursor AI tool is improving its support to Jave.  It's written in their blog at https://cursor.com/blog/java 

Gemini Drops

Here's September'25 updates on Google Gemini Drop product

• The Nano Banana image editing model has taken the world by storm. See some of the most popular use cases here.
• Share your camera with Gemini Live and it can highlight exactly what to focus on, giving you the visual guidance you need to get things done in real time. Coming soon to all Android and iOS devices.
• Gemini is coming to users in the U.S. on Chrome on desktop. Soon, you'll be able to ask for a quick summary, clarify concepts and find answers using the context of your open tabs.
• You can now share your custom Gems with others. Whether you're planning a project or a party, everyone can now use the same AI expertise.
• Create an app in Canvas with no coding experience, and now you can visually edit any part of your web app just by clicking an element and describing the change.