标签：#us

GitHub热门项目 | Browser automation CLI for AI agents | Stars: 35,196 | 105 stars today | 语言: Rust

GitHub热门项目 | Policy-driven, layered isolation and containment | Stars: 338 | 108 stars today | 语言: Rust

Rust implements an explicit error handling paradigm instead of a traditional exception-driven system. Outside of rapid prototyping or testing scenarios—where unwrap() and subsequent panics might be tolerated—Rust strictly enforces explicit error management. However, this can become cumbersome when dealing with numerous disparate errors or when multiple errors need to be aggregated. To alleviate this burden, Rust introduces the question mark operator (?) as syntactic sugar. Operating on the Result type, the ? operator either extracts the underlying success value or immediately returns the error from the current function. While powerful, direct usage of ? often leads to type mismatches when a function encounters different error types. To resolve this complexity, crate ecosystems like anyhow are widely adopted. anyhow provides a universal Error type that seamlessly integrates with most concrete error types implementing the std::error::Error trait, allowing the ? operator to propagate errors without triggering compiler friction. Furthermore, the Context trait from such libraries offers an idiomatic approach to transforming an Option into a meaningful Result.

A homeschooling center in Manhattan is part of the company’s nationwide expansion. Internal documents reveal its strategy: “Opening date > safety.”

Quantinuum, a quantum computing startup, is losing millions. Investors want in anyway.

Bilingual post · Post bilíngue Jump to: English · Português English {#english} Codegen to C: Native Binaries from Pascal (v2.18.0) Sprint 10 ( v2.18.0 ) closes the loop on CrabPascal's most ambitious feature: turning Pascal source into real native executables via C codegen — with string builtins that actually match the interpreter. The pipeline Pascal (.dpr/.pas) → AST → C source + stubs.c → gcc/clang → native binary run skips the last steps and executes in Rust. build-exe is for when you want an .exe or ELF on disk without carrying the CrabPascal runtime as a dependency. End-to-end example program NativeHello ; uses System . SysUtils ; begin WriteLn ( Trim ( ' Hello, native world! ' )); end . crab-pascal build-exe NativeHello.dpr ./NativeHello # or NativeHello.exe on Windows Expected output: Hello, native world! — no leading or trailing spaces. What Sprint 10 fixed Parser: Trim , Copy , Length , and friends are recognized as SysUtils builtins , not mistaken for type names starting with T . A denylist prevents hard-casts that produced invalid C. Codegen: Forward declarations for pascal_* helpers in generated C. WriteLn emits correct %s formats for string expressions. main returns 0 like a well-behaved C program. Tests: build_string_conformance_stdout_matches_run_when_toolchain_present runs only when gcc/clang is available — skipping cleanly in CI sandboxes without a compiler, failing loudly when a compiler is present but output diverges. cargo test --test run_build_parity stubs.c: shared runtime surface String functions implemented once in Rust for run mirror into stubs.c for native builds: // conceptual — see repo for full signatures int pascal_Length ( const char * s ); char * pascal_Trim ( const char * s ); Generated Pascal calls route through these instead of ad-hoc inline logic, keeping Sprint 5–8 string semantics intact in binaries. When build-exe is not enough yet Sprint 10 explicitly did not ship full OO, exception, or generics codegen parity — those appear

Prompts rot. Captured failures compound. Most of the AI skills you are building are mostly prompt, which is why most of them will not survive the year. Not because the prompts are bad. A skill's value is maybe twenty percent instruction and eighty percent scar tissue, and only that second part lasts. The instruction rots the moment the thing it describes moves. Encode how your team deploys and it works until the pipeline changes. Then you are debugging a prompt at 2am, with less to go on than if you had written the script yourself. So before you build another one, stop asking whether the prompt is good. Ask what the skill is holding onto, and whether that thing sits still. A skill rots at the speed of what it touches A skill rots in proportion to how tightly it is coupled to things that move. Generic scaffolding leans on stable ground like a language or a convention, so it ages slowly. Domain logic wired to a codebase that gets refactored every quarter ages fast, no matter how good the prompt is. The difference is the dependency count. "Write a unit test in this style" depends on a language and a convention. Both barely move. It keeps working for years because nothing under it shifts. Real company-specific procedure is the opposite. File layouts. Service contracts. The one edge case in the billing flow. Each detail you pack in is a thread tied to something that gets refactored. Pack in enough of them and the skill is not a tool anymore. It is a liability with good intentions, and it fails silently, because a stale prompt does not throw. It quietly does the wrong thing. That is what the skill-library pitch gets backwards. Volume is not value. A hundred skills wired to a moving codebase is a hundred things to maintain. The only part that compounds is the scar One part of a skill does not rot. The captured failure. The five-line check you added after a model confidently reported a 41 percent dividend yield. The retry that refuses to fire twice so a flaky webhook cannot

A visual, beginner-friendly Java 25 experiment that explains virtual threads, blocking work, carrier threads, and the production rules that matter.

Bilingual post · Post bilíngue Jump to: English · Português English {#english} Building REST APIs in Pascal with Horse Pascal is not stuck in desktop forms. With Horse — a lightweight HTTP framework popular in the Delphi ecosystem — CrabPascal v2.22.0 runs real REST servers from .dpr files. No IIS, no Apache: just crab-pascal run and curl. Why Horse in CrabPascal? Horse provides routing, JSON bodies, and middleware-style handlers. CrabPascal ships RTL shims and a runtime HTTP stack so examples work out of the box: Example Port Endpoints examples/crud/ 9000 Full product CRUD examples/time-server/ 9001 Time/date ping examples/agenda/ 9000 Contact registry All runnable with the internal runtime — no gcc required. Minimal API program SimpleAPI ; uses Horse , System . JSON ; begin THorse . Get ( '/ping' , procedure ( Req : THorseRequest ; Res : THorseResponse ; Next : TNextProc ) var J : TJSONObject ; begin J := TJSONObject . Create ; J . AddPair ( 'message' , 'pong' ); Res . Send ( J . ToJSON ); end ); THorse . Listen ( 9000 ); end . Run and test: crab-pascal run SimpleAPI.dpr curl http://localhost:9000/ping Expected response: {"message":"pong"} . CRUD example from the repo The examples/crud/crud.dpr project demonstrates production-style routes: THorse . Get ( '/produtos' , procedure ( Req , Res , Next ) begin Res . Send < TJSONObject >( TProdutoService . ListarProdutos ); end ); THorse . Post ( '/produtos' , procedure ( Req , Res , Next ) var json : TJSONObject ; begin json := Req . Body < TJSONObject >; Res . Send ( TProdutoService . CriarProduto ( json . GetValue ( 'nome' ). Value , json . GetValue ( 'categoria' ). Value , StrToFloatDef ( json . GetValue ( 'preco' ). Value , 0 ), StrToIntDef ( json . GetValue ( 'estoque' ). Value , 0 ) )); end ); Start the server: cd examples/crud crab-pascal run crud.dpr Testing with curl List products: curl http://localhost:9000/produtos Create a product: curl -X POST http://localhost:9000/produtos \ -H "Content-Type: application/j

Bilingual post · Post bilíngue Jump to: English · Português English {#english} Configuring CrabPascal with crabpascal.toml Every serious compiler needs project-level configuration. CrabPascal v2.22.0 reads crabpascal.toml from your project root — search paths, preprocessor symbols, Delphi vs FPC mode, output format, and runtime defaults. Where the file lives The compiler searches in order: crabpascal.toml (project root) .crabpascal.toml (hidden) config/crabpascal.toml If none exist, sensible defaults apply. Add the file when your project grows beyond a single .dpr . Starter configuration [compiler] version = "2.22.0" search_paths = [ "rtl/" , "lib/" , "examples/" ] defines = [ "CRABPASCAL" , "RELEASE" , "MSWINDOWS" ] mode = "DELPHI" # or "OBJFPC" strict = false warnings = true [preprocessor] enabled = true process_includes = true symbols = [] [output] error_format = "vscode" # or "gcc", "delphi" colors = true [runtime] default_http_port = 9000 [paths] rtl_path = "rtl/" output_path = "output/" Place this beside your .dpr file. All CLI commands ( check , run , build-exe ) pick it up automatically. Common use cases Delphi vs Free Pascal mode [compiler] mode = "DELPHI" defines = [ "CRABPASCAL" , "MSWINDOWS" ] Switch to FPC compatibility: [compiler] mode = "OBJFPC" defines = [ "FPC" , "UNIX" ] Mode affects parsing rules and RTL resolution under rtl/ . Custom unit search paths Large projects split units across folders: [compiler] search_paths = [ "rtl/" , "src/units/" , "src/services/" , "third_party/" ] This replaces hardcoded -U flags in scripts. Preprocessor symbols Match Delphi conditional compilation: [preprocessor] enabled = true symbols = [ "DEBUG" , "TESTING" ] Your Pascal code can use: {$IFDEF DEBUG} WriteLn ( 'Debug build' ); {$ENDIF} Run crab-pascal preproc MyApp.dpr to inspect expanded source. CI-friendly error output [output] error_format = "gcc" colors = false show_stacktrace = false GitHub Actions parsers often prefer gcc-style lines. Local development can

The Bengaluru startup has crossed 1 million orders and reached a $50 million annualized GMV run rate within a year of launch.

A while back, when I was still job hunting, building mini-projects, and trying to figure out what I...

Mutagen 0.4.0 addresses the friction points that plague agentic workflows: context bloat, brittle persona transitions, and the lack of a deterministic path from design document to deployed artifact. We aren't trying to make prompts smarter; we are making the harness that executes them more precise. This release introduces a Rust-based service extraction layer that decouples static dependency mapping from generative reasoning, implements an adversarial verification pipeline to gate deployment, and enforces strict stage transitions to prevent the agent personas we rely on from drifting into one another's scopes. The Service Extraction Layer: Decoupling Logic from LLM Context The primary bottleneck in current agentic stacks is token consumption. When a model attempts to reason about a codebase that spans multiple dependencies, it often spends its context window parsing file headers and resolving imports before it can actually write logic. This approach treats static infrastructure as if it were part of the reasoning problem. Mutagen 0.4.0 changes this by introducing a dedicated Rust layer designed to extract service definitions directly from your codebase without polluting the primary agent context. Instead of asking an LLM to map dependencies, the harness queries the local file system and executes static analysis routines. It isolates business logic execution from the generative reasoning loop used by Claude and Codex. This separation allows the model to focus on how to solve a problem rather than where the pieces are located. In practice, this means offloading static infrastructure queries to the harness rather than the LLM. The result is reduced latency and significantly lower token costs for complex applications. You get a dependency map that is as reliable as a compiler's parse tree, not a probabilistic guess from a prompt. // Example: Service extraction logic isolated from the reasoning loop fn extract_services_from_codebase () -> HashMap < String , Vec < Depende

The modified Ioniq 5 will be loaded with sensors to capture data for Uber's new AV Labs division.

GitHub热门项目 | Comfortably monitor your Internet traffic 🕵️‍♂️ | Stars: 37,908 | 30 stars today | 语言: Rust

GitHub热门项目 | Like htop, but for AI coding agents. Monitor Claude Code & Codex CLI sessions, tokens, context window, rate limits, and ports in real-time. | Stars: 2,448 | 21 stars today | 语言: Rust

GitHub热门项目 | an open source, extensible AI agent that goes beyond code suggestions - install, execute, edit, and test with any LLM | Stars: 46,323 | 65 stars today | 语言: Rust

GitHub热门项目 | dbt enables data analysts and engineers to transform their data using the same practices that software engineers use to build applications. | Stars: 12,917 | 10 stars today | 语言: Rust

GitHub热门项目 | An open-source remote desktop application designed for self-hosting, as an alternative to TeamViewer. | Stars: 115,484 | 77 stars today | 语言: Rust

Four people suing Elon Musk's AI firm under pseudonyms due to the risks of being identified may face a difficult choice: Reveal your real names, or drop the lawsuit.