标签：#us

GitHub热门项目 | Turso is an in-process SQL database, compatible with SQLite. | Stars: 20,044 | 774 stars today | 语言: Rust

Il pensiero di Popper si intreccia con diversi autori in modi che illuminano il rapporto tra tecnologia, potere e libertà. Hannah Arendt Arendt condivide con Popper l'attenzione per la società aperta, ma la declina in termini di azione politica piuttosto che epistemologici. Dove Popper vede la chiusura come rifiuto della falsificazione, Arendt la vede come perdita dello spazio pubblico dove gli individui appaiono come agenti plurali. L'AI che automatizza decisioni politiche o sociali rischia di eliminare proprio questo spazio di apparizione — non c'è più un "chi" che agisce, ma un "cosa" che calcola. Il banale della tecnocrazia, per Arendt, può essere altrettanto pericoloso del male radicale. Theodor Adorno e Max Horkheimer La Dialettica dell'illuminismo offre un intreccio più critico con Popper. I due della Scuola di Francoforte vedevano la ragione strumentale — quella che calcola mezzi per fini prefissati — come il germe del dominio moderno. Popper difendeva invece la ragione critica come antidoto al totalitarismo. Il punto di tensione è rilevante per l'AI: se l'intelligenza artificiale è pura ragione strumentale ottimizzata, rientra nella diagnosi frankfurtiana più che in quella popperiana. La risposta popperiana sarebbe che l'AI può essere strumento di criticismo se aperta alla confutazione e al controllo democratico. Norbert Wiener Il fondatore della cibernetica condivide con Popper la preoccupazione per i sistemi che sfuggono al controllo umano. Wiener, già negli anni Cinquanta, avvertiva che le macchine intelligenti potrebbero imporre obiettivi incompatibili con i valori umani. Popper avrebbe riconosciuto in questo un caso di teoria non falsificabile: un sistema che apprende senza possibilità di essere corretto dall'esterno è un dogma tecnologico. Entrambi insistono sul human-in-the-loop , anche se Wiener lo motiva in termini di stabilità dei sistemi, Popper in termini di libertà. Michel Foucault Foucault aggiunge una dimensione che Popper lascia in ombra: il

Working with AI Means Thinking More, Not Less Yes, this text is long. Yes, it repeats itself in places. I did not clean that up. A text that sounded too smooth while arguing that AI forces you to think more, not less, would be at least slightly dishonest. This is not fast food for quick consumption. And yes, don’t worry: you won’t hear anything especially new here. That is part of the problem too. There is a popular and very seductive story about AI in software development. Now that the machine can write code, the human gets to think less. You just point it in the right direction, and the model will quickly and cheaply do a significant part of the work on its own. In that picture, AI is primarily an accelerator for code production, and human thinking gradually shifts from necessity to optional extra. I keep feeling more and more strongly that this description is dangerously wrong. A more accurate formula for my own experience right now is this: I’m the tech lead, the AI is the entire team in one body . And if you take that metaphor seriously, the conclusion is the exact opposite of the mainstream narrative. Working with AI is not a way to think less. It is a mode in which you need to think more, not less . Not because the AI is bad. But because it is too good at one very treacherous thing: it confidently and smoothly fills in what was left unsaid. I’m the tech lead, the AI is the team At first this metaphor felt like a neat formulation. Now it feels like a literal description of what is going on. If you treat AI as a very fast and very capable executor, a lot of things become clearer immediately. It really can wipe out months of routine work. It can spin up prototypes quickly, take over test scaffolding, try out alternatives, make local edits, help break a task into parts, and sometimes even suggest a decent direction. On the surface, this really does look like a silver bullet. Especially if the human knows the stack and can read code. The pace becomes so extreme th

Dalla libreria embedded che ha invaso ogni dispositivo a un’implementazione moderna con concorrenza, async I/O e vector search: cosa cambia davvero per chi sviluppa app. Nel frontend e nel full‑stack capita spesso di parlare di database come servizi: Postgres gestito, cluster, repliche, connessioni, pooling, credenziali e una lunga lista di “cose che possono rompersi”. Ma esiste un’altra filosofia, più vicina all’idea di “dipendenza” che di “infrastruttura”: un motore SQL che vive dentro l’applicazione. Questa è la ragione per cui SQLite è ovunque. È una libreria, non un server. Legge e scrive su un singolo file su disco. Riduce drasticamente configurazione, porte, processi separati e complessità operativa. Ed è proprio questa semplicità a renderla una delle fondamenta silenziose dell’informatica moderna: la usi in browser, smartphone, desktop app, tool CLI, IoT… spesso senza nemmeno accorgertene. Ora immagina di riscrivere tutto da capo, in Rust, cercando di essere compatibile al 100% e allo stesso tempo più “moderna”. Sembra un’idea folle per definizione—finché non inizi a guardare ai limiti pratici che oggi emergono in molte applicazioni. Perché toccare SQLite, se funziona così bene? SQLite non è “il problema”. Anzi: è considerata estremamente robusta perché è conservativa, minimalista, e custodita con un rigore quasi maniacale. Il punto è un altro: il suo modello di sviluppo e manutenzione è atipico rispetto a quello che molti intendono per open source collaborativo . Il codice è disponibile e utilizzabile liberamente, ma l’evoluzione è guidata da pochissime persone e—di fatto—non segue la dinamica classica delle contribution esterne. Questa scelta ha un effetto collaterale positivo: riduce il rischio di regressioni introdotte da cambiamenti non coerenti con la visione del progetto. Ma ha anche un costo: se la tua azienda o il tuo prodotto hanno esigenze nuove (concorrenza più spinta, I/O non bloccante, funzionalità specifiche), “aspettare che arrivi upstream” n

The cycle number on a lithium battery's spec sheet is true and almost useless, because it describes a life the battery will live only in a temperature-controlled lab being cycled gently by a machine that never has a bad day. A cycle, in that test, means a full charge and a full discharge under mild, steady conditions, repeated until the pack fades to some fraction of its original capacity, often eighty percent. Your warehouse does none of that. It charges in bursts, discharges to whatever the shift demanded, bakes the pack in summer and chills it in winter, and counts a cycle as whatever happened between two plug-ins. Depth is the lever nobody quotes The single biggest mover of cycle count is how deep you run the pack on each outing, and that figure almost never shares the page with the headline number that sells the battery. The relationship is steeply nonlinear, which is the part that surprises people. Drain a lithium pack to nearly empty every time and you spend cycles fast. Use the top half and tuck it back on charge, and the same cell can deliver many times the number of shallow cycles before reaching the same faded state. The chemistry is mechanical about it: every deep swing stretches and contracts the electrode structures further, and the wider the swing the more wear each one inflicts. Two fleets on identical batteries can see lifespans years apart purely from how hard they drain them. This is why opportunity charging does double duty. It keeps the truck running, and it keeps each cycle shallow, which stretches the pack's life as a side effect. It also means a published cycle figure measured at full depth understates what a top-up fleet will see, while a figure measured shallow oversells what a run-it-flat operation will get. The same battery, the same number, two outcomes the sheet never warned you about. You have to know the test depth to know what the promise means. Heat is the other clock Cycles are only one of two clocks ticking on a battery, and the s

Manually converting invoice data from PDF or Excel files into CSV format is one of the most time-consuming tasks in accounting and data management workflows. It often involves repetitive copy-pasting, formatting adjustments, and a high risk of human error. In many real-world scenarios, invoices arrive in different formats such as PDF, XLS, XLSX, or even HTML. Handling them individually can slow down reporting pipelines and create inconsistencies in structured data storage. The Problem with Manual Conversion Traditional invoice processing usually involves: Extracting line items manually from PDFs Reformatting Excel sheets for database compatibility Fixing inconsistencies in columns and values Rechecking for missing or misaligned data As invoice volume increases, these tasks quickly become inefficient and error-prone. Automated Approach to Invoice Conversion A more efficient approach is using tools that automatically parse invoice documents and convert them into structured CSV format. These tools typically: Read multiple file formats (PDF, XLS, XLSX, HTML) Detect table structures and line items Normalize data into rows and columns Export clean CSV files ready for spreadsheets or databases For example, uploading a multi-page invoice PDF can result in fully structured rows representing each item, without manual formatting adjustments. Why CSV Output Matters CSV remains one of the most widely used formats for: Accounting software imports Database ingestion Data analysis workflows Spreadsheet processing Having clean CSV output ensures compatibility across systems and reduces preprocessing work. Practical Impact Automating invoice-to-CSV conversion helps reduce: Repetitive manual data entry Formatting inconsistencies Processing time for bulk invoices It also improves accuracy when handling large datasets. Closing Note As data-driven workflows become more common in finance and operations, automating repetitive tasks like invoice conversion can significantly improve efficien

Đối với một developer, trackpad không chỉ là thiết bị điều hướng mà còn là công cụ tối ưu hóa workflow. Khi làm việc với các IDE nặng như VS Code hay IntelliJ, khả năng phản hồi của trackpad quyết định tốc độ xử lý tác vụ. Trong bài so sánh giữa ROG Zephyrus G14 GA403 hay MSI Creator 16 AI? Đâu là lựa chọn cho sáng tạo chuyên nghiệp? , trải nghiệm trackpad là một điểm nhấn quan trọng. Trải nghiệm cử chỉ và độ chính xác trong lập trình Khi làm việc với code, các cử chỉ như chuyển đổi desktop ảo (Virtual Desktops) là cực kỳ quan trọng để tách biệt môi trường chạy Docker, trình duyệt và editor. Vuốt 3-4 ngón: Cả hai dòng máy đều hỗ trợ tốt, nhưng trên MSI Creator 16 với diện tích lớn hơn, việc nhận diện cử chỉ vuốt ngang giữa các workspace mượt mà hơn đáng kể. Độ chính xác chọn văn bản: Với một developer, việc bôi đen một đoạn code dài hoặc chọn chính xác một ký tự nhỏ là yếu tố sống còn. Trackpad trên G14 có độ nhạy cao nhờ kích thước gọn nhẹ, trong khi Creator 16 cho cảm giác vững chãi, ít bị trượt hơn khi thao tác nhanh. Độ trễ (Latency): Cả hai đều đạt chuẩn cao, tuy nhiên trên Windows, trải nghiệm đôi khi không mượt bằng macOS. Để khắc phục, việc sử dụng driver tùy chỉnh là cần thiết. So sánh hệ điều hành và mẹo cấu hình cho Developer Trải nghiệm trackpad thay đổi rõ rệt giữa Windows và Linux : Windows: Hỗ trợ tốt Precision Drivers. Bạn nên vào Settings > Bluetooth & devices > Touchpad để tinh chỉnh độ nhạy.\n- Linux: Nếu bạn dùng Ubuntu hay Fedora, hãy cài đặt libinput . Để tối ưu hóa cho workflow code, bạn có thể cấu hình file .wslconfig nếu chạy môi trường Windows Subsystem for Linux nhằm đảm bảo tài nguyên không bị nghẽn khi thao tác giao diện.\n Thông số kỹ thuật tóm tắt: ROG Zephyrus G14 GA403: Ryzen 9 8945HS, RTX 4070, 32GB LPDDR5X, OLED 14" 120Hz, nặng 1,5 kg. MSI Creator 16 AI Studio: Core Ultra 9 185H, RTX 4080/4090, lên đến 64GB DDR5, Mini LED 16" 120Hz, nặng 2,1-2,5 kg. Bài viết này là bản tóm tắt kỹ thuật. Xem chi tiết tại bài gốc.

Event Handling Basics in euv Project Code： https://github.com/euv-dev/euv euv is a Rust + WASM frontend UI framework that enables developers to build interactive web applications using the power of reactive signals and the html! macro. One of the most critical aspects of any UI framework is how it handles user interactions. In this article, we will take a deep dive into euv's event handling system — from inline closures to native event handlers, from input events to form changes, and from the comprehensive list of supported event names to utility functions that simplify common patterns. Table of Contents Inline Closure Events NativeEventHandler Input Events Form Change Events Supported Event Names Accessing Event Data Utility Functions for Event Handling Putting It All Together Inline Closure Events The most straightforward way to handle events in euv is through inline closures. You define the event handler directly within the html! macro using the move |event: Event| { ... } syntax. html! { button { onclick : move | event : Event | { } "Click me" } } This pattern is ideal for simple, self-contained event handlers that don't need to be reused across multiple components. The move keyword ensures that any captured variables (like signals) are moved into the closure, which is essential for the Rust ownership model. Inline closures work with any event type — not just onclick . You can use them for keyboard events, focus events, mouse events, and more. The closure receives an Event object that you can inspect to extract relevant data. NativeEventHandler For more complex scenarios where you need reusable event handlers or want to define handlers outside the html! macro, euv provides the NativeEventHandler type. This allows you to create named, parameterized event handler functions. pub fn counter_on_increment ( counter : Signal < i32 > ) -> NativeEventHandler { NativeEventHandler :: create ( "click" , move | _event : Event | { let current : i32 = counter .get (); counter

Fusion startups have raised $7.1 billion to date, with the majority of it going to a handful of companies.

A finance bot kept issuing refunds in a loop because nobody built a way to stop it. Clean code. Sound logic. No off switch. A small bug became a long night. Here is the opinion most teams do not want to hear. Building the agent is the easy 80 percent. That off switch is the 20 percent that decides whether you can ship it at all. We celebrate the wrong milestone. Picture the demo where the agent books the meeting, writes the email, updates the record. That part is genuinely fun to build and genuinely easy now. Harder is the boring question nobody claps for. What happens when it is wrong, fast, and confident. An AI agent is not a chatbot. It takes actions in the real world. It spends money, deletes rows, messages real people, moves files. Wrong answers in a chat are annoying. A wrong action at machine speed is an incident with your name on it. So before features, I build the stop. One real kill switch is not a single button. Think of it as a small set of bounds that live from the first version. A spend ceiling, so a retry loop cannot drain the account A blast radius limit, so one task can never touch more than it should A human gate on anything irreversible, so the agent proposes and a person commits A global stop that halts everything in one move, with no redeploy None of that is glamorous. All of it is what lets you sleep at night. Teams skip this for a reason that feels rational in the moment. Bounds feel like negative work. They never show up in the demo. Your agent runs fine without them right up until the one time it does not, and that one time is the only time anyone remembers. Here is the reframe that changed how I build. Treat the stop as the feature that makes an agent shippable. Bolt it on at the end and you have already shipped a liability that happens to pass the demo. Honest about the trade-off. Bounds slow you down. You will watch the agent pause for an approval it could technically have skipped, and it will feel like friction. That friction is the pric

NTS Radio and Swedish audio company Atonemo have teamed up on a dedicated player that brings NTS's genre-defying mixes and streaming stations to almost any stereo or speaker setup. And, like Atonemo's existing Streamplayer, you can also listen to your favorite streaming services with it, using AirPlay 2, Google Cast, Spotify Connect, or Tidal Connect. […]

Block, Inc. describes migrating ~450 JVM repositories into a monorepo across Cash App and Square engineering to reduce dependency drift and coordination overhead. The system supports ~8,800 weekly builds with ~10 min p90 CI time. The approach improves cross-service changes, build visibility, and developer experience through dependency graph–based builds, selective CI, and custom IDE tooling. By Leela Kumili

GitHub热门项目 | ⚡ Pure-Rust WebGPU inference engine — OpenAI-API compatible, GGUF native, runs on any GPU. No Python. No llama.cpp. Single binary. | Stars: 5,511 | 29 stars today | 语言: Rust

GitHub热门项目 | Coding Agent Harness | Stars: 7,204 | 52 stars today | 语言: Rust

GitHub热门项目 | Sui, a next-generation smart contract platform with high throughput, low latency, and an asset-oriented programming model powered by the Move programming language | Stars: 7,714 | 2 stars today | 语言: Rust

Call it a startup with a sole founder and a very large seed round, but what's next is less clear.

CircleCI has launched Chunk Sidecars, a new capability designed to bring CI-style validation directly into an AI coding agent's inner development loop By Craig Risi

The biggest World Cup ever is pushing fans, players, and host cities to their limits—and experts say this is only the beginning.

The “5-minute market” concept is gaining attention because of how fast new prediction rounds appear and how quickly volume builds up. Each cycle is short, which creates both opportunity and risk for anyone trying to analyze or trade it. In this article, I’ll break down how I’ve been approaching this space from a data perspective, how I’m thinking about building an edge, and the tools I’ve been experimenting with. What is the 5-minute market? A 5-minute market is a fast-cycle prediction or trading window where outcomes resolve quickly and new markets appear frequently. Compared to longer timeframes (like 15-minute markets), these shorter cycles: Generate more trading opportunities per hour Require faster data collection and processing Make latency and execution extremely important Increase noise in price action Because of this, traditional slow analysis often doesn’t work well here. Data collection approach My current setup focuses on continuously pulling market data in real time. The idea is simple: Connect to a market data source (I’m using a Gamma API as part of the pipeline) Stream or request live market updates Store order book + price movement data Aggregate it into 5-minute windows for analysis The goal is to build a dataset that can later be used for backtesting and feature extraction. Right now, I’m mainly focusing on a single asset (PPC) to keep things simple while testing the pipeline. Where the potential edge might come from The key question is: can we predict short 5-minute movements better than random chance? Some areas I’m exploring: 1. Order book behavior Tracking: Liquidity changes Bid/ask imbalances Sudden volume spikes 2. Session-based behavior Some traders observe patterns during different market sessions: Asian session behavior London session volatility Overlap periods These may or may not hold in 5-minute markets, but they’re worth testing. 3. Micro momentum patterns Since markets reset frequently, short momentum bursts might matter more than lo

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. I boot up my machine. The desktop loads. And before I open my editor, before I check Slack, before I do a single productive thing, I right-click an empty patch of desktop and hit Refresh . Then I do it again. And again. I am a person who can explain event loops and reason about cache invalidation, and yet here I am, mashing F5 on a static wallpaper like it owes me money. If you've never done this, congratulations, you're better than me. If you have ... welcome. You're among friends. First, let's kill the myth There's a folk belief that refreshing the desktop is a tiny act of system maintenance. A little spring cleaning. A gift to your hardworking CPU. It is not. Manually refreshing your desktop does not : free up RAM reduce CPU load clear some mysterious cache make your PC faster in any way, shape, or form All it does is tell Windows Explorer to redraw the current view . That's it. That's the whole feature. What's actually happening under the hood Here's the part that's actually interesting (we're devs, we live for the "actually"). Windows doesn't repaint your entire screen on every frame, that would be wildly wasteful. Instead it leans on a composition engine that, with help from your GPU when one's available, only redraws the regions that changed since the last frame. Already drawn elements get cached and reused. Icons, the taskbar, your wallpaper they're all mostly static, so mostly left alone. When something genuinely changes (you save a file, delete a folder, plug in a drive), the OS detects it and tells the composition engine: "hey, this little rectangle changed, repaint just that." The desktop refreshes itself, automatically, all day long, without you ever touching anything. So the manual Refresh button is really just a manual overrid