Gemini CLI v1 Roadmap and Key Features

🌶️ You know I'm not a fan of Apollo Connectors, hehe, but hear me out... When Connectors came out, I kept telling people that it's never going to work. Enterprises must always have control over the http client for multiple reasons, for example signing requests, logging, tracing, retries, AND of course authentication. Here's a snipped from a sales call. People need to wake up and realize that declaratively adding REST APIs to a Supergraph is a neat toy, but nothing more. Cosmo Connect goes a different route: 1. Define your Subgraph Schema 2. Compile into plugin proto (gRPC) 3. Implement gRPC plugin in your language of choice Language of choice is key here, because most enterprises have internal libraries for security or to call services, so you can just use them.

When we run LLMs in production, we track Time to First Token (TTFT): how long before the first word shows up. Then Tokens per Second (TPS): how fast the next words keep flowing. Prefill is heavy compute.The second part decode is memory lookups, that’s why tokens stream one by one. Lets try to under the lifecycle of a request from the user's point of view 1. You send a prompt. 2. You wait for sometime. Nothing happens. This is the prefill phase, and it determines TTFT. 3. The first token appears. 4. A stream of tokens follows. This is the decode phase, and it determines TPS. As SREs, we use prometheus or any kind of oveserability tools to measure TTFT and TPS in real time. How the inference cluster is built has a direct impact on these two metrics.

🚀 𝗧𝗵𝗲 𝗣𝗿𝗼𝗺𝗶𝘀𝗲 𝗧𝗿𝗮𝗽 𝗧𝗵𝗮𝘁 𝗘𝘃𝗲𝗻 𝗘𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲𝗱 𝗝𝗦 𝗗𝗲𝘃𝘀 𝗠𝗶𝘀𝘀 - Here’s a small snippet that looks innocent but hides a sneaky bug 👇 What do you think is the output in the given image? Actual Output: Uncaught (in promise) Something went wrong! 💡 Why? Because Promise.reject() doesn’t throw an error synchronously, it returns a rejected Promise. And try...catch only catches synchronous errors, not Promise rejections. So the rejection goes uncaught, and the .then() never runs. ✅ Fix: Make the function async and await the Promise: async function init() { try { await processing(); } catch (err) { console.log("Error in processing."); } } init().then(() => console.log("End")); Output: Error in processing. End Moral of the story: If you’re using Promises, remember --> try...catch only works when you await

A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null. Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. None of the pointers in the new list should point to nodes in the original list.Today is 23/10/2025

Good observability isn't just a nice to have, we know developers need to be able to easily debug when things go wrong. We use @opentelemetry (OTEL) for our run logs, giving you a lot of detailed info about your tasks. It also allows us to support: ⚗️ Adding additional instrumentation like Prisma, OpenAI, etc 🛩️ Exporting your logs and traces to other external tools like Axiom, Datadog, etc When you add instrumentation you get distributed tracing for your dependencies, with automatic spans for every query and request. Also, your observability data isn't locked in, you can export traces wherever you need them. Learn how to add custom instrumentation and export telemetry to your other services in our docs: https://lnkd.in/es2X_JY4

📽️ Did you miss our Model Context Protocol (MCP) #Webinar that just passed? We've got the recording for you. https://lnkd.in/getNe6jf MinIO's Pavel Anni covered Using Human Language to Manage MinIO AIStor with MCP, walking through: - Using MCP to manage MinIO AIStor in plain English - Performing common tasks like managing objects, buckets & monitoring cluster health - Exploring advanced workflows, including data lake migration with Apache Iceberg Be sure to watch the replay! #MCP #Iceberg #AIStor

🔹 SLL_Medium_Part3_DSA — Single Linked List (Medium) From symmetry checks to smart rearrangements — uncover the beauty in list manipulation! 📌 This covers: 🔷 CheckPalindrome — Detects if a linked list reads the same forward and backward using half-reversal logic. 🔷 SegregateEvenOdd — Splits nodes into even and odd sequences while keeping their original order intact. 🟢 Real-world parallels & attention-grabbers: • Ensuring mirrored workflows or consistent data states. • Grouping user requests or transactions efficiently by type. #DSA #LinkedList #Algorithms

MinIO-Compatible Image, Maintained and Secure - from Minimus According to MinIO’s public release notes, MinIO has updated how it distributes its Docker images. As a result, some teams now choose to build from source to keep their deployments consistent. Minimus built a MinIO-compatible image that stays small, clean, and up to date - so you don’t have to handle that work yourself. Highlights: ======= * Minimal base - zero-CVE layer, no extras. * Continuous rebuilds - triggered automatically with each upstream change or CVE disclosure. * Full transparency - SBOMs and provenance data for every build. Same API, smaller surface, fully maintained by Minimus. If you just want an image that keeps running without surprises - this one’s for you.

In case you missed the recent P4 Developer Days webinar, “Enabling Portable and High-Performance SmartNIC Programs with Alkali”. Jiaxin Lin, Cornell University and Zhiyuan Guo, UC San Diego, you can now view the video and slides on-demand. Overview: In this presentation, we will present the demo and design of Alkali, a SmartNIC compilation framework that enables developers to write target-independent programs, while the compiler automatically handles cross-NIC porting and performance tuning. Alkali achieves this by: (1) introducing a novel intermediate representation (IR) that supports building a reusable and extensible compiler across diverse NICs, and (2) developing an optimization algorithm that automatically transforms and parallelizes programs based on the target NIC’s hardware characteristics. View Video | https://lnkd.in/gh5aEj-v View Slides | https://lnkd.in/grZifhbC #P4 #P4lang #SmartNIC #OpenSource

Architecting the Orbital Data Fabric: A Practical Look at LEO-Integrated Infrastructure The evolution of distributed computing is pushing the perimeter beyond terrestrial constraints. We are now architecting systems where data center modules in Low Earth Orbit (LEO) become functional nodes in a global fabric. The enabling layer? Advanced LEO satellite constellations. Constellation Analysis: Operational Profiles · SpaceX Starlink: Characterized by its proliferated LEO architecture, Starlink provides a high-density, low-latency transport layer. Its primary value is in creating a "bent-pipe" backbone for high-throughput data exfiltration and command/control with sub-50ms latency, effectively acting as a redundant, global WAN. · Sovereign Systems (e.g., GuoWang): These networks prioritize a sovereign and secure operational envelope. They are engineered for integrated data governance, offering a regulated and compliant pipeline, which is a critical design parameter for national and enterprise security postures. The Critical Path: Autonomous Network Operations Terrestrial network management paradigms fail in this environment. Success hinges on two core principles: 1. Intent-Based Verification & Pre-Deployment Modeling: Every configuration and policy change must be validated against a high-fidelity digital twin. Using tools like Juniper vMX in NS-3 simulations, we can model satellite pass dynamics, link budgets, and routing protocol behavior (BGP/OSPF over intermittent links) to prevent pathological states before they are committed to orbit. 2. Closed-Loop Control via Streaming Telemetry: The traditional SNMP poller is obsolete. The operational model must shift to a gRPC/gNMI streaming telemetry fabric, feeding a ground-based controller (e.g., Juniper Paragon). This enables real-time state awareness and allows for predefined automation playbooks to execute path selection, traffic engineering, and failure remediation without ground-in-the-loop delay. The future of this architecture is a multi-constellation, software-defined internet in space. The role of the network engineer evolves to define the intent and policies that autonomous systems execute across this dynamic, hybrid fabric. #SpaceNetworking #LEO #SDWAN #Juniper #Starlink #NetworkAutomation #IntentBasedNetworking #DataCenter https://lnkd.in/gB5z3Xcm