标签：#data

As the AI Engineer World’s Fair kicked off officially on Monday, the halls were filled for the...

Modern web application architectures typically run each layer in its own process, like a NodeJS server and database both running in their own processes. They communicate via a network connection or localhost socket. This separation introduces protocol overheads, TCP stack latency, and data serialization/deserialization costs on every single query. Planck is designed around the concept of Zero-Distance Architecture that co-locates data and application code. It combines the database engine and a WebAssembly application runtime into a single, unified process. By running your application code directly inside the database process, database calls become direct in-memory function calls rather than network round-trips. This article provides a practical guide to getting started with Planck. We will look at the core toolchain, walk through setting up a self-contained local benchmark, compare its performance against a NodeJS, ExpressJS, MongoDB stack, and look at how to build more complex features. The Toolchain: Planck, planctl, and Workbench Running and managing a zero-distance app requires three main components. Planck itself is the core binary. It functions as both the storage engine (a WiscKey-style, LSM-tree-based engine) and the WebAssembly host. Instead of running a database in one process and your application server in another, you run a single Planck process. It loads your compiled WebAssembly application directly into its memory, running it in the same process space as the database. To manage this runtime, you use planctl. This is the command-line tool for developers. It handles the compilation of your code, packages it, and deploys it to the Planck host. It also allows you to perform database operations, like creating stores and defining indexes, export/import, backup/restore directly from your terminal. Finally, there is the Workbench. This is a web console that comes built into the platform. It provides a visual dashboard to monitor your applications, view databa

A database without relationships is just a spreadsheet with delusions of grandeur. If you've ever stared at a Power BI report showing wrong numbers...totals that don't add up, filters that filter nothing, there's a good chance your data model was broken. Not a bug. Just two tables that should've been talking to each other… and weren't. This is your practical guide to data modeling, schemas, relationships, and joins in Power BI, what they are, how they connect, and how to stop getting burned by them. What Is Data Modeling and How Does It Work? Data modeling is the process of defining how your tables connect to each other inside Power BI's engine (called VertiPaq). Think of it like drawing a map between your tables, telling Power BI this column in Table A is the same thing as this column in Table B. When you load multiple tables into Power BI, it doesn't automatically know they're related. A Sales table and a Products table, sitting separately, can't filter each other. Data modeling builds the bridges. Power BI's model view lets you: Define relationships between tables Set cardinality and cross-filter direction Build star or snowflake schemas Create calculated columns and measures using DAX Under the hood, Power BI compresses and stores each column separately ( columnar storage ). Relationships are resolved in-memory at query time, which is why a well-structured model is blazing fast, and a messy one will bring your report to its knees. Key Concepts | Concept | What It Means | |--------------------------|-----------------------------------------------------| | Fact Table | Stores measurable events (sales, transactions, logs)| | Dimension Table | Stores descriptive context (products, customers) | | Primary Key (PK) | Unique identifier column in a dimension table | | Foreign Key (FK) | Column in a fact table referencing a PK in a dim | | Relationship | The defined link between a PK and FK across tables | | Cardinality | Describes how many rows on each side match | | Cro

South Korea targets physical AI lead and commercial humanoid robots by 2028.

The Database resource in Oracle Cloud Infrastructure Database service provides an optional auto_backup_window option in its API during creation ( Terraform resource: oci_database_database ). The database resource can be used in an OCI Base DB system or Exadata Cloud VM Cluster pluggable database (PDB) for example. The time window enum value selected for initiating automatic backup for the database system is available in twelve two-hour UTC time windows as the following: Slot Description SLOT_ONE 12:00AM - 2:00AM UTC SLOT_TWO 2:00AM - 4:00AM UTC SLOT_THREE 4:00AM - 6:00AM UTC SLOT_FOUR 6:00AM - 8:00AM UTC SLOT_FIVE 8:00AM - 10:00AM UTC SLOT_SIX 10:00AM - 12:00PM UTC SLOT_SEVEN 12:00PM - 2:00PM UTC SLOT_EIGHT 2:00PM - 4:00PM UTC SLOT_NINE 4:00PM - 6:00PM UTC SLOT_TEN 6:00PM - 8:00PM UTC SLOT_ELEVEN 8:00PM - 10:00PM UTC SLOT_TWELVE 10:00PM - 12:00AM UTC Timezone used for the slots is always UTC regardless of the timezone used in the database. For example, if the user selects SLOT_TWO from the enum list, the automatic backup job will start in between 2:00 AM (inclusive) to 4:00 AM (exclusive) If no option is selected, a start time between 12:00 AM to 7:00 AM in the region of the database is automatically chosen. Reference Terraform resource: oci_database_database OCI API Reference: Database DbBackupConfig Safe harbor statement The information provided on this channel/article/story is solely intended for informational purposes and cannot be used as a part of any contractual agreement. The content does not guarantee the delivery of any material, code, or functionality, and should not be the sole basis for making purchasing decisions. The postings on this site are my own and do not necessarily reflect the views or work of Oracle or Mythics, LLC. This work is licensed under a Creative Commons Attribution 4.0 International License (CC-BY 4.0) .

The Trump administration's moves threaten $121 billion in new solar and wind power, two energy sources that are the biggest contributors to new capacity in the U.S.

The GitHub Advisory Database is processing more vulnerability reports than ever before. Here's what's driving the surge, how we're responding, and how the community can help. The post Inside the Advisory Database and what happens when vulnerability volume breaks records appeared first on The GitHub Blog .

Target built a generative AI system to improve marketing campaign forecasting by retrieving and ranking similar historical campaigns. Using embeddings, vector search, and LLM ranking, it replaces rule-based workflows. Evaluation shows 75% top-1 and 100% top-3 coverage. The system reduces manual effort, improves consistency, and uses feedback loops to refine retrieval using campaign outcomes. By Leela Kumili

You export a CSV from a UK system and double-click it in US Excel — 28/05/2026 suddenly looks like May 28, or something even stranger. The file isn't corrupt. Excel is guessing your date format based on your computer's locale. This short guide covers why that happens, how to import CSV correctly, and how to batch-fix dates that are already wrong. For the full walkthrough with examples, see the official guide: How to Fix Excel CSV Date Import Problems . Why Excel breaks CSV dates A CSV is plain text. It does not store whether a value is a date or a string. When you double-click to open, Excel parses using your regional settings: US Excel: MM/DD/YYYY UK / Europe: DD/MM/YYYY Dates like 03/04/2025 are the most dangerous — both parts are ≤ 12. US Excel may read April 3; UK Excel reads March 4. Excel won't warn you. Other common traps: Dates exported as serial numbers (e.g. 44927 ) Two-digit years triggering century guesses Re-saving as CSV destroys formats a second time The right way: don't double-click the CSV Open Excel first — don't double-click the .csv file Data → Get Data from Text/CSV (older Excel: Data → From Text) Set date columns to Text if you need to preserve the original string Confirm the source region (US / UK), then convert to a single format For team data exchange, agree on ISO 8601: YYYY-MM-DD in your schema — unambiguous, sorts correctly as text, and works in JSON APIs and databases. Ambiguous value US reads as UK reads as Safe format (ISO) 03/04/2025 2025-04-03 2025-03-04 Confirm source region 28/05/2026 — 2026-05-28 2026-05-28 05/28/2026 2026-05-28 — 2026-05-28 Already broken? Fix dates in the browser (no server upload) I built a free tool cluster on FormatList — everything runs locally in your browser : 1. Date Format Fixer — bulk repair Paste a date column or upload .csv / .txt Ambiguous rows highlighted; optional US / UK preference Export ISO / US / UK or download a fixed CSV Best for: normalizing a whole column to ISO before a database or API imp

Denormalization has been the standard approach to analytical data modeling for good reason. Moving joins, lookups, and business rules out of query time and into ingestion gives you the fastest possible reads for a known access pattern. For most of the past decade, it was often the practical default for latency-sensitive analytics. Earlier columnar engines and distributed query processors could execute joins, but many workloads paid for them through higher latency, higher compute cost, spill-to-disk, or distributed coordination overhead. That constraint has loosened. Modern columnar databases with advanced join algorithms have reduced the cost of runtime joins enough that normalization is now a genuinely viable option for many analytical workloads. Denormalization still delivers faster reads, but normalization can bring operational benefits: simpler pipelines, flexible schemas, and cleaner governance. Engineers can now make the decision based on their actual workload characteristics, rather than being forced into one approach by engine limitations. This guide is a decision framework for making that choice in ClickHouse. It starts with why denormalization became the default, explains what has changed in join performance, then compares the tradeoffs on both sides so you can decide where to denormalize, where to join, and where to use ClickHouse primitives that bridge the gap. For a broader evaluation framework covering latency, concurrency, ingest throughput, SQL flexibility, and cost across real-time OLAP options, see our guide to choosing a database for real-time analytics in 2026 . For a deeper comparison of how ClickHouse executes star schema joins against Druid, Pinot, and cloud DWHs, see our star schema and fast joins guide . TL;DR Denormalization and normalization are both valid modeling strategies. The right choice depends on your workload. Denormalization's tradeoffs are primarily operational : pipeline complexity, write-path overhead, data freshness lag, back

Have you ever wondered how apps like university portals know which courses a student is enrolled in, or how they pull up an instructor's full schedule in seconds? The answer lies in database relationships - one of the most important concepts in backend development. In this article, we'll explore: What database relationships are and why they matter The three types of relationships: One-to-One, One-to-Many, and Many-to-Many How relationship schemas work (primary keys, foreign keys) How SQL Joins let you pull connected data from multiple tables To keep things grounded, we'll use one running example throughout: a University Management System . By the end, you won't just understand the theory, you'll see exactly how these concepts connect in a real-world scenario. What Are Database Relationships? A database relationship defines how data in one table connects to data in another. Instead of storing the same information repeatedly, relational databases organize data into separate tables and link them using keys . Think about our university system. We have a table for students and another for courses . A student can enroll in multiple courses, and each course can have many students. Rather than storing a student's full details on every course record, we store the student's info once and create a relationship between the two tables. This keeps data clean, reduces duplication, and makes updates easy. If a student's email changes? Update it in one place - done. Here's a simple visual of what that looks like: +------------------+ +------------------+ | Students | | Courses | +------------------+ +------------------+ | student_id (PK) | | course_id (PK) | | name | | title | | email | | credits | +------------------+ +------------------+ \ / \ / \ / Enrollments (links students ↔ courses) Now let's look at the three types of relationships you'll encounter. Types of Database Relationships 1. One-to-One (1:1) Each record in Table A matches exactly one record in Table B and vice versa

I recently completed an exploratory data analysis project on the NHANES (National Health and Nutrition Examination Survey) dataset from Kaggle. It's a real-world health survey collected by the CDC covering body measurements, lifestyle habits, and demographic data from thousands of US adults. In this article I'll walk you through exactly what I did — from loading and cleaning the data all the way to running statistical tests — and share what I found along the way. The Dataset The dataset has 5,735 rows and 28 columns , but for this project I focused on 8 columns that were relevant to the questions I wanted to answer: Column Description smoking Has the person smoked at least 100 cigarettes? gender Male or Female age Age in years education Highest level of education weight Weight in kg height Height in cm bmi Body Mass Index Step 1 — Loading and Selecting Columns import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns db = pd . read_csv ( ' NHANES.csv ' ) data = db . loc [:, ( ' SEQN ' , ' SMQ020 ' , ' RIAGENDR ' , ' RIDAGEYR ' , ' DMDEDUC2 ' , ' BMXWT ' , ' BMXHT ' , ' BMXBMI ' )] data = data . rename ( columns = { ' SEQN ' : ' id ' , ' SMQ020 ' : ' smoking ' , ' RIAGENDR ' : ' gender ' , ' RIDAGEYR ' : ' age ' , ' DMDEDUC2 ' : ' education ' , ' BMXWT ' : ' weight ' , ' BMXHT ' : ' height ' , ' BMXBMI ' : ' bmi ' }) One thing worth knowing about NHANES: all the columns come in as numeric codes. 1 means Male, 2 means Female. 1 means the person smoked, 2 means they didn't. You have to map these to readable labels before doing any analysis, otherwise your charts are meaningless. Step 2 — Cleaning the Data Drop the ID column and remove nulls data . drop ( ' id ' , axis = 1 , inplace = True ) data . dropna ( inplace = True ) This brought us from 5,735 rows down to 5,406 — about 6% lost, which is acceptable. Remove outliers using the IQR method The IQR (Interquartile Range) method flags values that fall too far outside the middle 50% of

I Built a Free Apache Kafka Course from Scratch — Here's the Full Curriculum (and What I Got Wrong) I spent months building a free Apache Kafka course covering everything from first principles to a real-time analytics platform final project. No paywall. No "premium tier." 9 modules, 470 minutes of content, completely free. Here's the full syllabus, the Python code that actually works, and the honest mistakes I made building the curriculum — so you don't repeat them. Why I Built This Every time someone asked me "how do I learn Kafka?", I sent them to the same 3 places: The official Confluent docs (dense, assumes you already know what you're doing) A $15 Udemy course that spends Module 1 explaining what a computer is A YouTube playlist where half the videos are deleted None of them answered the real question beginners have: why does Kafka exist, and what problem does it actually solve before I write a single line of code? That's the gap I built for. The Problem With Most Kafka Tutorials Most tutorials start with: "Kafka is a distributed event streaming platform..." And then they immediately show you a Docker Compose file with 6 services. Beginners copy-paste it, something breaks, they don't know why, they quit. The real problem is that Kafka is an answer to a specific architectural problem — and if you don't understand the problem first, the solution makes no sense. So Module 1 and 2 of this course don't touch Kafka at all. They build the problem statement from scratch. The Full Syllabus (9 Modules, 470 Minutes) Module 1: Introduction to Kafka — 35 min Not "what is Kafka" — but why event streaming exists at all. What breaks in traditional request-response architectures at scale. Module 2: The Problem Statement — 30 min A real-world scenario: you're building an e-commerce platform. Orders, inventory, notifications, analytics — all tightly coupled. What happens when one service goes down? This module makes the pain visceral before Kafka enters the picture. Module 3: How

The decision to migrate an on-premises database to the cloud is rarely a simple one. It touches infrastructure, budget, team workflows, and application uptime all at once. Yet for most organizations, moving your on-premises database to the cloud is no longer a question of if but when — and more importantly, how to do it without bringing production systems to their knees. Whether you're running PostgreSQL on bare metal or SQL Server in a company-owned data center, the path to cloud-hosted data has predictable pitfalls and, when navigated carefully, significant payoffs. This guide walks through the full migration process: from pre-migration assessment to post-migration validation, with real configuration examples and the kind of hard-won detail that vendor documentation tends to skip. Why Organizations Make the Move On-premises databases carry hidden costs that compound over time. Hardware refresh cycles, licensing renewals, physical security, power, and cooling — these expenses are easy to underestimate when they're already baked into the operating budget. Cloud databases shift that burden to a consumption model, where you pay for what you use and scale without a procurement cycle. Beyond cost, there's the question of availability. Cloud providers like AWS, Google Cloud, and Azure run managed database services with built-in replication, automated failover, and point-in-time recovery that would take a dedicated DBA weeks to configure manually. A startup can get enterprise-grade durability out of the box. A mid-sized company can stop worrying about what happens when a hard drive fails at 2 a.m. Performance is another draw — though it comes with caveats. Managed cloud databases excel at read-heavy workloads and benefit from proximity to cloud-native application services. Latency-sensitive operations or highly custom storage configurations sometimes perform better on dedicated hardware. Knowing which category your workload falls into is the first real question to answer.

The opening kickoff of Super Bowl LVII was still three weeks away when sharp bettors began their work. While casual fans were scrolling through prop bets and debating quarterback matchups on social media, a handful of disciplined bettors with sophisticated models were already identifying the first exploitable edges. Within hours, sportsbooks registered the shift: Kansas City opened at -2.5, but sharp action pushed the line to -3. By game day, it had settled at -2.5 again after public money flooded in on the Chiefs. This seemingly minor dance of numbers contains profound lessons about market efficiency, behavioral psychology, and where consistent value in sports betting actually exists. The difference between sharp money and public money isn't merely a matter of skill—it's a window into how financial markets process information in real time. For researchers, data scientists, and anyone interested in understanding how markets function under uncertainty, betting lines offer a peculiar advantage: instantaneous, objective outcomes. You can know within hours whether your hypothesis was correct. This article explores what line movement data reveals about market inefficiencies, the methodology behind detecting them, and what this teaches us about information asymmetry in competitive markets. The Hidden Market Beneath the Surface Most bettors see a line and make a decision: is this price fair or favorable? But they miss the crucial information happening before they ever see that number. Sportsbooks don't set lines based on game probability—they set them based on where they predict the money will flow. This distinction transforms betting markets into fascinating research subjects. Consider the structure: A sportsbook's primary goal isn't prediction; it's profit through balanced exposure. They're market makers, not forecasters. When sharp bettors arrive first with informational advantages, they move the line. When public money arrives later with no informational advantage but

When the referee checks their watch in the 85th minute, something predictable happens in soccer—but almost nobody is modeling it correctly. I spent three months analyzing 1,085 professional soccer matches using StatsBomb's open data, focusing specifically on goal-scoring patterns in the final 15 minutes of regulation play and stoppage time. What I found challenges the conventional wisdom that late goals are chaotic, random events determined purely by desperation and fortune. Instead, the data revealed a structured pattern that, when properly identified, has produced an 79.3% accuracy rate in backtesting across multiple leagues and seasons. The bookmakers aren't missing this pattern because the pattern doesn't exist—they're missing it because it requires looking at the problem completely differently than traditional sports analytics approaches it. The Setup: Why Late Goals Matter Before diving into methodology, let's establish why this question even matters. Late goals are the most emotionally charged moments in soccer. They're also economically significant. A goal in the 88th minute creates a cascade of outcomes: It flips match results It triggers goal-line drama and potential VAR decisions It creates dramatic shifts in market odds It validates or destroys betting positions The conventional narrative treats late goals as the result of two factors: increased urgency from trailing teams and increased vulnerability from leading teams. This is directionally correct but strategically useless. It's like saying "stock prices move when sentiment changes"—technically true, but not actionable. The real question isn't whether late goals happen more frequently. The real question is: which teams score them, under which specific conditions, with what measurable precursors? Methodology: Building the Dataset I used StatsBomb's open data repository, which contains event-level information from 1,085 professional matches across multiple seasons and competitions. StatsBomb's data inclu

The Night Everything Changed It was 87 minutes into a Premier League match. The score was 1-1. The home team had controlled possession for most of the second half, but their shots were consistently blocked or saved. Then something happened that's been happening for decades, yet nobody seems to adequately explain it: a late goal completely shifted the match outcome. This scene repeats thousands of times across professional soccer every season. But here's what most analysts miss—late goals aren't chaotic, unpredictable events. They follow patterns. Measurable, quantifiable patterns that exist independently of team quality or circumstance. Over the past 18 months, I analyzed 1,085 professional soccer matches using StatsBomb's publicly available open data. What emerged from this analysis wasn't revolutionary in isolation, but when combined with standard soccer metrics, it revealed something striking: late-game scoring (goals in the final 15 minutes of regulation) follows predictable behavioral and tactical patterns that, when properly identified, show a 79.3% correlation with specific pre-match and in-match conditions. This isn't about predicting individual goals with certainty. It's about understanding that late goals exist within a framework—one governed by fatigue, tactical desperation, compressed time, and predictable defensive adjustments. And once you see this framework, you can't unsee it. The Data Foundation Before diving into patterns, let me establish what we're working with. StatsBomb's open data includes detailed shot maps, pass completion sequences, player positioning, and event-by-event timelines from top-tier professional matches. When they made portions of this data publicly available, it created an unusual opportunity: examining thousands of matches with granular timing and contextual information. My analysis focused specifically on: 1,085 professional matches across five seasons (2017-2022) Shot events in the final 15 minutes of regulation (minutes 75-

Hello Dev Community! 👋 It is officially Day 76 of my 100-day full-stack engineering streak! For the past several weeks, I have been heavily immersed in NoSQL databases, using MongoDB documents to back my full-stack clones. Today, I decided to broaden my database engineering skill set by taking a deep dive into Relational Databases (SQL) ! 📊⚡ Stepping out of flexible JSON-like structures and adjusting to rigid, highly optimized tables is an essential step for any well-rounded backend developer. 🧠 What I Learned Today: SQL vs. NoSQL Before writing code, I mapped out the core architectural differences between the two paradigms: Feature NoSQL (e.g., MongoDB) SQL (e.g., MySQL / PostgreSQL) Data Model Flexible, schema-less collections & documents. Strict table-based structures with rows & columns. Relationships Typically nested embedded sub-documents or references. Explicit Relational Mapping via Primary & Foreign Keys. Scaling Horizontally scalable (distributed sharding across nodes). Vertically scalable (requires increasing horsepower on one machine). Transactions Great for high-write, unstructured or dynamic data shapes. Strict ACID compliance, making it excellent for financial or tabular data. 🛠️ Analyzing My First Query Block on Day 76 As showcased in "Screenshot (174).png" , I configured an entire relational lifecycle inside an independent database script: 1. Database Provisioning & Focus Selection I initialized the data cluster safely using standard syntax constraints to ensure execution safety and loaded the working context into the active engine: sql CREATE DATABASE IF NOT EXISTS XYZ_Company; USE XYZ_Company;CREATE TABLE employee_info ( id INT PRIMARY KEY, name VARCHAR(30), SALARY INT );

The sportsbook odds for UFC 287 showed Sean Strickland at +340 against Dricus du Plessis. Most bettors saw a reasonable risk-reward opportunity. What they didn't see—what the market systematically misses—is that fighters in Strickland's exact statistical profile win substantially more often than their odds suggest. When Strickland knocked out du Plessis in the second round, it wasn't luck. It was a textbook case of market inefficiency that data reveals happens repeatedly in MMA. I spent six months building a comprehensive dataset of 500 UFC fights, cross-referencing striking accuracy, takedown defense, fight duration patterns, and historical betting odds against actual outcomes. What emerged was clear: the UFC betting market is inefficient in predictable ways. Certain underdog profiles generate consistent positive return on investment (ROI) that would be impossible if prices reflected true win probabilities. This isn't hindsight bias or cherry-picked examples. This is systematic analysis of where prediction markets get MMA wrong—and how you can identify it before the bell rings. The UFC Analytics Ecosystem: Why Data Matters More Than Ever Five years ago, serious MMA analytics barely existed outside Reddit threads and YouTube channels. Today, the landscape has transformed completely. UFCStats.com provides granular fight data that didn't exist in the sport's early years. Betting markets across DraftKings, FanDuel, and international books generate millions in handle. Meanwhile, fighter training data, coaching staff analytics, and institutional scouting reports are becoming increasingly sophisticated. Yet there's a persistent gap between information availability and information utilization . The casual bettor sees a -250 favorite and assumes the math is settled. Sportsbooks, operating on relatively thin margins and managing liability across thousands of bets, often make conservative assumptions. They price based on public perception, recent results, and popularity rathe

Everyone is sick of spam calls and creeper sites that show weirdos where you live—but can any service solve it?