Explore other dev related sites in this ring. If you find this idea useful click here to join.
devring.club Previous Random Next

🦃 linksfor.dev(s)

Posts for 'rust'

  1. Django: Introducing Djade, a template formatter - Adam Johnson
  2. On "Safe" C++
  3. Harmful Practices Considered Best | Zakhary's Home
  4. hyper in curl Needs a Champion
  5. Blogging through the decades | The Observation Deck
  6. Efficiency is fundamentally at odds with elegance
  7. The opposite of DRY isn't WET, it's YAGNI
  8. GPT-4o’s Personality Revealed: An INFJ in the Machine?
  9. Stop Making Me Memorize The Borrow Checker
  10. What To Use Instead of PGP - Dhole Moments
  11. CMTOPS.DEV
  12. Jujutsu: A Haven for Mercurial Users at Mozilla
  13. Rails 8.0: No PaaS Required
  14. Why I love Rust for tokenising and parsing
  15. How WebSockets cost us $1M on our AWS bill
  16. How I Improved Video Streaming with FFmpeg and Node.js | Mayallo
  17. Notes from the Carbon panel session at EuroLLVM 2024
  18. Love letter to Hurl | Lambros Petrou
  19. I Waited 10 Billion Cycles and All I Got Was This Loading Screen
  20. Re-ranking search results on the client side
  21. Rewrite it in Rails
  22. An update on Apple M1/M2 GPU drivers [LWN.net]
  23. TIL emalloc() auto-exits on out-of-memory errors
  24. Matrix 2.0 Is Here!
  25. kimono koans' blog! - A Somewhat Opinionated Guide to Effective ZFS Snapshots
  26. Pimp My `man` | Kalman Szenes
  27. Golang developers should try Odin
  28. Quality | Justin Fuller
  29. Wayland: i3 to Sway migration
  30. Ruby on (Guard)Rails
  31. Building a better and scalable system for data migrations
  32. There are some limitations when developing locally with Cloudflare Workers that process messages fro
  33. Building Images: Gzip vs Zstd
  34. devenv is switching Nix implementation to Tvix - devenv
  35. Zig is everything I want C to be
  36. GitHub - levkk/rwf: Comprehensive framework for building web applications in Rust.
  37. Learn the differences between handling HTTP requests and processing messages from a queue when build
  38. a short rant on culture – Daniel Frank
  39. Queueing Up Success: The Art of Async on Cloudflare Workers
  40. High Performance Postgres with Cloudflare and Rust
  41. Introduction - Steve's Jujutsu Tutorial
  42. RAGs to RIChes — machtiani
  43. There are exactly 8 bits in a byte
  44. Announcing Rust 1.82.0 | Rust Blog
  45. Yes, Go Does Have Exceptions
  46. Maelstrom Software
  47. When should I use String vs &str?
  48. EQL - EVM Query Language
  49. A Missing IDE Feature
  50. Anjan's Homepage
  51. High Performance Postgres with Rust, Cloudflare & Hyperdrive
  52. how-i-think-of-the-expression-problem - Chad Nauseam Home
  53. Psychopath or Autistic? What's the Difference?
  54. GitHub - samuel-vitorino/lm.rs: Minimal LLM inference in Rust
  55. My negative views on Rust
  56. When single threaded Node.js becomes a trouble
  57. Designing A Fast Concurrent Hash Table
  58. Announcing Deno 2
  59. Rust's design goals should be about code
  60. Putting a full power search engine in Ecto
  61. Why I like Tcl
  62. Purity is Great for Collaboration
  63. Personal reflections on moving from Canada to NYC – Daniel Frank
  64. Stay in the gap | everything changes
  65. Effect polymorphism fixes dependency inversion
  66. Mitmproxy 11: Full HTTP/3 Support
  67. Why the number of Gleam programmers is growing so fast? — Taha Shashtari
  68. Make your shell 370.52% faster with this easy trick (fix nvm startup times)
  69. Web Components are not Framework Components — and That’s Okay • Lea Verou
  70. 5 Years Making a Toy with an SDK
  71. Rust needs a web framework for lazy developers
  72. Migrating from AWS to Self-Hosting ⚡ Zig Programming Language
  73. GitHub - zhengkyl/qrframe: code-based qr code generator
  74. I Want Process-Aware Types
  75. xUnit v3 and some stuff about TUnit
  76. Rewriting Rust
  77. The Watermelon Operator
  78. Why I still blog after 15 years
  79. Whence ' '? – Casey Rodarmor's Blog
  80. Stop using REST for state synchronization
  81. How Discord Reduced Websocket Traffic by 40%
  82. Cryptographic Innuendos - Dhole Moments
  83. 50 Ideas That Changed My Life - David Perell
  84. Announcing Swift 6
  85. How I Lie to You
  86. The 6.11 kernel has been released [LWN.net]
  87. GitHub - phil-opp/blog_os: Writing an OS in Rust
  88. GitHub - RyanWelly/lisp-in-rs-macros: A Lisp interpreter written fully in rust macros.
  89. Safe C++
  90. Why is language documentation still so terrible?
  91. How we verify the correctness of a spreadsheet engine
  92. Why I Prefer Exceptions to Error Values
  93. YAML feature extraction with yamlpath
  94. Just for Fun. No, Really.
  95. Redox OS 0.9.0 - Redox
  96. What is the best pointer tagging method?
  97. Pop!_OS Lead: Linux Developers are “Patronizing Pedantic Megalomaniacs”
  98. Building a healthy and sustainable funding model for open source software
  99. Asynchronous IO: the next billion-dollar mistake?
  100. GitHub - Scthe/nanite-webgpu: UE5's Nanite implementation using WebGPU. Includes the meshlet LOD hierarchy, software rasterizer and billboard impostors. Culling on both per-instance and per-meshlet basis.
  101. Async Rust can be a pleasure to work with (without `Send + Sync + 'static`)
  102. 1Password vs. Bitwarden
  103. Firefox will consider a Rust implementation of JPEG-XL by bholley · Pull Request #1064 · mozilla/standards-positions
  104. Beyond Ctrl-C: The dark corners of Unix signal handling :: sunshowers
  105. Hacking sales as an introvert
  106. Step-Based Cascading Prompts: Deterministic Signals from the LLM Vibe Space
  107. Who Wins With Cursor & Copilot? - Tim Kellogg
  108. This month in Servo: tabbed browsing, Windows buffs, devtools, and more! - Servo, the embeddable, independent, memory-safe, modular, parallel web rendering engine
  109. Frak Lopez | I will f(l)ail at your tech interviews, here's why you should care
  110. UV with Django
  111. [PATCH 0/1] Retiring from the Rust for Linux project
  112. How to Hire a CTO
  113. You're not just buying hardware with Oxide
  114. Why am I writing a Rust compiler in C?
  115. Why Solid?
  116. I sped up serde_json strings by 20%
  117. Reframing ADHD in dogs: a compassionate perspective
  118. Notes from Figma I: How We Succeeded In Design
  119. Exposing youth to programming by finding the password
  120. An unordered list of hidden gems inside NixOS — kokada
  121. I’m Tired of Fixing Customers’ AI Generated Code
  122. The Easiest Way to Stand Out With Your Work
  123. Async hazard: mmap is secretly blocking IO
  124. .:: Phrack Magazine ::.
  125. uv: Unified Python packaging
  126. Building a modular softsynth from scratch (Week 1)
  127. Bevy ECS as a data layer for static site generation with Leptos
  128. Introducing Zed AI - Zed Blog
  129. Reimagining architecture principles
  130. To broadcast or not to broadcast
  131. A Terminal Based Workflow
  132. Leaving Neovim for Zed
  133. It's not just B2C vs B2B anymore
  134. An underrated software engineering interview question – Jake Zimmerman
  135. Should I Close Source my Company? Replying to Supabase | Ben Butterworth
  136. PyTorch is dead. Long live JAX.
  137. CSVs Are Kinda Bad. DSVs Are Kinda Good.
  138. STD Doesn't Have to Abstract OS IO
  139. You should make a new programming language
  140. You should make a new programming language
  141. GitHub - judofyr/spice: Fine-grained parallelism with sub-nanosecond overhead in Zig
  142. Quote-unquote "macros"
  143. What's Next? (2024 edition)
  144. Against Names
  145. GitHub - DioxusLabs/blitz: High performance HTML and CSS renderer powered by WGPU
  146. Rust GUI library via Flutter, done simple
  147. Progress on porting Firefox
  148. GitHub - versotile-org/verso: A web browser that plays old world blues to build new world hope
  149. Chevy Ray | How I Created 175 Fonts Using Rust
  150. System76 - Linux Laptops, Desktops, and Servers
  151. Making Linux C++ Crashes Less Chaotic
  152. First impressions of Gleam: lots of joys and some rough edges
  153. Full Text Search over Postgres: Elasticsearch vs. Alternatives - ParadeDB
  154. Debugging a rustc segfault on illumos :: sunshowers
  155. WebGPU Unleashed: A Practical Tutorial
  156. GitHub - lvkv/whenfs: A FUSE Filesystem for your Google calendar
  157. You Can't Spell WebRTC without RCE - Part 1
  158. Advice to Young Engineers - Robotic Sea Bass
  159. How I learned to love Zig's diagnostic pattern
  160. Open source AI coding assistance with the Granite models | Red Hat Developer
  161. The trouble with __all__
  162. Don't Use Preludes And Globs | corrode Rust Consulting
  163. How do you change browser in Slack anyway?
  164. cppfront: Midsummer update
  165. Translating All C to Rust
  166. Windows Security best practices for integrating and managing security tools | Microsoft Security Blog
  167. We Chose Meilisearch Over 10+ Other Search Engines Despite a Major Drawback
  168. Bril: An Intermediate Language for Teaching Compilers
  169. Evolving Languages Faster with Type Tailoring
  170. Announcing Rust 1.80.0 | Rust Blog
  171. The Computer Genius the Communists Couldn’t Stand
  172. Developers want more, more, more: the 2024 results from Stack Overflow’s Annual Developer Survey - Stack Overflow
  173. module: add --experimental-strip-types by marco-ippolito · Pull Request #53725 · nodejs/node
  174. Studying 0days: How we hacked Anki, the world's most popular flashcard app
  175. Handling lifecycle events on iOS and MacCatalyst with .NET MAUI
  176. Brr Wants A Job – brr
  177. When Objects Are Not Enough
  178. Baking An Open Source Cake
  179. GitHub - BurntSushi/jiff: A date-time library for Rust that encourages you to jump into the pit of success.
  180. How We Achieved Over 30,000 Installs on Our VSCode Extension
  181. Pin
  182. Ruby methods are colorless
  183. Why is spawning a new process in Node so slow?
  184. Thought Experiments on RTO and WFH
  185. Creating an already-completed asynchronous activity in C++/WinRT, part 9 - The Old New Thing
  186. Creating an already-completed asynchronous activity in C++/WinRT, part 8 - The Old New Thing
  187. We need visual programming. No, not like that.
  188. Mercurial is simply too good
  189. Writing GUI apps doesn't have to be painful
  190. The Hidden Marriage Market
  191. Welcome to Thunderbird 128 "Nebula"
  192. The missing parts in Cargo
  193. Free-threaded CPython is ready to experiment with!
  194. Beating the compiler
  195. dut
  196. Using use in Gleam
  197. Timeseries Indexing at Scale - Artem Krylysov
  198. Life without the front page
  199. gRPC Over HTTP/3
  200. The dual nature of seniority in software development
  201. Rye: a Hassle-Free Python Experience
  202. Personality Basins | near.blog
  203. A reawakening of systems programming meetups
  204. Enabling containers to access the GPU on macOS
  205. How LLMs Learn: What We Know, What We Don't (Yet) Know, and What Comes Next
  206. Xuanwo's VISION: Data Freedom
  207. Properly Testing Concurrent Data Structures
  208. Taking PyTorch for Granted | wh
  209. Kafka versus Nabokov
  210. Synchronous Core, Asynchronous Shell
  211. GitHub - wader/jqjq: jq implementation of jq
  212. WebAssembly vs JavaScript: A Comparison — SitePoint
  213. OOP Isn't Obsessed Enough About Time Control
  214. Dolev Hadar
  215. gRPC: The Good Parts
  216. Big Data Engineering in the 2020s
  217. Dynamic watermarking on the JVM
  218. It's time to abolish the builder pattern in Rust
  219. Mako - Mako is Now Open Source
  220. A Bunch of Programming Advice I’d Give To Myself 15 Years Ago
  221. 5 things we learned from sponsoring a sampling of our open source dependencies  - Microsoft Open Source Blog
  222. Industrial macros
  223. How Where Conditions Work in Entity Framework Core | The .NET Tools Blog
  224. The Super Effectiveness of Pokémon Embeddings Using Only Raw JSON and Images
  225. Amazing Learning Resources
  226. Microfeatures I Love in Blogs and Personal Websites
  227. How to Build a Fullstack Webapp with F#
  228. Yet Another Frontend Framework? The Rise Of Svelte
  229. What Happens When You Put a Database in Your Browser?
  230. Let’s Write a Letter of Reconciliation — Jagunbae
  231. Learning Machine Learning in Elixir | zacksiri.dev
  232. Announcing the Pre-Scheme Restoration — Pre-Scheme
  233. Aspire Dashboard
  234. Mastering Concurrency in Rust: Advanced Patterns with Async/Await and Tokio
  235. A Gentle Introduction to Metathics
  236. Lemmy and my Switch to PieFed; Threadyverse software alternatives
  237. Comments on Scripting, CGI, and FastCGI
  238. HowToWare
  239. Do not try to be the smartest in the room; try to be the kindest. | Jorge Galindo's blog
  240. Spending too much time optimizing for loops
  241. Announcing Rust 1.79.0 | Rust Blog
  242. My experience crafting an interpreter with Rust
  243. The Most Popular Build Tools for React Developers in 2024
  244. From Chaos to Clarity: My Journey with Obsidian
  245. Shaoru Ian Huang
  246. The Weird Nerd comes with trade-offs
  247. So You Want To Build A Browser Engine
  248. Cloning Windows Recall in 30 Lines of Bash
  249. Yes, you too, reader, should believe you may be world-class – Daniel Frank
  250. Speeding up rustc by being lazy
  251. Reflections from Local-First Conf - Daniel Norman
  252. Why I'm looking into algorithmic trading.
  253. Core Competencies
  254. Streamline Testing Processes with Contract Testing and Pact in .NET
  255. Moving Beyond Type Systems | Vhyrro's Digital Garden
  256. Icing or Cake? — dthompson
  257. Disassembling Dalvik
  258. Compilers | Rasheed Starlet
  259. Do I not like Ruby anymore?
  260. GitHub - quickwit-oss/tantivy: Tantivy is a full-text search engine library inspired by Apache Lucene and written in Rust
  261. wave-sim — Connor Code
  262. Abusing Go's infrastructure
  263. Replacing pyinstaller with 100 lines of code
  264. If you have to create a Windows Runtime Vector from C++/WinRT, do it as late as possible - The Old New Thing
  265. Unwind considered harmful? · baby steps
  266. vu128: Efficient variable-length integers
  267. Is Morality Real?
  268. CADmium: A Local-First CAD Program Built for the Browser
  269. Meta Releases Open Source React Compiler
  270. Enlightenmentware
  271. Runtime code generation and execution in Go: Part 1
  272. Designing a Scalable OCPP server - Siddharth Sabron
  273. Thoughts on Forester: A Scientist's Zettelkasten
  274. Test Driving ChatGPT-4o (Part 3)
  275. Happy Developers. It is Possible
  276. High Agency in Software Engineering
  277. GitHub - HigherOrderCO/Bend: A massively parallel, high-level programming language
  278. 100 Exercises To Learn Rust
  279. How to Simulate MEV Arbitrage with REVM, Anvil and Alloy
  280. Translation of the Rust's core and alloc crates | Formal Land
  281. References are like jumps
  282. Tuning ZIO for high performance
  283. Thomas Eckert
  284. Wasm vs. Docker | Docker
  285. Parsing PNG images in Mojo
  286. TypeScript: undefined and null are nothing and should keep being nothing — Domain Specific Language
  287. GitHub - Hirrolot/datatype99: Algebraic data types for C99
  288. Development notes from xkcd's "Machine"
  289. Jonas Hietala: Browse posts with telescope.nvim
  290. Zed Decoded: Linux when? - Zed Blog
  291. A comprehensive introduction to CDNs
  292. Careful with That Lock, Eugene: Part 2
  293. Pair Your Compilers At The ABI Café - Faultlore
  294. Using age with org-journal
  295. Let me tell you a story - Byte Tank
  296. Sakshat's blog - Is software engineering for you
  297. Blog | atchyut.dev
  298. Building a Rocket Engine from Scratch
  299. The Sisyphean struggle and the new era of data infrastructure — Jack Vanlightly
  300. Jonas Hietala: Customizing Neovim
  301. Why I Left NixOS for Ubuntu
  302. On Programming Languages
  303. Thoughts on Zig
  304. Working with Rust Libraries from C# .NET Applications
  305. GitHub - borgo-lang/borgo: Borgo is a statically typed language that compiles to Go.
  306. Borgo Programming Language
  307. What Computers Cannot Do: The Consequences of Turing-Completeness
  308. Memory Management Every Programmer Should Know
  309. Thoughts on WASM
  310. bun.report is Bun's new crash reporter
  311. LogLog Games
  312. The Importance of Maybe
  313. Ruby might be faster than you think
  314. The only two log levels you need are INFO and ERROR
  315. Vimmer tries Emacs
  316. C isn’t a Hangover; Rust isn’t a Hangover Cure
  317. Building FocusGuardian, my TribeHacks IX submission, in 24 hours
  318. Issue 54: Personal Library Science
  319. Id30 – magnushoff.com
  320. Good Ideas in Computer Science
  321. An entire Social Network in 1.6GB (GraphD Part 2)
  322. Adventures In Rust: Bringing Exchange Support To Thunderbird
  323. The Real C++ Killers (Not You, Rust)
  324. 10x Engineers vs -10x Burdens
  325. The Optimal Workspace
  326. LLVM is Smarter Than Me
  327. The Illustrated Word2vec
  328. Do best practices really matter?
  329. Yet Another REST Client?
  330. Diffusion Models for Video Generation
  331. Java 23: The New Features are Officially Announced
  332. Getting Started with perlimports
  333. Design Notes
  334. My useless philosophical ramblings about the ecology of programming languages (and OOP is not Java)
  335. Getting started with sched-ext development
  336. Open Source, Supply Chains, and Bears (oh my!)
  337. How to write a code formatter
  338. GCC version 14 coming soon – and will drop Itanium support
  339. Comparing Multiple Large Language Models in one Pass · Analyst 18
  340. The case of the string being copied from a mysterious pointer to invalid memory - The Old New Thing
  341. "BatBadBut" Vulnerability Discovered in Rust Standard Library on Windows - Cyber Kendra
  342. EuroRust 2024 officially welcomes independent workers (updated)
  343. The Simple Beauty of XOR Floating Point Compression
  344. Open Source Financial Sponsorship Breakdown for 2023
  345. The server chose violence - Cliffle
  346. Thoughts on the xz backdoor: an lzma-rs perspective | Blog | Guillaume Endignoux
  347. Twenty Years Is Nothing
  348. A Brief Comparison of Modern Programming Languages
  349. Looking for Alice
  350. Self Modifying Code
  351. An IRC client in your motherboard
  352. HTTP/2 `CONTINUATION` Flood
  353. Performance insights: Engineering for high performance
  354. Oneiblog
  355. How to create a blog using Golang
  356. A lazy and flippant classification of programming languages
  357. NixOS is not reproducible
  358. Conway's Game of Life Through Time
  359. GitHub - tedkim97/adcache
  360. Lattice now compiles to .NET IL — John Austin
  361. GitHub - buserror/libmui: Classic MacOS & GS/OS widget library for linux (and other?)
  362. Type Inference Was a Mistake
  363. Explaining the internals of async-task from the ground up
  364. xorvoid
  365. Helix
  366. Garbage Collection for Systems Programmers
  367. We are under DDoS attack and we do nothing
  368. My list of challenging software projects some programmers should try
  369. [Media] Lars Bergstrom (Google Director of Engineering): "Rust teams are twice as productive as teams using C++."
  370. Processing 6 Billion Chess Games in Less Than 2 Hours
  371. Is Europe Better Than America for Working in Tech?
  372. Sudo-rs dependencies: when less is better - Blog - Tweede golf
  373. Binary array set
  374. What Computers Cannot Do: The Consequences of Turing-Completeness
  375. Writing GNOME Apps with Swift
  376. On Tech Debt: My Rust Library is now a CDO
  377. RIP Redis: How Garantia Data pulled off the biggest heist in open source history — Momento
  378. Why choose async/await over threads?
  379. Build time is a collective responsibility
  380. Cranelift code generation comes to Rust
  381. A review of the Thinkpad X13s with Ubuntu Linux ⋅ ahoneybun.net
  382. Batyr Nuryyev | Biting Off More Than We Can Chew with OLAP Libraries
  383. devenv 1.0: Rewrite in Rust - devenv
  384. Knee Deep in tree-sitter Queries
  385. Eio 1.0 Release: Introducing a new Effects-Based I/O Library for OCaml
  386. 🔬 Rustls: Continuous Benchmarking Case Study
  387. Regex character “$” doesn't mean “end-of-string”
  388. GitHub - ynqa/jnv: interactive JSON filter using jq
  389. Let's create a Tree-sitter grammar
  390. C++ creator rebuts White House warning
  391. commit message rant (part 1 of n) - hēg denu
  392. I’m Finally Quitting Trying to Quit My Bad Habits
  393. Code samples for the opening chapter of Refactoring
  394. 50 Ideas for Life I Repeatedly Share – Daniel Frank
  395. GitHub - 0x192/universal-android-debloater: Cross-platform GUI written in Rust using ADB to debloat non-rooted android devices. Improve your privacy, the security and battery life of your device.
  396. Zig, Rust, and other languages
  397. How to Patch A Package Source on NixOS
  398. Achieving awful compression with digits of pi
  399. Why software projects fail
  400. 10 years in Open Source
  401. Words of Wisdom: Backend Edition
  402. Release Bebop v3.0.4 · betwixt-labs/bebop
  403. smeso - Memory ordering and atomic operations synchronization
  404. How to Lose Control of your Shell
  405. Regex character “$” doesn't mean “end-of-string”
  406. Why Can't Programmers Agree on Anything?
  407. LLM with Ollama and similarity search with Qdrant, vector database - Vincent Composieux - Tech Lead Full Stack / DevOps & Architect over Go, PHP Symfony, NodeJS, Cloud (AWS, GCP) and much more
  408. Sorting with CUDA (SIMD) shuffling
  409. vorant94 | Divide and conquer: right concerns to separate
  410. Why Browsers Get Built - Infrequently Noted
  411. Secure by Design: Google’s Perspective on Memory Safety
  412. The AI Dilemma: When Large Language Model Training Reaches A Dead End
  413. Regex character “$” doesn't mean “end-of-string”
  414. What high-performance language to learn?
  415. Bleacher Report gutting out OTP
  416. Interview Feedback to an Upcoming Computer Science Student
  417. I'm a programmer and I'm stupid
  418. Dapr v1.13 is now available
  419. Making Make a README
  420. Autogenerating a Book Series From Three Years of iMessages
  421. The "missing" graph datatype already exists. It was invented in the '70s
  422. C skill issue; how the White House is wrong
  423. Let's not over-hype rust.
  424. The Hunt for the Missing Data Type
  425. Gleam version 1 – Gleam
  426. How To Run Your Benchmarks - 2 Ways To Run BenchmarkDotNet
  427. The hater’s guide to Kubernetes
  428. Why F# is a fun programming language
  429. Applying Growth Mindset to Learning Rust – Dev Leader Weekly 33
  430. GitHub - pydantic/FastUI: Build better UIs faster.
  431. Snapshot Testing - blag
  432. XeDN on Tigris - Xe Iaso
  433. In praise of Nushell
  434. Introducing oneRepo: the JavaScript & TypeScript monorepo toolchain for safe, strict, & fast development • Paul Armstrong
  435. Instrument Serverless Rust Applications with Open Telemetry
  436. GitHub - cloudflare/pingora: A library for building fast, reliable and evolvable network services.
  437. Marc Kerbiquet's Website
  438. White House urges developers to dump C and C++
  439. About Rapier | Rapier
  440. OOP and Design Patterns are garbage - Douglas' Blog
  441. Scheduling Internals
  442. ARCHITECTURE.md
  443. Language Checklist
  444. Things I Used to Care About
  445. formats
  446. Cycles all way down
  447. How to Make a List of Nearly Every Minecraft Player
  448. Atuin - Magical Shell History
  449. The eBook for 'Why Cryptocurrencies?' is now available for free
  450. GitHub - Speykious/cve-rs: Blazingly 🔥 fast 🚀 memory vulnerabilities, written in 100% safe Rust. 🦀
  451. VisualStudio.Extensibility: Install extensions without restarting Visual Studio! - Visual Studio Blog
  452. A simple but safe deploy script
  453. Introducing Safecat
  454. The most useful programming language
  455. Microsoft Abandons DotNet For Rust?! - Uncover The Truth
  456. From 1s to 4ms
  457. We Have to Start Over: From Atom to Zed - Zed Blog
  458. .NET Continuous Profiler: CPU and Wall Time Profiling
  459. API Part 7 – Swagger Comments
  460. uv: Python packaging in Rust
  461. Observable 2.0 | Observable
  462. Aaron Schlesinger's Personal Site
  463. The Perfect Project Structure for Production Ready Serverless Rust
  464. SP1 Book
  465. The CMS I would like to see.
  466. Improve your SQL skills X2 in 5 minutes
  467. Hello world, and the future for PyO3
  468. I worry our Copilot is leaving some passengers behind
  469. Antithesis – autonomous testing
  470. I applied for a software role at FedEx and was asked to take this bizarre personality test.
  471. Shell scripting with Elixir - Michal (arathunku)
  472. AMD Quietly Funded A Drop-In CUDA Implementation Built On ROCm: It's Now Open-Source
  473. Sudo On Windows a Quick Rundown
  474. dax - Cross-platform shell tools for Node.js
  475. Announcing Rust 1.76.0 | Rust Blog
  476. On the virtues of the trailing comma - The Old New Thing
  477. A Splendid Scala Journey
  478. Garbage Collection Without Unsafe Code
  479. Calling System Functions in a JIT
  480. What's the hype with Rust and AWS Lambda?
  481. The Genius of Peter Thiel in attacking the Ivy Leagues and high school dropouts shattering the college gospel
  482. Google throws $1M at Rust Foundation to build C++ bridges
  483. Why RustPython?
  484. Microsoft Ditches C# for Rust: M365 Core Gets Safety and Perf Boosts
  485. Deno in 2023
  486. Microsoft Is Abandoning C# for Rust! Now What?
  487. Let futures be futures
  488. Generating code was never the hard part - Nick Scialli
  489. The Duty to Data Portability
  490. jj init — Sympolymathesy, by Chris Krycho
  491. Is Apple Gonna Be Okay?
  492. Reverse-engineering the Synacor Challenge
  493. Blogging in Djot instead of Markdown
  494. GitHub - vitoplantamura/HackerNewsRemovals: List of stories removed from the Hacker News Front Page, updated in real time.
  495. Embracing Functional Programming in C#
  496. Build vs. Buy for Feature Flags: My Experience as a CTO with a 20+ Engineer Team - Flagsmith
  497. What You Need Is Motivation — Ethan Lalakea Alter
  498. The undercover generalist
  499. Polars — Why we have rewritten the string data type
  500. Colin Woodbury - Subsetting your Life
  501. Improving upon my OpenTelemetry Tracing demo
  502. A few thoughts on intensity.
  503. Playing with Nom and parser combinators
  504. Principles for Managing Remote Teams and Freelancers
  505. PGXN Challenges
  506. I Just Wanted Emacs to Look Nice — Using 24-Bit Color in Terminals
  507. Colin Woodbury - A Tour of the Lisps
  508. One Billion Record Challenge in Elixir
  509. Asymptotic Closeness
  510. Introducing: Green Thumb Guide
  511. An old solution to modern OpenAI GPTs problems
  512. GitHub - oxidecomputer/helios: Helios: Or, a Vision in a Dream. A Fragment.
  513. The Performance Management Formula
  514. Arend van Beelen jr.
  515. Informal Leadership in Software Engineering – What You Need To Progress
  516. Hype — bayindirh
  517. War Room Wisdom for Software Developers
  518. My Impressions of Hare
  519. Safe Manual Memory Management with Coeffects
  520. GitHub - FractalFir/rustc_codegen_clr: This rust compiler backend emmits valid CIL (.NET IR), enabling you to use Rust in .NET projects
  521. My experience working on rustc_codegen_clr
  522. SourceGear Rust - Visual Studio Marketplace
  523. Python & JavaScript Libraries · Ollama Blog
  524. Use Azure Quantum 'Playground' to Explore New v1.0 Dev Kit -- Visual Studio Magazine
  525. Meta Blog: I'm a JS Developer now
  526. Against Normalcy: Why Being Normal Can Be Dangerous
  527. Alec’s Blog - How to (Almost) Never Lose A Game
  528. Zero-Sum vs. Positive-Sum Product Theory
  529. Overcoming My Reddit Addiction
  530. The case of the fail-fast trying to log a caught exception - The Old New Thing
  531. Different Node.js Versions & Package Managers Per Project
  532. JARMuary continues - Converting a Razor Pages website to Blazor - Part 11
  533. Maybe don't use Blake3 on Short Inputs
  534. What makes an entrepreneur succeed?
  535. Perfecting Protocol Parsing (Probably) with eBPF
  536. NixOS on Hetzner Dedicated - mhu.dev
  537. David Adam (@zanchey@aus.social)
  538. Let's Help Org Mode Escape From Emacs
  539. In C++/WinRT, how can I await multiple coroutines and capture the results?, part 3 - The Old New Thing
  540. Code Reviews
  541. In search of a Search Engine, beyond Elasticsearch: Introducing Zinc
  542. GitHub - every-day-things/citadel: Manage your ebook library without frustrations. Calibre compatible.
  543. The Slow Frontier of Genetic Choice
  544. #1 BRC in .NET: even faster than Java and C++
  545. Attending NeurIPS 2023
  546. Programming in just ONE language should be lauded. – Cliffski's Blog
  547. In C++/WinRT, how can I await multiple coroutines and capture the results?, part 3 - The Old New Thing
  548. .NET Continuous Profiler: Under the Hood
  549. JSON Web Tokens are actually great, just not for sessions
  550. Local Development With Mirrord | LinuxBlog.xyz
  551. Jonas Hietala: Exploring the Gleam FFI
  552. The Simplest Way To Implement a Background Job
  553. Binius: a Hardware-Optimized SNARK
  554. Why stdout is faster than stderr? - Orhun's Blog
  555. path.join Considered Harmful, or openat() All The Things
  556. How to stop Linux threads cleanly
  557. Python 3.13 gets a JIT
  558. Polars
  559. Reimagining Web APIs - Multilingual/ Rusty Web Servers
  560. Iced through an example: A Twenty-One game
  561. GitHub - moturus/motor-os
  562. GitHub - extrawurst/gitui: Blazing 💥 fast terminal-ui for git written in rust 🦀
  563. Weird things engineers believe about Web development
  564. Race and Fantasy
  565. Pete Millspaugh
  566. Rust, Ruby, and the Art of Implicit Returns
  567. What I learned Joining a Climate Civil Resistance Organization For 18 Months - Guillaume L'Hostis
  568. Data Protection assessment of Privacy Sandbox's Protected Audience API
  569. What I did in 2023
  570. GitHub - uutils/coreutils: Cross-platform Rust rewrite of the GNU coreutils
  571. Maestro - Introduction
  572. Differences Between NUnit, xUnit and MSTest - Code Maze
  573. Why doesn't my code compile when I change a shared_ptr<T>(p) to an equivalent make_shared<T>(p)? - The Old New Thing
  574. Lookahead 2024 — Domain Specific Language
  575. Writing a TrueType font renderer
  576. Compiling Success: My Aspirations for a Transformative Year Ahead - Chris Woodruff's Blog
  577. This year in LLVM (2023)
  578. How They’re Connected and What to Do About It – Solving Procrastination
  579. 7 watts idle on Intel 12th/13th gen: the foundation for building a low power server/NAS | mattgadient.com
  580. You should be using rtx
  581. Poor Man's Web
  582. Challenging projects every programmer should try
  583. std::print in C++23
  584. Best engineers are focusing on helping others
  585. Update in Thrussh: the SSH Terrapin attack
  586. How I Have Fun With Rust
  587. Memory Safety is a Red Herring
  588. Perl Advent Calendar 2023 - Elves Versus Typos
  589. .NET Developer tries Laravel PHP
  590. Security and Crashing with Modal Logic
  591. Progress toward a GCC-based Rust compiler
  592. GitHub - wasm3/wasm3: 🚀 A fast WebAssembly interpreter and the most universal WASM runtime
  593. Mickey, Disney, and the Public Domain: a 95-year Love Triangle | Duke University School of Law
  594. I'm still fed up and a browser is coming along fine
  595. A curiously recurring lifetime issue
  596. The JavaScript Oxidation Compiler
  597. How do I specify an optional string parameter to a Windows Runtime method? - The Old New Thing
  598. VS Code Used to Survey Go Devs, Who Name VS Code No. 1 Editor -- Visual Studio Magazine
  599. How do I specify an optional parameter to a Windows Runtime method? - The Old New Thing
  600. Adopting Rust: the missing playbook for managers and CTOs - Mainmatter
  601. Usability Digest Dec. 2023: Improved autofill reliability, lock state, and item title generation
  602. How can I work around the absence of default parameters in the Windows Runtime? - The Old New Thing
  603. U.S. and International Partners Issue Recommendations to Secure Software Products Through
  604. 4 ways to create Unit Tests without Interfaces in C#
  605. My Christmas tree has a custom processor
  606. An adventure with whisper, wasi, and wazero
  607. Trying chDB, an embeddable ClickHouse engine
  608. Non-Send Futures When?
  609. VS Code's Copilot 'AI Pair Programmer' Improves Chat UI, Explains Rust Code -- Visual Studio Magazine
  610. What's New in Blazor in .NET 8 (What is Blazor SSR)
  611. Nginx is Probably Fine
  612. Non-Send Futures When?
  613. Make a Linux App
  614. Calling a bureaucrat by its name
  615. The Plug-in System Hiding in Your App
  616. Skills to plugins: fully embracing the OpenAI plugin spec in Semantic Kernel | Semantic Kernel
  617. Things I learned from teaching
  618. Hexagonal Architecture with Rust & AWS Lambda | James Eastham Personal Blog
  619. All my favorite tracing tools: eBPF, QEMU, Perfetto, new ones I built and more
  620. Stupid Tools | Obiter dicta
  621. Your Interview Process Is Too Damn Long (and How To Fix It)
  622. Smart Constructors
  623. A Decade of Developing a Programming Language: A Response Response
  624. Vicyyn - Simple Obsidian System for 99% of Your Needs
  625. Why does everyone install crates globally?
  626. Native Rust in Visual Studio Is Top Dev Request, but Progress Slow -- Visual Studio Magazine
  627. ripgrep is faster than {grep, ag, git grep, ucg, pt, sift}
  628. Is c# underhyped?
  629. GitHub - 01mf02/jaq: A jq clone focussed on correctness, speed, and simplicity
  630. Yusuf Aytas - Becoming a Rockstar Engineer
  631. Rust std fs slower than Python!? No, it's hardware!
  632. Rust: Memory Management
  633. Five Learnings from Five Years as a First-Time Founder
  634. Consider Writing Documentation for Your House
  635. GitHub - federico-busato/Modern-CPP-Programming: Modern C++ Programming Course (C++11/14/17/20)
  636. Serverless Speed: Rust vs. Go, Java, and Python in AWS Lambda Functions
  637. Python is Easy. Go is Simple. Simple != Easy.
  638. $20k Bounty was Claimed! · Prettier
  639. Update on the rust port · fish-shell/fish-shell · Discussion #10123
  640. VectorDB
  641. The largest number representable in 64 bits
  642. Registering My Hypotheses On Starting A Business — Ludicity
  643. Fastify Frontends Are Here
  644. I hereby pardon all junior engineers
  645. Launch Week Day 3 - Fastest self-hostable open-source workflow engine | Windmill
  646. Vlang or: How I learned even open-source communities can operate as fascist regimes
  647. How mathematics built the modern world - Works in Progress
  648. Dealing with Failures and Postmortems
  649. Plonky 3 / Valida October Review
  650. Test-Driving Windows 11 Dev Drive for .NET
  651. Building a digital vigil for those we've lost
  652. The Roc Programming Language
  653. Sweet Jesus, Pooh! That's Not Honey! - You're Eating Recursion!
  654. Tree-Sitter Highlighting in Vim
  655. Every Day is Acting School: How to Manage Creative Works, with Humans, for Money.
  656. Announcing Vite 5
  657. The dangers of reproducing while old
  658. Half-Life
  659. Announcing Rust 1.74.0 | Rust Blog
  660. Aaron Schlesinger's Personal Site
  661. Smol's introduction blogpost
  662. Minimize global process | Organizing Chaos
  663. Why does calling a coroutine allocate a lot of stack space even though the coroutine frame is on the heap? - The Old New Thing
  664. Hacking ADHD - Strategies for the Modern Developer | Ledger
  665. You should track your finances in TOML
  666. Yusuf Aytas - The Path to Leadership
  667. Cancellation and Async State Machines
  668. Building an occupancy sensor with an ESP32 and a serverless DB
  669. Top 10 highest paid programming languages in 2023
  670. Fast and Portable Llama2 Inference on the Heterogeneous Edge
  671. Gartner and your Life Partners
  672. Nader Ouerdiane - Software Engineer
  673. mht.wtf
  674. Data Oriented Blogging
  675. How I got here
  676. I Skipped to the Ending
  677. Faster compilation with the parallel front-end in nightly | Rust Blog
  678. Octoverse: The state of open source and rise of AI in 2023
  679. Hare aims to become a 100-year programming language
  680. Officially Qualified - Ferrocene
  681. Constraint Oriented Programming in C#
  682. 10x Developer Workflow on Windows
  683. Creating Hyperlinks in .NET MAUI – AskXammy
  684. Bevy 0.12
  685. How I learned to stop worrying and love byte ordering
  686. Why you should outsource your opinions
  687. A new way to bring garbage collected programming languages efficiently to WebAssembly · V8
  688. Wolf, goat and cabbage problem TLA+ modeling
  689. C# Unit Testing Tutorial For Beginners
  690. Analyzing Data 170,000x Faster with Python
  691. Gregory Szorc's Digital Home | My User Experience Porting Off setup.py
  692. Open Telemetry – Instrumentation and Metrics
  693. mht.wtf
  694. Now add a walrus: Prompt engineering in DALL-E 3
  695. I Rewrote my CV in Typst and I'll Never Look Back
  696. An Open Letter to Cryptographers: Please Work Together
  697. Things I like about Gleam's Syntax
  698. Helix
  699. Was Rust Worth It?
  700. Crafting boring APIs: lessons learned from implementing fallback handlers in Pavex | Luca Palmieri
  701. axo blog - System dependencies are hard (so we made them easier)
  702. Triggering `entr`
  703. The Most Memory Safe Native Programming Language
  704. I got my genome sequenced
  705. The Cache Storage Layer
  706. He Who Gives Up Correctness for Performance Deserves Neither
  707. A programming system
  708. Just paying Figma $15/month because nothing else fucking works
  709. The State of WebAssembly 2023
  710. Ava for Windows – Kamil Tomšík
  711. Galactic Civilizations: Does N=1? | Centauri Dreams
  712. Thousands of elderly twins assure me that my kids will be alright | Robert Heaton
  713. How Does Pattern Matching Work in C#? #shorts
  714. Write more "useless" software | nicole@web
  715. GitHub - hadashiA/VYaml: The extra fast, low memory footprint YAML library for C#, focued on .NET and Unity.
  716. Magical Software Sucks
  717. Managers Can Know They're Being Evil — Ludicity
  718. Intercepting Allocations with the Global Allocator
  719. Why async Rust? - Without boats, dreams dry up
  720. LSP could have been better
  721. Quantifying Hope On A Global Scale
  722. ChatGPT-AutoExpert/System Prompts.md at main · spdustin/ChatGPT-AutoExpert
  723. How to compare signed and unsigned integers in C++20?
  724. On Organizing Bookmarks
  725. Okay, fine, I'm using a static site generator now - Xe Iaso
  726. Unpopular Opinion: It’s harder than ever to be a good software engineer
  727. Oort
  728. My E-Reader Setup
  729. How I made a heap overflow in curl
  730. My Quest for Perfect Mental Health and Sanity
  731. Feminism
  732. Bare-metal Rust in Android
  733. WinUI 3 ObservableCollectionEx AddRange | WinAppSDK | XAML | UWP | WPF | .NET
  734. Was async fn a mistake?
  735. Open Sourcing Ferrocene
  736. Strong static typing, a hill I'm willing to die on...
  737. I don't want to know IPs: encryption in TORRENTDYNE
  738. A journey into zero-knowledge proofs
  739. Build simple fuzzer - part 6
  740. Static Site Build Tool - Pranab’s Site
  741. Mozilla and the burning need for clients for power users
  742. A Reflection on my B.S. in Software Engineering
  743. influxdb officially made the switch from Go => Rust
  744. Easing tradeoffs with profiles · baby steps
  745. Chasing the Myth of Zero-Overhead Memory Safety (plus pictures of mythical birds!)
  746. Template meta-programming: Avoiding saying a type before it is complete - The Old New Thing
  747. Subtraction Is Functionally Complete | orlp.net
  748. Comparing reactivity models: Redux vs MobX vs Vuex vs others
  749. Dotfiles matter!
  750. On the future of cloud services and BYOC — Jack Vanlightly
  751. GitHub - microsoft/windows-drivers-rs: Platform that enables Windows driver development in Rust. Developed by Surface.
  752. No Stale Bots
  753. Bottlerocket
  754. www which wasm works
  755. Choosing a more optimal `String` type
  756. The State of Async Rust: Runtimes
  757. Matrix 2.0: The Future of Matrix
  758. Microsoft Remakes Azure Quantum Dev Kit with Rust, 'and It Runs in the Browser!' -- Visual Studio Magazine
  759. Exploring Generative AI
  760. Stability without stressing the !@#! out · baby steps
  761. When Zig Outshines Rust - Memory Efficient Enum Arrays
  762. Java 21 makes me actually like Java again
  763. 🎙️ Trustfall and cargo-semver-checks with Predrag Gruevski - RustShip
  764. Weekly Update 365
  765. Reverse engineering natively-compiled .NET apps
  766. Role Of Algorithms
  767. Introducing RustRover – A Standalone Rust IDE by JetBrains | The IntelliJ Rust Blog
  768. RustRover: Rust IDE by JetBrains
  769. How I review code challenges for recruitment
  770. Three years of Bevy
  771. Good performance is not just big O - Julio Merino (jmmv.dev)
  772. Async Rust Is A Bad Language
  773. HackYourNews
  774. Oxidised Moss | Serpent OS
  775. Simulation extractable versions of Groth’s zk-SNARK revisited - International Journal of Information Security
  776. Tracing Specifics – Know your System with OpenTelmetry
  777. Amor Fati
  778. Why is Bitwarden returning 503s to my Windows app?
  779. cola: a text CRDT for real-time collaborative editing
  780. sled theoretical performance guide
  781. Simulating Gravitational Lensing
  782. Episode 289: Penumbra Catch Up with Finch, Erwan and Jen - ZK Podcast
  783. Orhun's Blog
  784. GameRoy: JIT compilation in High-Accuracy Game Boy Emulation
  785. Your Quick Guide to Pattern Matching in C# - Coding Sonata
  786. Rust: Generics Considered Colorful
  787. Becoming a contractor
  788. X-ray CT scans reveal the art and science of coffee as never before
  789. Costs exposed: Frameworks - Julio Merino (jmmv.dev)
  790. The First Stable Release of a Memory Safe sudo Implementation
  791. GitHub - Ruddle/Fomos: Experimental OS, built with rust
  792. Compiling Rust for .NET, using only tea and stubbornness!
  793. Automata Part 1: Understanding Position Automata
  794. Ruby Outperforms C: Breaking the Catch-22
  795. Modern High Performance C# 2023 Edition
  796. OpenTelemetry in 2023
  797. Using nix-shell to create and share reproducible embedded development environments
  798. A List of Really Obvious Things
  799. Do disturb me | Goto Assignment: A better local Goto Definition
  800. Detecting boomerang values in zero-knowledge circuits using tag analysis
  801. How SNARKs fall short for FHE
  802. Penumbra Security Audits Q3 2023
  803. Rethinking the `setup` convention in Neovim. Is it time for a paradigm shift?
  804. Replacing Mock and Stub with a Fake
  805. Exploring Generative AI
  806. Exploring Generative AI
  807. Understanding Lasso and Jolt, from theory to code
  808. using serde_derive without precompiled binary · Issue #2538 · serde-rs/serde
  809. The Scourge of 00UB | Gavin D. Howard
  810. Finding the right UUID generation algorithm for FlashMQ.com – BigSmoke
  811. Algebraic data types in Lua (Almost)
  812. Abbrev: A Hidden Ruby Gem
  813. Bare Metal Space Invaders
  814. Rachit Nigam | PhD Candidate, Cornell University
  815. Recoverable Errors with Result - The Rust Programming Language
  816. GitHub - valida-xyz/valida: A STARK-based VM focused on code reuse, performance, and modularity
  817. Tailscale vs. Narrowlink | Narrowlink
  818. Building Darklang in F# | fsharpConf 2023
  819. Corrode Rust Consulting
  820. Making AMD GPUs competitive for LLM inference
  821. ReSharper 2023.2: New Features, AI Assistant, and Predictive Debugger Mode
  822. What's missing from values in data tables
  823. Winning Connect4
  824. Should everything be blazingly fast?
  825. GitHub - huggingface/candle: Minimalist ML framework for Rust
  826. Inside STL: The unordered_map, unordered_set, unordered_multimap, and unordered_multiset - The Old New Thing
  827. Getting my library cards onto my phone the hard way — iliana.fyi
  828. Getting Started: Solution Architecture
  829. why 'age int' is better than 'int age'
  830. Being a Disciplined Person In an Undisciplined World
  831. Inside STL: The map, set, multimap, and multiset - The Old New Thing
  832. Engaging volunteer developers effectively | Software and puns
  833. GitHub - supabase/postgres_lsp: A Language Server for Postgres
  834. On Good Men
  835. Logan Keenan - Client-Side Server with Rust: A New Approach to UI Development
  836. Paired benchmarking. How to measure performance
  837. Wiki - ElixirForCynicalCurmudgeons
  838. Inside STL: The string - The Old New Thing
  839. A Gentle Introduction to LLVM IR · mcyoung
  840. On Modularity of Lexical Analysis
  841. Reflections on a Month with BBEdit and Nova — Sympolymathesy, by Chris Krycho
  842. Cachelines and Striped Locks — ~ngp
  843. AI Diaries: Two Important Facts About Generative Prose
  844. Plugin Architecture in ASP.NET Core – How To Master It
  845. A Git Query Language written in Rust
  846. Hamel’s Blog - Optimizing LLM latency
  847. Digital Bum: Finding a Home/lessness on the Internet
  848. Worldcoin isn’t as bad as it sounds: It’s worse
  849. Building and operating a pretty big storage system called S3
  850. Spirited Away
  851. BadAppleFont
  852. GitHub - PRQL/prql: PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
  853. Introduction to Pocket: obfuscator for MBA expressions
  854. Empathetic tools | Software and puns
  855. GitHub - Uriopass/Egregoria: 3D City Builder without a grid
  856. Exploring garbage collection in V8 with WebGL
  857. Feeds are Not Fit for Gardening — Sympolymathesy, by Chris Krycho
  858. Totality
  859. Rethinking infrastructure as code from scratch
  860. How to clone a Windows Runtime map in the face of possible concurrent modification, part 3 - The Old New Thing
  861. Live from OpenBSD in Amsterdam
  862. How to clone a Windows Runtime map in the face of possible concurrent modification, part 2 - The Old New Thing
  863. Sharing code between Deno and Node where Bun and ts-node failed
  864. Minimalism in Web Development
  865. Stay boring
  866. Why the “Null” Lifetime Does Not Exist
  867. How I run my servers
  868. GitHub - rust-lang/mdBook: Create book from markdown files. Like Gitbook but implemented in Rust
  869. Lemmy frontend alternatives are popping off
  870. Living Life as a B- Student
  871. On Personal Relations As A Manager
  872. The looming demise of the 10x developer
  873. Announcing Rust 1.71.0 | Rust Blog
  874. Cycles of curves: what are they and do we need them?
  875. Regex Isn't Hard - Tim Kellogg
  876. Put a Pin on That
  877. Announcing Windows 11 Insider Preview Build 25905
  878. Finding Your Mojo – Mike Innes
  879. WebAssembly and replayable functions
  880. Being a good mentor - a developers guide
  881. How to Succeed: Lessons from Sam Altman
  882. Computer as she is spoke
  883. Phased Array Microphone
  884. Experiments with eBPF: Snitchrs
  885. My Kind of REPL
  886. GitHub - zksecurity/noname: Noname: a programming language to write zkapps
  887. The Tragic Death of Inheritance
  888. Announcing turmoil | Tokio - An asynchronous Rust runtime
  889. The magic of dependency resolution
  890. MagicPhysX — A Cross-Platform Physics Engine for .NET
  891. How libstdc++ `std::unordered_map` implemented?
  892. Survival mode, life immediately after and Paul Graham's How to do great work
  893. Test Autodiscovery is a Silver Bullet
  894. On Dark Triads in Silicon Valley
  895. Json Parser in C# using Functional Programming
  896. Fastest Branchless Binary Search
  897. File for Divorce from LLVM · Issue #16270 · ziglang/zig
  898. How to wait for multiple C++ coroutines to complete before propagating failure, custom promise - The Old New Thing
  899. Programming Languages Going Above and Beyond
  900. Engineering Guardrails
  901. Lili’s pieces - CV4Animals 2023
  902. Why I chose php for my new side project
  903. How to Write a Flexbox Layout Engine
  904. Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022
  905. The hardest part of building software is not coding, it's requirements
  906. Open at Microsoft: Dapr
  907. ayb: A multi-tenant database that helps you own your data
  908. How to wait for multiple C++ coroutines to complete before propagating failure, initial plunge - The Old New Thing
  909. Nick Chapsas
  910. XML is the future
  911. My journey into Microsoft – Unstructed.tech
  912. Understanding asynchronous I/O; building an event loop from scratch | mbinjamil.dev
  913. System Initiative: The Second Wave of DevOps
  914. The case of the make_shared on a C++/WinRT type - The Old New Thing
  915. what do you find most frustrating about dotnet?
  916. My first steps with Nix on Mac OSX as Homebrew replacement
  917. Why LLM-assisted table transformation is a big deal
  918. Generate HTTP Client for your API
  919. Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection
  920. Why I Became an Instructor at Zero to Mastery - Claudio Bernasconi
  921. What are the scenarios where "Rewrite it in Rust" didn't meet your expectations or couldn't be successfully implemented?
  922. sort-research-rs/text.md at main · Voultapher/sort-research-rs
  923. Browsertech Digest: “We should stop using JavaScript”
  924. Reordering C++ template type parameters for usability purposes, and type deduction from the future - The Old New Thing
  925. F# is the .NET Rust
  926. Effortlessly Support Next Gen Image Formats --or-- A Picture Is Worth A Better Image
  927. Build your own Genetic Algorithm
  928. Proto-Danksharding: Speeding Up Blobs Verification
  929. ASP.NET Core Authentication with YARP
  930. Bounds Safety: Avoiding Death by a Thousand Constructors
  931. Demystifying WebAssembly: What Beginners Need to Know
  932. Understanding the Tech Right
  933. Release Blink 1.0 · jart/blink
  934. graydon2 | The Rust I Wanted Had No Future
  935. Taming the Beast: Comparing Jsonnet, Dhall, Cue
  936. My radical philosophy of programming
  937. ZK app developers should be able to see down to the constraints
  938. Promoted from Dev to Team Lead: 8 Things They Didn’t Tell Me
  939. JuLox: What I Learned Building a Lox Interpreter in Julia
  940. wasmati: You should write your WebAssembly in TypeScript
  941. Announcing Rust 1.70.0 | Rust Blog
  942. The RustConf Keynote Fiasco, explained
  943. What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
  944. A locking war story
  945. I think Zig is hard...but worth it
  946. Announcing WASIX
  947. Open at Microsoft - Dapr
  948. Rust: The wrong people are resigning
  949. Expected performance of a Bloom filter
  950. Language Pragmatics Engineering
  951. A path to niche skill-sets and community
  952. Controlling Your Fate with OIDC and Tailscale
  953. On being paid to learn
  954. I Am No Longer Speaking at RustConf 2023
  955. Extreme Bevy: Making a p2p web game with rust and rollback netcode
  956. phaazon.net
  957. Standardized exams measure intrinsic ability, not racial or socioeconomic privilege
  958. Getting rid of phishing training mails
  959. Interesting links of the week 2023-21 (#73)
  960. One complex setup
  961. Being a Full-Stack Developer is no longer a dirty word
  962. Talent is overestimated
  963. crates - Visual Studio Marketplace
  964. On creating (and using) a transforming iterator - The Old New Thing
  965. GitHub - stepchowfun/typical: Data interchange with algebraic data types.
  966. How Much Memory Do You Need to Run 1 Million Concurrent Tasks?
  967. Compress-a-Palooza: Unpacking 5 Billion Varints in only 4 Billion CPU Cycles
  968. Writing Python like it’s Rust
  969. Intelligence as efficient model building
  970. Improving the terminal
  971. Microsoft Azure security evolution: Embrace secure multitenancy, Confidential Compute, and Rust | Azure Blog | Microsoft Azure
  972. ReSharper 2023.2 Kicks Off the Early Access Program! | The .NET Tools Blog
  973. Single Abstract Method Traits · mcyoung
  974. Experimenting with multi-factor encryption
  975. Compiling C# like Rust, Go and C++
  976. Fast hashing, it's not that simple
  977. Estimated IQ distribution of children given IQ of parents
  978. Monolith vs Microservices: With Elixir You Don't Need to Choose
  979. Memory Allocation
  980. You are holding it wrong
  981. Announcing Dart 3
  982. Implementing Vale's Region Borrowing, and its Unexpected Quest
  983. Updating Buck
  984. GitHub Code Search Now Generally Available, 'Way More than grep' -- Visual Studio Magazine
  985. On Custom-Width Integer Types
  986. A few words on Ruby's type annotations state
  987. Exploring the Personal Web
  988. Native AOT libraries with TypeScript
  989. I want to talk about WebGPU
  990. What can I do if I don't want my file version number to be a sequence of four integers? - The Old New Thing
  991. What is Type-Level Programming? - sulami's blog
  992. Error handling patterns
  993. Bringing Hardware Accelerated Language Models to Consumer Devices
  994. How AI coding companions will change the way developers work
  995. Microsoft is rewriting core Windows libraries in Rust
  996. Blog | Samuel
  997. Using Crates.io with Buck
  998. Introduction to HTTP Multipart
  999. Well-maintained Software
  1000. Are pull requests bad because they originate from open-source development?
  1001. GitHub - mitsuhiko/rye: an experimental alternative to poetry/pip/pipenv/pyenv/venv/virtualenv/pdm/hatch/…
  1002. Manning
  1003. Current Issues With The Qt Project - From The Outside Looking In
  1004. Announcing Rust 1.69.0 | Rust Blog
  1005. How RocksDB works - Artem Krylysov
  1006. Simplifying Bézier paths
  1007. Welcome to Peter's DevLog - Wrapping C libraries in Nim
  1008. Make It Memory Safe: Adapting curl to use Rustls
  1009. Using buck to build Rust projects
  1010. Entity-Based Reinforcement Learning
  1011. I Think I Found a Privacy Exploit in ChatGPT
  1012. touchHLE in depth, part 1: a day in the life of a function call
  1013. NuGet.org Terms of Service Update on Unexpected Behavior and Hate Speech - The NuGet Blog
  1014. Sponge API for Field Elements
  1015. Why I built zp?
  1016. Why I’m leaving the Shopify Apps business
  1017. Writing the most reliable driver ever (Part 1)
  1018. Binding Generator Preview Release
  1019. Rust Foundation Solicits Feedback on Updated Policy for Trademarks - Slashdot
  1020. Introduction - Mina book
  1021. Can You Trust a Compiler to Optimize Your Code?
  1022. If It's So Good, Why Isn't Everyone Doing It?
  1023. Style Conformance for Blind Developers: Sonica
  1024. The Autocomplete Myth
  1025. GitHub - snarkify/arkmsm
  1026. Using TLA⁺ at Work
  1027. The Language Wars Are Over: ChatGPT Won
  1028. All you need is data and functions
  1029. Looking at C# 12 Proposals and Beyond
  1030. Making a Bloom Filter Keyboard - Blog by Maryanne Wachter
  1031. UB Might Be a Wrong Term for Newer Languages
  1032. Bullsh*t Jobs
  1033. Moving from Rust to C++
  1034. Helix
  1035. Janet for Mortals
  1036. Julia's latency: Past, present and future
  1037. Enabling low-latency, syntax-aware editing using Tree-sitter - Zed Blog
  1038. It's Not About the Job Openings
  1039. Why I Spent a Week on a 10-Line Code Change
  1040. How to Review and Refactor Code with GPT-4 (and ChatGPT) — SitePoint
  1041. Recognition and rewards at work
  1042. Flecs 3.2 is out!
  1043. Zig And Rust Mar 26, 2023
  1044. Software is not defined by the language it's written in
  1045. None of Your Business - Why, I Wonder?
  1046. The AsyncIterator interface - Without boats, dreams dry up
  1047. Curl, the URL fetcher that can, marks 25 years of transfers
  1048. Why am I getting a weird error about promise_type when I try to write a coroutine? part 2 - The Old New Thing
  1049. GitHub - typst/typst: A new markup-based typesetting system that is powerful and easy to learn.
  1050. Logging and the Homelab - PV;WTF
  1051. Betraying vim for the IDEs of March
  1052. Stuff I use in the terminal
  1053. Footage of my game engine built from scratch in Rust (with Multiplayer support)
  1054. Speeding up the JavaScript ecosystem - npm scripts
  1055. Everything I know | Everything I know
  1056. What is Functional Programming? |
  1057. Dan Ports (@dan@discuss.systems)
  1058. The birth of a package manager
  1059. GitHub - epilys/gerb: Graphical font editor (GTK + Rust)
  1060. How to use Prometheus for web application monitoring
  1061. Patterns & Abstractions - Without boats, dreams dry up
  1062. HaveIBeenPwned, DevSecOps, and Other Security Things with Troy Hunt
  1063. SQLx Compile Time Woes
  1064. Jonas Hietala: Battling burnout
  1065. What is Deno? | zaynetro
  1066. Observing and Understanding Backlog Queues in Linux | Kris Nóva
  1067. Weird web pages
  1068. What a good debugger can do
  1069. Taking Full Advantage of NoSideEffects, Or What's It Like To Be An Obsessional Researcher
  1070. An Engine For An Editor
  1071. When Zig is safer and faster than Rust
  1072. How Discord Stores Trillions of Messages
  1073. Write a First Person Game in 2KB With Rust
  1074. vim users are better programmers
  1075. GitHub - Drew-Alleman/DataSurgeon: DataSurgeon: Quickly Extracts IP's, Email Addresses, Hashes, Files, Credit Cards, Social Secuirty Numbers and more from text
  1076. The World's Smallest Hash Table
  1077. 346: Calling .NET Libraries from Rust with Native AOT
  1078. CI/CD Best Practises: Scaling A Delivery Platform — Evan Smith
  1079. bryan garza
  1080. Dangerously good product managers
  1081. .NET R&D Digest (February, 2023)
  1082. Getting Out of Character - Simple Talk
  1083. One Book, Many Readings
  1084. axo blog - Thanks For Breaking cargo-dist! (I Rewrote It)
  1085. Introducing the Determinate Nix Installer — Determinate Systems
  1086. Defining Database Developer Experience
  1087. Making Go telemetry opt-in is a mistake
  1088. Rust Coreutils: Fixing Low-Hanging Performance Fruit
  1089. Programming Will Always Use Text
  1090. GCC Gets a New Frontend for Rust - Slashdot
  1091. Over-engineering my document storage system with Paperless-ngx
  1092. Why am I getting an unhandled exception from my C++ function that catches all exceptions? - The Old New Thing
  1093. GitHub - MichalStrehovsky/sizegame: Compare binary sizes of canonical Hello World in different languages
  1094. GDB 13.1 released!
  1095. 346: Calling .NET Libraries from Rust with Native AOT
  1096. Avg, mean, and average - Pravesh Koirala
  1097. What Austral Proves (Crash Lime)
  1098. Why is building a UI in Rust so hard?
  1099. Making Sense of Acquire-Release Semantics
  1100. So long, and thanks for all the deployments: deprecating Wrangler v1
  1101. How to Create a Pharo Smalltalk Plugin
  1102. How I Decreased ETL Cost by Leveraging the Apache Arrow Ecosystem
  1103. Gamebert: a Game Boy emulator built by Robert | Robert Heaton
  1104. EVM at Risc0 | Odra Blog
  1105. Writing a Debugger From Scratch - DbgRs Part 1
  1106. Lean BDD and Code Generation
  1107. The unsafe language doom principle
  1108. Containers and Serverless—Rivals or Cohorts?
  1109. The case of the RPC_E_DISCONNECTED error thrown from await_resume
  1110. WebView2, Electron challengers, and (slightly) lighter desktop web applications
  1111. It is becoming difficult for me to be productive in Python - blag
  1112. Comparing the Same Project in Rust, Haskell, C++, Python, Scala and OCaml
  1113. New ideas
  1114. Marketing Yourself As A Junior Engineer
  1115. Bare-bones Diffusion Models
  1116. Contributing to open source projects and about learning zero-knowledge proofs
  1117. Trust Networks: How We Actually Know Things
  1118. Reversing UK mobile rail tickets
  1119. Carving The Scheduler Out Of Our Orchestrator
  1120. Rust's Ugly Syntax
  1121. JetBrains Dev Report: TypeScript Is Fastest-Growing Programming Language -- Visual Studio Magazine
  1122. Python’s “Disappointing” Superpowers
  1123. Wasm compression benchmarks and the cost of missing compression APIs
  1124. Rewrite it in Rust by ridiculousfish · Pull Request #9512 · fish-shell/fish-shell
  1125. Windows I/O completion - One little trick · James Sturtevant
  1126. A Catalog of Big Visions for Biology
  1127. Measuring the Impact of False Sharing
  1128. Multi-cursor code editing: An animated introduction
  1129. You're probably learning a technology in its seventh season, not its pilot
  1130. Forking Chrome to render in a terminal
  1131. Cyber - Fast and concurrent scripting.
  1132. Announcing Rust 1.67.0 | Rust Blog
  1133. What is a type system, really?
  1134. Dear Retro Community, Stop Writing Tools in C
  1135. Stoic Personality Disorder
  1136. pagerank for my Obsidian notes
  1137. Add notes when blocking users | GitHub Changelog
  1138. It’s 2023, You Should Be Using Typescript!
  1139. It’s the future — you can stop using JPEGs — Daniel Immke
  1140. Ruff: The First 200 Releases
  1141. Good Software Architectures are mostly about Boundaries
  1142. Good leaders set a vision and secure buy-in
  1143. Checking for Overflow in C#
  1144. Lane-accurate street maps with OpenStreetMap – writing a vector tileserver for osm2streets - Jake Coppinger
  1145. Servo to Advance in 2023
  1146. py-tsbs-benchmark/README.md at main · questdb/py-tsbs-benchmark
  1147. How to Become .NET Architect
  1148. The Everything Algorithm — Zac Pustejovsky
  1149. GitHub - juspay/hyperswitch: An Open Source Financial Switch to make Payments fast, reliable and affordable
  1150. Your tech stack is not the product
  1151. Supporting the Use of Rust in the Chromium Project
  1152. Writing a TLA⁺ tree-sitter grammar
  1153. What's New in Ruby 3.2
  1154. Fighting Cognitive Biases in Software Engineering: A Guide to Rational Decision-Making - 𝖅𝕵
  1155. Is coding in Rust as bad as in C++?
  1156. Production Twitter on One Machine? 100Gbps NICs and NVMe are fast
  1157. Microfeatures I'd like to see in more languages
  1158. The faker's guide to reading (x86) assembly language
  1159. Chunking strings in Elixir: how difficult can it be?
  1160. Join Mina's zkIgnite, Cohort 1
  1161. bflat - C# as you know it but with Go-inspired tooling
  1162. phaazon.net
  1163. Luciano Remes | Golang is 𝘼𝙡𝙢𝙤𝙨𝙩 Perfect
  1164. Hardware-friendliness of HyperPlonk - HackMD
  1165. Nix journey part 1: creating a flake
  1166. Introducing Austral: A Systems Language with Linear Types and Capabilities
  1167. One-line Journaling | mkaz.blog
  1168. The Catch-22 of Democracy - Pravesh Koirala
  1169. The Matrix Holiday Update 2022 | Matrix.org
  1170. Chris's Wiki :: blog/programming/RustIsInevitable
  1171. Lessons Learnt From Solving AoC in One Second
  1172. On Giving Better Advice
  1173. Default Interface Method in C# And When to Use It - Code Maze
  1174. Orhun's Blog
  1175. 5 traits of a successful team
  1176. Nix on the Steam Deck — Determinate Systems
  1177. Implementing the MySQL server protocol for fun and profit
  1178. What are the biggest reasons newcomers give up on OCaml?
  1179. What are the biggest reasons newcomers give up on OCaml?
  1180. GitHub - Spotifyd/spotifyd: A spotify daemon
  1181. Functional error-handling with stack traces
  1182. The top 10 discoveries about ancient people from DNA in 2022
  1183. Automatically scaling Drone CI with Gitea | Jacob Kiers
  1184. Software complexity and potential solutions
  1185. Bias and performance
  1186. WebGPU — All of the cores, none of the canvas — surma.dev
  1187. Preparing to move away from Twitter
  1188. If we must, let's talk about safety
  1189. Inside C++/WinRT: IReference<T>
  1190. Why you can’t build a web browser and why you should anyway.
  1191. Does .NET 6 support windows 98 · Discussion #79642 · dotnet/runtime
  1192. A Neat XOR Trick
  1193. Consuming .NET WebAssembly From JavaScript in the Browser
  1194. Easing Deployment Without Containers
  1195. What does it mean when the compiler tells me that promise_type: is not a member of coroutine_traits<void>?
  1196. ECMAScript proposal: iterator helpers
  1197. RC Week 12: What's Next, and Speedrunning Crafting Interpreters
  1198. dev-wasm
  1199. Using Layouts for Personal Automation
  1200. What I have been working on: Modal
  1201. Implications of choosing State instead of Cache
  1202. Goodbye to the C++ Implementation of Zig ⚡ Zig Programming Language
  1203. Nix Knowledge Sharing
  1204. Technique: Recursive variants and boxes
  1205. GitHub - betaveros/noulith: *slaps roof of [programming language]* this bad boy can fit so much [syntax sugar] into it
  1206. The top programming languages
  1207. engineering + product + health
  1208. Day 2: Less Variable Wattage = More Flow
  1209. 2022 Advent of Code Day 1: Calorie Counting
  1210. Memory Safe Languages in Android 13
  1211. How much does Rust's bounds checking actually cost?
  1212. Tales of the M1 GPU - Asahi Linux
  1213. out-of-bounds memory access bug
  1214. Be less scared of overconfidence
  1215. GCC undefined behaviors are getting wild
  1216. How do I pass a raw pointer to a Windows Runtime function?
  1217. Using Rust at a startup: A cautionary tale
  1218. How does JavaScript represent output parameters in the Windows Runtime?
  1219. Using Rust at a startup: A cautionary tale
  1220. Sometimes perfect forwarding can be too perfect: Lazy conversion is lazy
  1221. Hachyderm.io
  1222. Let's Talk About WASM and WASI — Offline Stream #11
  1223. Let's Talk About WASM and WASI — Offline Stream #11
  1224. My worst job offer ever
  1225. Zero-Cost Memory Safety with Vale Regions (Preview)
  1226. How I Made A Webiste
  1227. davidfowl (@davidfowl@hachyderm.io)
  1228. C# support in Fleet Public Preview | The .NET Tools Blog
  1229. Million Dollar Infrastructure for Tic-Tac-Toe
  1230. Sapling SCM | Sapling
  1231. Penrose tiling quilt
  1232. C++ constexpr parlor tricks: How can I obtain the length of a string at compile time?
  1233. #lang lua
  1234. Infrequent, Pragmatic, Lambda Blog - Let's agree to be different. On empirical and deductive nature of coding.
  1235. Crate List - Blessed.rs
  1236. NSA urges orgs to use memory-safe programming languages
  1237. The Fediverse is Inefficient (but that's a good trade-off)
  1238. A Simple Computation Engine in F#
  1239. Minikin retrospective
  1240. The Age of PageRank is Over
  1241. C Isn't A Programming Language Anymore - Faultlore
  1242. SortedSet in C# - Code Maze
  1243. Traits in Rust
  1244. In the debugger, how can I get from a projected type back to the C++/WinRT implementation?
  1245. How to contribute to Kimchi
  1246. Vaultwarden on an RPi
  1247. Introduction - Mina book
  1248. C++ is the next C++
  1249. HashSet in C# - Code Maze
  1250. Is Turbopack really 10x Faster than Vite? · Discussion #8 · yyx990803/vite-vs-next-turbo-hmr
  1251. We Just Gave $260,028 to Open Source Maintainers
  1252. fleetwood.dev
  1253. Using WASM and WASI to run .NET 7 on a Raspberry PI Zero 2 W
  1254. Setting properties in C++/WinRT is done by a function call, but you need to call the function the right way
  1255. Fable · Announcing Snake Island (Fable 4) Alpha Release
  1256. It's time to to thank UVM and say goodbye
  1257. Encapsulation in Functional Programming
  1258. Introducing the Docker+Wasm Technical Preview
  1259. Discuss the problem, not the solution
  1260. Debugging C With Cosmopolitan Libc
  1261. GitHub - losvedir/transit-lang-cmp: Programming language comparison by reimplementing the same transit data app
  1262. What's wrong with a for loop?
  1263. The HTTP crash course nobody asked for
  1264. How Trying New Programming Languages Helped Me Grow as a Software Engineer
  1265. Top 10 highest paid programming languages in 2022
  1266. An API-first approach to building Node.js applications | Red Hat Developer
  1267. GitHub - microsoft/foss-fund: The Microsoft FOSS Fund provides a direct way for Microsoft engineers to participate in the nomination and selection process to help communities and projects they are passionate about. The FOSS Fund provides $10,000 sponsorships to open source projects as selected by Microsoft employees.
  1268. Delivering consistency and transparency for cloud hardware security
  1269. Announcing KataOS and Sparrow
  1270. How To Stop Worrying And Love Frontend Dev - Bill Prin's Tech Blog
  1271. Writing An Incremental Typesetting Engine | Laurenz's Blog
  1272. The case of the memory corruption from a coroutine that already finished
  1273. How observability-driven development creates elite performers
  1274. The Missing Prelude to The Little Typer's Trickiest Chapter
  1275. [Last Week in .NET #104] – Roast Beef CVEs
  1276. The 4th year of SerenityOS
  1277. An improved guide for compiling WASM with Emscripten and Embind
  1278. Dave's Garage: Ask a Former Microsoft Windows Developer Anything!
  1279. Zig-style generics are not well-suited for most languages
  1280. Why is it hard to learn another programming language?
  1281. Hard Mode Rust
  1282. Setting up my new computer, vim, and listening to Spotify in the terminal
  1283. 🤓 So you're using a weird language 🧠
  1284. My Personal Tech Limbo (and Elixir vs Rust)
  1285. Compiling C# into NATIVE code, just like Go, Rust and C++
  1286. Thread by @LinaAsahi on Thread Reader App
  1287. Beyond Freedom and Dignity (B. F. Skinner)
  1288. Orhun's Blog
  1289. GitHub - jamii/hytradboi-jam-2022
  1290. .NET vs Go vs Node
  1291. git/torvalds/linux.git - Linux kernel source tree
  1292. Why dating apps don’t work
  1293. How (and why) nextest uses tokio, part 1 :: sunshowers
  1294. The official documentation is so good it makes me sad.
  1295. LKML: Linus Torvalds: Re: [PATCH v9 12/27] rust: add `kernel` crate
  1296. Steady State means Continuous Rewriting - Bruno Scheufler
  1297. cairo-rs/field_utils.rs at a8e8fa9aa2554e6bfb76d145ab1acd5ff29888e4 · lambdaclass/cairo-rs
  1298. Blazor Among Top Libraries for 'Niche' WebAssembly, Which Sees Shrinking Usage -- Visual Studio Magazine
  1299. Debugging coroutine handles: Looking for the source of a one-byte memory corruption
  1300. Announcing ICU4X 1.0
  1301. Modern C# Techniques, Part 1: Curiously Recurring Generic Pattern
  1302. Four Important Eras that Define Art
  1303. Someone is pretending to be me.
  1304. Rust is eating into our systems, and it's a good thing
  1305. Linus Torvalds: Rust will go into Linux 6.1
  1306. roapi/README.md at main · roapi/roapi
  1307. The road to Zettalinux
  1308. Announcing Rust 1.64.0 | Rust Blog
  1309. Virtual tables with zig-sqlite
  1310. The impossible case of pitching rust in a web dev shop
  1311. The Wage Gap 2
  1312. Renaming Our Company Revealed a Critical Bug
  1313. Release Cosmopolitan v2.1 · jart/cosmopolitan
  1314. TODO: Post an Article
  1315. Over-engineering my TV watching - Part 1: bypassing geo-block with a custom reverse proxy
  1316. Rust is coming to the Linux kernel
  1317. PostgresML is Moving to Rust for our 2.0 Release
  1318. Test X by Controlling X
  1319. WebAssembly Users a Mix of Backend and Full Stack Developers
  1320. Hacker News
  1321. GitHub - nviennot/core-to-core-latency: Measures the latency between CPU cores
  1322. Location independent jobs in Programming, Marketing, Sales, Design, and more.
  1323. Graphite | Redefining state-of-the-art graphics editing.
  1324. noname developer updates: structs are working!
  1325. Cloudflare Ditches Nginx For In-House, Rust-Written Pingora
  1326. Raised Bars, Or Breaking into Tech
  1327. GitHub - aws-samples/serverless-dotnet-demo
  1328. Rustdoc cleanups and improvements
  1329. A pair of Rust kernel modules
  1330. My Blog is Hilariously Overengineered to the Point People Think it's a Static Site
  1331. 6 Simple and Useful PostgreSQL Features that I wish I knew when I started
  1332. GitHub - crate-ci/cargo-release: Cargo subcommand `release`: everything about releasing a rust crate.
  1333. [Last Week in .NET #100] – Where’s the cool kids table?
  1334. Who Cares About Diversity?
  1335. GitHub - tlepoint/fhe.rs: Fully Homomorphic Encryption library in Rust
  1336. Build Your Career on Dirty Work
  1337. Ed25519 Deep Dive Addendum
  1338. GitHub - migueldeicaza/SwiftTerm at uiscrollview-2022-07
  1339. Parallel curves of cubic Béziers
  1340. The Case for Use.GPU
  1341. Working with programming languages you DON'T like
  1342. Battle of the Text Editors
  1343. Zig, the small language
  1344. Dart is Boring | akos.ma
  1345. Difftastic, the Fantastic Diff
  1346. What's Inside Of a Distroless Image - Taking a Deeper Look
  1347. Introducing Riff — Determinate Systems
  1348. HTTP Timeouts
  1349. An almost religious case for Rust
  1350. Formal Verification of ZK Constraint Systems
  1351. Maik Klein
  1352. Tips to Get Started with Cosmopolitan Libc
  1353. Arti 1.0.0 is released: Our Rust Tor implementation is ready for production use. | Tor Project
  1354. GitHub - mimoo/noname: Noname: a programming language to write zkapps
  1355. Introduction - The Rust Reference
  1356. How we clone a running VM in 2 seconds - CodeSandbox Blog
  1357. Run
  1358. Webscraping on hard mode with Purescript
  1359. Writing a .NET profiler in C# - Part 1
  1360. My 40GBe NAS Journey.
  1361. .NET 7 - Pattern Matching With Spans #shorts
  1362. Devs don’t want to do ops
  1363. Inside the Pinecone | Pinecone
  1364. Is Game Development a Dream Job?
  1365. Vulnerability in Linux containers – investigation and mitigation
  1366. What is Lattice-based Cryptography?
  1367. The `collapsist` debate in Spain: a summary
  1368. On being busy
  1369. I Went to a “Dangerous Alt-Right Rally” | The Blog of Dr. Josh C. Simmons
  1370. How I Learned to Stop Worrying and Love Macros
  1371. Programming breakthroughs we need
  1372. Physical buttons outperform touchscreens in new cars, test finds
  1373. Big Changes Ahead for Deno
  1374. Will Bun JavaScript Take Node's Crown
  1375. Maxim Marshall - eInk VNC
  1376. Announcing Rust 1.63.0 | Rust Blog
  1377. SAFE (Sponge API for Field Elements) – A Toolbox for ZK Hash Applications - HackMD
  1378. GitHub - filecoin-project/neptune: Rust Poseidon implementation.
  1379. Write a Note to Your Spouse Every Day
  1380. Gregory Szorc's Digital Home | Achieving A Completely Open Source Implementation of Apple Code Signing and Notarization
  1381. On being a staff engineer
  1382. Announcing: MiniRust
  1383. Microdosing with psilocybin mushrooms: a double-blind placebo-controlled study - Translational Psychiatry
  1384. Designing for the last earth
  1385. Weird Expressions and Where to Find Them
  1386. So Zero It's ... Negative? (Zero-Copy #3)
  1387. 'The best thing we can do today to JavaScript is to retire it,' says JSON creator Douglas Crockford • DEVCLASS
  1388. Why I Love Still PHP and Javascript After 20+ years
  1389. Making a PR to Nixpkgs
  1390. Minimal Container Images: Towards a More Secure Future
  1391. To Be Determined - Generic Recursion Applied to Algebraic Graphs
  1392. Please stop citing TIOBE
  1393. Understanding Jane Street
  1394. How I regained concentration and focus
  1395. GitHub - phiresky/sqlite-zstd: Transparent dictionary-based row-level compression for SQLite
  1396. Rust Playground
  1397. Microsoft open sources its software bill of materials (SBOM) generation tool
  1398. EdgeDB 2.0 | EdgeDB Blog
  1399. Actually Portable Executables with Rust and Cosmopolitan Libc
  1400. The different ways to handle errors in C
  1401. Twenty years of Valgrind
  1402. GitHub - o1-labs/proof-systems: The proof systems used by Mina
  1403. proof-systems/CONTRIBUTING.md at master · o1-labs/proof-systems
  1404. Tech Burnout - A Retrospective
  1405. Laurenz's Blog
  1406. ~icefox/garnet - sourcehut hg
  1407. Some Thoughts on Zig — Sympolymathesy, by Chris Krycho
  1408. Gregor Riegler · Getting better at CI
  1409. Write your own Javascript/Typescript tests runner in 80 lines of code </>
  1410. What happens when you press a key in your terminal?
  1411. GitHub - MystenLabs/narwhal: Narwhal & Tusk are a high throughput mempool & consensus, used in the Sui smart contract platform
  1412. GitHub - codecrafters-io/build-your-own-x: Master programming by recreating your favorite technologies from scratch.
  1413. GitHub - carbon-language/carbon-lang: Carbon language specification and documentation.
  1414. Using Apache Kafka to process 1 trillion messages
  1415. A story about AF_XDP, network namespaces and a cookie
  1416. State of the SqueakPhone—Syndicated Actors
  1417. Scratch is a big deal
  1418. Advice for the next dozen Rust GUIs
  1419. GitHub - mgunyho/tere: Terminal file explorer
  1420. How I went about learning Rust
  1421. GitHub - nalinbhardwaj/zordle
  1422. Lessons from Writing a Compiler
  1423. How to be an Architect?
  1424. Learn a language by writing too many Forths
  1425. VS Code and Python: A Natural Fit for Data Science -- Visual Studio Magazine
  1426. Introduction - Roguelike Tutorial - In Rust
  1427. WAF from the scratch
  1428. Rust front-end
  1429. Argo workflow as performance test tool
  1430. Lichess
  1431. Is it time to look past Git?
  1432. Announcing support for WASI on Cloudflare Workers
  1433. SourceHut is committed to making IRC better
  1434. Octopus Intelligence and the Puzzle of Sociality
  1435. A Social Theory of Intelligence (that Includes the Seemingly Unsocial Octopus)
  1436. How to get a job in a new industry without experience | Jason Tu
  1437. Average Software Engineering Salaries by Country in 2022
  1438. Announcing Ruby Shield
  1439. Hacker's Guide to Making Circuit Boards (Part 1)
  1440. Bun is a fast all-in-one JavaScript runtime
  1441. nabeelqu
  1442. 5 lessons I learnt after coding for 10 years
  1443. The last two years in Miri
  1444. Toward Robust
  1445. What Metric to Use When Benchmarking?
  1446. Find programming work by increasing luck surface area
  1447. TypeScript Vaults Ahead of Java to Crack Stack Overflow Top 5 -- Visual Studio Magazine
  1448. haibane_tenshi's blog - Obscure Rust: reborrowing is a half-baked feature
  1449. rustc_typeck - Rust
  1450. rustc_typeck::collect - Rust
  1451. Expr in rustc_ast::ast - Rust
  1452. Asked and answered: the results for the 2022 Developer survey are here!
  1453. Build your Golang package docs locally
  1454. GitHub Quick Reviews
  1455. Introducing PyScript
  1456. The State of WebAssembly 2022
  1457. Deno raises $21M
  1458. WebAssembly Everywhere
  1459. My 40-liter backpack travel guide
  1460. V Language Review (2022)
  1461. Citybound
  1462. Because cross-compiling binaries for Windows is easier than building natively
  1463. GitHub - sarsko/CreuSAT: CreuSAT - A formally verified SAT solver written in Rust and verified with Creusot.
  1464. Matrix notes - anarcat
  1465. Ante
  1466. My other database is a compiler
  1467. Everything Is Broken: Shipping rust-minidump at Mozilla – Part 1 – Mozilla Hacks - the Web developer blog
  1468. Electric vehicle battery capable of 98% charge in less than ten minutes
  1469. Cranelift, Part 4: A New Register Allocator
  1470. Site Update: Hero Images
  1471. Overview of eBPF procfs kernel parameters
  1472. eBPF, sidecars, and the future of the service mesh
  1473. Jack of all trades, master of hyperfocus
  1474. GitHub - ClueLang/Clue: C/Rust like programming language that compiles into Lua code
  1475. Microsoft Ships Windows App SDK 1.1 to Build Apps Using WinUI 3, WebView2 -- Visual Studio Magazine
  1476. Supertag — Supertag 0.1.0 documentation
  1477. How Effective Abstractions Are Opinionated | 8th Light
  1478. (async) Rust doesn't have to be hard
  1479. Macro Patterns - A match made in heaven
  1480. Is tree-sitter good enough? – Jake Zimmerman
  1481. The Misery of Mainstream Programming
  1482. Syntax highlighting on the web
  1483. Why I'm hyped about Julia for Bioinformatics | Next.js Blog Example with Org
  1484. Async destructors, async genericity and completion futures
  1485. raku & rust: a romance?
  1486. Major Version Numbers are Not Sacred
  1487. Multiplicity Choices Are Hard to Model and Change
  1488. Why are tools such as Docker and Kubernetes written in Go and not C#? : csharp
  1489. We Already Have Go 2
  1490. r/csharp - Why are tools such as Docker and Kubernetes written in Go and not C#?
  1491. Why are tools such as Docker and Kubernetes written in Go and not C#?
  1492. It’s good to bet on .NET
  1493. Why are tools such as Docker and Kubernetes written in Go and not C#? : csharp
  1494. Why are tools such as Docker and Kubernetes written in Go and not C#? : csharp
  1495. Oren Eini on RavenDB, including Consistency Guarantees and C# as the Implementation Language
  1496. Announcing CBL-Mariner 2.0
  1497. Modern programming languages require generics
  1498. Rust Guide: Sum-Check protocol
  1499. Happy 10th Birthday Compiler Explorer! — Matt Godbolt’s blog
  1500. Visual Studio Code Nods to Rapidly Rising Rust Language -- Visual Studio Magazine
  1501. GitHub - sharkdp/fd: A simple, fast and user-friendly alternative to 'find'
  1502. Memory safety for SerenityOS
  1503. GitHub - zefchain/serde-reflection: Rust libraries and tools to help with interoperability and testing of serialization formats based on Serde.
  1504. bunnie's blog
  1505. Spotify issues - Shogan.tech
  1506. What's New in Visual Studio Code 1.67 (April 2022 Update) -- Visual Studio Magazine
  1507. Laurence Tratt: Static Integer Types
  1508. The Shape of Code » A new career in software development: advice for non-youngsters
  1509. Network performance update: Platform Week
  1510. Wrong by Default
  1511. A clean start for the web - macwright.com
  1512. Introducing Lurk: A programming language for recursive zk-SNARKs
  1513. Interesting Things #56 — So long
  1514. Improved Process Isolation in Firefox 100 – Mozilla Hacks - the Web developer blog
  1515. Regular Expression Improvements in .NET 7
  1516. What’s new
  1517. Earn $200K by fuzzing for a weekend: Part 1
  1518. Let's talk about this async
  1519. Vulnerability Engineer (Cyber Security / Penetration Testing) - Careers at Apple
  1520. Laurence Tratt: Programming Style Influences
  1521. Automatic Differentiation: Forward and Reverse
  1522. Xilem: an architecture for UI in Rust
  1523. How to stop synchronous code in a web worker?
  1524. Unix command line conventions over time
  1525. GitHub - copy/v86: x86 virtualization in your browser, recompiling x86 to wasm on the fly
  1526. Programming Languages Trends in 2022: The Future of Tech
  1527. A shiny future with GATs
  1528. GitHub - mimoo/cargo-specification: The code is the spec
  1529. Criticizing Hare language approach for generic data structures
  1530. What's two-adicity?
  1531. A Difficult Diagnosis (Part 1) - Ronny Liu
  1532. I won free load testing
  1533. Experience Report: 6 months of Go
  1534. Zaplib post-mortem - Zaplib docs
  1535. GitHub - spacedriveapp/spacedrive: Spacedrive is an open source cross-platform file explorer, powered by a virtual distributed filesystem written in Rust.
  1536. Lies we tell ourselves to keep using Golang
  1537. Inform 7 v10.1.0 is now open-source - Authoring / Inform 7 - The Interactive Fiction Community Forum
  1538. Principal Software Engineer in Redmond, Washington, United States | Engineering at Microsoft
  1539. I want off Mr. Golang's Wild Ride
  1540. Personal Knowledge Management is Bullshit
  1541. Help shape the Azure SDK for Rust
  1542. All Roads Lead to Rome: The Machine Learning Job Market in 2022
  1543. Deploy any Web App to Lambda in 60 seconds | Kevin Wang's Blog
  1544. Speeding up Prettier locally and on your CI with dprint
  1545. Why LSP?
  1546. Chris Lattner Interview Transcript — Accidental Tech Podcast
  1547. Celebrating 40 years of ZX Spectrum ❤️ 💛 💚 💙 | GitHub
  1548. Jacques Corby-Tuech - Don't Throw Data Governance Out With the Bathwater
  1549. Magic Beans
  1550. Python’s “Type Hints” are a bit of a disappointment to me
  1551. Laurence Tratt: Practising Programming
  1552. Hot reloading your cargo docs
  1553. Walking Through ECDSA Distributed Key Generation (DKG) - HackMD
  1554. Signature in ecdsa - Rust
  1555. Time safety is more important than memory safety
  1556. On Removing Let and Let Mut
  1557. Changing std::sort at Google’s Scale and Beyond
  1558. Rust YJIT by XrXr · Pull Request #5826 · ruby/ruby
  1559. The absurd complexity of server-side rendering
  1560. Emacs Configuration Generator
  1561. GitHub - pisto/oggify: Download Spotify tracks to Ogg Vorbis (with a premium account)
  1562. GitHub - Tyrrrz/GitHubActionsTestLogger: Test logger for .NET that reports results in a format that GitHub Actions understands
  1563. Mads Asks What You Want for Visual Studio 2022 -- Visual Studio Magazine
  1564. GitHub - freenet/locutus: Declare your digital independence
  1565. A Web Renaissance
  1566. How To Build an Evil Compiler
  1567. Building a crawler in Rust: Associated Types
  1568. Watch People Doing the Thing
  1569. You need to stop idolizing programming languages.
  1570. The smallest Docker image to serve static websites
  1571. Deconstructing programs for compiler fuzzing · Comby
  1572. GitHub - facebookexperimental/eden: EdenSCM is a cross-platform, highly scalable source control management system.
  1573. Inline Assembly Miscompilation.md
  1574. GitHub - ekzhang/bore: 🕳 bore is a simple CLI tool for making tunnels to localhost
  1575. Updates from the Poezio ecosystem
  1576. Matt Roelle | Fennel: The Practical Lisp
  1577. O(1) Labs
  1578. Typescript as fast as Rust: Typescript++
  1579. Zas Editor
  1580. Gregory Szorc's Digital Home | Bulk Analyze Linux Packages with Linux Package Analyzer
  1581. Announcing Rust 1.60.0 | Rust Blog
  1582. jes post
  1583. Pharo - Pharo 10 Released!
  1584. How I Teach Myself to Code
  1585. Warp: The terminal for the 21st century
  1586. A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
  1587. What I'm Building in 2022
  1588. Playing with Matrix: Conduit and Synapse
  1589. [RFC] Lifetime annotations for C++ - Clang Frontend - LLVM Discussion Forums
  1590. Why I love Elm
  1591. A few things to know before stealing my 914
  1592. Edge Functions are now available in Supabase
  1593. SerenityOS: A remarkable achievement for a small project
  1594. Running .NET 7 apps on WASI on arm64 Mac
  1595. The weird world of non-C operating systems
  1596. Zulip 5.0: Threaded open-source team chat
  1597. My First Clippy Lint - Statistically Insignificant
  1598. Recommendations when publishing a Wasm library
  1599. Post-quantumify internal services: Logfwrdr, Tunnel, and gokeyless
  1600. Oxide on My Wrist: Hubris on PineTime was the best worst idea
  1601. How to write a linter using tree-sitter in an hour
  1602. GitHub - Wilfred/difftastic: a diff that understands syntax 🟥🟩
  1603. A thanks to the traits working group in 2021
  1604. mimoo - Overview
  1605. Please stop writing shell scripts
  1606. How Side Effects Work in FP
  1607. Lanai, the mystery CPU architecture in LLVM
  1608. Error handling across different languages
  1609. SendilKumarN
  1610. Searching for outliers
  1611. Rust's Unsafe Pointer Types Need An Overhaul - Faultlore
  1612. Episode 94 - Open .NET with Geoffrey Huntley
  1613. Lapce
  1614. C Isn't A Programming Language Anymore - Faultlore
  1615. GitHub - rothgar/awesome-tuis: List of projects that provide terminal user interfaces
  1616. The Aptos Vision
  1617. Arti 0.1.0 is released: Your somewhat-stable API is here! | Tor Project
  1618. Oxide at Home: Propolis says Hello
  1619. The code is the specification? Introducing cargo spec
  1620. Hamblingreen's Pinephone Setup
  1621. Veloren
  1622. GitHub - facebookresearch/narwhal: Narwhal and Tusk: A DAG-based Mempool and Efficient BFT Consensus.
  1623. Why digital transformation won’t solve the productivity paradox
  1624. s11e09: A short conversation with a bank
  1625. Job Search 2022 Update: Week 1
  1626. Things I hate about Rust, redux
  1627. CXX — safe interop between Rust and C++
  1628. SQL-Powered Reading List
  1629. AlphaCode: Competition-Level Code Generation with Transformer Based Architectures | Paper Review
  1630. WebGPU — All of the cores, none of the canvas — surma.dev
  1631. Rust Playground
  1632. The rise of WebAssembly
  1633. Part 2: Improving crypto code in Rust using LLVM’s optnone
  1634. Part 1: The life of an optimization barrier
  1635. Run and Test HTTP Requests
  1636. disabling ANSI color output in various Unix commands
  1637. Self-obfuscating value objects - Eric Mann's Blog
  1638. 10 HTML tags you have never used before
  1639. Writing an OS in Rust
  1640. GitHub - zdimension/embed-c: Embed C code at compile time inside Rust using C2Rust
  1641. Announcing Rust 1.59.0 | Rust Blog
  1642. pip and cargo are not the same
  1643. Why we are acquiring Area 1
  1644. smart-release - crates.io: Rust Package Registry
  1645. workspaces - crates.io: Rust Package Registry
  1646. rust-analyzer joins the Rust organization! | Rust Blog
  1647. Nix Flakes: an Introduction
  1648. Dynamic Linking Is Bad For Apps And Static Linking Is Also Bad For Apps
  1649. Programming things that have gotten easier
  1650. GitHub - martinvonz/jj: A Git-compatible DVCS that is both simple and powerful
  1651. Repos that always pass their tests
  1652. Shader translation benchmark
  1653. GitHub - mustafaquraish/cup: simple, C-like programming language
  1654. GitHub - yoav-lavi/melody: Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable
  1655. Home - cargo-nextest
  1656. Pure-Impure Segregation Principle | Oleksii Holub
  1657. Learn Privacy-Enhancing Techniques with Cryptographic Games
  1658. Rustup packages availability on x86_64-unknown-linux-gnu
  1659. David Nicholas Williams
  1660. jless - Command Line JSON Viewer
  1661. Calling Windows APIs from React Native just got easier · React Native for Windows + macOS
  1662. A Rust match made in hell
  1663. Our User-Mode WireGuard Year
  1664. With New Windows Desktop Support, Flutter Throws a Dart at .NET MAUI -- Visual Studio Magazine
  1665. Senior Software Engineer in Other, Other, United States | Engineering at Microsoft
  1666. An open-source distributed storage service
  1667. Some mistakes Rust doesn't catch
  1668. Lessons Learned from Restoring a Bike
  1669. Slicing and Dicing Instant Logs: Real-time Insights on the Command Line
  1670. Announcing Flutter for Windows
  1671. On Building 30K Debian Packages
  1672. GitHub - Kindelia/HVM: A massively parallel, optimal functional runtime in Rust
  1673. The Slackware Linux Project: Slackware Release Announcement
  1674. Some business advice for academic startups/spinouts - Bert Hubert's writings
  1675. Rustenstein 3D: Game programming like it's 1992 - NextRoll
  1676. Update Solana to 1.9.4 · certusone/wormhole@7edbbd3
  1677. Retrospective and Technical Details on the recent Firefox Outage – Mozilla Hacks - the Web developer blog
  1678. AdaCore and Ferrous Systems Joining Forces to Support Rust
  1679. Pay attention to WebAssembly
  1680. Destroy All Values: Designing Deinitialization in Programming Languages
  1681. mikerourke.dev
  1682. Rust has a small standard library (and that's ok)
  1683. There’s No Such Thing as Clean Code
  1684. How Prime Video updates its app for more than 8,000 device types
  1685. Speeding up VSCode (extensions) in 2022 – Jason Williams
  1686. Sometimes, rewriting in another language works
  1687. Why (Enterprise) Software Is Bloated
  1688. Does the software industry learn?
  1689. Durability and Redo Logging
  1690. David Nicholas Williams
  1691. Devblog of @kdy1
  1692. Introducing Rainway: Interactive App Streaming for Everyone | Rainway
  1693. Biscuit 2.0 release
  1694. Fundamentals of Garbage Collection
  1695. In defense of complicated programming languages
  1696. Supply chain attacks are the new big thing
  1697. Underjord | My Elm Experience
  1698. Senior Software Engineer in Redmond, Washington, United States | Engineering at Microsoft
  1699. Software Engineer II in Redmond, Washington, United States | Engineering at Microsoft
  1700. Jean G3nie
  1701. Seven Days of OCaml
  1702. How safe is zig?
  1703. Why Static Languages Suffer From Complexity
  1704. CSRF: How to exploit and how to defend
  1705. Zef: Low-latency, Scalable, Private Payments
  1706. Ballerina - Ballerina Home
  1707. Failing to Learn Zig via Advent of Code - ForrestTheWoods
  1708. C# and C++ type aliases and their consequences
  1709. How TypeScript Can Speed Up Your Adoption of WebAssembly
  1710. Resolving confusion over how to return from a C++ coroutine - The Old New Thing
  1711. I hate Conventional Commits
  1712. Why I use a debugger
  1713. Life at 800MHz
  1714. Announcing Rust 1.58.0 | Rust Blog
  1715. Exploring System76's New Rust Based Desktop Environment
  1716. 2022 01 11 bench results · LesnyRumcajs/grpc_bench Wiki
  1717. Announcing Parcel CSS: A new CSS parser, compiler, and minifier written in Rust!
  1718. GitHub - deadpixi/ergex: The Ergex Regular Expression Library
  1719. Waifu Labs - Welcome to Waifu Labs v2: How do AIs Create?
  1720. Parsing Text with Nom
  1721. Rachit Nigam | PhD Candidate, Cornell University
  1722. Why I Like D – Andrea Radaelli
  1723. Donald Knuth - The Patron Saint of Yak Shaves
  1724. Bevy - Bevy 0.6
  1725. Tech I want to focus in 2022
  1726. Why aren't the most useful Mac apps on the App Store?
  1727. 6 Ways I'm Improving Mental Health in 2022
  1728. Miniflare 2.0: fully-local development and testing for Workers
  1729. Rust is more portable than C for pngquant/libimagequant
  1730. The joy of building a ray tracer, for fun, in Rust.
  1731. GitHub - tkellogg/dura: You shouldn't ever lose your work if you're using Git
  1732. tvu-compare: rust and zig
  1733. Text Aesthetics: Command Line UI/UX
  1734. Kurtis Knodel // Blog
  1735. Why is my Rust build so slow?
  1736. Why the C Language Will Never Stop You from Making Mistakes
  1737. GitHub - sslab-gatech/Rudra: Rust Memory Safety & Undefined Behavior Detection
  1738. Writing a minimal Lua implementation with a virtual machine from scratch in Rust
  1739. A Review of the Zig Programming Language (using Advent of Code 2021)
  1740. Justin Pombrio
  1741. “Autism is a Spectrum” Doesn’t Mean What You Think
  1742. A Programmer Union Can Save Open Source
  1743. Cray-1 Digital Archeology – chrisfenton.com
  1744. GitHub - dani-garcia/vaultwarden: Unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs
  1745. The QOI File Format Specification
  1746. A challenger to the throne of vector graphics. SVG is dead, long live TinyVG!
  1747. GitHub - swc-project/swc: swc is a super-fast compiler written in rust; producing widely-supported javascript from modern standards and typescript.
  1748. How to create your own .NET CLI tools to make your life easier
  1749. The Non-Productive Programmer (NPP)
  1750. GitHub - haimgel/display-switch: Turn a $30 USB switch into a full-featured multi-monitor KVM switch
  1751. How not to learn Rust
  1752. Announcing Tokio Console 0.1 | Tokio
  1753. Introduction to WebAssembly components - radu's blog
  1754. From 0 to 20 billion - How We Built Crawler Hints
  1755. Don’t start with microservices – monoliths are your friend – Arnold Galovics
  1756. Allocgate is coming in Zig 0.9, and you will have to change your code
  1757. How to build large-scale end-to-end encrypted group video calls
  1758. Introducing Zed
  1759. 2021 in Memory Unsafety - Apple's Operating Systems
  1760. GitHub - lapce/lapce: Lightning-fast and Powerful Code Editor written in Rust
  1761. Remote debugging on Kubernetes using VS Code | Red Hat Developer
  1762. Reducing Developer Cycle time with Dapr and AKS
  1763. Mati's dating profile
  1764. The New Stack's Top Kubernetes Stories of 2021 - The New Stack
  1765. Introducing stack graphs | The GitHub Blog
  1766. GitHub Previews Improved Code Search: 'Way More than grep' -- Visual Studio Magazine
  1767. LKML: Miguel Ojeda: [PATCH 00/19] Rust support
  1768. Rust takes a major step forward as Linux's second official language | ZDNet
  1769. Lies, damned lies, and (Cloudflare) statistics: debunking Cloudflare’s recent performance tests
  1770. Ten years of measurement
  1771. Automate testing of poor network conditions with Shopify's Toxiproxy
  1772. Don't Make My Mistakes: Common Infrastructure Errors I've Made
  1773. Do we really need Undefined Behavior?
  1774. On the Use of Pedersen Commitments for Confidential Payments
  1775. How can my C++/WinRT component pass a std::vector back to the caller?
  1776. Oxide / Hubris and Humility
  1777. Will Nix Overtake Docker?
  1778. 4x smaller, 50x faster · asciinema blog
  1779. Open .NET
  1780. GitHub - vv9k/dockeye: GUI app for managing Docker
  1781. Add It Up: Takeaways from GitHub's Octoverse Report - The New Stack
  1782. The New Life of PHP – The PHP Foundation | The PhpStorm Blog
  1783. Announcing Argo for Spectrum
  1784. we like the runners
  1785. mod team resignation by BurntSushi · Pull Request #671 · rust-lang/team
  1786. The Introverts Guide to Increasing Energy
  1787. The Skeptic's Case for Personality Testing
  1788. Deno for Infrastructure as Code
  1789. hacspec [![hacspec chat][chat-image]][chat-link]
  1790. GitHub - elfshaker/elfshaker: elfshaker stores binary objects efficiently
  1791. Where is Ruby Headed in 2021? - Big Nerd Ranch
  1792. Zettelkasten #1: Classes in D with betterC
  1793. Backdooring Rust crates for fun and profit
  1794. Windows App SDK ('Project Reunion') Hits Version 1.0 -- Visual Studio Magazine
  1795. Bramble: A Purely Functional Build System and Package Manager
  1796. AppFlowy.IO
  1797. wrangler 2.0 — a new developer experience for Cloudflare Workers
  1798. Writing new system software
  1799. Why asynchronous Rust doesn't work
  1800. How Nix and NixOS Get So Close to Perfect
  1801. GitHub - michidk/rost: Rust programming, in German.
  1802. The Surreal Horror of PAM
  1803. System76 is building a new Linux desktop in Rust
  1804. GitHub - adria0/plonk-by-fingers: Implementation of Plonk by Hand in rust
  1805. Deep dive into Yrs architecture
  1806. Rust Playground
  1807. Guide to Online Dating for the Rest of Us | Engin Arslan
  1808. GitHub - axelarnetwork/tofn: A threshold cryptography library in Rust
  1809. Type Parameters Proposal
  1810. Top programming languages: Most popular and fastest growing choices for developers | ZDNet
  1811. Timeline of the human condition
  1812. How we build software at Cloudflare
  1813. GitHub - 1Password/1password-teams-open-source: Get a free 1Password Teams membership for your open source project
  1814. C# - async/await - The Breakfast Example
  1815. Security advisory for rustc (CVE-2021-42574) | Rust Blog
  1816. runtimelab/samples/NativeLibrary at 8e81d3a5bfd7639a197b51a1f65fcbba129d3b5f · dotnet/runtimelab
  1817. Manning
  1818. Debian's which hunt
  1819. Software Engineer II in Redmond, Washington, United States | Engineering at Microsoft
  1820. Next.js 12
  1821. Privacy is a Human Right | Tor Blog
  1822. bitbottle
  1823. FROST: Flexible Round-Optimized Schnorr Threshold Signatures
  1824. Choosing a cache
  1825. GitHub - nuta/kerla: A new operating system kernel with Linux binary compatibility written in Rust.
  1826. GitHub - mthom/scryer-prolog: A modern Prolog implementation written mostly in Rust.
  1827. Signals and Threads | Language Design
  1828. Transitioning an existing project to a new edition
  1829. Announcing Rust 1.56.0 and Rust 2021 | Rust Blog
  1830. We Just Gave $154,999.89 to Open Source Maintainers
  1831. 7 awesome improvements for LINQ in .NET 6
  1832. Microsoft Takes VS Code to the Browser (but No Debugger or Terminal) -- Visual Studio Magazine
  1833. vscode.dev Visual Studio Code for the Web
  1834. vscode.dev Visual Studio Code for the Web
  1835. Function pipelines: Building functional programming into PostgreSQL using custom operators
  1836. Version 1.6.0 released
  1837. Learn C# with CSharpFritz - Async, await, and Multi-threaded code
  1838. NixOS on Framework laptop
  1839. Implementing Hash Tables in C
  1840. Introducing Nuntius - Cronokirby
  1841. Good Riddance: Steam Bans Games That Feature Crypto And NFTs
  1842. How opcache works
  1843. What Do I Want from My Next Job?
  1844. Long Tiny Loop: Attempt #2
  1845. Principal Software Engineering Manager in Redmond, Washington, United States | Engineering at Microsoft
  1846. Geo Key Manager: Setting up a service for scale
  1847. Overview · Serde
  1848. Mythbusting Julia speed
  1849. Hands-on Rust
  1850. Generating Software Bills of Materials (SBOMs) with SPDX at Microsoft
  1851. On Multi-Set Hashing - Cronokirby
  1852. With .NET 6 RC 2 Release, Developers Push Back on C# Changes -- Visual Studio Magazine
  1853. Team Work
  1854. AWS Lambda battle 2021: performance comparison for all languages (cold and warm start)
  1855. Windows App SDK ('Project Reunion') Polished Ahead of v1.0 GA Debut -- Visual Studio Magazine
  1856. Parsing JSON is a Minefield
  1857. Cloudflare Research: Two Years In
  1858. The road to OCaml 5.0 - Ecosystem - OCaml
  1859. 20 Things I've Learned in my 20 Years as a Software Engineer
  1860. Why We Moved From Pony To Rust — Wallaroo
  1861. I’ve loved Wasmer, I still love Wasmer
  1862. How to replace estimations and guesses with a Monte Carlo simulation
  1863. Implicit Overflow Considered Harmful (and how to fix it)
  1864. Secrets I use to becoming a better developer working remotely 2021 edition
  1865. Should trait bounds be duplicated in struct and impl?
  1866. Things unlearned
  1867. Renato Athaydes
  1868. Confessions of a 1x Programmer
  1869. Practical frontend philosophy - jaredgorski.org
  1870. Coding Practice: Learning Rust with Fibonacci Numbers
  1871. CSAW Quals 2021 Bits
  1872. The difference between Go and Rust – dominikbraun.io
  1873. QR error correction helps and hinders scanning
  1874. Something Weird Is Happening on Facebook
  1875. GitHub - alexhallam/tv: 📺(tv) Tidy Viewer is a cross-platform CLI csv pretty printer that uses column styling to maximize viewer enjoyment.
  1876. Chrome 94 released with controversial Idle Detection API
  1877. GitHub - adam-mcdaniel/dune: A shell by the beach!
  1878. Improving Software ‘Numbers’
  1879. Initial Impressions of Rust
  1880. Reverse a string
  1881. A terminal case of Linux
  1882. My Janet Story | Jungle Coder
  1883. GitHub Advisory Database now supports Rust
  1884. Bringing OAuth 2.0 Flow to Wrangler
  1885. Spotify Box
  1886. DIY RGB Icosahedron build — GsD
  1887. Taming Go’s Memory Usage, or How We Avoided Rewriting Our Client in Rust — Akita Software
  1888. The Bagel Language 🥯 | Brandon's Website
  1889. GitHub - seed-rs/seed: A Rust framework for creating web apps
  1890. How I made $50K in 3 days with NFTs
  1891. The long-term consequences of maintainers’ actions – Ariadne's Space
  1892. Rust Playground
  1893. Go'ing Insane Part One: Endless Error Handling
  1894. Extending .NET Minimal APIs with Swagger, Authentication & Validation
  1895. Building an Alternative Ecosystem | Joshua Strobl
  1896. Engineer vs Entrepreneur Mindset
  1897. Developer Burnout: Why it Happens and What We Can Do About It
  1898. PHP: rfc:fibers
  1899. GitHub - dtolnay/inventory: Typed distributed plugin registration
  1900. Disclosing CVE-2021-40823 and CVE-2021-40824: E2EE vulnerability in multiple Matrix clients | Matrix.org
  1901. Resource efficient Thread Pools with Zig
  1902. The KDL Document Language
  1903. Steam Top 50 Games: 72% Work on Linux in Sept. 2021 - Boiling Steam
  1904. Sylvain Kerkour
  1905. Support type classes or implicits · Issue #243 · fsharp/fslang-suggestions
  1906. Native Rust support on Cloudflare Workers
  1907. How We Went All In on sqlc/pgx for Postgres + Go
  1908. Proposal: Expression blocks · Issue #3086 · dotnet/csharplang
  1909. The mystery of load average spikes
  1910. Maintain it With Zig
  1911. GitHub - mgdm/htmlq: Like jq, but for HTML.
  1912. Access modern GPU features with WebGPU
  1913. Svelte and SvelteKit - Why We Love It and Why You Should Try It
  1914. Writing Well-Documented Code - Learn from Examples
  1915. Foundation Interview
  1916. The Persistent Gravity of Cross Platform
  1917. Quick Tunnels: Anytime, Anywhere
  1918. GitHub - mTvare6/hello-world.rs: 🚀Memory safe, blazing fast, configurable, minimal hello world written in rust(🚀) in a few lines of code with few(1061🚀) dependencies🚀
  1919. Bebop ❤️ Rust | Rainway
  1920. Directories.Net 1.0.0
  1921. Monkey: the satirical Go package used unwittingly by Arduino and SalesForce
  1922. The open calendar, task and note space is a mess
  1923. Hell Is Other REPLs
  1924. Making Reasonable Use of Computer Resources: Part 2
  1925. Summary after Four Months with Ada — Programming with Ada documentation
  1926. NSO group, Pegasus, Zero-Days, i(OS|Message) security - Security. Cryptography. Whatever.
  1927. Every Web Browser Absolutely Sucks. – Luke Smith
  1928. GitHub - hecrj/iced: A cross-platform GUI library for Rust, inspired by Elm
  1929. The Three Pillars of WebAssembly - The New Stack
  1930. Great hackers are fearless - Blog by Amir Bolous
  1931. Linux in a Pixel Shader - A RISC-V Emulator for VRChat
  1932. Error Handling — Problem Overview
  1933. Pin, Unpin, and why Rust needs them
  1934. Cryptography Engineer
  1935. Absurdest Academia (A ‘Darkest Dungeon’ Parody)
  1936. Friendship ended with the garbage collector
  1937. The Windows Runtime PassArray is a read-only array, even though it isn't declared const
  1938. Platform Security Part Deux, feat. Justin Schuh - Security. Cryptography. Whatever.
  1939. Adventures in fuzzing libolm | Matrix.org
  1940. The Founder vs. Hired Executive Gap
  1941. Building a Pet Cam using a Raspberry Pi, Cloudflare Tunnels and Teams
  1942. Keeping Up
  1943. GitHub - jpochyla/psst: Fast and multi-platform Spotify client with native GUI
  1944. A Minimalist Full-Text Search Engine
  1945. GitHub - emilk/egui: egui: an easy-to-use immediate mode GUI in pure Rust
  1946. I stopped sleeping, then I started hallucinating.
  1947. ADHD at aged 42 and 1/2
  1948. LLVM internals, part 2: parsing the bitstream
  1949. Rust in Action: Systems programming concepts and techniques
  1950. Mindat.org
  1951. So you want to write a GUI framework
  1952. Intelligence through evolution
  1953. When Zero Cost Abstractions Aren’t Zero Cost
  1954. Why am I getting a weird error about promise_type when I try to write a coroutine?
  1955. Support for local vaults? - Page 3
  1956. Growing Object-Oriented Software vs what I would do
  1957. Micah Lerner
  1958. Looking into Zig
  1959. Looking into Zig
  1960. Modernizing a familiar approach to REST APIs, with PostgreSQL and Cloudflare Workers
  1961. GitHub - facebookresearch/Cupcake: A Rust library for lattice-based additive homomorphic encryption.
  1962. GitHub - agocke/serde-dn
  1963. Full-Time Open Source - CoRecursive Podcast
  1964. GitLab as your Continuous Deployment one-stop shop
  1965. GitHub - langjam/langjam
  1966. 5000x faster CRDTs: An Adventure in Optimization
  1967. NSO group, Pegasus, Zero-Days, i(OS|Message) security - Security. Cryptography. Whatever.
  1968. Idiots And Maniacs
  1969. Voice Content and Usability
  1970. GitHub - vrtbl/passerine: A small extensible programming language designed for concise expression with little code.
  1971. 6 Command Line Tools for Productive Programmers
  1972. Working With AI: Your Guide to a Potential Future Career
  1973. What's bad about Julia?
  1974. Understanding Rust futures by going way too deep - fasterthanli.me
  1975. C# vs Java: Which is Faster? Computer Language Drag Racing Series E03
  1976. Bare Bones Software | BBEdit 14 is here!
  1977. Announcing tokio-uring: io-uring support for Tokio
  1978. Heritability is a ratio, not a measure of determinism
  1979. yoeo/guesslang
  1980. janpaulthoughts - The quest for the Ultimate Game Engine
  1981. erikgrinaker/toydb
  1982. HashWires: Range Proofs from Hash Functions | ZKProof Standards
  1983. mxgmn/WaveFunctionCollapse
  1984. Inserting One Billion Rows in SQLite Under A Minute - blag
  1985. UFOs: Why so weird?
  1986. I Love Elixir
  1987. microsoft/foss-fund
  1988. Zig, Skia, Clojure, Geometry and the Japanese TV Show: ICFP Contest 2021
  1989. Pharo - Pharo 9 Released!
  1990. prathyvsh/pl-catalog
  1991. diekmann/wasm-fizzbuzz
  1992. Trusting Everybody
  1993. Beating TimSort at Merging
  1994. webpack? esbuild? Why not both?
  1995. Against SQL
  1996. Announcing Arti, a pure-Rust Tor implementation | Tor Blog
  1997. What Is WebAssembly — and Why Are You Hearing So Much About It? - The New Stack
  1998. Wilfred/difftastic
  1999. Compiling Rust is NP-hard
  2000. CouleeApps/git-power
  2001. [PATCH 00/17] Rust support - ojeda
  2002. Bringing emulation into the 21st century
  2003. Constant-Time Big Numbers: An Introduction
  2004. reacherhq/check-if-email-exists
  2005. Globally Distributed Postgres
  2006. Functional, Declarative Audio Applications
  2007. Serverless Authentication and Authorization in Minutes with Fauna and Auth0
  2008. C# Language Highlights: Null Coalescing Operator
  2009. MichalStrehovsky/bflat
  2010. The Era Of Customized Blockchains Is Rising Because Smart Contracts Aren’t Really ‘Smart’
  2011. Rewriting the GNU Coreutils in Rust
  2012. The State of WebAssembly 2021
  2013. The Reality of Attractiveness Bias
  2014. Ignoring extra words in Meili Search
  2015. Back To The Office
  2016. On Charming Engineering Culture: My Notes
  2017. Safari 15 on Mac OS, a user interface mess
  2018. Learning to Love a Rigid and Inflexible Language
  2019. make me a sandwich
  2020. Announcing WARP for Linux and Proxy Mode
  2021. ibraheemdev/modern-unix
  2022. Introducing cap-std, a capability-based version of the Rust standard library
  2023. In praise of depth – Pravesh
  2024. Bear plus snowflake equals polar bear
  2025. Bee Travels: A microservices coding adventure | Red Hat Developer
  2026. Attempts at solving the online social media
  2027. Traits of a healthy team
  2028. Audit of ING’s Threshold ECDSA Library – And a dangerous vulnerability in existing Gennaro-Goldfeder’18 implementations
  2029. Jonas Hietala: The T-34 keyboard layout
  2030. Introducing NativeShell for Flutter
  2031. rust-lang/rust
  2032. Brilliant Jerks in Engineering
  2033. Network-based policies in Cloudflare Gateway
  2034. Rust for Rustaceans
  2035. Using Wikipedia as an Impromptu RottenTomatoes API
  2036. Measuring potential complexity in popular Open Source projects
  2037. Helix
  2038. Conversation about .NET interop | .NET Blog
  2039. Remove bogus assert in FindRefs by CyrusNajmabadi · Pull Request #53793 · dotnet/roslyn
  2040. Learn X in Y Minutes: Scenic Programming Language Tours
  2041. QUIC Version 1 is live on Cloudflare
  2042. Adventures in rustc Forking
  2043. Oxide
  2044. Chris's Wiki :: blog/programming/RustInOurFuture
  2045. facundoolano/rpg-cli
  2046. What do shells do, and do we need them?
  2047. .NET Basics - Dusted Codes
  2048. Hacking third-party APIs on the JVM
  2049. Zig Makes Rust Cross-compilation Just Work · Um, actually...
  2050. utam0k/youki
  2051. Building regex.help
  2052. Willfulness
  2053. Improving Firefox stability on Linux – Mozilla Hacks - the Web developer blog
  2054. I am sick and tired of hearing tech companies complain about a developer shortage
  2055. Sleep Evolved Before Brains. Hydras Are Living Proof. | Quanta Magazine
  2056. Azure Icon Is Changing, So Far No Backlash -- Visual Studio Magazine
  2057. Welcoming Linux to the 1Password Family | 1Password
  2058. Sébastien Wilmet - Blog post
  2059. Things you can’t do in Rust (and what to do instead) - LogRocket Blog
  2060. The stack monoid revisited
  2061. Why “Unqualified” People Sometimes Make the Best Hires
  2062. OrGY: My Personal Technology Stack
  2063. Deno 1.10 Release Notes
  2064. The Plan for the Rust 2021 Edition | Rust Blog
  2065. Realizing the Mina vision in Rust
  2066. Rust for Windows Achieves Full Consumption (Call any Windows API) -- Visual Studio Magazine
  2067. .NET News Roundup - Week of May 3rd, 2021
  2068. Are some personalities just better?
  2069. The Problem With Design is Designers
  2070. broadcast - crates.io: Rust Package Registry
  2071. GitHub Quick Reviews
  2072. Searching the web for < $1000 / month | Search more with less
  2073. Gleam v0.15 released! – Gleam
  2074. The Great Rewriting In Rust
  2075. Portability is Reliability
  2076. Engineering promotions are broken
  2077. Output in password_hash - Rust
  2078. Migrating From Python to Kotlin for Our Backend Services
  2079. Rust Language Gains Traction in .NET Community -- Visual Studio Magazine
  2080. The Hassle-Free JavaScript Tool Manager
  2081. banga/git-split-diffs
  2082. Rust's Most Unrecognized Contributor
  2083. Rust programming language: We want to take it into the mainstream, says Facebook
  2084. Microsoft Joins Bytecode Alliance to Further Blazor-Backing WebAssembly Tech -- Visual Studio Magazine
  2085. C++ coroutines: Adding COM context support to our awaiter | The Old New Thing
  2086. Microsoft joins Bytecode Alliance to advance WebAssembly – aka the thing that lets you run compiled C/C++/Rust code in browsers
  2087. Sherlock Holmes and the case of a crashing devenv.exe | The .NET Tools Blog
  2088. Report: Mac Developers Prefer VS Code over Xcode -- Visual Studio Magazine
  2089. The Linux Foundation's demands to the University of Minnesota for its bad Linux patches security project | ZDNet
  2090. Best Practices in Software Development—Part 4
  2091. University of Minnesota security researchers apologize for deliberately buggy Linux patches | ZDNet
  2092. Rust Language Cheat Sheet
  2093. C++ coroutines: Associating multiple task types with the same promise type | The Old New Thing
  2094. Zellij: a Rusty terminal workspace releases a beta
  2095. Green Vs. Brown Programming Languages
  2096. Thoughts And Projects For The Future
  2097. Rust and cryptographic code | Bulletproof TLS Newsletter
  2098. Microsoft says mandatory password changing is “ancient and obsolete”
  2099. Llama Preview: Swift on .NET
  2100. Rosenzweig – Dissecting the Apple M1 GPU, part III
  2101. What's in the box? - fasterthanli.me
  2102. Take your first steps with Rust - Learn
  2103. Rust in the Linux kernel
  2104. [PATCH 00/13] [RFC] Rust support
  2105. Why Rust strings seem hard
  2106. [PATCH 00/13] [RFC] Rust support
  2107. Gregory Szorc's Digital Home | Rust is for Professionals
  2108. Is WebAssembly magic performance pixie dust? — surma.dev
  2109. Is WebAssembly magic performance pixie dust? — surma.dev
  2110. No, Google! Vivaldi users will not get FloC’ed. | Vivaldi Browser
  2111. Deno 1.9 Release Notes
  2112. A build tool for the rest of us
  2113. Two Paths to the Future | Fantastic Anachronism
  2114. Playing the Open Source Game
  2115. Trying Zombodb
  2116. zhuowei/nft_ptr
  2117. In defense of Signal
  2118. mratsim/constantine
  2119. My programming principles • Borislav Grigorov
  2120. Introducing Dawn (Part 1)
  2121. microsoft-sponsorships/microsoft-foss-fund
  2122. Docker without Docker
  2123. Creating Videos with React and Remotion
  2124. MPC-Over-Signal
  2125. Jakub Konka Hired Full Time ⚡ Zig Programming Language
  2126. C++ coroutines: Making the promise itself be the shared state, the outline | The Old New Thing
  2127. The Fastest, Safest PNG Decoder in the World
  2128. GitHub Sponsors Community
  2129. Eliminating Data Races in Firefox – A Technical Report – Mozilla Hacks - the Web developer blog
  2130. Static methods considered evil?
  2131. Moving to Desktop Applications in .NET Core/.NET 5
  2132. Google Is Testing Its Controversial New Ad Targeting Tech in Millions of Browsers. Here’s What We Know.
  2133. C++ coroutines: Making the promise itself be the shared state, the outline | The Old New Thing
  2134. soywod/himalaya
  2135. Matthew Walker's "Why We Sleep" Is Riddled with Scientific and Factual Errors - Alexey Guzey
  2136. My "shiny future"
  2137. Obvious and possible software innovations nobody does
  2138. XKCP/K12
  2139. Unveiling Gavran: RavenDB re-written in C
  2140. MakAir Series: Engineering Focus on Ventilator Software
  2141. gd/rust - platform/system/bt - Git at Google
  2142. C++ coroutines: The initial and final suspend, and improving our return_value method | The Old New Thing
  2143. akavel/up
  2144. My Self-Taught Tech Career - Work & Life Notes
  2145. Introducing 'innernet' | tonari blog
  2146. C++ coroutines: Basic implementation of a promise type | The Old New Thing
  2147. gruns/icecream
  2148. 208.43.231.11 Git
  2149. A new Cloudflare Web Application Firewall
  2150. How Much of the Hitchhiker's Guide to the Galaxy Can You Fit on a QR Code?
  2151. Pin and suffering - fasterthanli.me
  2152. Being a woman in tech should not be controversial
  2153. Compiler Explorer - C++ (x86-64 clang (assertions trunk))
  2154. We asked a Retired Microsoft Windows Engineer 100 Questions! Why oh Why? Find out!
  2155. Announcing Rust 1.51.0 | Rust Blog
  2156. A "Better C" Benchmark
  2157. facebookresearch/Cupcake
  2158. A solution to dependency hell: static binaries by default
  2159. Solo V2 — Safety Net Against Phishing
  2160. C++, Getting Started with the Basics: Working with Dependencies and Linker
  2161. Linus Torvalds on where Rust will fit into Linux | ZDNet
  2162. denji/awesome-http-benchmark
  2163. Load Testing and Benchmarking With siege vs wrk
  2164. Consider upgrading a few PC components - a good SSD is so fast it's not even funny
  2165. How safe is zig?
  2166. git/next/linux-next.git - The linux-next integration testing tree
  2167. Random Employee Chats at Cloudflare
  2168. ezrosent/frawk
  2169. totally_safe_transmute, line-by-line
  2170. Starving Threads In Ruby
  2171. Why bother with Scripting?
  2172. Performance comparison: counting words in Python, Go, C++, C, AWK, Forth, and Rust
  2173. Is Crossplane the Infrastructure LLVM?
  2174. I wrote one of the fastest DataFrame libraries - Ritchie Vink
  2175. Speed of Rust vs C
  2176. He got Facebook hooked on AI. Now he can't fix its misinformation addiction
  2177. Calling .NET APIs from Rust
  2178. Jeremy A Boyd |
  2179. ARMs Race: Ampere Altra takes on the AWS Graviton2
  2180. Microsoft Releases Project Reunion 0.5 Preview
  2181. Zig, Parser Combinators - and Why They're Awesome
  2182. half of curl’s vulnerabilities are C mistakes
  2183. What's New in Visual Basic on .NET 5?
  2184. Creating other types of synchronization objects that can be used with co_await, part 2: The basic library | The Old New Thing
  2185. Debian running on Rust coreutils
  2186. Why asynchronous Rust doesn't work
  2187. Developing with Rust on Windows
  2188. Clojure from a Schemer's perspective
  2189. Facial recognition technology can expose political orientation from naturalistic facial images
  2190. The Teams Dashboard: Finding a Product Voice
  2191. Google’s FLoC Is a Terrible Idea
  2192. Business or People
  2193. Announcing Flutter 2
  2194. Deno - A secure runtime for JavaScript and TypeScript
  2195. Event Sourcing: Rehydrating Aggregates with Snapshots
  2196. Semantic Versioning Will Not Save You
  2197. Deno - A secure runtime for JavaScript and TypeScript
  2198. Level up your .NET libraries - Ben Foster
  2199. Foam: Six Months Later
  2200. Back To The Office
  2201. nullpo-head/WSL-Hello-sudo
  2202. The small web is beautiful
  2203. Weird architectures weren't supported to begin with
  2204. Const generics MVP hits beta! | Rust Blog
  2205. Librsvg, Rust, and non-mainstream architectures
  2206. Map of my personal data infrastructure | beepb00p
  2207. Being a workplace crusader - Articles
  2208. Don't define functions inline in your public headers
  2209. Why Discord is switching from Go to Rust
  2210. Parsing floating-point numbers really fast in C#
  2211. tree-sitter/tree-sitter
  2212. Immediate-Mode-UI/Nuklear
  2213. The modern packager’s security nightmare – Michał Górny
  2214. A year of Rails - macwright.com
  2215. Ask the Expert: Rust at Microsoft
  2216. Build smaller, faster, and more secure desktop applications with a web frontend | Tauri Studio
  2217. Using HPKE to Encrypt Request Payloads
  2218. The Launch Space: Surface Duo for Xamarin and .NET developers
  2219. Mitigating Memory Safety Issues in Open Source Software
  2220. Objective or Biased
  2221. A primer on code generation in Cranelift
  2222. Maybe We Can Have Nice Things
  2223. Distributed Application Runtime (Dapr) v1.0 Announced
  2224. The Worst Experience I've Had With an aarch64 MacBook
  2225. I Really Blew It | Interactive Storytelling Tools for Writers
  2226. Being a COBOL developer can be very fun
  2227. Julia 1.6: what has changed since Julia 1.0?
  2228. thegrims/UsTaxes
  2229. Multi-asset shielded pool project (MASP)
  2230. For the Love of Macros
  2231. ratfactor/ziglings
  2232. Why no one should use the AT&T syntax ever, for any reason, under any circumstances
  2233. Our Solo v2 launch is official!
  2234. jimblandy/context-switch
  2235. Building A Custom Event Hubs Event Processor with .NET | Azure SDK Blog
  2236. Announcing Rust 1.50.0 | Rust Blog
  2237. Why I don't use the "else" keyword in my code anymore
  2238. Are we game yet?
  2239. Llofty Ambitions
  2240. Mozilla Welcomes the Rust Foundation – The Mozilla Blog
  2241. Google joins the Rust Foundation
  2242. State of the Common Lisp ecosystem, 2020 🎉 - Lisp journey
  2243. Reverie: An optimized zero-knowledge proof system
  2244. Rust Foundation
  2245. Taming Environments with Volta, the JavaScript Tool Manager
  2246. ARCHITECTURE.md
  2247. Programming for Cats
  2248. rust-analyzer/rust-analyzer
  2249. Coaching sessions: here’s what I talk about with junior developers
  2250. The reshaped Mac experience
  2251. My Third Year as a Solo Developer
  2252. Llama Rust SDK preview 0.1.3
  2253. Discover - Pony
  2254. PyO3/pyo3
  2255. A Quest to Find a Highly Compressed Emoji :shortcode: Lookup Function
  2256. Narrative Driven Development
  2257. Microsoft Using Metadata to Enable Idiomatic Win32 Interop from Rust and Other Languages
  2258. Zig Makes Go Cross Compilation Just Work
  2259. GitHub Ships Enterprise Server 3.0 Release Candidate -- Visual Studio Magazine
  2260. Python in VS Code Adds Data Viewer for Debugging -- Visual Studio Magazine
  2261. Rust for Windows
  2262. Design Draft: First Class Fuzzing
  2263. Microsoft Opens Up Old Win32 APIs to C# and Rust, More Languages to Come -- Visual Studio Magazine
  2264. Why Electron is a Necessary Evil
  2265. microsoft/windows-rs
  2266. README.md · master · LinuxCafeFederation / Awesome Alternatives
  2267. Porting Firefox to Apple Silicon – Mozilla Hacks - the Web developer blog
  2268. Preview: The SQLite Llibrary as a .NET assembly
  2269. The worrying trend of game technology centralization
  2270. Reducing tail latencies with automatic cooperative task yielding
  2271. Would Rust secure cURL?
  2272. Fully Homomorphic Encryption Part Three: Three Strawmans for the FHE Scheme
  2273. Rust is a hard way to make a web API - macwright.com
  2274. How the Pandemic Opened the Door to My Career in Tech
  2275. Being a Tech Lead in an Empowered Product Team
  2276. What is Social Cooling?
  2277. Learn X by doing Y - A project-based learning search engine
  2278. Rebuilding the most popular spellchecker. Part 1
  2279. Lessons from my first (very bad) on-call experience
  2280. theseus-os/Theseus
  2281. A practical guide to WebAssembly memory - radu's blog
  2282. Rust-GCC/gccrs
  2283. Elzear - 🗳 Ranked voting systems
  2284. Chemistry of Cast Iron Seasoning: A Science-Based How-To
  2285. What I did on my winter vacation
  2286. Rosenzweig – Dissecting the Apple M1 GPU, part I
  2287. Pointers Are Complicated, or: What's in a Byte?
  2288. Everything You Always Wanted To Know About GitHub (But Were Afraid To Ask)
  2289. Wasmer 1.0
  2290. GRVYDEV/Project-Lightspeed
  2291. How to Stop Endless Discussions
  2292. Make smaller console apps with .NET and CoreRT - { Destructured }
  2293. Zig in 30 minutes
  2294. Patterns and Habits
  2295. A half-hour to learn Rust - fasterthanli.me
  2296. artichoke/artichoke
  2297. Announcing Rust 1.49.0 | Rust Blog
  2298. What's new in PHP 8 - stitcher.io
  2299. Colin Stebbins Gordon
  2300. Buttplug Hits v1 Milestone - Nonpolynomial
  2301. Cosmopolitan C Library
  2302. Executable PNGs - djhworld
  2303. Using One Cron Parser Everywhere With Rust and Saffron
  2304. Tokio
  2305. Cakelisp: a programming language for games
  2306. My Engineering Axioms
  2307. Counterfactual communication and intimidation
  2308. tuhdo/tuhdo.github.io
  2309. The Shape of 1.7M Lines of Code · Stefan-Marr.de
  2310. An Old New Adventure
  2311. On the Graying of GNOME | Et tu, Cthulhu
  2312. Azure Functions in Any Language with Custom Handlers
  2313. Top Articles I've Read in 2020
  2314. Last Week in .NET #22 – Microsoft Parrots Google
  2315. These Modern Programming Languages Will Make You Suffer
  2316. Notes on Learning Languages
  2317. Fast AF Fourier Transform (FafFT) | Conrad Ludgate
  2318. Aiming for correctness with types - fasterthanli.me
  2319. Deno 1.6 Release Notes
  2320. WerWolv/ImHex
  2321. Improving DNS Privacy with Oblivious DoH in 1.1.1.1
  2322. imazen/imageflow
  2323. #DevDecember Week 1 Recap: Growth
  2324. std::visit is everything wrong with modern C++
  2325. The case for Elixir
  2326. Uno Platform Blazor WebAssembly (client-side) with AOT and SkiaSharp
  2327. libra/libra
  2328. How I Translate Feature Requests into Code
  2329. rga: ripgrep, but also search in PDFs, E-Books, Office documents, zip, tar.gz, etc.
  2330. The Cryptopals Crypto Challenges
  2331. Writing Rust the Elixir way
  2332. Pijul - The Mathematically Sound Version Control System Written in Rust
  2333. Ruffle
  2334. Risp (in (Rust) (Lisp))
  2335. Modern storage is plenty fast. It is the APIs that are bad.
  2336. dcz-self/breedmatic
  2337. Modern storage is plenty fast. It is the APIs that are bad.
  2338. How do people find bugs?
  2339. Why AWS loves Rust, and how we’d like to help | Amazon Web Services
  2340. zkSummit 6 | Hopin
  2341. building a roam-like, networked, heavily-customized realtime editor, part 1
  2342. A Taste of OCaml's Predictable Performance - Dev.Poga
  2343. Announcing Rust 1.48.0 | Rust Blog
  2344. jsomers.net | I should have loved biology
  2345. reHackable/awesome-reMarkable
  2346. Servo’s new home
  2347. Graphics for JVM
  2348. Vulnerability, leadership and paternity leave ft. Erran Berger
  2349. The C Standard Library Is Not Dependency Free
  2350. Why an IDE?
  2351. Using Rust to Scale Elixir for 11 Million Concurrent Users
  2352. What is a System-on-Chip (SoC), and Why Do We Care if They are Open Source? « bunnie's blog
  2353. How to Recalculate a Spreadsheet
  2354. Rust vs Go — Bitfield Consulting
  2355. Building a Weather Station UI
  2356. Why Dark didn't choose Rust
  2357. NewReleases.io
  2358. bddisasm: The Bitdefender x86 Disassembler
  2359. ocornut/imgui
  2360. Dark's new backend will be in F#
  2361. Episode 13: Andrew Gallant (BurntSushi), creator of ripgrep
  2362. curlpipe/ox
  2363. The Guide to Deno
  2364. Leaving OCaml
  2365. Why men's health depends on feminism
  2366. adamsky/globe
  2367. Are we web yet? Yes, and it's freaking fast!
  2368. For Complex Applications, Rust is as Productive as Kotlin
  2369. What's in a Linux executable? - fasterthanli.me
  2370. gRPC performance improvements in .NET 5 | ASP.NET Blog
  2371. Bytecode Alliance: One year update
  2372. Standard ML in 2020 | notes.eatonphil.com
  2373. Add PriorityQueue<T> to Collections · Issue #14032 · dotnet/runtime
  2374. Parenting doesn’t do what I thought
  2375. 1Password for Linux beta is now open 🎊 🐧 🎊 | 1Password
  2376. Assorted thoughts on zig (and rust)
  2377. Towards sockets and networking in WebAssembly and WASI - radu's blog
  2378. dandavison/delta
  2379. Collections: Iron, How Did They Make It, Part IVb: Work Hardening, or Hardly Working?
  2380. Abundance
  2381. Why and How Use Azure Active Directory (AAD) with Blazor Web Assembly (WASM)
  2382. How to add C++ structured binding support to your own types | The Old New Thing
  2383. Exchanging UDP messages - Low-Level Academy
  2384. Bidding Farewell to Software Engineering — cdahmedeh
  2385. As election looms, a network of mysterious ‘pink slime’ local news outlets nearly triples in size
  2386. The Observation Deck » Rust after the honeymoon
  2387. CRISPR is Dead
  2388. Paul Rouget - Goodbye Mozilla
  2389. Memory Safe ‘curl’ for a More Secure Internet
  2390. rust in curl with hyper
  2391. Llama preview 0.1.2
  2392. Police violence: Your ratios don’t prove what you think they prove
  2393. Announcing Rust 1.47.0 | Rust Blog
  2394. Writing JavaScript tools in other languages – a new trend?
  2395. Building a Weather Station Bot
  2396. Motivation and why finishing a personal project is hard.
  2397. It’s 255:19AM. Do you know what your validation criteria are?
  2398. Basic Concepts in Unity for Software Engineers
  2399. Wiki - RustStarterKit2020
  2400. LLVM provides no side-channel resistance
  2401. Computers Are Hard: app performance with Jeff Fritz
  2402. Why not PHP?
  2403. Personality Does Not Define Success
  2404. Rust 2021: GUI
  2405. WebAssembly Could Be the Key for Cloud Native Extensibility – The New Stack
  2406. Things I Was Wrong About: Types  — Sympolymathesy, by Chris Krycho
  2407. I was wrong. CRDTs are the future
  2408. Thoughts on Structured Editing: Breaking Away from Syntax
  2409. Zig's New Relationship with LLVM
  2410. A Blog About Computer Systems and Language Design
  2411. Things Elixir's Phoenix Framework Does Right
  2412. Remarkable software engineers write remarkable code - Joannes Vermorel's blog
  2413. This is a pretty dire assessment of Mozilla
  2414. rotoclone/strategic-communication
  2415. Firefox usage is down 85% despite Mozilla's top exec pay going up 400%
  2416. My Least Favorite Rust Type
  2417. Why not rust for security?
  2418. Why Not Rust?
  2419. Why Not Rust?
  2420. Throw Away Code
  2421. TL;DR Rust
  2422. My Principles for Building Software
  2423. mrDIMAS/rg3d
  2424. An introduction to Data Oriented Design with Rust
  2425. Herding Code 242: The COVID Cabin Fever
  2426. Microsoft submits Linux kernel patches for a 'complete virtualization stack' with Linux and Hyper-V
  2427. Reinforcement learning, non-Markov environments, and memory
  2428. Who Influences Your Working Pace?
  2429. Thoughts on giving feedback
  2430. coin_artist – 34700 $coin Puzzle Write-Up ($20,000)
  2431. How to Build a RESTful API with Deno
  2432. The Automated CIO
  2433. Dhghomon/programming_at_40
  2434. How to speed up the Rust compiler one last time – Nicholas Nethercote
  2435. Web-to-App Communication: The Native Messaging API
  2436. Add contibutors to the release notes by Brar · Pull Request #46 · npgsql/doc
  2437. Everything You Need to Know to Get Started with Deno
  2438. samizdatco/skia-canvas
  2439. In Defense of a Switch
  2440. Synthesizing a when_all coroutine from pieces you already have | The Old New Thing
  2441. Rewritten in Rust: Modern Alternatives of Command-Line Tools · zaiste.net
  2442. How to Spot Toxic Software Jobs From Their Descriptions
  2443. Announcing the General Availability of Bottlerocket, an open source Linux distribution built to run containers | Amazon Web Services
  2444. What is .NET? How does it work? Is it a language or a Platform?
  2445. Supporting Linux kernel development in Rust
  2446. System Programming in 2k20
  2447. Less is more
  2448. Zen and Development | Potemkin Life
  2449. Objective-Rust
  2450. Linux Hardware Reviews, Open-Source Benchmarks & Linux Performance
  2451. Pure and Applied Chess
  2452. Announcing Rust 1.46.0 | Rust Blog
  2453. Racket
  2454. If Humans Spoke in Vectors...
  2455. Rust Contributors
  2456. .NET &amp; JavaScript Ninjas Community Program | Telerik
  2457. Daily links from Cory Doctorow
  2458. Thinking about dependencies :: sunshowers
  2459. You don’t always have to be productive - WEEB TRASH LIFE
  2460. First thoughts on Rust vs OCaml
  2461. Why Did Mozilla Remove XUL Add-ons?
  2462. Porting a Golang and Rust CLI tool to D
  2463. Laying the foundation for Rust's future | Rust Blog
  2464. Hiding messages in x86 binaries using semantic duals
  2465. WebAssembly Weekly Issue #126
  2466. Code Smell: Concrete Abstraction
  2467. linksfor.dev(s)
  2468. Frustrated? It's not you, it's Rust - fasterthanli.me
  2469. Survey: Native AOT · Issue #40430 · dotnet/runtime
  2470. A Guide to Understanding What Makes a Typeface Accessible, and How to Make Informed Decisions.
  2471. twilco/kosmonaut
  2472. Mozilla’s uncertain future
  2473. Unicode In Five Minutes ⌚
  2474. Commiserations, skepticism, and antirealism about genomics and Truth
  2475. Mozilla's failures and a path to profitability
  2476. Write your Own Virtual Machine
  2477. servo/servo
  2478. Mozilla: The Greatest Tech Company Left Behind
  2479. "Rust does not have a stable ABI"
  2480. Byron/gitoxide
  2481. Mozilla Alumni Network
  2482. Bevy - Introducing Bevy
  2483. Let’s implement a Bloom Filter
  2484. Single Page Applications using Rust
  2485. Changing World, Changing Mozilla – The Mozilla Blog
  2486. Why the C Language Will Never Stop You from Making Mistakes
  2487. We Can Do Better Than SQL
  2488. An attempt to make a font look more handwritten
  2489. How to better design your game communities for kindness
  2490. First Impressions of Rust
  2491. liljencrantz/crush
  2492. Accelerating Standard C++ with GPUs Using stdpar | NVIDIA Developer Blog
  2493. simdjson/simdjson
  2494. Native AOT Survey
  2495. 1Password for Linux development preview
  2496. LesnyRumcajs/grpc_bench
  2497. Go vs Rust: Writing a CLI tool
  2498. Python is now the second most popular language for programming - newserector
  2499. The Era of DNA Database Hacks Is Here
  2500. Dual-monitor 4K@60hz KVM switch for $30
  2501. Firefox 79: The safe return of shared memory, new tooling, and platform updates – Mozilla Hacks - the Web developer blog
  2502. WasmBoxC: Simple, Easy, and Fast VM-less Sandboxing
  2503. Writing a file system from scratch in Rust · carlosgaldino
  2504. Tech vs Biotech — Celine Halioua
  2505. Apache Arrow 1.0.0 Release
  2506. adam-mcdaniel/oakc
  2507. SuperTails/langcraft
  2508. Considering Rust
  2509. The Indie Consulting Business Model Canvas V0.1
  2510. Dhghomon/easy_rust
  2511. Add support for binding record types by pranavkm · Pull Request #23976 · dotnet/aspnetcore
  2512. Complexity of Hello World & what comes after
  2513. NerdyPepper/dijo
  2514. Cryptography Dispatches: DSA Is Past Its Prime
  2515. Announcing Rust 1.45.0 | Rust Blog
  2516. Hacking Reolink cameras for fun and profit
  2517. crates.io: Rust Package Registry
  2518. crates.io security advisory | Rust Blog
  2519. zombodb/pgx
  2520. Linux kernel in-tree Rust support
  2521. Trending
  2522. stu2b50
  2523. The Soul of a New Debugger
  2524. Tour of Rust
  2525. Testing Firefox more efficiently with machine learning – Mozilla Hacks - the Web developer blog
  2526. Linux kernel in-tree Rust support
  2527. Linux kernel in-tree Rust support
  2528. Moving from TypeScript to Rust / WebAssembly
  2529. tauri-apps/tauri
  2530. braver-browser/braver-browser
  2531. Writing a winning 4K intro in Rust
  2532. A Deep Introduction to JIT Compilers: JITs are not very Just-in-time | Carol's Blog
  2533. nabeelqu
  2534. Giving code presentations
  2535. A look at the Gemini protocol: a brutally simple alternative to the web
  2536. Code Only Says What it Does
  2537. Desugaring - taking our high-level language and simplifying it!
  2538. 'It's really hard to find maintainers': Linus Torvalds ponders the future of Linux
  2539. The Pain of Debugging WebAssembly – The New Stack
  2540. How CDNs Generate Certificates
  2541. home
  2542. Documenting with PowerShell: Breaches using the HIBP API - CyberDrain
  2543. Python may get pattern matching syntax
  2544. xi-editor retrospective
  2545. What's in a Linux executable?
  2546. PEP 622 -- Structural Pattern Matching
  2547. Path Building vs Path Verifying: Implementation Showdown
  2548. dabreegster/abstreet
  2549. nabeelqu
  2550. the-benchmarker/web-frameworks
  2551. 3K, 60fps, 130ms: achieving it with Rust | tonari blog
  2552. Generics and Compile-Time in Rust | TiDB
  2553. Black Google manager: “My education and elocution cannot save me from these situations”
  2554. Build yourself a weather station. Part I
  2555. Fast 2D rendering on GPU
  2556. May 2020 news · Gwern.net
  2557. Microsoft: Rust Is the Industry’s ‘Best Chance’ at Safe Systems Programming – The New Stack
  2558. In Defense of Myers Briggs
  2559. Flat UI Elements Attract Less Attention and Cause Uncertainty
  2560. How async should have been
  2561. Compressing Synapse database | Levans' workshop
  2562. dapr/dapr
  2563. 25 Years of PHP History
  2564. A Tiny, Static, Full-Text Search Engine using Rust and WebAssembly | Matthias Endler
  2565. Playing Around With The Fuchsia Operating System
  2566. New inline assembly syntax available in nightly | Inside Rust Blog
  2567. Hacking Windows with F# 5.0 Scripts
  2568. dapr/dapr
  2569. Rust: Dropping heavy things in another thread can make your code 10000 times faster
  2570. The 2020 Developer Survey results are here! - Stack Overflow Blog
  2571. Patrik Svensson - Targeting ARM64 for Windows in Rust
  2572. Chrome: 70% of all security bugs are memory safety issues | ZDNet
  2573. I made a NES emulator in Rust using generators
  2574. Adding peephole optimization to Clang | Egor Bogatov — Developer at Microsoft
  2575. Releasing Today! Visual Studio 2019 v16.6 & v16.7 Preview 1 | Visual Studio Blog
  2576. Remembering Why Agile was a Big Deal
  2577. Five Years of Rust | Rust Blog
  2578. Deno 1.0
  2579. My Mid-Career Job-Hunt: A Data Point for Job-Seeking Devs
  2580. Make LLVM fast again
  2581. A Rust-based TLS library outperformed OpenSSL in almost every category | ZDNet
  2582. [Question] CoreRT future plans · Issue #7200 · dotnet/corert
  2583. [Question] CoreRT future plans · Issue #7200 · dotnet/corert
  2584. Microsoft's GitHub account allegedly hacked, 500GB stolen
  2585. Add tags for programming languages / genres
  2586. PHP showing its maturity in release 7.4
  2587. Explainable Deep Learning: A Field Guide for the Uninitiated
  2588. Making rust as fast as go
  2589. 'Re: Integrating "safe" languages into OpenBSD?'
  2590. Rust/WinRT Public Preview - Windows Developer Blog
  2591. C# interop with C/C++ and Rust in WebAssembly - Uno Platform
  2592. First Release
  2593. First Release
  2594. Teleforking a process onto a different computer!
  2595. [Question] CoreRT future plans · Issue #7200 · dotnet/corert
  2596. Announcing Rust 1.43.0 | Rust Blog
  2597. Closing the gap: cross-language LTO between Rust and C/C++
  2598. Engineering code quality in the Firefox browser: A look at our tools and challenges – Mozilla Hacks - the Web developer blog
  2599. Lab — CS-3210, Spring 2020 1 documentation
  2600. A Possible New Backend for Rust – Jason Williams
  2601. What Is Interesting About Factorio
  2602. “Stubs” in the .NET Runtime
  2603. A Taste of GPU Compute
  2604. Cloudflare Workers Now Support COBOL
  2605. Writing a Book with Pandoc, Make, and Vim — Vladimir Keleshev
  2606. Introduction
  2607. I can't keep up with idiomatic Rust
  2608. Migrating Duolingo’s Android app to 100% Kotlin
  2609. Introducing Krustlet, the WebAssembly Kubelet
  2610. Replicate your favorite VSCode theme in Windows Terminal
  2611. Await | Writing an OS in Rust
  2612. How I Became a Better Programmer
  2613. `zig cc`: a Powerful Drop-In Replacement for GCC/Clang
  2614. Software Engineer - Jobs at Apple
  2615. I Am Mesmerized By Our New Robotic Vacuum
  2616. Starship: Cross-Shell Prompt
  2617. Rust/WinRT coming soon
  2618. Researching the optimal; implementing the practical
  2619. Announcing Rust 1.42.0 | Rust Blog
  2620. My exploration of Rust and .NET
  2621. How I Start: Nix
  2622. Table 4 . Normalized global results for Energy, Time, and Memory 
  2623. Automatic indexes and garbage collection, features that you shouldn’t need which save the day
  2624. On the shoulders of the giants
  2625. Firecracker
  2626. Microsoft's Miguel de Icaza Ponders New Use for WebAssembly -- Visual Studio Magazine
  2627. Abhishek Gupta – Medium
  2628. Stateful Programming Models in Serverless Functions | QCon San Francisco 2020
  2629. Stark - Language And Frontend Compiler - Prototype 2019
  2630. - Miguel de Icaza
  2631. Rust Ownership Rules
  2632. A journey to searching Have I Been Pwned database in 49μs (C++)
  2633. A half-hour to learn Rust
  2634. I want off Mr. Golang's Wild Ride
  2635. What is a type in TypeScript? Two perspectives
  2636. Securing Firefox with WebAssembly – Mozilla Hacks - the Web developer blog
  2637. Acrobat on the Web, Powered by WebAssembly
  2638. On Voice Coding
  2639. Andreessen-Horowitz craps on “AI” startups from a great height
  2640. Bastion
  2641. Learning Rust With Entirely Too Many Linked Lists
  2642. Getting started with Uno Platform and ReactiveUI - Uno Platform
  2643. Update on our new and upcoming security keys
  2644. Why Do So Many Incompetent Men Become Leaders?
  2645. The Horrifically Dystopian World of Software Engineering Interviews - Blog by Jared Nelsen
  2646. Rust for professionals
  2647. Examples of calling an API HTTP GET for JSON in different languages - Joe Kampschmidt's Code
  2648. This Goes to Eleven (Part. 2/∞)
  2649. You’re probably using the wrong dictionary « the jsomers.net blog
  2650. The Bright Side of Imposter Syndrome.
  2651. The bright side of imposter syndrome. | Leo Gopal
  2652. Todo-Backend
  2653. Google's OpenSK lets you BYOSK – burn your own security key
  2654. tock/tock
  2655. Stack Overflow
  2656. KnightOS was an interesting operating system
  2657. martinber/noaa-apt
  2658. Add support for high level Assembler by xoofx · Pull Request #60 · 0xd4d/iced
  2659. microsoft/verona
  2660. Building Graphical Applications with WASI, Wasmer, and the experimental I/O Devices
  2661. Build Rust environment for ESP32
  2662. Containerized builds for Rust on the ESP32 - DEV Community 👩‍💻👨‍💻
  2663. Browser Games Aren't an Easy Target — Jakob's Personal Webpage
  2664. Racor - PSM-1R - Pro Store Multi-Use Storage Bracket - Wheelbarrow and Ladder Hanger - Utility Hooks - Amazon.com
  2665. BLAKE3-team/BLAKE3
  2666. Developer Tools Weekly : Issue 100 : January 6, 2020
  2667. imsnif/bandwhich
  2668. “Stack Walking” in the .NET Runtime
  2669. Signal >> Blog >> Technology Preview for secure value recovery
  2670. patriksvensson/waithandle-rs
  2671. Using WebAssembly from .NET with Wasmtime – Mozilla Hacks - the Web developer blog
  2672. Using WebAssembly from .NET with Wasmtime
  2673. Consuming Ethernet frames with the nom crate
  2674. More implementations · Issue #4 · mimoo/disco
  2675. dapr/dapr
  2676. New release – PeachPie Sdk 0.9.600 @ PeachPie | PHP compiler to .NET
  2677. The State of the Octoverse
  2678. Using Rust in Windows - Microsoft Security Response Center
  2679. How Swift Achieved Dynamic Linking Where Rust Couldn't
  2680. patriksvensson/rustcalc
  2681. Facebook Libra is Architecturally Unsound
  2682. NordVPN users’ passwords exposed in mass credential-stuffing attacks
  2683. TLS Post-Quantum Experiment
  2684. Safe and Secure Drivers in High-Level Languages
  2685. Apple, Your Developer Documentation is… Missing
  2686. dapr/dapr
  2687. Add 64 bits support to Array underlying storage · Issue #12221 · dotnet/runtime
  2688. A Talk Near the Future of Python (a.k.a., Dave live-codes a WebAssembly Interpreter)
  2689. Announcing the Open Application Model (OAM), an open standard for developing and operating applications on Kubernetes and other platforms - Open Source Blog
  2690. rust-p2p/disco
  2691. AWS’ sponsorship of the Rust project | Amazon Web Services
  2692. Improving the LibraBFT protocol · Libra
  2693. “Stubs” in the .NET Runtime
  2694. Dave Glick - Default Interface Members, What Are They Good For?
  2695. r/programming - A high-speed network driver written in C, Rust, Go, C#, Java, OCaml, Haskell, Swift, Javascript, and Python
  2696. ixy-languages/ixy-languages
  2697. My RustConf 2018 Closing Keynote
  2698. Utf8String design proposal · Issue #2350 · dotnet/corefxlab
  2699. Why Are So Many Developers Hating on Object-Oriented Programming? - The New Stack
  2700. What's new in C# 8.0 - C# Guide
  2701. Highlights from Git 2.23
  2702. Potentially unsafe uses of unsafe · Issue #145 · mozilla/neqo
  2703. RustPython/RustPython
  2704. What's Deno, and how is it different from Node.js? - LogRocket Blog
  2705. How we integrate Rust with C#
  2706. C# and Rust: combining managed and unmanaged code without sacrificing safety - Ashley Mannix
  2707. gothinkster/realworld
  2708. What does debugging a program look like? - Julia Evans
  2709. Archive
  2710. jeanqasaur/dsl-syllabus-fall-2016
  2711. Open Source Game Clones
  2712. Rust: A Language for the Next 40 Years - Carol Nichols
  2713. Users
  2714. Elon Musk Says ‘Hyperloop’ Tunnel Is Now Just a Normal Car Tunnel Because ‘This Is Simple and Just Works’
  2715. WCF vs gRPC
  2716. Visual Studio Code Remote Development may change everything - Scott Hanselman
  2717. 0xd4d/iced
  2718. Graphics Programming Weekly - Article Database
  2719. Error Management: Future vs ZIO
  2720. Error Management: Future vs ZIO
  2721. Community and Communication going forward
  2722. Keynote: The Last Hope for Scala's Infinity War - John A. De Goes
  2723. distractionware » The Dice are Cast
  2724. Rust's 2019 roadmap | Rust Blog
  2725. ericsink/wasm2cil
  2726. Running WebAssembly and WASI with .NET
  2727. BurntSushi/ripgrep
  2728. [question] choosing between class and struct · Issue #12489 · dotnet/runtime
  2729. Functional Scala: Next Level by John A. De Goes (LambdaConf Edition)
  2730. The electronic song “Scary Monsters and Nice Sprites” reduces host attack and mating success in the dengue vector Aedes aegypti
  2731. Tastes Like Chicken
  2732. Announcing Lucet: Fastly's native WebAssembly compiler and runtime
  2733. cloudflare/boringtun
  2734. BoringTun, a userspace WireGuard implementation in Rust
  2735. Standardizing WASI: A system interface to run WebAssembly outside the web – Mozilla Hacks - the Web developer blog
  2736. How to Debug Rust with Visual Studio Code
  2737. [Question] CoreRT future plans · Issue #7200 · dotnet/corert
  2738. Why Hashbrown Does A Double-Lookup
  2739. Explaining Code using ASCII Art – Embedded in Academia
  2740. Testing Incrementally with ZIO Environment by John De Goes - Signify Technology
  2741. Writing A Compiler In Go | Thorsten Ball
  2742. Writing An Interpreter In Go | Thorsten Ball
  2743. Deep thoughts on other languages Like Rust, Go, etc.
  2744. Testing Incrementally with ZIO Environment
  2745. Cats instances taking the environmental parameter by gvolpe · Pull Request #593 · zio/zio
  2746. Leadersheep — Trinity Farm
  2747. CensoredUsername/dynasm-rs
  2748. Paper: Hyperscan: A Fast Multi-pattern Regex Matcher for Modern CPUs
  2749. Combining iterator blocks and async methods in C# | Premier Developer
  2750. sharkdp/bat
  2751. Hotswapping Haskell · Simon Marlow
  2752. vmg/sundown
  2753. ApoorvaJ/tiny-jpeg-rs
  2754. Introducing HacSpec
  2755. The 10 Secrets to Indie Game Success (and Why They Do Not Exist)
  2756. crates.io: Rust Package Registry
  2757. dalek-cryptography/ed25519-dalek
  2758. LLVM: include/llvm/Support/Casting.h Source File
  2759. Undefined Behavior Is Really Undefined
  2760. sharkdp/hyperfine
  2761. Zcash Counterfeiting Vulnerability Successfully Remediated - Electric Coin Company
  2762. (Now Go Bang!) Snowflake Archeology (DEC PDP-1)
  2763. Deep Learning with Darwin: Evolutionary Synthesis of Deep Neural Networks
  2764. The Web We Lost
  2765. » The Sierra Discovery Adventures The Digital Antiquarian
  2766. » The Game of Everything, Part 7: Civilization and Government I (Despotism, Monarchy, and the Republic) The Digital Antiquarian
  2767. » Games on the Mersey, Part 5: The Lemmings Effect The Digital Antiquarian
  2768. » A Tale of the Mirror World, Part 5: The Inflection Point The Digital Antiquarian
  2769. lemire/simdjson