标签：#TL

One of those questions that looks like it should have a one-click answer and does not. Here is exactly what Confluence Cloud can and cannot do with numbers, and how to pick between the three ways out. Short answer. A normal Confluence table cannot add anything up: there is no formula engine behind it, and the number on the page is whatever somebody typed. A Confluence database can show a total at the bottom of a field, including Sum and Average. Neither can calculate a value per row, so nothing in Confluence Cloud gives you a column that multiplies price by quantity. You have three ways out, and the right one depends on how often the numbers change. What Confluence actually does It is worth separating two things that look similar on a page, because the answer is different for each. Tables The classic table you get from the editor is a layout element. It stores text, numbers, links and macros in cells, it merges cells, it sorts columns for the reader. It does not compute. There is no cell reference, no formula bar, nothing that recalculates when a value changes. If a total sits in the bottom row, a person put it there, and it stays wrong until a person notices. This is not an oversight anyone forgot about. The request to add spreadsheet behaviour to Confluence tables is one of the older open items in Atlassian's public tracker, and it is still open. Databases Databases are the newer structured-data feature, and they do calculate, within limits. Each field can show a calculation at the bottom, and for number fields the list is genuinely useful: Field type Calculations available Number Sum, Average, Min, Max, Count values, Count unique values, Count empty, Percent empty Everything else Count values, Count unique values, Count empty, Percent empty The calculation can be saved as part of a view, so the total is there for the next reader rather than something each person switches on. Worth knowing before you plan around them: databases are not available in the Atlassian G

Oh, this thing? It's just a crossbody strap. It's a fun and youthful way to carry your phone. It's all the rage with Europeans and young people. I love it, and I definitely don't feel weird and self-conscious using it. Plus, it's great to have a $700 investment dangling near your waist while you walk […]

GitLab warns that isolating an AI coding agent in a sandbox does not necessarily make the agent safe. In a new security analysis, the company describes an internal evaluation in which an AI agent escaped its sandbox by exploiting a vulnerable package proxy that had been explicitly placed on the sandbox's allowlist. By Craig Risi

Introduction Repository migrations are often perceived as straightforward infrastructure activities. In reality, developers frequently face a more complicated challenge: "What happens to the work that is already in progress?" I recently faced a situation where an ongoing feature was being developed in a repository originally hosted in one Git platform while the organization migrated to another platform. The challenge was not simply moving code. The challenge was safely migrating active work without: Losing commits Pushing to deprecated branches Creating merge conflicts Breaking the development workflow Introducing confusion among team members This article summarizes the lessons learned and the approach that ensured a smooth transition. The Situation The development team received guidance similar to: Stop pushing to branches originally created in the old repository platform. Create new branches in the new platform. Verify branch history before using migrated branches. Use new authentication credentials for the new platform. At first glance the instructions seemed simple. However, there was already: Ongoing feature development Local commits Existing branch history Local test configurations New authentication requirements The biggest question became: "How can existing work be moved safely without starting over?" Step 1: Verify the Current State Before making any migration-related changes, it is important to understand exactly where the work exists. A few simple checks help answer: Which branch am I on? Are there uncommitted files? Have commits already been created? Which remote repository am I connected to? Understanding the current state prevents accidental mistakes later. One of the most valuable lessons was: Never assume your local branch matches the remote branch. Verify first. Act second. Step 2: Separate Real Changes from Local Testing In most projects there are usually two types of modifications: Functional Changes Actual feature development or defect fixes inte

I could not make myself log time in Jira. Not because it is hard. Because nothing happens afterwards. You type a number into a box, the box says nothing back, and by Thursday the habit is gone again. Every tool I tried fixed this by adding another box. So I built the missing half instead. Feed The Troll gives everyone on a team a pixel-art troll that gains XP from the work they already do in Jira, and turns sprint results into a village the whole project shares. It is on the Atlassian Marketplace now. This post skips the game itself. It is about five problems that turned out to be hard in ways I did not expect, each one a consequence of building the thing on Atlassian Forge, alone. What Forge gives you, and what it takes back Forge runs your code on Atlassian's infrastructure. There is no server of mine anywhere in the picture. That is the line on the listing page, and it was the single fact that shaped every decision underneath it. You get a Node 22 runtime, Forge SQL (TiDB under the hood) for storage, and Custom UI modules that reach the backend through @forge/bridge . You give up a backend you control, a cache you can reach, and outbound HTTP to anything you did not declare. The one that keeps mattering: any way to open the database at three in the morning and fix a single row by hand. The whole app declares six scopes. None of them are write scopes: read:board-scope:jira-software read:issue-details:jira read:jira-work read:jira-user read:sprint:jira-software storage:app That last line is the entire persistence layer. Twenty-one tables live behind it now, but only ten shipped with v1.0: trolls, XP events, daily activity, kudos, quests, inventory, team quests, villages, raids, project settings. Every table added since arrived the only way the platform makes comfortable, as a new migration appended to the list, never an edit to one already deployed. migrationRunner . enqueue ( ' v001_create_trolls ' , CREATE_TROLLS_TABLE ) // ... . enqueue ( ' v012_create_product_m

Prologue: Open the window and look at the sky 🌌 Right now, while you read this, multi-million euros satellites are passing over your head. Some of them are transmitting pictures of the Earth to anyone who cares to listen. Not to their partner companies. Not to governments. To anyone . The images go out unencrypted, raining down over whole continents on frequencies you can pull in with about 100 euros of hardware and a balcony facing the sky. That is true for Earth pictures, for weather data, aviation/maritime tracking, amateur radio, even videos from the International Space Station 🛰️! I didn't know that either... until I did! And when I did, I felt a new frontier opening up, like I could reach the stars for real, from my home. New space adventures and discoveries were expecting me, one satellite at a time. This is a story about reaching (weather imagery) satellites. It's also a story of how a "let me just try one thing" turned into a distributed ground station running across two countries, a dead laptop resurrected as a server, my dad on a ladder in Théding while I watch from Barcelona and, as I write this, a geostationary satellite drifting slowly across the sky toward the one spot that would let me receive it. The project isn't finished. I mean that literally: this article ends on a spacecraft that is still in motion. But I should introduce the cast first, because the difference between two kinds of satellite is the key to this whole project. Weather satellites come in two families. The first are polar orbiters 🛰️. They fly low, a few hundred kilometers up, and fast, looping North to South while the Earth turns underneath them, so they eventually pass over everywhere (over your home too! 👾). They're the ones I chase in this story: the Russian METEOR-M series, 800 km over our heads, broadcasting down in the VHF band around 137 MHz . The catch is they're only up there for about ten to fifteen minutes at a time. The satellite climbs out of the horizon, arcs over us,

The choice is usually made by whoever draws the first diagram, and then everybody lives with it for years. It is worth five minutes of thought, and the deciding question is not which tool is best but who will edit this thing next. Short answer. A visual editor such as draw.io for diagrams that non-engineers maintain. Mermaid or PlantUML when the diagram belongs with the code and should be reviewed like code. An attached SVG when the picture comes from a design tool and you need it to look exactly right. A screenshot when the diagram will genuinely never change again. The four options A diagramming app inside Confluence draw.io is the common choice, and it is free for small teams. The diagram is created and edited inside the page, links on shapes work, and anyone who can use a mouse can maintain it. This is the default answer for architecture maps, process flows and floor plans that live in the documentation and get corrected by whoever notices the mistake. The cost is lock-in of a mild kind: the diagram lives in the app's format, and moving to something else later means exporting and redrawing. Mermaid or PlantUML: diagrams as text Here the diagram is source code — a few lines describing nodes and arrows, rendered into a picture. The appeal is real: text goes into version control, diffs are readable, and a diagram can be generated by a script from the system it describes. Two things to know before choosing this. Confluence Cloud does not render Mermaid natively, so you need an app for it, and several of them exist including free ones. And the editing audience narrows sharply: a technical writer will not touch a diagram that has to be edited as syntax, so the diagram becomes the property of the engineers, whether you intended that or not. An SVG made somewhere else The diagram comes from Figma, Illustrator, Inkscape, Visio or an architecture tool, and lands on the page as an attachment. It looks exactly as designed, which is why people do it. The catch is documented

Turning Data Into Decisions Bar charts, histograms, scatter plots, subplots, and plotting straight from pandas Previously learned to draw a line — literally. we now know how to create a figure, style it, and save it. But real analyst work rarely stops at trends over time. You'll need to compare categories , understand distributions , spot relationships between variables , and show several views of the data at once . That's exactly what today covers. Grab a coffee — let's turn raw numbers into charts that actually tell a story. 1. Bar Charts: Comparing Categories When to use one Bar charts are your go-to whenever you're comparing discrete categories against each other — regions, products, departments, months. If someone asks "which one is bigger?", a bar chart answers it instantly. The code import matplotlib.pyplot as plt regions = [ " North " , " South " , " East " , " West " ] revenue = [ 420 , 380 , 510 , 290 ] fig , ax = plt . subplots ( figsize = ( 7 , 5 )) ax . bar ( regions , revenue , color = " teal " ) ax . set_title ( " Revenue by Region " ) ax . set_xlabel ( " Region " ) ax . set_ylabel ( " Revenue ($K) " ) plt . show () A useful variant: horizontal bars When category names are long, flip the chart with barh() — it's far easier to read than squeezing labels sideways: fig , ax = plt . subplots ( figsize = ( 7 , 5 )) ax . barh ( regions , revenue , color = " darkorange " ) ax . set_title ( " Revenue by Region " ) ax . set_xlabel ( " Revenue ($K) " ) plt . show () Rule of thumb: categories on the x-axis → bar() . Long labels or many categories → barh() . 2. Histograms: Understanding Distributions Bar chart vs. histogram — don't mix them up This trips up almost every beginner: a bar chart compares separate categories. A histogram shows how continuous numeric data is distributed by grouping values into ranges called bins . There are no gaps between histogram bars by convention, because the x-axis is continuous, not categorical. The code import matplotlib.pyplot

A new identity theft service launched on the dark web this week is selling digital scans of more than 153 million drivers licenses from people in the United States and Canada. Based on interviews with individuals whose licenses are available for purchase on this service, it appears to be siphoning images collected by a widely-used identity verification company based in Louisiana. KrebsOnSecurity also has learned that the New Orleans field office of the Federal Bureau of Investigation (FBI) today launched an official inquiry into the source of the images.

When the average car could only do 40 mph, this Bentley could break 100.

Microsoft 365 and Outlook are still seeing service degradations on Tuesday, the company's status page indicates.

It's the lightest Bentley in 85 years.

Microsoft says it's testing a fix for the widespread Outlook issues that have led to email delays and failures.

The Battery-Free Smart Card Revolution: A Hands-On Review of NFC Energy-Harvesting MCU PCBs In professional networking, first impressions are everything. But in a landscape crowded with QR codes and cheap plastic tap-to-share cards, how does a high-tier developer, cybersecurity expert, or tech founder stand out? Enter the NFC Energy-Harvesting MCU PCB Business Card . It’s not just a card; it's a fully functional, battery-free embedded system packed inside a 1.6mm-thick piece of FR-4 fiberglass. In this review, we’ll dive deep into the tech behind passive RF power harvesting, explore the hardware stack making this possible, and evaluate whether building (or selling) these high-tech novelties is worth your time. What is an NFC Energy-Harvesting MCU PCB? At its core, this device is a printed circuit board (PCB) styled to the dimensions of a standard business card. However, unlike passive NFC tags that simply store a URL, this card integrates an onboard Microcontroller Unit (MCU)—such as the ultra-cheap WCH CH552 or Microchip ATTiny85 —and an array of LEDs or an e-paper display. The real engineering marvel? It has no battery. +-------------------------------------------------------------+ | [ NFC Coil Antenna ] -> (Harvests 13.56 MHz RF Field) | | | | | v | | [ Schottky Rectifier Bridge ] | | | | | v | | [ Voltage Regulator ] | | | | | v | | [ Ultra-Low Power MCU ] | | / \ | | v v | | [ Status LEDs ] [ Dynamic NFC payload ] | +-------------------------------------------------------------+ When tapped against an NFC-enabled smartphone, the phone's transmitter emits a magnetic field at 13.56 MHz . The trace antenna etched directly into the outer edges of the PCB acts as an inductor, harvesting this RF energy and converting it into AC electricity. This current is rectified to DC, regulated to a stable 3.3V, and powers up the MCU to execute its onboard program instantly. The Tech Stack: Under the Hood To truly appreciate these cards, we have to look at the components that m

The atmosphere in the room was dense, the kind where every whisper echoes. I was sitting in the third row of a local community center during a Friday prayer session, my head bowed in reflection. Suddenly, a high-pitched, synthetic ringtone shattered the silence. My pocket vibrated violently, sending a jolt of anxiety through my chest. I scrambled to silence it, but the damage was done; a dozen heads turned in my direction. I wasn't just embarrassed; I was frustrated with myself for the thousandth time for forgetting the simple task of toggling a silent switch. This wasn't an isolated incident. I found myself constantly caught in a cycle of human error. I would arrive at the office, launch into a deep-work sprint, and realize two hours later that my phone had been chirping with notifications through three separate meetings. Then, I would leave the office and forget to turn the ringer back on, missing urgent calls from family throughout the evening. The friction wasn't in the hardware; it was in the expectation that a human should perfectly manage a state machine that they interact with hundreds of times a day. I realized that my phone was intelligent enough to track my location, calculate prayer times, and sync my schedule, yet it remained stubbornly passive regarding its own audio profile. Most existing automation tools were either too heavy, draining the battery within hours, or relied on cloud-based triggers that failed the moment I lost signal. I wanted something that lived on the device, respected the user's privacy, and handled the transition between 'Silent', 'Vibrate', and 'Normal' states without me ever needing to touch the screen. The goal was simple: build a background service that watches the world and adjusts the phone's volume automatically. I needed an architecture that could handle geofencing, calendar events, and time-based triggers without turning the device into a space heater. When I started building the geofencing engine for Muffle, the immediate

What is ZeroDroid? ZeroDroid is an open-source Android toolkit that exposes the radios, sensors and connected-device capabilities already present in a phone. GitHub: https://github.com/theabhishekchandra/ZeroDroid What problems does it address? The app contains 29 tools across five areas: Wireless: Wi-Fi, BLE, NFC, Bluetooth Classic and peer-to-peer connections RF and signals: IR, UWB, SDR-device detection and ultrasonic analysis Sensors: GPS/GNSS, QR analysis, device sensors and magnetic anomalies Network: USB inspection, cell-tower information and wardriving Security: tracker scanning, hidden-camera indicators, rogue-AP detection, network scanning and deauthentication indicators Architecture ZeroDroid uses Kotlin, Jetpack Compose, Material 3, MVVM, StateFlow, Hilt and Room. Services are lazy-loaded, and scanning begins only when the user starts a tool. Important limitations A smartphone cannot guarantee that it has found every camera, tracker, bug or network threat. Several detections are heuristic and may produce false positives or miss threats. Hardware availability also differs between Android devices. The project is intended only for education, defensive security and testing devices or networks you own or are authorized to assess. Feedback wanted I am looking for: Compatibility reports from different Android phones Feedback about permission handling False-positive reports Contributions, tests and documentation improvements Repository: https://github.com/theabhishekchandra/ZeroDroid

The electric Torcal will be Bentley's entry model and cost less than a Bentayga.

AWS describes a specification-driven approach for composing flexible data workflows by separating intent from processing logic. Architecture uses declarative specifications, reusable processing capabilities, and validation before execution. AWS reports that the approach can reduce dataset onboarding from weeks to days while supporting traceability, versioning, data classification, and governance. By Leela Kumili

When you're building an AI evaluation platform with multiple microservices, the "core" services get all the attention — the evaluation engine, the scoring system, the RAG pipeline. But a platform doesn't work without the connective tissue: the workflow orchestration that keeps humans in the loop, the taxonomy engine that classifies tasks intelligently, the platform service that ties authentication together, and the evaluation suites that ensure models actually remember context. These four services don't make headlines, but they're what turned a collection of microservices into an actual platform. Here's what went into each one and why the engineering decisions mattered. Workflow Orchestration: The Human-in-the-Loop Engine AI evaluation is not fully automated — and it shouldn't be. Certain decisions require human judgment: Is this model response harmful? Does this evaluation rubric make sense for this domain? Is this edge case a genuine failure or acceptable behavior? The workflow orchestrator manages these decision points. It coordinates multi-step evaluation workflows where some steps are automated (LLM scoring, data validation) and others require human approval before the pipeline continues. The Architecture The core is a state machine built on FastAPI and PostgreSQL. Each workflow is a DAG (directed acyclic graph) of tasks, where each node can be: Automated: Runs immediately, calls another service (scoring, data enrichment), stores the result Human gate: Pauses the workflow, notifies the assigned reviewer via the notification service, waits for approval/rejection Conditional: Routes to different branches based on previous step outcomes (e.g., if confidence score < threshold, escalate to senior reviewer) State transitions are persisted in PostgreSQL with Alembic-managed migrations. Every transition is logged — who approved what, when, and with what context. This audit trail turned out to be critical for client reporting. Real-Time Updates with WebSocket The origin

If you are building an iOS app with Kotlin Multiplatform (KMP) or Compose Multiplatform, you might have opened your generated Shared.h header at some point and wondered why it is 20,000+ lines long. I ran into this recently while optimizing one of my personal KMP apps. I kept seeing Objective-C classes generated for every single theme color, dimension constant, and internal state model, even though my Swift code never touched any of them. To get a clear picture of what was actually going on, I built a small Gradle plugin called kmprofiler . It parses the generated Objective-C header, scans your Swift source files, and highlights which exported declarations have zero call sites in Swift. The numbers on my app caught me off guard, but cleaning it up took just a few minutes. Why does Kotlin/Native export so much? In Kotlin, declarations are public by default. When targeting iOS, the Kotlin/Native compiler looks at every public class, top-level function, and property in your shared module and creates an Objective-C class interface and runtime method trampolines in the framework binary. The compiler cannot dead-strip these automatically because Objective-C relies on dynamic dispatch. It has to assume Swift or Objective-C could call them at runtime. If your UI is built with Compose Multiplatform or your Swift app only interacts with a couple of high-level bridge interfaces, most of those exported Objective-C wrappers end up being dead weight. The Audit: 459 Exports, 282 Unused When I ran kmprofiler on my app (Framed), it gave me this breakdown: ### 📊 KMP iOS Export Profile Export surface: 459 Kotlin declarations exported to Objective-C. No direct Swift call site found for 282 of them (61.4% uncalled). The unused exports mostly fell into three buckets: File Facades ( *Kt classes): Top-level properties in files like Dimens.kt (38 spacing constants) or Color.kt generated synthetic Objective-C classes like DimensKt with static getters for every single constant. Internal UI St