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 'compilers'

  1. Why DSPy is worth using (beyond prompt optimization)
  2. Wild Linker Update - 0.6.0
  3. Funding
  4. Wild Performance Tricks | David Lattimore
  5. Animated Sign-In Dialog
  6. Ankit Sultana
  7. Building Search for this Site
  8. The performance impact of vertex shader exports
  9. Introduction to Arm Memory Tagging Extensions :: Thore Göbel
  10. Object-Oriented Programming in C
  11. Faster argmin on floats
  12. A postmortem of three recent issues
  13. Wasm 3.0 Completed - WebAssembly
  14. Machine Scheduler in LLVM - Part I
  15. React Won by Default – And It's Killing Frontend Innovation | Loren Stewart
  16. What's New in C# 14: Null-Conditional Assignments
  17. Ray Tracing in JAX - Kaylee George
  18. Writing an operating system kernel from scratch
  19. Trusting builds with Bazel remote execution
  20. AI Coding
  21. Death💀 to type classes
  22. Unweaving Warp Specialization
  23. How to keep package.json under control
  24. Trial and Error Driven Development
  25. Performance Improvements in .NET 10 - .NET Blog
  26. i ran Claude in a loop for three months, and it created a genz programming language called cursed
  27. Splitting a long string in lines efficiently – Daniel Lemire's blog
  28. Max Leiter
  29. Using Claude Code to modernize a 25-year-old kernel driver – Dmitry Brant
  30. Homepage
  31. When should you use an actor?
  32. Fil-C
  33. 40 years later, are Bentley's "Programming Pearls" still relevant?
  34. Vibe Coding Terminal Editor
  35. C tooling
  36. How is Ultrassembler so fast?
  37. Tradeoffs of highly-expressive types · Programming should be enjoyable
  38. Replacing developers with GPUs
  39. Xcode 26 Beta 7 Release Notes | Apple Developer Documentation
  40. A Review of Nim 2: The Good & Bad with Example Code
  41. Bazel Knowledge: dive into unused_deps
  42. How to Slow Down a Program? And Why it Can Be Useful.
  43. The unexpected productivity boost of Rust
  44. Dependency Management with uv in Kubeflow Pipelines – Fabrizio Damicelli
  45. Dissecting the Apple M1 GPU, the end
  46. A Fast Bytecode VM for Arithmetic: The Compiler
  47. Nicolas Rinaudo - Hands on Capture Checking
  48. Retry Loop Retry
  49. Authoring binary files, using an assembler
  50. LLMs Won't Replace Programming Languages
  51. Crank.js | Why Be Reactive?
  52. I Preserve the Old Ways...I Guess?
  53. Anno 1800: Frame Analysis | Thomas Poulet
  54. When 'when' went wonky
  55. How I Made Ruby Faster than Ruby
  56. A Clock That Doesn't Snap | Ethan Niser | Blog
  57. Retro Rogue-Like: Modular Programming in C
  58. Why Lean 4 replaced OCaml as my Primary Language
  59. Our relationship to technology is broken
  60. Why I chose OCaml as my primary language
  61. an engineer's perspective on hiring
  62. the joy of building a bytecode VM from scratch
  63. My Ideal Array Language - Asher's Blog
  64. In Support Of Shitty Types
  65. 2024 - The 28th IOCCC
  66. Valley of Despair
  67. Ayush Gundawar — Post
  68. Welcome to the Seed7 Homepage
  69. How I ported Penko Park to Switch: From crashes to rock-solid 60 FPS - Ghostbutter
  70. The Useless useCallback
  71. placing functions
  72. Learning About GPUs Through Measuring Memory Bandwidth | Evolve
  73. Rust running on every GPU | Rust GPU
  74. ramalama/mesa : benchmarks on my hardware and open source vs proprietary
  75. There is no memory safety without thread safety
  76. Is MVVM Dead? Why One Engineer Says 'Yes' and What He's Using Instead
  77. Solving the source generator 'marker attribute' problem in .NET 10: Exploring the .NET 10 preview - Part 4
  78. Why Lists are not lowered to a while loop
  79. How I Fixed Ruby's Most Annoying Problem: 60-Second Gem Installs"
  80. Billions of Tokens Later: Scaling LLM Fuzzing in Practice
  81. Binary Vector Search at 350GB/s using ARM NEON
  82. [WIP] CUDA backend by zcbenz · Pull Request #1983 · ml-explore/mlx
  83. My foray into Vlang | Kris Tun
  84. Wasm the Hard Way: Porting the Chicory Compiler to Android
  85. Phrase origin: Why do we “call” functions?
  86. Behind the scenes of dotnet run app.cs: Exploring the .NET 10 preview - Part 2
  87. Sandboxes? In my process? It's more likely than you think.
  88. Vim Setup
  89. How Many Agents Does it Take to Beat PyTorch?(surprisingly not that much)
  90. How much code does that proc macro generate?
  91. Introducing tmux-rs
  92. How fast is it really? On latency, measurement, and optimization in algorithmic trading systems | Architect: Trade Futures, Options, Digital Assets
  93. Doing My Day Job on Chimera Linux
  94. What should a native DOM templating API look like?
  95. ORMs Are Annoying! Until You Try Living Without One
  96. I Shipped a macOS App Built Entirely by Claude Code
  97. I Write Type Safe Generic Data Structures in C
  98. “True Lies” – or “What LLVM Claims, but Fails to Deliver”
  99. Abstraction boundaries are optimization boundaries
  100. So you want to serialize some DER? · Alex Gaynor
  101. Vibe Coding is Not an Advantage
  102. On Large Language Models
  103. What The Heck Just Happened?
  104. Balaji Arumugam
  105. Writing Toy Software Is A Joy
  106. Building a language server · Bull no one
  107. You can't use switch expressions in Blazor
  108. My First Impressions of Gleam
  109. TPU Deep Dive
  110. Makefile Tutorial by Example
  111. Open Sourcing Any Distance
  112. KSP and Me · paul-samuels.com
  113. Run C# Scripts With dotnet run app.cs (No Project Files Needed)
  114. OxCaml | About
  115. Writing a Verified Postfix Expression Calculator in Ada/SPARK
  116. LLMs Expand Computer Programs by Adding Judgment
  117. Async Traits Can Be Directly Backed By Manual Future Impls
  118. crawshaw - 2025-06-08
  119. Rust is Officially in the Linux Kernel
  120. Devlog ⚡ Zig Programming Language
  121. Getting started with QT, without the nonsense
  122. How I program with Agents
  123. Branch prediction and speculative execution
  124. How Compiler Explorer Works in 2025 — Matt Godbolt’s blog
  125. Why I Wrote the BEAM Book
  126. Uniqueness for Behavioural Types · KC Sivaramakrishnan
  127. Optimizing AI Model Load Times
  128. Vibe Xcoding your apps
  129. Unexpected Gotchas in Making a Game Deterministic
  130. CRDTs #3: Do Not Read!
  131. Why LLM tool calls are hard to get working reliably, and how to fix it
  132. Zero-overhead checks with fake stack overflows
  133. Announcing dotnet run app.cs - A simpler way to start with C# and .NET 10 - .NET Blog
  134. Linux cgroup from first principles
  135. Unlocking Ractors: class instance variables
  136. Avoiding reflection in C# in way unsafer ways!
  137. Vibe coding is metaprogramming - foobuzz
  138. KotlinConf 2025 is a real bowl of fresh air for backend Devs
  139. Introducing Zod 4 | Zod
  140. Vibe coding is metaprogramming - foobuzz
  141. Compiling OCaml to the TI-84+ CE Calculator
  142. Welcome to the Seed7 Homepage
  143. Dusk OS
  144. Writing that changed how I think about PL
  145. Flattening Rust's Learning Curve | corrode Rust Consulting
  146. PDCA Quality Control: Applying Plan-Do-Check-Act in Modern Industries
  147. GitHub - Efeckc17/simple-todo-c: A lightweight, native Windows Todo application built with pure C and the Win32 API.
  148. Leaving Google – Airs – Ian Lance Taylor
  149. 15 Years of Shader Minification - Ctrl-Alt-Test
  150. Type-Safe Routing in Gleam | kurz.net
  151. C# 14 - Exploring extension members - .NET Blog
  152. The Many Types of Polymorphism
  153. What Happens If We Inline Everything?
  154. LLMs are like compilers, sort of
  155. GitHub - Anemll/Anemll: Artificial Neural Engine Machine Learning Library
  156. Jonathan Peppers Unleashes Code Chaos: How .NET Meets the NES
  157. The Joy of Aeroplane Mode Programming |
  158. How I Solved the Expression Problem
  159. Understanding the CPython Compiler
  160. Python sub-micro GPIO – PyXL Benchmark
  161. Stefan Abi-Karam
  162. Compiler reminders
  163. GitHub - joexbayer/RetrOS-32: A x86 32bit Hobby Operatingsystem with graphics, multitasking, networking and 32bit C-Compiler for i386 architecture.
  164. How to Hire Engineers Who Ship Kernels
  165. Diving into the .NET World: Beginner's Diary #1
  166. Llama 2 LLM on DOS
  167. Coding NEON kernels for the Cortex-A53 – Daniel Estévez
  168. Extensions get an update in .NET 10
  169. Add an .editorconfig file to your solution right from the start! 🛠️
  170. Things Zig comptime Won't Do
  171. 15,000 lines of verified cryptography now in Python
  172. What We Mean When We Say “Think”
  173. What the Hell Is a Target Triple? · mcyoung
  174. C has its limits. If you know where to look.
  175. Global rename and find references
  176. Dijkstra would’ve (incorrectly) HATED vibe-coding
  177. Optimizing memory usage with modern .NET features
  178. detached observations - Smol Nero
  179. Parser Combinators Beat Regexes
  180. A surprising enum size optimization in the Rust compiler · post by James Fennell
  181. NVIDIA Drops a Game-Changer: Native Python Support Hits CUDA - <FrontBackGeek/>
  182. Writing C for curl
  183. Social Media Engineers
  184. V8 Explicit Compile Hints with Magic Comments
  185. Nix derivations by hand, without guessing
  186. Things I learned rewriting a project from scratch
  187. Trip To China
  188. NVIDIA Finally Adds Native Python Support to CUDA
  189. Celebrating 50 years of Microsoft | Bill Gates
  190. Announcing Rust 1.86.0 | Rust Blog
  191. Celebrating 50 years of Microsoft | Bill Gates
  192. How to Make Your Neural Network Run Faster: An Overview of Optimization Techniques
  193. GitHub - luskaner/ageLANServer: Web Server for AoE 1, 2 and 3 DE supporting LAN multiplayer 100% offline
  194. Porting Tailscale to Plan 9
  195. We Need More Words for Snow
  196. Static types are for perfectionists
  197. On Binary Distribution Rebuilds – Simon Josefsson's blog
  198. Emjay - implementing function calls
  199. Malware is harder to find when written in obscure languages
  200. Calculate Throughput with LLVM's Scheduling Model
  201. Spade | Spade Hardware Description Language
  202. Golang on the PlayStation 2
  203. Ferrous Systems Donates Ferrocene Language Specification to Rust Project - The Rust Foundation
  204. Arguments against static typing
  205. Just write a test for it
  206. leaving the Sea of Nodes · V8
  207. Snakes in a Pane: Building Snake Entirely Within a tmux Config File
  208. Reproducible Software Releases – Simon Josefsson's blog
  209. TypeScript Migrates to Go: What's Really Behind That 10x Performance Claim?
  210. Notes on coreutils in Rust · Alex Gaynor
  211. The design and impact of building a simple key-value database in Inko
  212. Optimizing Django by not being silly
  213. How NixOS and reproducible builds could have detected the xz backdoor for the benefit of all
  214. I want a good parallel computer
  215. OCaml’s Standard Library (Stdlib)
  216. Memory safety for web fonts  |  Blog  |  Chrome for Developers
  217. Make Ubuntu packages 90% faster by rebuilding them
  218. Programming isn't enough
  219. Apple restricts Pebble from being awesome with iPhones
  220. JangaFX - Insight: Linux Binary Compatibility
  221. TypeScript-Go: A 10x Faster TypeScript without .NET but in Go
  222. How will LLMs take our jobs?
  223. The Defer Technical Specification: It Is Time
  224. Getting Started with Compilers
  225. I spent 181 minutes waiting for the Zig compiler this week
  226. Choosing Languages
  227. Nix Dynamic Derivations: A practical application
  228. My Seventh Year as a Bootstrapped Founder
  229. A 10x Faster TypeScript - TypeScript
  230. Bypassing the branch predictor
  231. Announcing Melange 5 | Sandtracks
  232. Performance of the Python 3.14 tail-call interpreter
  233. Hello echo! Hello git! - Gleam
  234. Four Years of Jai
  235. Madmeg's Blog
  236. Improving on std::count_if()'s auto-vectorization
  237. LLM not LLVM
  238. LLMs Don’t Know What They Don’t Know—And That’s a Problem
  239. Sum Types and Subtypes and Unions
  240. Garbage collection theory - Basic Algorithms - Michał 'Chlebik' Piotrowski
  241. 0.14.0 Release Notes ⚡ The Zig Programming Language
  242. .NET Aspirations - Tailor It To Your Stack
  243. Why fastDOOM is fast
  244. Creating an analyzer to detect infinite loops caused by ThreadAbortExceptions
  245. Async, Sync, in Between
  246. C++ creator calls for action to address 'serious attacks'
  247. Hallucinations in code are the least dangerous form of LLM mistakes
  248. Microsoft’s .NET 10 arrives in first preview
  249. Release fish 4.0.0 (released February 27, 2025) · fish-shell/fish-shell
  250. Over the Clouds: CPython, Pyodide, and SPy
  251. Eric Chiang | Protobuf generators for fun and profit
  252. GitHub - deepseek-ai/DeepGEMM: DeepGEMM: clean and efficient FP8 GEMM kernels with fine-grained scaling
  253. Why do frame pointers matter for OCaml? · Perpetually Curious Blog
  254. Memory hell · Nova
  255. High-Performance Logging in .NET 9
  256. C# 14: Null-conditional assignment
  257. Why Clojure?
  258. asm-lessons/lesson_01/index.md at main · FFmpeg/asm-lessons
  259. Overview - Neut Programming Language
  260. Announcing Rust 1.85.0 and Rust 2024 | Rust Blog
  261. C# Object and Dynamic Types
  262. Client state management, sync engines, and Foundry
  263. Why I'm Writing a Scheme Implementation in 2025 (The Answer is Async Rust)
  264. Designing type inference for high quality type errors
  265. A new interpreter in Python 3.14 delivers a free speed boost
  266. IEnumerable vs IEnumerator in C#: One is 2x Faster - LinkedIn Edition
  267. Comments on NASA's 10 rules
  268. Emjay - a simple JIT that does math
  269. Multi-files fixes
  270. Tiny JITs for a Faster FFI
  271. strongly-typed-thoughts.net
  272. GitHub - Grubre/smol-gpu: An rv32i inspired ISA, SIMT GPU implementation in system-verilog.
  273. Tech's Dumbest Mistake: Why Firing Programmers for AI Will Destroy Everything
  274. How I learned to stop worrying and love the LLM · baby steps
  275. Elementary Functions and NOT Following the IEEE 754 Floating-Point Standard — TRYING TO FIND THE OBVIOUS
  276. computer graphics, mathematics, shaders, fractals, demoscene and more
  277. Devlog ⚡ Zig Programming Language
  278. GitHub - Sawyer-Powell/chatgcc: A bash script to use ChatGPT as your C compiler
  279. Gleam gets ‟rename variable” - Gleam
  280. Julia for R users – vituri’s blog
  281. String vs &str
  282. The future belongs to idea guys who can just do things
  283. The inevitability of the borrow checker
  284. strongly-typed-thoughts.net
  285. rewrite.md
  286. Type Theater and Pushing Left
  287. Optimizing with Novel Calendrical Algorithms
  288. GitHub - kspalaiologos/bzip3: A better and stronger spiritual successor to BZip2.
  289. Does O3 beat a specalized numeric compiler?
  290. Starflate: Deflate decompression in C++23
  291. The Next Chapter in Swift Build Technologies
  292. Falsehoods programmers believe about null pointers
  293. How we accidentally built a better build system for OCaml
  294. Creating source-only NuGet packages
  295. Where are they?
  296. My Technological Regrets
  297. Cache Conscious Hash Maps
  298. I Tried To Bootstrap A Startup - memoricide
  299. New Years resolutions for PyTorch in 2025 : ezyang’s blog
  300. TB
  301. GitHub - davidlattimore/wild: A very fast linker for Linux
  302. My impressions of Gleam
  303. Rust's Superpower: Speed Meets Smarts - Chris Woody Woodruff
  304. Using the most unhinged AVX-512 instruction to make the fastest phrase search algo
  305. C Is Not Suited to SIMD
  306. Level Up Your Skills: Learning Rust as a C# Dev - Chris Woody Woodruff
  307. WinForms: Analyze This (Me in Visual Basic) - .NET Blog
  308. Threads, Tasks, and Ownership: C# and Rust Concurrency Explored - Chris Woody Woodruff
  309. Rethinking MediatR Validation: Moving from Pipeline to Domain Objects
  310. Programing Pipelines Using Dependent Types
  311. How we made Blurhash 128x faster — Uploadcare Blog
  312. Garbage Collection in C# vs. Ownership in Rust – Chris Woody Woodruff
  313. A Look at Common Constructs in C# and Rust – Chris Woody Woodruff
  314. Learning about excellence from Roger Rabbit
  315. Beating cuBLAS in Single-Precision General Matrix Multiplication
  316. Beating OpenBLAS in FP32 Matrix Multiplication
  317. Yashovardhan Srivastava
  318. The missing tier for query compilers
  319. Memorization Is Important In CS
  320. Apple is Killing Swift
  321. Perspectives after 4 years – tylerrussell.dev
  322. Building Bauble
  323. I quit my job to work on my programming language
  324. eBPF Research Papers
  325. Announcing Rust 1.84.0 | Rust Blog
  326. Fidget
  327. Fired From Meta After 1 Week: Here’s All The Dirt I Got
  328. Build an LVGL Touchscreen App with Zig
  329. Comptime: Scott Redig
  330. A 2-ply minimax chess engine in 84,688 regular expressions
  331. crawshaw - 2025-01-06
  332. This year in LLVM (2024)
  333. Improved performance and publishing - Gleam
  334. Weak references and garbage collectors
  335. The JIT calculator challenge
  336. GitHub - indiv0/aoc-fastest
  337. Programming a GPU on bare metal
  338. Reflecting on ten years of my personal project
  339. Pytest is fast
  340. Fish 4.0: The Fish Of Theseus
  341. Solving Sudoku with tmux
  342. How to add metaprogramming to Gleam – lpil.uk
  343. Write your Own Virtual Machine
  344. GitHub - facundoolano/software-papers: 📚 A curated list of papers for Software Engineers
  345. Into CPS, never to return
  346. RAG + Semantic Markup
  347. Ways to use torch.export : ezyang’s blog
  348. Simplifying disassembly with LLVM tools
  349. NPM search is broken
  350. 5 Years of Compiler Jobs — Matthew Gaudet
  351. Go's Weird Little Iterators · mcyoung
  352. How I Made My SIMD Code 1700x Faster Without Writing Any Intrinsics
  353. Building blogmate.io: Recursive Phoenix Components
  354. Wiki - SurveyOfSystemLanguages2024
  355. Let's CRUNCH! | More magic
  356. Go Protobuf: The new Opaque API - The Go Programming Language
  357. Fast, Constrained Optimization in the Browser with SCIP
  358. Fast LLM Inference From Scratch
  359. Your First day on the team = releasing Your first feature
  360. All Your Codebase
  361. Zero to CMake | Fred's Blog
  362. Common Misconceptions about Compilers
  363. Using the YamlDotNet source generator for Native AOT
  364. Tree Calculus
  365. Memory-safe PNG decoders now vastly outperform C PNG libraries
  366. Ways to use torch.compile : ezyang’s blog
  367. Defining All Undefined Behavior and Leveraging Compiler Transformation APIs
  368. Having fun with ValueTuple
  369. runtime/docs/design/specs/runtime-async.md at main · dotnet/runtime
  370. Making Computer Faster: a Deep Dive into Dynamic Dispatch (part 1)
  371. You can use C-Reduce for any language
  372. You have built an Erlang
  373. Apache NuttX and small systems - Hello, World !
  374. Functional programming self-affirmations
  375. Static, Dynamic, Mergeable, oh, my!
  376. Unsafe for work
  377. What I wished I knew when learning C
  378. Dear friend, you have built a Kubernetes
  379. Mirror: An LLM-powered programming-by-example programming language
  380. Learning LLVM (Part-1) - Writing a simple LLVM pass
  381. Keeping it small: helping the compiler to remove unused code in OCaml
  382. An Unreachable Hidden XKCD Easter Egg inside CPython
  383. On "Safe" C++
  384. How to Build a Chess Engine and Fail
  385. Context aware compilation - Gleam
  386. n times faster than C, Arm edition · Luna’s Blog
  387. The only computer science book worth reading twice?
  388. Stop Making Me Memorize The Borrow Checker
  389. ‘Reflections on Trusting Trust’, but completely by accident this time
  390. Calling methods is easier and faster with C# 13 params collections - .NET Blog
  391. Zig Reproduced Without Binaries - Motiejus Jakštys Public Record
  392. What's new in F# 9 - F# Guide - .NET
  393. Top 5 Language Features in C# 12 - Coding Sonata
  394. MVVM Toolkit v8.4: Custom Access Modifiers for Partial Properties – How To
  395. How dotnet.exe resolves and loads the hostfxr library - Exploring the .NET muxer - Steve Gordon - Code with Steve
  396. Where web components shine
  397. Notes from the Carbon panel session at EuroLLVM 2024
  398. Clean Architecture: The Missing Chapter
  399. Verifying code against architecture with Metalama
  400. Jia Tanning Go code
  401. Golang developers should try Odin
  402. What’s New in POSIX 2024 – XCU
  403. GitHub - aartaka/pretty.c: Making C Look ✨Pretty✨and Lua/Lisp/Python-esque
  404. GPGPU Compute Concepts
  405. Self-documenting Code
  406. Zig is everything I want C to be
  407. Free Productive C# Webinar - Meta-Programming in C# with Metalama (October 23)
  408. svelte
  409. 2 JVM problems Clojure has to handle
  410. Good tools are worth paying for • Dylan Fitzgerald
  411. Announcing Rust 1.82.0 | Rust Blog
  412. When should I use String vs &str?
  413. how-i-think-of-the-expression-problem - Chad Nauseam Home
  414. Every bug/quirk of the Windows resource compiler (rc.exe), probably
  415. Let's run some NFAs — 0xd34df00d.me
  416. C# 6.0 Overview
  417. C# Nullable reference types – No more null reference exceptions!
  418. My negative views on Rust
  419. Engineering the Scalable Vector Extension in .NET - .NET Blog
  420. Revisiting the DOS memory models
  421. .NET 9 Performance Improvements Summary
  422. Avoiding Repetitive Code With Metalama
  423. What’s New In Python 3.13
  424. 6 years with Gleam
  425. SYCL: A Portable Alternative to CUDA - Sasank's Blog
  426. Critical Social Infrastructure for Zig Communities
  427. An Introduction to Filament
  428. Pledging $300,000 to the Zig Software Foundation
  429. Migrating from AWS to Self-Hosting ⚡ Zig Programming Language
  430. C Until It Is No Longer C
  431. Tour of Hell
  432. On leaving my last job
  433. How DWARF Works: Table of Contents and Introduction
  434. Rewriting Rust
  435. Whence ' '? – Casey Rodarmor's Blog
  436. Tune Llama3 405B on AMD MI300x (our journey) - Felafax Blog - Obsidian Publish
  437. Optimizing Guile Scheme — dthompson
  438. What cpu context switch and cache pollution are and how do they impact performance
  439. Ratchets in software development
  440. Announcing Swift 6
  441. Vector math library codegen in Debug · Aras' website
  442. Safe C++
  443. Porting SBCL to the Nintendo Switch
  444. Arrays of Wisdom of the Ancients
  445. Performance Improvements in .NET 9 - .NET Blog
  446. The First HTML LSP That Reports Syntax Errors
  447. What’s in an e-graph?
  448. An ideology-induced bug in Mypy
  449. Why I Prefer Exceptions to Error Values
  450. Just for Fun. No, Really.
  451. What is the best pointer tagging method?
  452. Why is F# code so robust and reliable? - .NET Blog
  453. LINQ Joins on multiple columns in Entity Framework
  454. Clojure - Clojure 1.12.0
  455. Debugging a memory leak in a Clojure service
  456. Async Rust can be a pleasure to work with (without `Send + Sync + 'static`)
  457. The Fundamental Law Of Software Dependencies
  458. gRPC: 5 Years Later, Is It Still Worth It?
  459. Behavior Sanitizers in Elixir
  460. On the strange status of wchar_t in classic MIDL - The Old New Thing
  461. Understanding Angular AOT vs. JIT Compilations
  462. All Aboard the Bootstrap Transpiler Express
  463. live-bootstrap/parts.rst at master · fosslinux/live-bootstrap
  464. Why am I writing a Rust compiler in C?
  465. Fluid Simulation and Web Assembly
  466. GitHub - dpjudas/SurrealEngine: Unreal Tournament Engine Reimplementation
  467. State of Generics and Collections
  468. PyTorch is dead. Long live JAX.
  469. Instead of putting a hash in the Portable Executable timestamp field, why not create a separate field for the hash? - The Old New Thing
  470. Keeping Production Observable with rising costs
  471. STD Doesn't Have to Abstract OS IO
  472. An introduction to auto-vectorization with LLVM
  473. You should make a new programming language
  474. You should make a new programming language
  475. Building static binaries in Nix — kokada
  476. Quote-unquote "macros"
  477. async2 - The .NET Runtime Async experiment concludes
  478. csharplang/proposals/TypeUnions.md at 18a527bcc1f0bdaf542d8b9a189c50068615b439 · dotnet/csharplang
  479. First impressions of Gleam: lots of joys and some rough edges
  480. Tony Hawk's Pro Strcpy
  481. Debugging a rustc segfault on illumos :: sunshowers
  482. The difference between undefined behavior and ill-formed C++ programs - The Old New Thing
  483. Adding Serilog to ASP.NET Core: a practical guide
  484. Porting Lean to the ESP32-C3 RISC-V microcontroller
  485. cppfront: Midsummer update
  486. How to compress out interior padding in a std::pair and why you don't want to - The Old New Thing
  487. Avalonia 11.1: A Quantum Leap in Cross-Platform UI Development
  488. Bril: An Intermediate Language for Teaching Compilers
  489. Evolving Languages Faster with Type Tailoring
  490. strlcpy and how CPUs can defy common sense
  491. In my Visual Studio project, I set my Conformance mode to permissive, but it's still not permissive - The Old New Thing
  492. Mapping symbols: rethinking for efficiency
  493. How conditional breakpoints work 🐢
  494. The state machine in C# with async/await
  495. Migrating .NET APIs with Obsolete Attribute
  496. An interactive guide to x86-64 assembly - moving data
  497. My first program ever coded
  498. Rockin’ the Code World Season 4: Wisdom from the Trenches: Navigating Career Longevity in Software Engineering
  499. Pin
  500. Adding Serilog to ASP.NET Core: a practical guide
  501. How To Fix .NET Nullability Warnings For Guarded Members
  502. Free .NET 8 Web API Live Stream's
  503. Fastest C# Enum to String - NDepend Blog
  504. SCALE documentation
  505. How not to benchmark!
  506. The missing parts in Cargo
  507. Beating the compiler
  508. ASP.NET Core Basics: 12 Questions and Answers for Beginners
  509. Introducing wlhc: wayland hot corners
  510. neotraverse: unbloating traverse | Puru Vijay
  511. dut
  512. Creating an already-completed asynchronous activity in C++/WinRT, part 2 - The Old New Thing
  513. C# 13: Explore the latest preview features - .NET Blog
  514. Always Optimize the Feedback Loop
  515. (modal)
  516. Scan HTML faster with SIMD instructions: .NET/C# Edition – Daniel Lemire's blog
  517. I Have No Constructor, and I Must Initialize
  518. The Snapdragon X Elite’s Adreno iGPU
  519. Beating NumPy’s matrix multiplication in 150 lines of C code
  520. How do I produce a Windows Runtime asynchronous activity from C#? - The Old New Thing
  521. A Type for Overload Set
  522. GitHub - vslavik/diff-pdf: A simple tool for visually comparing two PDF files
  523. How to output a SARIF file from a .NET project - Gérald Barré
  524. Writing GUI apps for Windows is painful | Samuel Tulach
  525. The Great Database Migration
  526. Industrial macros
  527. Skip and Kotlin Multiplatform
  528. Why Google Sheets ported its calculation worker from JavaScript to WasmGC  |  web.dev
  529. Writing a remove_all_pointers type trait, part 1 - The Old New Thing
  530. What's New in React 19
  531. You probably wrote half a monad by accident
  532. Profiling with Ctrl-C
  533. Extension methods make code harder to read, actually
  534. Exploring How Cache Memory Really Works
  535. Learning Machine Learning in Elixir | zacksiri.dev
  536. Announcing TypeScript 5.5 - TypeScript
  537. Announcing the Pre-Scheme Restoration — Pre-Scheme
  538. How to convert between different types of counted-string string types - The Old New Thing
  539. The postmodern build system
  540. On the sadness of treating counted strings as null-terminated strings - The Old New Thing
  541. Code Style for Better Productivity - Tips and Tools from the Metalama Team | The .NET Tools Blog
  542. Static arrays are the best vectors
  543. Spending too much time optimizing for loops
  544. My experience crafting an interpreter with Rust
  545. TypeScript 5.5 Adds ECMAScript Set Support
  546. Elixir v1.17 released: set-theoretic types in patterns, calendar durations, and Erlang/OTP 27 support
  547. My very first production bug
  548. BCC to libbpf conversion guide
  549. Apple blocks PC emulator from being available in iOS App Store and third-party app stores - 9to5Mac
  550. Announcing TypeScript 5.5 RC - TypeScript
  551. The Rise of Groq: Slow, then Fast
  552. 0.13.0 Release Notes ⚡ The Zig Programming Language
  553. What's the deal with std::type_identity? - The Old New Thing
  554. Test-Driving HTML Templates
  555. Speeding up rustc by being lazy
  556. MSTest 3.4 is here with WinUI support and new analyzers! - .NET Blog
  557. Vulkan 1.3 on the M1 in 1 month
  558. A DSL for Implementing Math Functions
  559. DuckDB isn't just fast
  560. Fast and Compact Structured Logging in C# Using String Interpolation
  561. Refactor your code using alias any type - .NET Blog
  562. More on harmful overuse of std::move - The Old New Thing
  563. A graphical depiction of the steps in building a C++ executable, basics - The Old New Thing
  564. Icing or Cake? — dthompson
  565. A graphical depiction of the steps in building a C++ executable, with XAML and packaging - The Old New Thing
  566. Test-Driving HTML Templates
  567. Compilers | Rasheed Starlet
  568. Lessons learned on building an app from job seekers (in tech)
  569. Zig's New CLI Progress Bar Explained
  570. A graphical depiction of the steps in building a C++ executable, enhanced for classic Win32 - The Old New Thing
  571. Weakly and strongly typed values in .NET
  572. Middleware doesn't belong in the router
  573. F# developer stories: how we've finally fixed a 9-year-old performance issue - .NET Blog
  574. A graphical depiction of the steps in building a C++ executable, basics - The Old New Thing
  575. Continuous delivery without a CI server
  576. How to test a Roslyn analyzer - Gérald Barré
  577. Evolution of the ELF object file format
  578. Writing a Unix clone in about a month
  579. The Space Quest II Master Disk Blunder
  580. Creating a prepopulated Windows Runtime Vector from C++/WinRT without going through an explicit std::vector - The Old New Thing
  581. Authenticode in 2024
  582. If you have to create a Windows Runtime Vector from C++/WinRT, do it as late as possible - The Old New Thing
  583. Unwind considered harmful? · baby steps
  584. Test-Driving HTML Templates
  585. vu128: Efficient variable-length integers
  586. Quantifying the Impact of Styled Components on Server Response Times
  587. Meta Releases Open Source React Compiler
  588. How to Deal With NullReferenceException? Object reference not set to an instance of an object.
  589. Fundamentals
  590. Runtime code generation and execution in Go: Part 1
  591. Dapper And Strongly Typed IDs – How To Dynamically Register Mappings
  592. Compilers for free with weval
  593. Using Source Generators to Validate IOptions in ASP.NET Core - Code Maze
  594. Computers
  595. on hoot, on boot — wingolog
  596. Why can't I find the injected name of a templated class's templated base class? - The Old New Thing
  597. XUnit–Improve type safety
  598. The .NET Generic Math Library - NDepend Blog
  599. Localizing a .NET console or desktop application
  600. References are like jumps
  601. Exploring the c4... compiler?
  602. Un garçon pas comme les autres (Bayes) - An unexpected detour into partially symbolic, sparsity-expoiting autodiff; or Lord won’t you buy me a Laplace approximation
  603. Setting up Doom Emacs for Astro Development
  604. GitHub - Hirrolot/datatype99: Algebraic data types for C99
  605. Refactor your code with C# collection expressions - .NET Blog
  606. Awaiting a set of handles with a timeout, part 6: Capturing the handles efficiently - The Old New Thing
  607. Pair Your Compilers At The ABI Café - Faultlore
  608. Boosting Productivity with Analyzers
  609. 100x faster sorted array intersections
  610. With PowerPC, Windows CE and the WiiN-PAD slate, everyone's a WiiN-er (except Data General)
  611. GitHub - skeeto/hash-prospector: Automated integer hash function discovery
  612. Making a 3D Modeler, in C, in a Week
  613. On Programming Languages
  614. Thoughts on Zig
  615. Some more C# 12 | Red Hat Developer
  616. Working with Rust Libraries from C# .NET Applications
  617. GitHub - borgo-lang/borgo: Borgo is a statically typed language that compiles to Go.
  618. Borgo Programming Language
  619. Ruby's Complex Branching Options
  620. TypeScript compiler trick
  621. basysKom GmbH | How To Use Modern QML Tooling in Practice
  622. What Computers Cannot Do: The Consequences of Turing-Completeness
  623. No Web Without Women
  624. Memory Management Every Programmer Should Know
  625. Announcing TypeScript 5.5 Beta - TypeScript
  626. Switch expression for void methods
  627. [SOLVED]: node_modules/metro-hermes-compiler/src/emhermesc.js:77 throw ex; Error: EMFILE: too many open files
  628. LogLog Games
  629. Implementing a functionality with GitHub Copilot for Visual Studio
  630. C# 13 Params Collections
  631. Type pattern matching in C# and TypeScript
  632. Ruby might be faster than you think
  633. Thoughts on Primary Constructors in C#
  634. How quickly can you break a long string into lines? – Daniel Lemire's blog
  635. C isn’t a Hangover; Rust isn’t a Hangover Cure
  636. C# 12: Collection expressions and primary constructors | Red Hat Developer
  637. Does readonly make your code faster?
  638. I Wrote My Own Editor
  639. Adventures In Rust: Bringing Exchange Support To Thunderbird
  640. The Real C++ Killers (Not You, Rust)
  641. 0.12.0 Release Notes ⚡ The Zig Programming Language
  642. LLVM is Smarter Than Me
  643. Invariance, Contravariance, and Covariance in C# Generics - Code Maze
  644. Gleam version v1.1 – Gleam
  645. How to build an in-memory Message Bus in TypeScript - Event-Driven.io
  646. Fluent API to await multiple calls and get their respective results
  647. Go performance from version 1.0 to 1.22
  648. Implementing an SHA transformer by hand
  649. GCC version 14 coming soon – and will drop Itanium support
  650. Lennon McLean
  651. Fractals in Pure Lambda Calculus
  652. YETI programming language
  653. The server chose violence - Cliffle
  654. Discrete logic network card
  655. Integer overflow vulnerabilities in .NET
  656. Intel’s Ambitious Meteor Lake iGPU
  657. Thoughts on the xz backdoor: an lzma-rs perspective | Blog | Guillaume Endignoux
  658. smeso - MIPS stacktrace: an unexpected journey
  659. How to use Comments to Prompt GitHub Copilot for Visual Studio - Visual Studio Blog
  660. Overview of webpack, a JavaScript bundler | johnnyreilly
  661. Equip 3rd party types with a deconstructor
  662. Primary Constructor and Logging Don't Mix
  663. pkgsrc on macOS: still works
  664. IntelliJ IDEA 2024.1 Is Out! | The IntelliJ IDEA Blog
  665. xz backdoor and autotools insanity
  666. Self Modifying Code
  667. The Video That Inspired Me To Create Odin
  668. Measuring your system’s performance using software (Go edition) – Daniel Lemire's blog
  669. Oneiblog
  670. Toll-free Bridging in Kotlin Native - Alex DeLorenzo
  671. Testing Your Native AOT Applications - .NET Blog
  672. The Sweet Spot - Maximizing Llama Energy Efficiency · Jacques Mattheij
  673. Lattice now compiles to .NET IL — John Austin
  674. Top level internal is unnecessary
  675. The ancient world before computers had stacks or heaps - The Old New Thing
  676. Pattern matching and the compiler can be surprising
  677. Type Inference Was a Mistake
  678. Reverse Mode Differentiation is Kind of Like a Lens II
  679. xorvoid
  680. Porting the GCLC to the web
  681. Why x86 Doesn’t Need to Die
  682. Hello eBPF: Auto Layouting Structs (7) - Mostly nerdless
  683. I'm A Developer Not A Compiler
  684. Collection Expressions – Using C# 12 in Rider and ReSharper | The .NET Tools Blog
  685. .NET Framework - March 2024 Cumulative Update Preview - .NET Blog
  686. What Computers Cannot Do: The Consequences of Turing-Completeness
  687. Write OpenAPI with TypeSpec
  688. On the future of computer science
  689. Notes on debugging HotSpot’s JIT compilation
  690. Why isn't C++ using my default parameter to deduce a template type? - The Old New Thing
  691. Code It Any Way You Want: Performance of Out Variable Declaration
  692. C# 13: Allow ref and unsafe in iterators and async
  693. Build time is a collective responsibility
  694. Cranelift code generation comes to Rust
  695. Zig defer Patterns
  696. static vs dynamic types
  697. How to use Comments as Prompts in GitHub Copilot for Visual Studio
  698. Eio 1.0 Release: Introducing a new Effects-Based I/O Library for OCaml
  699. 🔬 Rustls: Continuous Benchmarking Case Study
  700. GoblinTools - Neil Turner's Blog
  701. Look ma, I wrote a new JIT compiler for PostgreSQL – Pinaraf's website
  702. Compiling With Constraints
  703. Core Guidelines are not Rules - Simplify C++!
  704. GitHub - albertan017/LLM4Decompile: Reverse Engineering: Decompiling Binary Code with Large Language Models
  705. A Scalable Framework for Folding-based SNARKs
  706. The Return of the Frame Pointers
  707. Zig, Rust, and other languages
  708. Nix is a better Docker image builder than Docker's image builder - Xe Iaso
  709. How well does WRL ComPtr support class template argument deduction (CTAD)? - The Old New Thing
  710. NumPy vs BLAS: Losing 90% of Throughput
  711. How well does ATL CComPtr support class template argument deduction (CTAD)? - The Old New Thing
  712. csharplang/proposals/params-collections.md at main · dotnet/csharplang
  713. 10 years in Open Source
  714. How well does MFC IPTR/CIP support class template argument deduction (CTAD)? - The Old New Thing
  715. C# 12: Primary Constructors
  716. Release Bebop v3.0.4 · betwixt-labs/bebop
  717. How well does _com_ptr_t support class template argument deduction (CTAD)? - The Old New Thing
  718. How to Automatically Cast Between Types in C#
  719. C and C++ Prioritize Performance over Correctness
  720. smeso - Memory ordering and atomic operations synchronization
  721. Why is Everybody Talking about Groq?
  722. A Primer On Randomness
  723. RAII all the things?
  724. How can I force a copy of a C++ value? - The Old New Thing
  725. Zama's homomorphic encryption tech lands it $73M on a valuation of nearly $400M | TechCrunch
  726. Optimizing Rabin-Karp Hashing · Pardon the Interrupt
  727. Proverbs
  728. Experimental C# Interceptors: AOT & Performance for free | .NET Conf 2023
  729. GitHub - NilsIrl/dockerc: container image to single executable compiler
  730. Autogenerating a Book Series From Three Years of iMessages
  731. C# Language Features vs. Target Frameworks
  732. Convert ANY Of Your C# Types Without Casting Using Implicit Operators
  733. Let's not over-hype rust.
  734. Typesafety in xUnit with TheoryData<T>
  735. Optional parameters may appear in the middle of the parameter list - Gérald Barré
  736. The Future That Never Was
  737. Is shadowing a member variable from a base class a bad thing? Maybe, but maybe not. - The Old New Thing
  738. Gleam version 1 – Gleam
  739. Implicit Operators in C#: How To Simplify Type Conversions
  740. CS 6120: The Self-Guided Course
  741. C++/WinRT performance trap: Switching to Windows Runtime too soon - The Old New Thing
  742. You’ve just inherited a legacy C++ codebase, now what?
  743. Marc Kerbiquet's Website
  744. Introduction To Low Latency Programming: Minimize Branching And Jumping
  745. Does this 8088 code in the Leisure Suit Larry 2 game actually do anything?
  746. EF Core - Cannot convert from 'string' to 'System.FormattableString'
  747. Lock statement patterns
  748. What if best practices were the norm?
  749. .NET JsonElement Error Handling | endjin
  750. Language Checklist
  751. Things I Used to Care About
  752. foojay – 12 Lessons Learned From Doing The 1BRC Challenge
  753. Extracting data from a small CSV file with Haskell
  754. Release Notes for February 15, 2024
  755. Soft Skills in Software Engineering
  756. Linting away manipulation of raw pointers with C++20
  757. Blazor Basics: HTML Forms and Capturing User Data
  758. Changing TypeScript library functions while keeping backwards compatibility
  759. Keywords for Top 10 Languages
  760. Conformant OpenGL 4.6 on the M1
  761. Antithesis – autonomous testing
  762. New Features in C# 12
  763. AMD Zen 5 Compiler Support Posted For GCC - Confirms New AVX Features & More
  764. What Is the Difference Between Properties and Fields in C# - Code Maze
  765. Building the DirectX shader compiler better than Microsoft?
  766. Why Bloat Is Still Software’s Biggest Vulnerability
  767. Django, SQLite, and the Database is Locked Error
  768. How to Get the Number of Files in a Folder With C# - Code Maze
  769. A Splendid Scala Journey
  770. Calling System Functions in a JIT
  771. Comparing for and foreach Loops in C# - Code Maze
  772. Building a HIP environment from scratch
  773. Go 1.22 Release Notes - The Go Programming Language
  774. Microsoft Migrates a Real-Time Service to .NET Core for Performance Gains
  775. Security policies in open source software | Red Hat Developer
  776. Finding New Mountains to Climb
  777. How I learned Haskell in just 15 years
  778. Statically and dynamically typed scripts
  779. .NET R&D Digest (January, 2024)
  780. Exploring the Code World: dotNetDave Inquires About Guests’ Hobbies and Pastimes – Part 1
  781. F# tips weekly #4: Record types
  782. A minimal, complete and correct ELF file
  783. Probabilistic Programming in C# With Infer.NET - Code Maze
  784. How is a binary executable organized? Let's explore it!
  785. Why Test-Driven Development? (Part 2) - Simple Talk
  786. Make Invalid States Unrepresentable
  787. The undercover generalist
  788. In the Debugger's Spotlight: A Year in Review - Visual Studio Blog
  789. Relational Databases Aren't Paying Off In Payments
  790. A Year of C++ Improvements in Visual Studio - Visual Studio Blog
  791. The C Bounded Model Checker: Criminally Underused
  792. Colored Functions Are Good, Actually
  793. How to Properly Create Message Templates for Logging in C# - Code Maze
  794. Error categories and category errors
  795. Checking if a collection is empty in C# - Gérald Barré
  796. F# 8: accessing properties without fuss
  797. Arend van Beelen jr.
  798. Woven Memories - Subroutines
  799. My Impressions of Hare
  800. Safe Manual Memory Management with Coeffects
  801. Common Language Runtime (CLR) overview - .NET
  802. S6E10 - The .NET Trilogy and Learning .NET with Mark J Price
  803. GitHub - FractalFir/rustc_codegen_clr: This rust compiler backend emmits valid CIL (.NET IR), enabling you to use Rust in .NET projects
  804. My experience working on rustc_codegen_clr
  805. Microsoft Office's RTC (Real-Time Channel) migration to modern .NET - .NET Blog
  806. Cake Build Tool Updated to .NET 8 in v4.0.0
  807. SourceGear Rust - Visual Studio Marketplace
  808. Blazor Basics: Component Parameters and State Management
  809. How we made an animated movie in 8kB - Ctrl-Alt-Test
  810. 4 reasons to try Mozilla’s new Firefox Linux package for Ubuntu and Debian derivatives | The Mozilla Blog
  811. Rockin’ the Code World Season 4: Special Guest Jared Parsons
  812. A Range kata implementation in C#
  813. Understanding how top-down operator precedence parsing works
  814. C23: a slightly better C
  815. GitHub - QuantGeekDev/lmaolang: 👏🏼A👏🏼brand👏🏼new👏🏼way👏🏼to👏🏼write👏🏼HTML👏🏼
  816. Ben Carlsson / Effective English
  817. lmaolang/README.md at main · QuantGeekDev/lmaolang
  818. DIY: your own Dependency Injection library!
  819. How to Escape Curly Brackets and Special Characters in C# - Code Maze
  820. Should you, could you AOT?
  821. How to Design an ISA
  822. Why Optimize Code for Performance
  823. Getting a strong reference from the this pointer too soon - The Old New Thing
  824. Some Memories of Niklaus Wirth
  825. Perfecting Protocol Parsing (Probably) with eBPF
  826. The architecture behind Alma – An experimental playground for generative graphics
  827. How to Escape the Backslash Character in C# - Code Maze
  828. A Range kata implementation in F#
  829. Going Native
  830. Between Art and Algorithms
  831. I'm A Developer Not A Compiler
  832. .NET Continuous Profiler: Under the Hood
  833. Jonas Hietala: Exploring the Gleam FFI
  834. Memory Safe C Compiler
  835. How to Distribute Roslyn Analyzers via NuGet
  836. Const strings are not so const after all
  837. What Does yield Do In C#: A Simplified View For Beginners
  838. What's New in F# 8.0: Simpler, Enhanced Uniformity, and Improved Performance
  839. Python 3.13 gets a JIT
  840. How do I prevent my C++/WinRT implementation class from participating in COM aggregation? - The Old New Thing
  841. Making primary constructor parameters read-only - Gérald Barré
  842. Programming as Theory Building - Peter Naur
  843. RIP: Software design pioneer Niklaus Wirth
  844. AoE is written in Assembly - is this actually TRUE?! :O
  845. scheme modules vs whole-program compilation: fight — wingolog
  846. Common Setup and Teardown in dotnet tests without test framework magic
  847. Is Objective-C <code>BOOL</code> a boolean type? It depends
  848. Speed up your code: don't pass structs bigger than 16 bytes on AMD64
  849. What We Got Right, What We Got Wrong
  850. Coding Stories: Me vs. The VNC Guy
  851. [Oberon] Niklaus Wirth 15.2.1934 - 1.1.2024
  852. What I did in 2023
  853. Maestro - Introduction
  854. 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
  855. Building a self-contained game in C# under 2 kilobytes
  856. This year in LLVM (2023)
  857. How do I prevent my ATL class from participating in COM aggregation? DECLARE_NOT_AGGREGATABLE didn't work - The Old New Thing
  858. How to Initialize Parameters of a Record in C# - Code Maze
  859. Bringing .NET to the Edge: How to Run Your CLI Applications on Cloudflare Workers with WASI
  860. Part 0: The Start
  861. Gentoo goes Binary! – Gentoo Linux
  862. terminal smooth scrolling
  863. Default Values for Lambda Expressions in C# - Code Maze
  864. Cold-blooded software
  865. Safer recursion in F# - .NET Blog
  866. The IDEs we had 30 years ago... and we lost
  867. 4 billion if statements
  868. Getting started with OCaml and Functional Programming | Sandro Maglione
  869. 4 billion if statements
  870. A new lock type in .NET 9
  871. What does it mean when the compiler says that it can't convert something to itself? - The Old New Thing
  872. Nintendo Switch’s iGPU: Maxwell Nerfed Edition
  873. Challenging projects every programmer should try
  874. std::print in C++23
  875. Cray 1 Supercomputer Performance Comparisons With Home Computers Phones and Tablets
  876. Ruby 3.3.0 Released
  877. Never delete tests
  878. I Wrote 2K+ Lines of Brainfuck. Here's What I've Learned
  879. Memory Safety is a Red Herring
  880. Writing Worse Code For Better Maintainability – My Own Blog
  881. Release dotnet-1.0.1 · microsoft/semantic-kernel
  882. Introducing Route Generator for .NET
  883. Validating appsettings becomes much faster with .NET 8
  884. Validate NuGet packages before publishing from GitHub Actions
  885. Discriminated Unions in C#
  886. Progress toward a GCC-based Rust compiler
  887. The best things and stuff of 2023
  888. What Is String Interpolation In C# – What You Need To Know
  889. Advancements in machine learning for machine learning
  890. A curiously recurring lifetime issue
  891. C#– Record types copy constructor
  892. V8 is Faster and Safer than Ever! · V8
  893. How do I specify an optional parameter to a Windows Runtime method? - The Old New Thing
  894. How can I work around the absence of default parameters in the Windows Runtime? - The Old New Thing
  895. File Access Modifier in C# - Code Maze
  896. Serializing restaurant tables in Haskell
  897. Non-Send Futures When?
  898. Building a React F# UI for an Embedded System
  899. Choosing Elegance: The Case for F# in Application Development
  900. Write Your Own Retro Compiler
  901. Non-Send Futures When?
  902. Searching Strings [Pt 6] | C# for Beginners
  903. Sep with me on The Modern .NET Show
  904. Improving programming language performance
  905. Unveiling secrets of the ESP32: creating an open-source MAC Layer
  906. My TypeScript Skills Improving and Best Practices
  907. Dissecting C# Ranges
  908. Building a Text Editor: the Gap Buffer
  909. Inline Snapshot testing in .NET - Gérald Barré
  910. MyOwnDB v2: tech lessons applied
  911. Let’s learn how modern JavaScript frameworks work by building one
  912. clang now makes binaries an original Pi B+ can't run
  913. .NET 8 and C# 12 — Inline Arrays
  914. A Decade of Developing a Programming Language: A Response Response
  915. Private fields with or without underscore
  916. Turbo Pascal turns 40
  917. .NET 8 and C# 12 — ref readonly Parameters
  918. How to make libraries compatible with native AOT - .NET Blog
  919. GitHub - Mozilla-Ocho/llamafile: Distribute and run LLMs with a single file.
  920. Rust: Memory Management
  921. .NET 8 and C# 12 — Experimental Attribute
  922. A journey about the new interceptors of .NET 8
  923. GitHub - federico-busato/Modern-CPP-Programming: Modern C++ Programming Course (C++11/14/17/20)
  924. What's New in TypeScript 5.3 -- Visual Studio Magazine
  925. C# 12 (Complete C# Quick Reference) • Ben Bowen's Blog
  926. on safepoints -- wingolog
  927. On harmful overuse of std::move - The Old New Thing
  928. C3 Documentation
  929. Primary Constructors – Using C# 12 in Rider and ReSharper | The .NET Tools Blog
  930. Racket Beyond Languages | Nikhil's blog
  931. .NET 8 and C# 12 — Primary Constructors
  932. Hixie's Natural Log
  933. Plonky 3 / Valida October Review
  934. Top 3 whole program optimizations for AOT in .NET 8
  935. Things Programmers Can Do in One Week | Blog | build-your-own.org
  936. Typst: Compose papers faster
  937. Announcing TypeScript 5.3 - TypeScript
  938. Improvements & Changes in Android resource generation in .NET 8 - .NET Blog
  939. Things Programmers Can Do in One Week | Blog | build-your-own.org
  940. Berkeley Mono Typeface
  941. Announcing Rust 1.74.0 | Rust Blog
  942. What's New in C# 12: Primary Constructors, Collection Expressions, and More
  943. Linus Torvalds on C++
  944. Aaron Schlesinger's Personal Site
  945. InternalsVisibleToAttribute Class (System.Runtime.CompilerServices)
  946. Why does calling a coroutine allocate a lot of stack space even though the coroutine frame is on the heap? - The Old New Thing
  947. Announcing F# 8 - .NET Blog
  948. Announcing C# 12 - .NET Blog
  949. CC golf
  950. Yes, Ubuntu Is Withholding Security Patches for Some Software
  951. Getting Started
  952. What's new in C# 12
  953. How to Use Interceptors in C# 12
  954. C#–Declaring attributes on positional record types
  955. Trip report: Autumn ISO C++ standards meeting (Kona, HI, USA)
  956. Cancellation and Async State Machines
  957. Removing allocations by reducing closure scopes using local variables - Gérald Barré
  958. How to dig into the CLR
  959. CLion Nova Explodes onto the C and C++ Development Scene | The CLion Blog
  960. Don’t Build AI Products The Way Everyone Else Is Doing It
  961. A quick look at destination-driven code generation
  962. Switching to Elixir
  963. Faster compilation with the parallel front-end in nightly | Rust Blog
  964. Read and Write Windows Registry in C# - Code Maze
  965. Hare aims to become a 100-year programming language
  966. The 'eu' in eucatastrophe – Why SciPy builds for Python 3.12 on Windows are a minor miracle
  967. Officially Qualified - Ferrocene
  968. Discovering The Features Of DotNetFiddle – How To Compile C# Online
  969. Speed up a program for the 50 years old processor by 180000% – Blog about my engineering projects
  970. What's New in Microsoft's F# Language for Functional-First Programming -- Visual Studio Magazine
  971. Announcing TypeScript 5.3 RC - TypeScript
  972. Impressions of .NET Developer Days 2023 Conference
  973. Building a high performance JSON parser
  974. GitHub - xoreaxeaxeax/movfuscator: The single instruction C compiler
  975. Choosing diagnostic IDs - C#
  976. Dunfield Development Services
  977. A new way to bring garbage collected programming languages efficiently to WebAssembly · V8
  978. Visual Studio 2022 17.8 Preview 3: Structured Diagnostics, SQL Server Data Tools Upgrade and More
  979. Circuit Simulator: Compiling a bitmap
  980. A new F# compiler feature: graph-based type-checking - .NET Blog
  981. Beginner’s CSharp Switch Statement Tutorial: How To Properly Use A Switch Statement
  982. GitHub - GaijinEntertainment/DagorEngine: Dagor Engine and Tools source code from Gaijin Games KFT
  983. Porting a ClojureScript project to Squint
  984. Cosmopolitan Third Edition
  985. Breaking change: BinaryFormatter disabled across most project types - .NET
  986. Blazor Basics: Blazor Event Callbacks
  987. The Role of the Control Flow Graph in Static Analysis
  988. Why does code die so soon?
  989. .NET 8 Performance Improvements in .NET MAUI - .NET Blog
  990. Things I like about Gleam's Syntax
  991. Microsoft Cranks Out Weekly Visual Studio 2022 17.8 Previews as GA Nears -- Visual Studio Magazine
  992. Oracle unveils Java development extension for Visual Studio Code
  993. Craig Stuntz - On Learning Compilers and Creating Programming Languages
  994. Source Code Generators, DIY
  995. Was Rust Worth It?
  996. axo blog - System dependencies are hard (so we made them easier)
  997. Metalama Source Code Available | PostSharp Blog
  998. C# Record Explained - NDepend Blog
  999. .NET 8 Top 10 New Features - NDepend Blog
  1000. Customizing the behavior of record copy constructors - Gérald Barré
  1001. Getting started with gRPC Service with .NET 7
  1002. He Who Gives Up Correctness for Performance Deserves Neither
  1003. Zig is now also a Windows resource compiler
  1004. The 5 Levels of Readable Code
  1005. Hash Tables
  1006. A programming system
  1007. Oracle Offers Java Language Server Tool for VS Code -- Visual Studio Magazine
  1008. Wrathmark: An Interesting Compute Workload (Part 1)
  1009. Which Interpreters are Faster, AST or Bytecode?
  1010. A Look at Tailwind CSS
  1011. TypeScript Compiler Explained - CodeJourney.net
  1012. At the boundaries, static types are illusory
  1013. C Is Not a Low-level Language
  1014. Why async Rust? - Without boats, dreams dry up
  1015. How Can I Write Code On My Phone? – Unlock Potential For Mobile-First Coders
  1016. LSP could have been better
  1017. GitHub - CherniakYura/tccurl: Implement include header files over https
  1018. How to compare signed and unsigned integers in C++20?
  1019. Fast(er) JavaScript on WebAssembly: Portable Baseline Interpreter and Future Plans
  1020. Overhauled F# code fixes in Visual Studio - .NET Blog
  1021. What Is DotNetFiddle? - A How To Guide on Using C# Anywhere
  1022. Announcing .NET 8 RC2 - .NET Blog
  1023. How To Use Embedded Resources in .NET
  1024. Visual Studio 2022 17.8 Preview 3 is here! - Visual Studio Blog
  1025. LLM’s reasoning and other abilities – Second Sight
  1026. Multi-language integration testing made easy with Bazel
  1027. Soft Orders of Magnitude
  1028. Bare-metal Rust in Android
  1029. How LinkedIn Adopted Protocol Buffers to Reduce Latency by 60%
  1030. Why is Debian the way it is?
  1031. Microservices without reason
  1032. Thriving in the age of AI
  1033. Build a Console App in .NET Core Like a Pro!
  1034. Padding for Overlaid Structs
  1035. Open Sourcing Ferrocene
  1036. Strong static typing, a hill I'm willing to die on...
  1037. How to Design a Practical Type System to Maximize Reliability, Maintainability, and Productivity in Software Development Projects / Part 1: What, Why, and How?
  1038. Announcing TypeScript 5.3 Beta - TypeScript
  1039. .NET R&D Digest (September, 2023)
  1040. If Conversion Within .NET - Part 1
  1041. Rolling Forward to Major Versions in .NET
  1042. Build simple fuzzer - part 6
  1043. A shallow survey of OLAP and HTAP query engines
  1044. Easing tradeoffs with profiles · baby steps
  1045. Chasing the Myth of Zero-Overhead Memory Safety (plus pictures of mythical birds!)
  1046. Beginning CMake : Quick Getting Started with CMake
  1047. Include interactive Clojure/script code snippets in a web page with SCI & friends
  1048. Template meta-programming: Avoiding saying a type before it is complete - The Old New Thing
  1049. Was Javascript really made in 10 days?
  1050. an aborted experiment with server swift
  1051. We Need More DSLs in the Database
  1052. ROCm Is AMD’s No. 1 Priority, Exec Says - EE Times
  1053. Exploring Linux command-line space time
  1054. Reading notes from Performance Improvements in .NET 8 - Kristoffer Strube’s Blog
  1055. Using a Discard Variable in C# - Code Maze
  1056. Performance Improvements in .NET 8
  1057. Internal Affairs
  1058. How to be a Good Programmer
  1059. Less boilerplate code with the new primary constructor in C# 12
  1060. Build reliable and secure C++ programs
  1061. 64-Bit Bank Balances ‘Ought to be Enough for Anybody’? | TigerBeetle
  1062. Inside New Query Engine of MongoDB
  1063. Introducing runes
  1064. Why does my C++/WinRT project get unresolved externals for constructors? - The Old New Thing
  1065. EI029: Data Processing Service (Part 1)
  1066. Stability without stressing the !@#! out · baby steps
  1067. What's new in System.Text.Json in .NET 8 - .NET Blog
  1068. Do ORMs reduce the need for mapping?
  1069. When Zig Outshines Rust - Memory Efficient Enum Arrays
  1070. Discriminated Unions in C#
  1071. Accessing private members without reflection in C# - Gérald Barré
  1072. Synchronization Mechanisms - Volatile vs Interlocked vs lock in C# - Code Maze
  1073. GitHub - CatalaLang/catala: Programming language for literate programming law specification
  1074. Strange Loop&#39;s greatest hits
  1075. How does the Linux Kernel start a Process
  1076. GitHub - jonathanpeppers/dotnes: .NET for the NES game console
  1077. Performance Improvements in .NET 8 - .NET Blog
  1078. GitHub - StereoDB/StereoDB: Ultrafast and lightweight in-process memory database written in F# that supports: transactions, secondary indexes, persistence, and data size larger than RAM.
  1079. Hidings Symbols Of Elf Files
  1080. Developing OCaml with Nix
  1081. Refusing TypeScript is a signal that you don't care about code quality
  1082. Beyond TypeScript: Differences Between Typed Languages
  1083. Async Rust Is A Bad Language
  1084. Null conditional await
  1085. Let's Read the Turbo Source: What Happens When You Click a Link?
  1086. Closures in C# demystified
  1087. OSS Power-Ups: bUnit – Webinar Recording | The .NET Tools Blog
  1088. Writing a C compiler in 500 lines of Python
  1089. Tail recursion
  1090. Can you use a class in C? · On the Joy of Problems
  1091. GameRoy: JIT compilation in High-Accuracy Game Boy Emulation
  1092. Turn on Nullability checks by default
  1093. Use explicit Lambdas with LINQ
  1094. Introduction to TDD
  1095. Reasoning Task, Async & Await in .NET
  1096. JUXT Blog: Clojure in Banking: Griffin
  1097. Compiling Rust for .NET, using only tea and stubbornness!
  1098. How to Not Build a React App (Part V)
  1099. Ruby Outperforms C: Breaking the Catch-22
  1100. Modern High Performance C# 2023 Edition
  1101. Run My Code! (code injection on Windows)
  1102. Elijah Potter
  1103. Premature Optimization: Universally Misunderstood
  1104. Readonly Modifier in C# - Code Maze
  1105. Initial Impressions of Microsoft Olive
  1106. You like Circom but you find it confusing? Introducing Circomscribe
  1107. How SNARKs fall short for FHE
  1108. How to Mark Methods as Deprecated in C# - Code Maze
  1109. 5 New ASP net core features in dotnet 8 You'll Love this Year - Doumer's Blog
  1110. The first conformant M1 GPU driver
  1111. NonEmpty catamorphism
  1112. Compile-time type-checked truth tables
  1113. ASP.NET Community Standup - ASP.NET Architecture Series: AOT in .NET 8
  1114. The Problem with Friendly C – Embedded in Academia
  1115. Metaphors for thinking about LLMs
  1116. Why Do You Have to Return "Task" Whenever You "await" Something in a Method in C#?
  1117. .NET 8 Interceptors
  1118. Breaking The Mutant Language's "Encryption"
  1119. The Scourge of 00UB | Gavin D. Howard
  1120. C# 11 (Complete C# Quick Reference) • Ben Bowen's Blog
  1121. Targeting Multiple Frameworks in a .NET Project - Code Maze
  1122. Microsoft Open Sources 'ONNX Script' for Python Machine Language Models -- Visual Studio Magazine
  1123. What it means when you convert between different shared_ptrs - The Old New Thing
  1124. Inside STL: The shared_ptr constructor and enable_shared_from_this - The Old New Thing
  1125. Bare Metal Space Invaders
  1126. Rachit Nigam | PhD Candidate, Cornell University
  1127. Differences Between Const and Readonly in C# - Code Maze
  1128. Backward Compatibility, Go 1.21, and Go 2 - The Go Programming Language
  1129. Software Engineering at Google
  1130. GitHub - valida-xyz/valida: A STARK-based VM focused on code reuse, performance, and modularity
  1131. Can you use a class in C? · Effective program synthesis
  1132. Primary Constructors for Classes and Structs - Code Maze
  1133. Corrode Rust Consulting
  1134. Let's Co-Create! Your Voice Matters  - Visual Studio Blog
  1135. Go 1.21 Release Notes - The Go Programming Language
  1136. GitHub - huggingface/candle: Minimalist ML framework for Rust
  1137. Raku: A Language for Gremlins • Buttondown
  1138. Inside STL: The map, set, multimap, and multiset - The Old New Thing
  1139. Should we stop writing functions?
  1140. Why it is hard to generate beautiful HTML emails (from Markdown)
  1141. IBM, Red Hat and Free Software: An old maddog’s view
  1142. Verifiable encryption on the Blockchain
  1143. 0.11.0 Release Notes ⚡ The Zig Programming Language
  1144. Implicit Operators – Clean Code Secrets Or Buggy Nightmare?
  1145. Source Generators in C# - Code Maze
  1146. A Gentle Introduction to LLVM IR · mcyoung
  1147. Why your GPU can (and probably should) do real function calls
  1148. New C# 12 Preview Features Available
  1149. Run Llama 2 on your own Mac using LLM and Homebrew
  1150. .NET R&D Digest (July, 2023)
  1151. Nim v2.0 released
  1152. Inside STL: The pair and the compressed pair - The Old New Thing
  1153. Using C# source generation for enhanced logging - Bruno Sonnino
  1154. Polyfills in .NET to ease multi-targeting - Gérald Barré
  1155. How to Use TypeScript Generics with Functional React Components
  1156. What's up, Python? The GIL removed, a new compiler, optparse deprecated...
  1157. Cap'n Proto: Cap'n Proto 1.0
  1158. Beyond the Basics: XAML Compilation in .NET MAUI
  1159. Advanced Performance Extensions (APX)
  1160. Perfect forwarding forwards objects, not braced things that are trying to become objects - The Old New Thing
  1161. Microsoft Improves Natural Language UI for LLMs with Open Source TypeChat -- Visual Studio Magazine
  1162. GitHub - PRQL/prql: PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
  1163. Common pitfalls in Go benchmarking
  1164. Thriving in the dynamically type-checked hell scape of Clojure
  1165. 7 Tips to Boost .NET MAUI Mobile App Performance
  1166. jaspervdj - Lazy Layout
  1167. Empathetic tools | Software and puns
  1168. GitHub - KTStephano/StratusGFX: Realtime 3D rendering engine
  1169. JuMP, GAMS, and the IJKLM model
  1170. Announcing TypeScript 3.0 - TypeScript
  1171. Totality
  1172. GitHub - erhant/zkbrainfuck: A Brainfuck zkVM with Circom.
  1173. The RyuJIT transition is complete! - .NET Blog
  1174. Announcing the .NET Framework 4.7.1 - .NET Blog
  1175. Best Practices for Regular Expressions in .NET
  1176. Should We Use Records or Classes or Structs in C# - Code Maze
  1177. Introducing TypeChat - TypeChat
  1178. .NET MAUI 8 Preview 6: Visual Studio Code Extension, Bug Fixes & Native AOT for iOS
  1179. Creating a Roslyn Analyzer to ensure that no duplicate values are added at compile time
  1180. csharplang/proposals/collection-expressions.md at main · dotnet/csharplang
  1181. How to clone a Windows Runtime map in the face of possible concurrent modification, part 1 - The Old New Thing
  1182. .NET Framework 4.8 to .NET 6 migration
  1183. Why the “Null” Lifetime Does Not Exist
  1184. How to clone a Windows Runtime vector in the face of possible concurrent modification, part 4 - The Old New Thing
  1185. What's new in C# 12 - C# Guide
  1186. Micro-optimization: Concatenating a string with a char using string.Concat - Gérald Barré
  1187. Extended C# Support in ReSharper and Rider 2023.2 EAP 9 | The .NET Tools Blog
  1188. GitHub - amis92/csharp-source-generators: A list of C# Source Generators (not necessarily awesome) and associated resources: articles, talks, demos.
  1189. Prompt Design
  1190. tinygrad + rusticl + aco: why not?
  1191. Required Parameters in Blazor WebAssembly - Code Maze
  1192. Patching GCC to build Actually Portable Executables
  1193. How to clone a Windows Runtime vector in the face of possible concurrent modification, part 2 - The Old New Thing
  1194. Put a Pin on That
  1195. Five Years of Rhovas
  1196. New C# 12 preview features - .NET Blog
  1197. MemoryExtensions.Split Method (System)
  1198. Why does the compiler complain about a missing constructor when I'm just resizing my std::vector to a smaller size? - The Old New Thing
  1199. Compare Byte Arrays in .NET - Code Maze
  1200. 10x Performance with SIMD Vectorized Code in C#/.NET | xoofx
  1201. Finding Your Mojo – Mike Innes
  1202. WebAssembly and replayable functions
  1203. How small is the smallest .NET Hello World binary?
  1204. TypeScript 5.1: declaring JSX element types | johnnyreilly
  1205. Parsing in Python: all the tools and libraries you can use
  1206. Matcheroni, a tiny C++20 header library for building lexers/parsers
  1207. Overload resolution in C#
  1208. {n} times faster than C
  1209. How to wait for multiple C++ coroutines to complete before propagating failure, finding the awaiter - The Old New Thing
  1210. Episode 126 - Slimming Down .NET: The Unofficial Experiments of Michal Strehovský
  1211. 7 Things about C#: If Statements
  1212. How to wait for multiple C++ coroutines to complete before propagating failure, preallocating the coroutine frame - The Old New Thing
  1213. Debugging xUnit Tests Using Reflection
  1214. GitHub - zksecurity/noname: Noname: a programming language to write zkapps
  1215. The Tragic Death of Inheritance
  1216. How to wait for multiple C++ coroutines to complete before propagating failure, memory allocation failure - The Old New Thing
  1217. 40 Years of Computing (Part 1: The First 20 Years)
  1218. Roslyn Compiler and Analyzers in .NET - Introduction
  1219. How to wait for multiple C++ coroutines to complete before propagating failure, symmetric transfer - The Old New Thing
  1220. Fastest Branchless Binary Search
  1221. Hashtable in C#
  1222. FP pattern - list of TODOs
  1223. How to wait for multiple C++ coroutines to complete before propagating failure, custom promise - The Old New Thing
  1224. Programming Languages Going Above and Beyond
  1225. 7 Things about C#: Console I/O
  1226. How to wait for multiple C++ coroutines to complete before propagating failure, false hope - The Old New Thing
  1227. Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022
  1228. csharplang/proposals/inline-arrays.md at main · dotnet/csharplang
  1229. How to wait for multiple C++ coroutines to complete before propagating failure, unhelpful lambda - The Old New Thing
  1230. A case for ClojureScript 2.0
  1231. Missing Stack trace when eliding the await keyword
  1232. Value Objects in C# - Code Maze
  1233. Dart Sass and Hugo Themes
  1234. 7 Things about C#: Running Apps
  1235. Get ready for fsharpConf 2023! - .NET Blog
  1236. The case of the make_shared on a C++/WinRT type - The Old New Thing
  1237. Why I started (and stopped) making games
  1238. Why am I being told about a signed/unsigned comparison, and why only sometimes, and how can I fix it? - The Old New Thing
  1239. Differences Between ExpandoObject, DynamicObject and dynamic
  1240. fsharpConf: The F# Community Virtual Conference
  1241. Ultimate Guide: NextJS, NestJS & TRPC Monorepo [Updated 2023]
  1242. Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection
  1243. The case of the invalid handle despite being managed by an RAII type - The Old New Thing
  1244. The C# Meta Programming Roadmap
  1245. Collatz sequences by function composition
  1246. What is WASI?
  1247. A note on Metal shader converter
  1248. The move constructor that you have to declare, even though you don't want anyone to actually call it - The Old New Thing
  1249. Debian -- News -- Debian 12 "bookworm" released
  1250. Introducing C# 12: Primary constructor on classes and struct
  1251. Derived Instances Can Break Smart Constructors, Too
  1252. sort-research-rs/text.md at main · Voultapher/sort-research-rs
  1253. Virtual Methods in C# - Code Maze
  1254. To Save C, We Must Save ABI
  1255. F# is the .NET Rust
  1256. Span / Memory / ReadOnlySequence in C#
  1257. More Unit Testing with Less Code - Combinatorial Unit Testing
  1258. Bounds Safety: Avoiding Death by a Thousand Constructors
  1259. Demystifying WebAssembly: What Beginners Need to Know
  1260. ASP.NET Community Standup - ASP.NET Architecture Series: AOT
  1261. Release Blink 1.0 · jart/blink
  1262. graydon2 | The Rust I Wanted Had No Future
  1263. It's great that you provide operator overloads, but it's also nice to have names - The Old New Thing
  1264. Tree Borrows
  1265. Hugo and Tailwind: peace at last (maybe) | BryceWray.com
  1266. ZK app developers should be able to see down to the constraints
  1267. JuLox: What I Learned Building a Lox Interpreter in Julia
  1268. ASP.NET Community Standup - ASP.NET Architecture Series: AOT
  1269. Announcing Rust 1.70.0 | Rust Blog
  1270. New Features in Generally Available TypeScript 5.1 -- Visual Studio Magazine
  1271. What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
  1272. I think Zig is hard...but worth it
  1273. Cloud, why so difficult? 🤷‍♀️ | Wing
  1274. alexw.nyc -- duskos-1.html
  1275. Language Pragmatics Engineering
  1276. Keeping software soft
  1277. Favour flat code file folders
  1278. Domain modelling with State Machines and TypeScript by Carlton Upperdine
  1279. nameof get's a bit better in C# 12
  1280. Building a baseline JIT for Lua automatically
  1281. I Am No Longer Speaking at RustConf 2023
  1282. xorvoid
  1283. The obvious final step
  1284. .NET Rocks! PHP and WebAssembly with Jakub Míšek
  1285. the tiny corp raised $5.1M
  1286. 17 Amazing Community Packages for .NET Developers - Claudio Bernasconi
  1287. The Importance of Removing Unnecessary Expression Values in Code in Microsoft .NET
  1288. On creating (and using) a transforming iterator - The Old New Thing
  1289. Compress-a-Palooza: Unpacking 5 Billion Varints in only 4 Billion CPU Cycles
  1290. The Ultimate .NET Version Guide
  1291. Object Initializers in C# - Code Maze
  1292. Hot Reload Supports Modifying Generics! - .NET Blog
  1293. .NET Rocks! Immutable Architectures with Michael Perry
  1294. Building a Dynamic Logical Expression Builder in C#
  1295. Bitwise Binary Search: Elegant and Fast
  1296. Summary of the duck-typing requirements of C++ COM wrappers - The Old New Thing
  1297. Folders versus namespaces
  1298. Introducing Deopt Explorer - TypeScript
  1299. Language Tooling Antipatterns
  1300. Single Abstract Method Traits · mcyoung
  1301. Learning Homebrew Game Boy Game Development in Assembly
  1302. [PATCH 00/32] bcachefs - a new COW filesystem
  1303. Init Only Setters in C# - Code Maze
  1304. What are the duck-typing requirements of ATL CComPtr? - The Old New Thing
  1305. Myths about F#: F#’s strict ordering is dumb! No, it’s great for taming dependencies.
  1306. Increase MAX_MOVES to prevent buffer overflow and stack corruption by ZealanL · Pull Request #4558 · official-stockfish/Stockfish
  1307. TypeScript 5: importsNotUsedAsValues replaced by ESLint consistent-type-imports | johnnyreilly
  1308. Implementing Vale's Region Borrowing, and its Unexpected Quest
  1309. Announcing CheerpJ 3.0: a JVM replacement in HTML5 and WebAssembly to run Java applications (and applets) on modern browsers - Leaning Technologies
  1310. Learn Unison | 💡 The big idea · Unison programming language
  1311. On Custom-Width Integer Types
  1312. What are the duck-typing requirements of _com_ptr_t? - The Old New Thing
  1313. .NET Community Toolkit 8.2: MVVM Toolkit Attributes, Performance Enhancements, and More
  1314. Why does XAML complain that none of the overloads of winrt::to_hstring could be used? - The Old New Thing
  1315. Myths about F#: F# is slow! No, F# can be really fast.
  1316. Driving Compilers
  1317. What is Type-Level Programming? - sulami's blog
  1318. Error handling patterns
  1319. Binary data version migration
  1320. VerificationException in .NET Framework when using structs
  1321. Using sizeof() Operator in C# - Code Maze
  1322. Generic Efficient Accumulation/Folding for Special Sound Protocols
  1323. Using modern decorators in TypeScript - LogRocket Blog
  1324. Virtual DOM: Back in Block | Million.js
  1325. Deborah Kurata's Favorite 'New-ish' C# Feature: Pattern Matching -- Visual Studio Magazine
  1326. Maybe you should store passwords in plaintext.
  1327. How to lock orientation at runtime on iOS 16 with .NET MAUI and Xamarin.Forms
  1328. Verifying your DI Container
  1329. Microsoft is rewriting core Windows libraries in Rust
  1330. How to Start a .NET Project in 2023
  1331. Just Works For Me
  1332. Beautiful Branchless Binary Search
  1333. Using Crates.io with Buck
  1334. Announcing .NET Community Toolkit 8.2! Faster generators, code fixers, performance improvements and more! - .NET Blog
  1335. What's up with this new memory_order_consume memory order? - The Old New Thing
  1336. Building from source all the way down — 2023 — Blog — GNU Guix
  1337. RPC over Websockets [or TCP]
  1338. Deterministic Finalization in C#: IDisposable and Best Practices | C# Tutorials Blog
  1339. Why is std::hardware_destructive_interference_size a compile-time constant instead of a run-time value? - The Old New Thing
  1340. Introduction to gRPC with Fiddler Everywhere
  1341. Automating HTML Validation for a Happier Life
  1342. Static Methods vs. Non-Static Methods in C#
  1343. Revisiting The Fast Inverse Square Root - Is It Still Useful?
  1344. Michael Tsai - Blog - Price Increases for Developer Tools
  1345. Announcing Rust 1.69.0 | Rust Blog
  1346. Working with Sass in an ASP.NET Core application
  1347. No Code, Clean Performance
  1348. Where's my feedback loop?
  1349. Web API Updates with .NET 8
  1350. Generalized Macros
  1351. Welcome to Peter's DevLog - Wrapping C libraries in Nim
  1352. How can I find the invalid class when C++/WinRT tells me that the class may not be final? - The Old New Thing
  1353. KotlinConf 2023: A Look at the Opening Keynote | The Kotlin Blog
  1354. Using buck to build Rust projects
  1355. Building the Linux kernel in under 10 seconds with Firebuild - Obsessed with reality
  1356. Converting Strings to .NET Objects – IParsable and ISpanParsable
  1357. touchHLE in depth, part 1: a day in the life of a function call
  1358. Upcasting and Downcasting in C# - Code Maze
  1359. C-styel print debug in golang
  1360. Why Janet?
  1361. How to Round Down a Number to a Nearest Integer in C#
  1362. Six Labors : Announcing ImageSharp.Web 3.0.0
  1363. Debugging native memory issues in a C# application
  1364. Can You Trust a Compiler to Optimize Your Code?
  1365. Towards a Nova-based ZK VM
  1366. C# 11.0 new features: Span<char> pattern matching | endjin
  1367. Monorepos, fast maps, and more – Gleam
  1368. Using Unpoly with Django — /var/
  1369. Mindset shifts for Functional Programming (with Clojure)
  1370. All you need is data and functions
  1371. Should you adopt .NET 7 or wait for .NET 8?
  1372. Looking at C# 12 Proposals and Beyond
  1373. Staff Software Engineer, Copilot IDE
  1374. Riding & Driving in Washington
  1375. C++17 creates a practical use of the backward array index operator - The Old New Thing
  1376. Asynchronous C# programming using async and await keywords | C# Tutorials Blog
  1377. Does OpenTelemetry in .NET Cause Performance Degradation?
  1378. Why Clean Code was (and still is) important?
  1379. Julia's latency: Past, present and future
  1380. What is this [uuid(...)] in front of my C++ class declaration? - The Old New Thing
  1381. Episode 119 - Comparers with Stephen Cleary
  1382. ReSharper IL Viewer and Low-Level C# | The .NET Tools Blog
  1383. Type system of Fortnite's Verse language
  1384. How can I box a std::optional into a C++/WinRT IInspectable? - The Old New Thing
  1385. Nix Turns 20. What the Hell Is It?
  1386. The Perils of Polishing (LONG!)
  1387. C++ Initialization Story in Print
  1388. Primary Constructors with C#
  1389. Zig And Rust Mar 26, 2023
  1390. C# Source Generators: How to get build information?
  1391. Building a DOS ChatGPT client in 2023
  1392. Introducing Kotlin/Wasm
  1393. On being bored as a tech enthusiast
  1394. How to add a Clojure REPL to a web page
  1395. The AsyncIterator interface - Without boats, dreams dry up
  1396. Fascination of AWK
  1397. JVM Performance Comparison for JDK 17
  1398. Why am I getting a weird error about promise_type when I try to write a coroutine? part 2 - The Old New Thing
  1399. GitHub - typst/typst: A new markup-based typesetting system that is powerful and easy to learn.
  1400. TypeScript 5.0: 'Smaller, Simpler and Faster' -- Visual Studio Magazine
  1401. Why does the usage of the initial registers of a Win32 process depend on whether it is a 32-bit or 64-bit process? - The Old New Thing
  1402. Betraying vim for the IDEs of March
  1403. SuperWord (Auto-Vectorization) - An Introduction
  1404. GitHub - SimonCropp/Polyfill: Source only package that exposes newer .net and C# features to older runtimes.
  1405. Announcing TypeScript 5.0 - TypeScript
  1406. The birth of a package manager
  1407. Mind your C++/WinRT namespaces - The Old New Thing
  1408. How Async/Await Really Works in C# - .NET Blog
  1409. fastGPT: Faster than PyTorch in 300 lines of Fortran
  1410. Patterns & Abstractions - Without boats, dreams dry up
  1411. Metaprogramming in Lean
  1412. System.Text.Json Serializing Hierarchical Data
  1413. Partial Classes In C# And How to Use Them - Code Maze
  1414. A Guide For New Programmers on C# Basics
  1415. RazorSlices 0.3.0
  1416. GitHub - DamianEdwards/RazorSlices: Lightweight Razor-based templates for ASP.NET Core without MVC, Razor Pages, or Blazor.
  1417. What is the expression language used by the Resource Compiler for non-preprocessor expressions? - The Old New Thing
  1418. Disambiguating Arm, Arm ARM, Armv9, ARM9, ARM64, Aarch64, A64, A78, ...
  1419. What a good debugger can do
  1420. Taking Full Advantage of NoSideEffects, Or What's It Like To Be An Obsessional Researcher
  1421. School, Home
  1422. TypeScript's Migration to Modules - TypeScript
  1423. What's new for the WinForms Visual Basic Application Framework - .NET Blog
  1424. Visual Basic language strategy - Visual Basic
  1425. When Zig is safer and faster than Rust
  1426. How To Use The yield break Statement In C#? - Code Maze
  1427. EF Core Mapping with Generic Types, Value Conversion, and JSON Columns
  1428. Required Keyword, Checked Operators, nameof Operator Scope – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
  1429. Warnings-as-errors friction
  1430. My Hardest Bug Ever
  1431. Signals vs Streams, in terms of backpressure (2023)
  1432. Nix Quickstart
  1433. csharplang/primary-constructors.md at main · dotnet/csharplang
  1434. Write a First Person Game in 2KB With Rust
  1435. The World's Smallest Hash Table
  1436. Open-Source COBOL .NET Compiler Otterkit Reaches Alpha
  1437. Delegates
  1438. bryan garza
  1439. Journey Through Freedreno
  1440. What Are the Enduring Innovations of Lisp?
  1441. Announcing TypeScript 5.0 RC - TypeScript
  1442. Dealing with the unknown
  1443. .NET R&D Digest (February, 2023)
  1444. Difference Between Returning and Awaiting a Task in C#
  1445. How to develop un-analyzable PL
  1446. "Clean" Code, Horrible Performance
  1447. Annileen Devlog #2 - C++20 and Modules
  1448. How to integrate your Roslyn Analyzer project with SonarQube
  1449. Raw Strings, UTF-8 Strings, and Multiline Interpolations – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
  1450. F# language strategy
  1451. Making Go telemetry opt-in is a mistake
  1452. How to contribute to a project you have no idea about
  1453. Programming Will Always Use Text
  1454. GCC Gets a New Frontend for Rust - Slashdot
  1455. Different Types of Comments in C# and Should We Use Them
  1456. Bean Machine Retrospective, part 8
  1457. Updated Modern Code Generation for WinForm's InitializeComponent - .NET Blog
  1458. Writing a bare-metal RISC-V application in D
  1459. C# "var" with a Reference Type is Always Nullable
  1460. Re-thinking the Visitor Pattern with the Double-Dispatch Approach
  1461. Resolving the Call Is Ambiguous Error While Using LINQ
  1462. GitHub - MichalStrehovsky/sizegame: Compare binary sizes of canonical Hello World in different languages
  1463. C# 11–The scoped keyword
  1464. .NET 8 Preview 1: Native AOT Upgrade and the New 'Blazor United' -- Visual Studio Magazine
  1465. roslyn/source-generators.cookbook.md at main · dotnet/roslyn
  1466. GitHub - o-oconnell/minixfromscratch: Development and compilation setup for the book version of MINIX (3.1.0) on QEMU
  1467. List and Span Pattern Matching – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
  1468. Welcome to Peter's DevLog - Dynamic libraries in Nim
  1469. The case of the mysterious "out of bounds" error from CreateUri and memmove - The Old New Thing
  1470. Few lesser known tricks, quirks and features of C
  1471. They are here
  1472. What Austral Proves (Crash Lime)
  1473. Errors are Not Failures
  1474. BenchmarkDotNet v0.13.5 | BenchmarkDotNet
  1475. Languages & Runtime Community Standup - Otterkit: an OSS COBOL compiler for .NET
  1476. What happens if you co_await a std::future, and why is it a bad idea? - The Old New Thing
  1477. Why is building a UI in Rust so hard?
  1478. Visual Studio 2022 17.5 Preview 3 Build Acceleration
  1479. Making Sense of Acquire-Release Semantics
  1480. Exploring maven incremental builds with maven-build-cache-extension | miguel codes
  1481. .NET Managed languages strategy - .NET
  1482. Google’s Fully Homomorphic Encryption Compiler — A Primer
  1483. Whatever happened to Elm, anyway?
  1484. My Time At The Recurse Center
  1485. What is .NET, and why should you choose it?
  1486. Non-nullable properties in C# 11
  1487. Digging Into Nullable Reference Types in C#
  1488. Beware of fast-math
  1489. Lean BDD and Code Generation
  1490. The unsafe language doom principle
  1491. Scala Resurrection
  1492. Context-dependant code is better than its reputation
  1493. User or *User - Do We Need Struct Pointers Everywhere?
  1494. Asynchronous Programming Patterns in .NET
  1495. Lowering in C#: What's really going on in your code? - David Wengier
  1496. Lowering in C#: What's really going on in your code? - David Wengier
  1497. C# Source Generators - Write Code that Writes Code
  1498. Sydney ALT.NET August - Roslyn Code Generators and CoRoutines with C#
  1499. C# Source Generators - Write code that writes code - David Wengier
  1500. Porting Custom Controls from Xamarin Forms to Uno Platform
  1501. C#11 – Records Demystified
  1502. Zig Meta Programming
  1503. Bean Machine Retrospective, part 7
  1504. C#11 - Immutable Object and Defensive Copy
  1505. Languages & Runtime Community Standup - Otterkit: an OSS COBOL compiler for .NET
  1506. IEnumerable in C# – A Simplified Beginners Guide - Dev Leader
  1507. Comparing the Same Project in Rust, Haskell, C++, Python, Scala and OCaml
  1508. Everything You Wanted to Know About Multiline Strings - Dev Leader
  1509. A Linking Adventure - nsnotes
  1510. Type inference that sticks | Jared Forsyth.com
  1511. Weird things I learned while writing an x86 emulator
  1512. Static and non-static interface member calls in .NET: they are not the same
  1513. Names can be so much more
  1514. The names of birds, part 4
  1515. Python’s “Disappointing” Superpowers
  1516. Inside C++/WinRT: Coroutine completions: Avoiding reentrant completion
  1517. .NET R&D Digest (January, 2023)
  1518. Checksum mismatches on .tar.gz files · Discussion #45830 · community
  1519. Opinionated tools are better
  1520. Announcing TypeScript 5.0 Beta
  1521. How Austral’s Linear Type Checker Works
  1522. Cyber - Fast and concurrent scripting.
  1523. C in WASM
  1524. Announcing Rust 1.67.0 | Rust Blog
  1525. Hello World - Introduction to C# interactive C# tutorial
  1526. C# Lowering
  1527. Languages & Runtime Community Standup - Dive into C# internals
  1528. Nullable reference types–Using the required keyword in C# 11
  1529. Agilean
  1530. Static libraries
  1531. Nim Meta Programming
  1532. What's inside a .EXE File?
  1533. Dear Retro Community, Stop Writing Tools in C
  1534. Required Members in C# - Code Maze
  1535. How I learned to learn as a developer
  1536. It’s 2023, You Should Be Using Typescript!
  1537. A Rough Debut for Visual Studio Spell Checker Preview -- Visual Studio Magazine
  1538. Native AOT Overview
  1539. Announcing .NET Community Toolkit 8.1! Better, faster MVVM source generators, .NET 7 support, and more!
  1540. C# 12: Primary Constructors
  1541. Software testing, and why I'm unhappy about it
  1542. reduce() is a Left Fold, But reduceRight() Isn't a Right Fold
  1543. GitHub - otterkit/otterkit: Otterkit COBOL Compiler
  1544. C# Online Compiler | .NET Fiddle
  1545. Boxing and Unboxing in C# - Code Maze
  1546. Supporting the Use of Rust in the Chromium Project
  1547. Machine Learning in .NET with F# and ML.NET 2.0
  1548. Visual Studio 2022 Release Notes
  1549. Getting rid of warnings with nullable reference types and JSON object models in C#
  1550. 5 new advanced features improving C# 11 | Red Hat Developer
  1551. Directly Access Your Physical Memory (dev/mem)
  1552. What's New in Ruby 3.2
  1553. What does it mean when I get a mismatch from MSVC for _COROUTINE_ABI?
  1554. Executing async operations onchange in Blazor
  1555. A Zig Diary
  1556. You should write React in F#
  1557. SDL2 common mistakes and how to avoid them
  1558. Is coding in Rust as bad as in C++?
  1559. Microfeatures I'd like to see in more languages
  1560. Historical Source Code That Every Developer Should See
  1561. Machine Learning in .NET with F# and ML.NET 2.0
  1562. Bean Machine Retrospective, part 6
  1563. The faker's guide to reading (x86) assembly language
  1564. 100R — weathering software winter
  1565. C# 11 List Patterns - Create compatible types - Gérald Barré
  1566. Impress your colleagues with your knowledge about..the PrintMembers method
  1567. Oly/README.md at main · TIHan/Oly
  1568. bflat - C# as you know it but with Go-inspired tooling
  1569. Give your strings context with StringSyntaxAttribute
  1570. experiments with BPF programs performance · Erthalion's blog
  1571. Learning OCaml in 2023 | sancho.dev
  1572. Misleading geometric mean | Andrey Akinshin
  1573. C# 12: Default Parameters in Lambdas
  1574. Introducing Austral: A Systems Language with Linear Types and Capabilities
  1575. ReadOnlySpan<char> and strings - How not to compare them
  1576. After importing a TLB, how do I convert from one type of _com_ptr_t to another?
  1577. Default Interface Method in C# And When to Use It - Code Maze
  1578. 50 Years of Wow- I lived through 5 decades of computing milestones
  1579. 2022 APFS Advent Challenge Day 17 - Blazingly Fast Checksums with SIMD
  1580. Go is modern PHP
  1581. IEnumerable in C# - Code Maze
  1582. Challenging algorithms and data structures every programmer should try
  1583. Introduction to MVVM Source Generators for C# .NET
  1584. Optimizing Symmetric Quadratic Form
  1585. What are the biggest reasons newcomers give up on OCaml?
  1586. What are the biggest reasons newcomers give up on OCaml?
  1587. Functional error-handling with stack traces
  1588. On the large number of ways of expressing Microsoft Visual C++ compiler versions
  1589. Ref-structs are technically obsolete - Turnerj (aka. James Turner)
  1590. OCaml 5.0.0 is out!
  1591. If we must, let's talk about safety
  1592. I want toast
  1593. A Neat XOR Trick
  1594. Baby Steps With TypeScript
  1595. C# 11: pattern matching and static abstract interfaces | Red Hat Developer
  1596. C# 11 – File Scoped Types
  1597. The best things and stuff of 2022
  1598. Nullable Types in C# - Code Maze
  1599. What does it mean when the compiler tells me that promise_type: is not a member of coroutine_traits<void>?
  1600. Releases · bflattened/bflat
  1601. At Least Assert Your Serialisation Roundtrips
  1602. The limited utility of the phrase “GNU/Linux”
  1603. RC Week 12: What's Next, and Speedrunning Crafting Interpreters
  1604. Bean Machine Retrospective, part 4
  1605. Goodbye to the C++ Implementation of Zig ⚡ Zig Programming Language
  1606. Apple GPU drivers now in Asahi Linux - Asahi Linux
  1607. Atari Dev Studio - Visual Studio Marketplace
  1608. C# 11–Generic Attributes
  1609. Bean Machine Retrospective, part 3
  1610. Reminder: If you intend to use a C++/WinRT namespace, you must include that namespace's header file
  1611. GitHub Copilot preliminary experience report
  1612. Technique: Recursive variants and boxes
  1613. JIT in ClickHouse
  1614. Bean Machine Retrospective, part 2
  1615. Managing CSS Scope With Razor Components
  1616. Our journey to F#: C#-F# Interop – planetgeek.ch
  1617. Twenty five thousand dollars of funny money
  1618. Enoch - Using Neovim as a Fennel Compiler
  1619. Introducing C# 11: Numeric IntPtr and UIntPtr
  1620. How to enumerate through a StringBuilder
  1621. Bean Machine Retrospective, part 1
  1622. Introducing C#11: Required properties
  1623. C++ template parlor tricks: Using a type before it is defined
  1624. .NET 7 - The StringSyntaxAttribute
  1625. Memory Safe Languages in Android 13
  1626. How much does Rust's bounds checking actually cost?
  1627. out-of-bounds memory access bug
  1628. C# 11: Raw strings, required members, and auto-default structs | Red Hat Developer
  1629. A long expected update
  1630. How To Easily Understand TypeScript Generics
  1631. [Apply by 12/08] Introducing our fellowship program
  1632. C# 11 Strings in the Raw
  1633. A Mostly Complete Guide to C# 11’s Final Features
  1634. Why Only Type-hints?
  1635. I/O is no longer the bottleneck?
  1636. Using Rust at a startup: A cautionary tale
  1637. C# String Interpolation - Code Maze
  1638. Using Rust at a startup: A cautionary tale
  1639. Building the fastest Lua interpreter.. automatically!
  1640. Sometimes perfect forwarding can be too perfect: Lazy conversion is lazy
  1641. C# 11 Improvements for Strings, List Patterns and Object Creation
  1642. .NET Serialization Roundup 2022
  1643. Relocatable linking
  1644. Building the fastest Lua interpreter.. automatically!
  1645. Little Languages Are The Future Of Programming
  1646. Quest for my perfect watch.
  1647. Zero-Cost Memory Safety with Vale Regions (Preview)
  1648. .NET 7.0's Performance Improvements with Dynamic PGO are Incredible
  1649. Considering C99 for curl | daniel.haxx.se
  1650. C# 11 and .NET 7 Bring Generic Parsing
  1651. Clojure's typing "problem"
  1652. Why won't C++/WinRT let me co_await a CoreDispatcher or DispatcherQueue?
  1653. Announcing TypeScript 4.9
  1654. C# 11 required members - NDepend
  1655. STAThread and async Main gotcha
  1656. How to Use the “Using Static” Feature in C# - Code Maze
  1657. Introducing the C# 11 Required Keyword
  1658. Why middleware may not be the right abstraction for your data policies.
  1659. How to Return null From a Generic Method in C#? - Code Maze
  1660. Immutability: Dart vs. F#
  1661. Array short-circuiting
  1662. The one about Lisp interactivity
  1663. Gorillas (video game) - Wikipedia
  1664. Twelve C# 11 Features
  1665. How static application security testing improves software security | Red Hat Developer
  1666. Why don't Windows functions begin with a pointless MOV EDI,EDI instruction on x86-64?
  1667. C Isn't A Programming Language Anymore - Faultlore
  1668. Traits in Rust
  1669. Arm64 Visual Studio is officially here!
  1670. Announcing F# 7
  1671. TypeScript for React Developers – Why TypeScript is Useful and How it Works
  1672. Marking API's as obsolete or as experimental
  1673. Mutable value types are evil! Sort of...
  1674. Announcing TypeScript 4.9 RC
  1675. GitHub - dotnet/razor: Compiler and tooling experience for Razor ASP.NET Core apps in Visual Studio, Visual Studio for Mac, and VS Code.
  1676. C++ is the next C++
  1677. Everything you need to know about the OpenSSL 3.0.7 Patch (CVE-2022-3602 & CVE-2022-3786) - MalwareTech
  1678. 0.10.0 Release Notes ⚡ The Zig Programming Language
  1679. local functions vs lambda expressions
  1680. C# 11 File Scoped Types - NDepend
  1681. PGO: Add new tiers by EgorBo · Pull Request #70941 · dotnet/runtime
  1682. A Team at Microsoft is Helping Make Python Faster
  1683. GitHub Copilot may steer Microsoft into a copyright lawsuit
  1684. Constructor Overloading in C# - Code Maze
  1685. Zig Is Self-Hosted Now, What's Next?
  1686. On Scala 3&#39;s Optional Braces
  1687. Episode 1: A basic expression evaluator
  1688. An argument for self-modifying applications
  1689. With Java 19, VS Code Now Does Virtual Threads While Debugging -- Visual Studio Magazine
  1690. bliki: ConwaysLaw
  1691. How Trying New Programming Languages Helped Me Grow as a Software Engineer
  1692. That Time I Tried Porting Zig to SerenityOS
  1693. That Shouldn't Happen - UnreachableException in .NET 7
  1694. When is a slice of any not a slice of any?
  1695. Simon Peyton Jones
  1696. Writing An Incremental Typesetting Engine | Laurenz's Blog
  1697. Cursed C# - Doing shenanigans in C#
  1698. Modern C# Techniques, Part 3: Generic Code Generation
  1699. C# UI and .NET Hot Reload - A Match Made in .NET MAUI
  1700. Boosting Performance With Sealed Classes in .NET - Code Maze
  1701. GitHub - clemedon/Makefile_tutor: This project aims to create a crystal clear tutorial on a cryptic looking topic.
  1702. The 4th year of SerenityOS
  1703. Zig-style generics are not well-suited for most languages
  1704. GitHub - woodrush/lambda-8cc: x86 C compiler written in untyped lambda calculus
  1705. My Personal Tech Limbo (and Elixir vs Rust)
  1706. Modern C# Techniques, Part 2: Value Records
  1707. Thread by @LinaAsahi on Thread Reader App
  1708. Introduction to WebApplicationFactory
  1709. git/torvalds/linux.git - Linux kernel source tree
  1710. Microsoft Claims Reduction in Cloud Cost from Migrating Internal Services to .NET 6
  1711. Pitfalls with eager loading of collections in EF Core
  1712. An elegy for GNU and RMS
  1713. Ten Years of TypeScript
  1714. Django 4 form rendering using Tailwind without Node or crispy
  1715. x86 vs x64 in .NET
  1716. Debugging coroutine handles: Looking for the source of a one-byte memory corruption
  1717. Peter Ritchie's Blog - By Reference in C#
  1718. Ken Thompson Really Did Launch His "Trusting Trust" Trojan Attack in Real Life
  1719. Getting started with OpenTelemetry Metrics in .NET. Part 2: Instrumenting the BookStore API
  1720. Linus Torvalds: Rust will go into Linux 6.1
  1721. What does the C++ error "A pointer to a bound function may only be used to call the function" mean?
  1722. the sad state of debug performance in c++
  1723. Mainlining Nexus 9: First Boot
  1724. CCPS, a Capcom CPS-1 SDK
  1725. Compiler Optimizations Are Hard Because They Forget - Faultlore
  1726. Announcing TypeScript 4.9 Beta
  1727. The road to Zettalinux
  1728. reading through the OCaml compiler: Part 1
  1729. GitHub - rochus-keller/LeanQt: LeanQt is a stripped-down Qt version easy to build from source and to integrate with an application.
  1730. Announcing Rust 1.64.0 | Rust Blog
  1731. The impossible case of pitching rust in a web dev shop
  1732. reading through the OCaml compiler: Part 1
  1733. Get Up To Date with the Latest Features of C# 11
  1734. Workflow for 3.12 cycle · faster-cpython/ideas Wiki
  1735. What is NullReferenceException in C#? - Code Maze
  1736. Rust is coming to the Linux kernel
  1737. When to refactor
  1738. csharplang/file-local-types.md at main · dotnet/csharplang
  1739. Why load fs:[0x18] into a register and then dereference that, instead of just going for fs:[n] directly?
  1740. Writing unsafe .NET code without the unsafe keyword - Gérald Barré
  1741. C# 11 - Top 5 Features in the new C# Version | Rubik's Code
  1742. GCC's new fortification level: The gains and costs | Red Hat Developer
  1743. GitHub - hsutter/cppfront: A personal experimental C++ Syntax 2 -> Syntax 1 compiler
  1744. Working Iteratively
  1745. It pays to be Circomspect
  1746. We Need Simpler Types
  1747. Architecture of a .NET Application: Case Studies - NDepend
  1748. ZeroBanana – Senior Engineers are Living in the Future
  1749. A pair of Rust kernel modules
  1750. C# Lambda Discards | endjin
  1751. Tutorial on using LLVM to JIT PyTorch fx graphs to native code (x86/arm/risc-v/wasm) (Part I – Scalars)
  1752. Writing a compiler. Bytecode finale
  1753. Writing a compiler. Bytecode finale
  1754. Arm64 Performance Improvements in .NET 7
  1755. OCaml By Example | <fun>
  1756. GitHub - meienberger/runtipi: ⛺️ Tipi is a homeserver for everyone! One command setup, one click installs for your favorites self-hosted apps. ✨
  1757. Byte Magazine Volume 08 Number 08 - The C Language : Free Download, Borrow, and Streaming : Internet Archive
  1758. The Case for Use.GPU
  1759. Security of ZK Systems
  1760. Episode 104 - C# with Mads Torgersen
  1761. Zig, the small language
  1762. TailwindCSS Tip: Arbitrary Values in Utility Classes
  1763. Formal Verification of ZK Constraint Systems
  1764. Using Go generics to pass struct slices for interface slices - Dusted Codes
  1765. Tips to Get Started with Cosmopolitan Libc
  1766. Arti 1.0.0 is released: Our Rust Tor implementation is ready for production use. | Tor Project
  1767. Simplicity and Survival
  1768. Security of ZK Systems
  1769. Why am I getting a null pointer crash when trying to call a method on my C++/WinRT object?
  1770. Infrequent, Pragmatic, Lambda Blog - Cognitive Loads in Programming
  1771. Performance Improvements in .NET 7
  1772. The x86-64 processor (aka amd64, x64): Whirlwind tour
  1773. Turning Methods Into Benchmarks
  1774. Refactor code to use new C# language features | The .NET Tools Blog
  1775. Visual Studio Build Tools Licensing Eased for Open Source C++ Projects -- Visual Studio Magazine
  1776. The AArch64 processor (aka arm64), part 25: The ARM64EC ABI
  1777. Writing a .NET profiler in C# - Part 1
  1778. OCaml at First Glance
  1779. New IKVM 8.2 & MavenReference for .NET projects
  1780. C# 11 Raw String Literals Explained - NDepend
  1781. The AArch64 processor (aka arm64), part 24: Code walkthrough
  1782. Using Generics in C# - Code Maze
  1783. On Caching Elixir Beam files · Anantha Kumaran
  1784. Generalizing Dijkstra's Algorithm — Monday Morning Haskell
  1785. The AArch64 processor (aka arm64), part 23: Common patterns
  1786. Tips for Using TypeScript With React in a Large Code Base
  1787. Running darktable on RISC-V
  1788. Stop saying 10x developer
  1789. We Deserve Better Than BEM
  1790. Inside the Pinecone | Pinecone
  1791. Strongly Typed Middleware in ASP.NET Core
  1792. The AArch64 processor (aka arm64), part 21: Classic function prologues and epilogues
  1793. Typescipt is terrible for library developers
  1794. A Peek at Latest C# 11 Features Coming in November with .NET 7 -- Visual Studio Magazine
  1795. How to Create a Class Dynamically in C#? - Code Maze
  1796. Can types replace validation?
  1797. C# 11 preview: generic math, required members, and more
  1798. The AArch64 processor (aka arm64), part 19: Miscellaneous instructions
  1799. Using TypeScript With React and KendoReact Components
  1800. Ekaitz's tech blog
  1801. Unix is not Linux
  1802. Self Hosted Compiler Upgrade Guide · ziglang/zig Wiki
  1803. The AArch64 processor (aka arm64), part 18: Return address protection
  1804. How I Learned to Stop Worrying and Love Macros
  1805. I Built a Ruby Compiler
  1806. It wasn't for nothing - Grasping gexps
  1807. jank programming language - Clojure/LLVM/Gradual Typing
  1808. What's New in Visual Studio 2022 17.4 Preview 1
  1809. GitHub - norvig/paip-lisp: Lisp code for the textbook "Paradigms of Artificial Intelligence Programming"
  1810. GitHub - oasislinux/oasis: a small statically-linked linux system
  1811. The AArch64 processor (aka arm64), part 14: Barriers
  1812. Choosing a .NET Memory Profiler in Visual Studio - part 1
  1813. C# 11: Preview of features for .NET 7
  1814. Microsoft Releases .NET Community Toolkit 8 with Automatic Source Generation
  1815. Tools I use: Eclipse — bayindirh
  1816. The AArch64 processor (aka arm64), part 11: Loading addresses
  1817. The Story of Mel
  1818. The AArch64 processor (aka arm64), part 10: Loading constants
  1819. That time I 10x’d a TI-84 emulator’s speed by replacing a switch-case
  1820. C23 is Finished: Here is What is on the Menu
  1821. Weird Expressions and Where to Find Them
  1822. So Zero It's ... Negative? (Zero-Copy #3)
  1823. DreamWorks Animation to Release MoonRay as Open Source
  1824. Type Checking and Type Casting in C# - Code Maze
  1825. How generics were added to .NET
  1826. C99 doesn't need function bodies, or 'VLAs are Turing complete'
  1827. Customizing TypeScript String Types with Template Literal Types and Utility Types
  1828. Rider 2022.2 Comes With More C# 11 Features,  Performance Improvements, and Extended Unreal Engine Support | The .NET Tools Blog
  1829. ReSharper 2022.2 Comes With C# 11 Support, Solution-Wide Analysis Optimizations, and Virtual Formatter | The .NET Tools Blog
  1830. Go 1.19 Release Notes - The Go Programming Language
  1831. Release Notes for August 1, 2022
  1832. Invariant functors
  1833. Effective TypeScript › What's TypeScript compiling? Use a treemap to find out.
  1834. Running Zig with WASI on Cloudflare Workers
  1835. Linux 5.19 [LWN.net]
  1836. Linux 5.19
  1837. Every programmer should care about UI design
  1838. Domenico Luciani - Misleading Pair Programming
  1839. Why the Windows Registry sucks … technically
  1840. TypeScript Bytecode Interpreter / Runtime Types · Issue #47658 · microsoft/TypeScript
  1841. TypeScript: Typechecker-Assisted Runtime Data Validation
  1842. Logging Source Code Generators
  1843. Union types in C# - Event-Driven.io
  1844. What are Minimal APIs in ASP.NET Core 6 - Code Rethinked
  1845. Twenty years of Valgrind
  1846. Transitional Apps with Phoenix and Svelte
  1847. Templates in C
  1848. What they don't teach you about sockets
  1849. ZpqrtBnk
  1850. finally. #embed
  1851. ~icefox/garnet - sourcehut hg
  1852. Some Thoughts on Zig — Sympolymathesy, by Chris Krycho
  1853. Don't Code Tired | Support Multiple Versions of .NET From A Single Class Library (.NET multi-targeting)
  1854. Why use the Bazel build system?
  1855. Meet Bun: A JavaScript Runtime for the Whole Dev Lifecycle
  1856. GitHub - carbon-language/carbon-lang: Carbon language specification and documentation.
  1857. ZpqrtBnk
  1858. Engineers on brink of extinction threaten entire ecosystems
  1859. Catering to Desktop & Mobile with .NET MAUI
  1860. System.CommandLine 2.0.0-beta4.22272.1
  1861. Native AOT deployment overview - .NET
  1862. Null Conditional Operators in C# - ?. and ?[]
  1863. Crystal is a Surprise | akos.ma
  1864. Nullability in C# - What It Is and What It Is Not
  1865. How I went about learning Rust
  1866. Lessons from Writing a Compiler
  1867. Compiler and Composability in ZKP
  1868. Integrate generator times into /reportAnalyzer by jaredpar · Pull Request #61661 · dotnet/roslyn
  1869. Learn a language by writing too many Forths
  1870. Build an LVGL Touchscreen App with Zig
  1871. Rust front-end
  1872. Unsafe Code in C# (unsafe keyword) - Code Maze
  1873. Succinct FSharp
  1874. Understanding the Stack and Heap in C# | endjin
  1875. Pernicious Nulls - using and abusing nulls in C#
  1876. Proebsting's Law
  1877. Scaling our Spreadsheet Engine from Thousands to Billions of Cells - The Causal Blog
  1878. What’s New In Python 3.11 — Python 3.11.0b3 documentation
  1879. How Clojure works for you
  1880. IKVM 8.2.0
  1881. GitHub - MeViMo/youbit: Using YouTube as a free file hosting service
  1882. I can’t believe that I can prove that it can sort
  1883. Another Update On The Bagel Language
  1884. Performance: Crystal vs Ruby
  1885. IKVM 8.2.0 : r/dotnet
  1886. IKVM 8.2.0 : r/dotnet
  1887. About the Crytal programming language
  1888. Using Graphs to Search for Code · Nick Gregory
  1889. Turns out gcc has imperative argument handling - hisham.hm
  1890. Another Open Source Group Blasts GitHub Copilot, Advocates Leaving GitHub -- Visual Studio Magazine
  1891. Challenge: Find the stack smash bug… – answer
  1892. Brian Robert Callahan
  1893. The Cell Programming Language
  1894. Binary Ninja - Introducing Tantō: Slicing Functions for Faster Finds
  1895. C# vNext - What could come
  1896. Give Up GitHub: The Time Has Come!
  1897. Linear Address Spaces - ACM Queue
  1898. Render Emails Using Razor Templating
  1899. Learning HTML was too hard so I made a compiler instead
  1900. Improve Git monorepo performance with a file system monitor | The GitHub Blog
  1901. Testimonials | The F# Software Foundation
  1902. Lambda Expressions in C# - Code Maze
  1903. What is Razor Templating, really?
  1904. csharplang/low-level-struct-improvements.md at main · dotnet/csharplang
  1905. How to Use Span in C# to Improve Application Performance - Code Maze
  1906. Nondestructive Mutation and Records in C#
  1907. haibane_tenshi's blog - Obscure Rust: reborrowing is a half-baked feature
  1908. Remove Duplicates From a List in C# - Code Maze
  1909. Pair Programming
  1910. Remove Duplicates From a List in C# - Code Maze
  1911. Undefined behavior in C is a reading error. – keeping simple
  1912. QBE - Compiler Backend
  1913. Crafting Interpreters: A Review
  1914. Gleam v0.22 released! – Gleam
  1915. C# 11 - Top 5 Features in the new C# Version | Rubik's Code
  1916. V Language Review (2022)
  1917. Ante
  1918. GitHub - dspinellis/unix-history-repo: Continuous Unix commit history from 1970 until today
  1919. C# 11 static abstract members - NDepend
  1920. My other database is a compiler
  1921. ⚡️ The computers are fast, but you don't know it
  1922. csharplang/required-members.md at main · dotnet/csharplang
  1923. C# Warning Waves Hint at New Keywords in the Future
  1924. Method Overloading In C# - Code Maze
  1925. Eurocrypt 2022 program
  1926. Visual Studio 2022 17.3 Preview 2 Is First Native Arm64 Release -- Visual Studio Magazine
  1927. Creating, Inspecting and Decompiling the World's Smallest C# Program - Steve Gordon - Code with Steve
  1928. Debug Driven Development
  1929. Arm64 Visual Studio
  1930. What is the difference between C#, .NET, IL and JIT?
  1931. Explaining TypeScript
  1932. The Perils of Combining Multicast Delegates with Tasks in C# | endjin
  1933. Multiple Precision Arithmetic: A Recreational Project
  1934. Quantum Development Kits adopts .NET6 and supports Visual Studio 2022
  1935. Data Race Patterns in Go
  1936. ZpqrtBnk
  1937. Delegate, Action, Func, Lamdba expression - What the heck!?
  1938. What Makes a Good Research Proposal?
  1939. Cranelift, Part 4: A New Register Allocator
  1940. Linux on A7-A8X
  1941. Overview of eBPF procfs kernel parameters
  1942. GitHub - ClueLang/Clue: C/Rust like programming language that compiles into Lua code
  1943. Runtime C# Code Compilation Revisited for Roslyn
  1944. Performance tricks I learned from contributing to open source .NET packages
  1945. How Effective Abstractions Are Opinionated | 8th Light
  1946. Go vs C#, Part 3: Compiler, Runtime, Type System, Modules, and Everything Else
  1947. (async) Rust doesn't have to be hard
  1948. The Misery of Mainstream Programming
  1949. Comparing Exceptions and Errors in D
  1950. Zig on RISC-V BL602: Quick Peek with Apache NuttX RTOS
  1951. #164 Jared Parsons, The C# Compiler, Part 2 | no dogma podcast
  1952. Stack in C# - Code Maze
  1953. Async destructors, async genericity and completion futures
  1954. The Appeal of Static Typing
  1955. Getting Functional with C#
  1956. 8 things about Records in C# you probably didn't know - Code4IT
  1957. sdk/Microsoft.PackageDependencyResolution.targets at 22c4860dcb2cf6b123dd641cc4a87a50380759d5 · dotnet/sdk
  1958. The Lazy monad
  1959. Anonymous Types in C# - Code Maze
  1960. Thoughts on Clojurescipt and BigDecimal
  1961. We Already Have Go 2
  1962. Remove Duplicates From a C# Array - Code Maze
  1963. Writing JIT Compiler on the Plane
  1964. How I think about C99 strict aliasing rules
  1965. Modern programming languages require generics
  1966. [Last Week in .NET #90] – Optimizing Cryware
  1967. How Uber Uses Zig - Motiejus Jakštys Public Record
  1968. Performance: Lambda Expressions, Method Groups, and delegate caching - Gérald Barré
  1969. Happy 10th Birthday Compiler Explorer! — Matt Godbolt’s blog
  1970. Visual Debugging Now!
  1971. Lotus 1-2-3 For Linux
  1972. Memory safety for SerenityOS
  1973. Unusual optimizations; ref foreach and ref returns
  1974. wtf is Clojure inlining anyway
  1975. Tips for Moving Your Xamarin Library to .NET MAUI
  1976. Laurence Tratt: Static Integer Types
  1977. A real life use-case for generics in Go: API for client-side pagination
  1978. Calculating type sets is harder than you think
  1979. Thorsten Ball - Professional Programming: The First 10 Years
  1980. The Identity monad
  1981. Remembering Buildtool - Julio Merino (jmmv.dev)
  1982. Operator precedence by textual substitution
  1983. Regular Expression Improvements in .NET 7
  1984. Structure and Organize .NET Projects with Rider | The .NET Tools Blog
  1985. Earn $200K by fuzzing for a weekend: Part 1
  1986. Converting Integers to Floats Using Hyperfocus
  1987. Embedding Truffle Languages - Kevin Menard's Weblog
  1988. Announcing Entity Framework 7 Preview 4
  1989. Check if a Number is a Power of 2 in C# - Code Maze
  1990. Auto-Regenerating API Client for Your Open API Project
  1991. EProgrammerNotFound exception in Delphi?
  1992. Unix command line conventions over time
  1993. Why Ballerina is a language
  1994. Case Study: How many colors are too many colors for Windows Terminal?
  1995. You Probably Don't Need to Worry About MediatR
  1996. .NET R&D Digest (April, 2022)
  1997. Implementing a ZK-focused authenticated-encryption scheme
  1998. Techniques and tools to update your C# project - Migrating to nullable reference types - Part 4
  1999. Semantic Versioning for TypeScript Types
  2000. Nvidia sees trillion-dollar future in open and parallel code
  2001. Set C# Language Version for All the Projects in a Solution - Code Maze
  2002. Experience Report: 6 months of Go
  2003. Welcome to a World of OCaml
  2004. Update SDK and use 'u8' string literals by BrennanConroy · Pull Request #41449 · dotnet/aspnetcore
  2005. Release 3.7.10 · fable-compiler/Fable
  2006. Learning JAX by Learning to Learn
  2007. Tutorial: Build gRPC & OData in ASP.NET Core
  2008. Lies we tell ourselves to keep using Golang
  2009. #163 Jared Parsons, The C# Compiler, Part 1 | no dogma podcast
  2010. Inform 7 v10.1.0 is now open-source - Authoring / Inform 7 - The Interactive Fiction Community Forum
  2011. Brian Robert Callahan
  2012. Create .NET Objects without Calling The Constructor
  2013. 5 Software Engineering Foot-guns - Ken Kantzer's Blog
  2014. The Maybe monad
  2015. Protocol Buffers  |  Google Developers
  2016. Announcing the Hare programming language
  2017. Why LSP?
  2018. Annotating your C# code - Migrating to nullable reference types - Part 3
  2019. 2fsharp/csharp2fsharp.md at master · knocte/2fsharp
  2020. Chris Lattner Interview Transcript — Accidental Tech Podcast
  2021. Why must JSX expressions have only ONE parent element? - Dillion's Blog
  2022. Celebrating 40 years of ZX Spectrum ❤️ 💛 💚 💙 | GitHub
  2023. C++ For C# Developers: Part 1 – Introduction
  2024. Async and Async Void Event Handling in WPF
  2025. GitHub - janestreet/magic-trace: magic-trace collects and displays high-resolution traces of what a process is doing
  2026. Azure DevOps Podcast: Mark Seemann: Code That Fits In Your Head - Episode 189
  2027. Python’s “Type Hints” are a bit of a disappointment to me
  2028. TypeScript Basics: How Generic Types Work - DZone Web Dev
  2029. C# async await explained - NDepend
  2030. Fundamentals
  2031. Changing std::sort at Google’s Scale and Beyond
  2032. .NET Community Toolkit v8.0 Preview 3 Tweaks MVVM Source Generators -- Visual Studio Magazine
  2033. Internals of C# nullable reference types - Migrating to nullable reference types - Part 2
  2034. C# 11 Preview Updates - Raw string literals, UTF-8 and more!
  2035. Richard Stallman - "The state of the Free Software movement" - April 13, 2022
  2036. Make self hosted compiler capable of building itself by Vexu · Pull Request #11442 · ziglang/zig
  2037. How To Build an Evil Compiler
  2038. Do You Really Code? · It Will Never Work in Theory
  2039. Value types and exceptions in .NET profiling
  2040. Introducing .NET Annotations Lambda Framework (Preview) | Amazon Web Services
  2041. How EEx Turns Your Template Into HTML
  2042. Try-Catch Block in C# - Code Maze
  2043. Using the Roslyn APIs to Analyse a .NET Solution - Steve Gordon - Code with Steve
  2044. What's New in IntelliJ IDEA - 2022.1
  2045. Deconstructing programs for compiler fuzzing · Comby
  2046. Sorry, Wrong Number: Debugging a Crash under Wine
  2047. Keeping up with .NET: learning about new features and APIs
  2048. Introduction to the Node.js reference architecture, Part 8: TypeScript | Red Hat Developer
  2049. Warning on lower case type names in C# 11
  2050. Nullable reference types in C# - Migrating to nullable reference types - Part 1
  2051. Announcing .NET Community Toolkit v8.0.0 Preview 3
  2052. Inline Assembly Miscompilation.md
  2053. Matt Roelle | Fennel: The Practical Lisp
  2054. How To Prevent Bugs
  2055. tsup
  2056. Announcing Rust 1.60.0 | Rust Blog
  2057. GitHub - nebuly-ai/nebullvm: Easy-to-use library to boost AI inference leveraging multiple DL compilers
  2058. Answer: Why is this code broken?
  2059. Use Git tactically
  2060. Clojure isnt for me
  2061. Pharo - Pharo 10 Released!
  2062. C# Pattern Matching Explained - NDepend
  2063. Can You Name Top C# IDEs Provided by Microsoft? I Couldn't -- Visual Studio Magazine
  2064. A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
  2065. csharplang/checked-user-defined-operators.md at main · dotnet/csharplang
  2066. csharplang/auto-default-structs.md at main · dotnet/csharplang
  2067. Handling date strings in TypeScript - LogRocket Blog
  2068. 03.30.2022 - TypeScript/How some utility types are implemented
  2069. Handling null: optional and nullable types
  2070. csharplang/utf8-string-literals.md at main · dotnet/csharplang
  2071. Managing RavenDB indexes in production, a DevOps guide
  2072. Introduction
  2073. Enable QJFL and OSR by default for x64 and arm64 by AndyAyersMS · Pull Request #65675 · dotnet/runtime
  2074. [RFC] Lifetime annotations for C++ - Clang Frontend - LLVM Discussion Forums
  2075. Lessons learned with Elm | 20Y
  2076. Episode 95 - Avalonia UI with Dan Walmsley
  2077. Generics can make your Go code slower
  2078. OCaml 4.14.0 is released - Ecosystem - OCaml
  2079. CVE-2022-1015,CVE-2022-1016 in nf_tables cause privilege escalation, information leak [LWN.net]
  2080. Monads
  2081. Convenience is King and Polish is quality
  2082. Discovering basic blocks
  2083. Remix: The Yang to React's Yin
  2084. The Dependencies' Reckoning - Considerations when selecting third-party software
  2085. Performance of Discriminated Unions and Active Patterns
  2086. Remixing React Router
  2087. On the importance of trusting trust
  2088. Zhenghao
  2089. How Side Effects Work in FP
  2090. Go To Definition improvements for external source in Roslyn
  2091. Lanai, the mystery CPU architecture in LLVM
  2092. Hooks Considered Harmful
  2093. Error handling across different languages
  2094. SendilKumarN
  2095. Brian Robert Callahan
  2096. Performance benefits of sealed class in .NET - Gérald Barré
  2097. Building a gRPC Client in .NET - Sahan Serasinghe - Personal Blog
  2098. Optimizing Julia code
  2099. Rust's Unsafe Pointer Types Need An Overhaul - Faultlore
  2100. C# Source Generators - Write Code that Writes Code
  2101. A year on Windows: System debugging - Julio Merino (jmmv.dev)
  2102. roslyn-analyzers/PublicApiAnalyzers.Help.md at main · dotnet/roslyn-analyzers
  2103. C Isn't A Programming Language Anymore - Faultlore
  2104. Reducing WebAssembly size by exploring all executions in LLVM
  2105. Go 1.18 Release Notes - The Go Programming Language
  2106. Writing a device driver for Unix V6
  2107. Swapping two numbers in C#
  2108. A Mostly Complete Guide to C# 11’s Future Features
  2109. C# 11 Features Now Previewing in Visual Studio: Generic Attributes and More -- Visual Studio Magazine
  2110. Contributing to Complex Projects
  2111. Writing IL according to the specification
  2112. C# 10 New Features - Code Maze
  2113. GitHub - Cogmasters/concord: C library for handling the Discord API
  2114. Creating a Compiler with Raku – Andrew Shitov
  2115. Software Engineer - F# tools team in Prague, Prague, Czech Republic | Engineering at Microsoft
  2116. How to Add Parameters to a String in C# - Code Maze
  2117. Zhenghao
  2118. Things I hate about Rust, redux
  2119. A Proposal For Type Syntax in JavaScript
  2120. Racing the Hardware: 8-bit Division
  2121. Bugs in Hello World
  2122. Custom Attributes in .NET - Code Maze
  2123. A type-safe DI Container as a tuple
  2124. csharplang/pattern-match-span-of-char-on-string.md at main · dotnet/csharplang
  2125. What’s the maximum number of arguments for method in C# and in .NET?
  2126. I Can No Longer Compile My First Flash Game
  2127. Part 2: Improving crypto code in Rust using LLVM’s optnone
  2128. Part 1: The life of an optimization barrier
  2129. Working with untyped structured data in C# · Discussion #5863 · dotnet/csharplang
  2130. Sharing code between ASP.NET and ASP.NET Core
  2131. Difference Between Task.Run and Task.Factory.StartNew - Code Maze
  2132. proposal/generics-implementation-dictionaries-go1.18.md at master · golang/proposal
  2133. Use a cached delegate for method group conversion · Issue #5835 · dotnet/roslyn
  2134. Minimal APIs in .NET 6 - Code Maze
  2135. Parameter Null Checking in C#11 and optimising throw methods
  2136. Using Zig As Cross Platform C Toolchain
  2137. Linus Torvalds prepares to move the Linux kernel to modern C | ZDNet
  2138. Zig Build System Internals
  2139. Debugging C# in Visual Studio - Code Maze
  2140. Gödel's Incompleteness Theorem, in Bash
  2141. Moving the kernel to modern C
  2142. Announcing Rust 1.59.0 | Rust Blog
  2143. C++ exceptions are becoming more and more problematic
  2144. GitHub - sbp/hedgehog: Concise implementation of a lisp-like language for low-end and embedded devices
  2145. These violent delights
  2146. Early peek at C# 11 features
  2147. rust-analyzer joins the Rust organization! | Rust Blog
  2148. Params Keyword in C# - Code Maze
  2149. System.CommandLine 2.0.0-beta3.22114.1
  2150. ASP.NET Core on .NET 7.0 - Roadmap, preview 1 and file upload in minimal APIs
  2151. How to Convert Int to String in C# - Code Maze
  2152. Nix: An Idea Whose Time Has Come
  2153. Build tool requirements
  2154. Year 2038 problem is still alive and well
  2155. GitHub - mustafaquraish/cup: simple, C-like programming language
  2156. GitHub - yoav-lavi/melody: Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable
  2157. Twenty years of .NET - Yay! — robmiles.com
  2158. The right thing for the wrong reasons: FLOSS doesn't imply security
  2159. Why We Use Julia, 10 Years Later
  2160. A Practical Guide to Dapper - Simple Talk
  2161. C# Nullable Features thru the times
  2162. Type You An Actor Runtime For Greater Good! (with Java 17, records, switch expressions and JBang)
  2163. Announcing TypeScript 4.6 RC - TypeScript
  2164. Kimchi: The latest update to Mina’s proof system
  2165. Question: How is !! envisaged to be used? · Discussion #5735 · dotnet/csharplang
  2166. Attacking an Ethereum L2 with Unbridled Optimism
  2167. Different Ways to Initialize Arrays in C# - Code Maze
  2168. Diagnosing and Fixing MediatR Container Issues
  2169. Writing native WinDbg extensions in C#
  2170. C# 10.0 improves handling of nullable references in generic types - no more AllowNull | endjin
  2171. Initial roll out of !! by stephentoub · Pull Request #64720 · dotnet/runtime
  2172. Improvements and Optimizations for Interpolated Strings – A Look at New Language Features in C# 10 | The .NET Tools Blog
  2173. Visitor Design Pattern in C# - Code Maze
  2174. Why Windows isn't ready for Arm developers | ZDNet
  2175. On finding the average of two unsigned integers without overflow - The Old New Thing
  2176. Debug attributes in .NET
  2177. On Building 30K Debian Packages
  2178. Using Zig to Build Native Lua Scripts
  2179. An advanced, composable, reactive model-view-viewmodel framework
  2180. The Story of Mel
  2181. Compiler Explorer - C# (.NET 6.0.101)
  2182. Go performance from version 1.2 to 1.18
  2183. AdaCore and Ferrous Systems Joining Forces to Support Rust
  2184. WebVM: server-less x86 virtual machines in the browser
  2185. Piped
  2186. Welcome to My Site!
  2187. WebVM: Client side X86 virtual machines in the browser
  2188. Pay attention to WebAssembly
  2189. [Last Week in .NET #79] – Space Newts
  2190. Destroy All Values: Designing Deinitialization in Programming Languages
  2191. Game Performance Optimization - A Practical Example From Industry Idle
  2192. OCaml - Generalized algebraic datatypes
  2193. In defense of NIR
  2194. Difference Between ValueTuple and Tuple in C# - Code Maze
  2195. Writing an open source GPU driver – without the hardware
  2196. Sometimes, rewriting in another language works
  2197. GitHub - dzautner/Sel: A compiler for thin Symbolic Expressions abstraction layer over Lambda calculus.
  2198. Hey Ethereum, Let's Break Solidity's Composability!
  2199. Machine readable specifications at scale
  2200. Raising Coding Standards with .NET 6.0 Code Analyzers | endjin
  2201. Devblog of @kdy1
  2202. Solving the source generator 'marker attribute' problem - Part 1: Creating a source generator - Part 7
  2203. No one cares that you’re right
  2204. Type-level DI Container prototype
  2205. GitHub - max-sixty/prql: PRQL is a modern language for transforming data — a simpler and more powerful SQL
  2206. Implementing a file pager in Zig: Pages, buffers and metadata, oh my!
  2207. Awaiting an async void method in .NET - Gérald Barré
  2208. Top-Level Statements in C# - Code Maze
  2209. Announcing TypeScript 4.6 Beta
  2210. In defense of complicated programming languages
  2211. Surgical programming
  2212. Structure and Interpretation of Computer Programs
  2213. C# 10 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2214. Underjord | My Elm Experience
  2215. Seven Days of OCaml
  2216. How safe is zig?
  2217. The mystery of the crash that seems to be on a std::move operation
  2218. Introduction to .NET Framework | Pro Code Guide
  2219. Execute Program
  2220. Why Static Languages Suffer From Complexity
  2221. GitHub - water111/jak-project
  2222. Mastering mapped types in TypeScript - LogRocket Blog
  2223. Enumerate Wordle combinations with an applicative functor
  2224. Failing to Learn Zig via Advent of Code - ForrestTheWoods
  2225. Saving source generator output in source control: Creating a source generator - Part 6
  2226. Catch Multiple Exceptions in C# - Code Maze
  2227. Parameterized xUnit Tests with F#
  2228. GitHub - ForNeVeR/Cesium: C compiler for the CLI platform
  2229. Resolving confusion over how to return from a C++ coroutine - The Old New Thing
  2230. Rethinking errors, warnings, and lints
  2231. Cache the delegate for static method group conversions. by pawchen · Pull Request #58288 · dotnet/roslyn
  2232. Announcing Rust 1.58.0 | Rust Blog
  2233. 5.5 mm in 1.25 nanoseconds
  2234. Nullable reference types
  2235. The oracle always tells the truth, even when it is wrong: COM method calls with a user-defined type as a return value - The Old New Thing
  2236. Flow control in C# | endjin
  2237. Announcing Parcel CSS: A new CSS parser, compiler, and minifier written in Rust!
  2238. Standing on the shoulders of giants: Let the compiler tell you what the ABI is - The Old New Thing
  2239. Implementing a file pager in Zig: Reclaiming memory
  2240. Why non-defaultable value types are needed in C#
  2241. Rachit Nigam | PhD Candidate, Cornell University
  2242. Merge pull request #10831 from ocaml-multicore/multicore-pr · ocaml/ocaml@001997e
  2243. Why your Typescript compiles when you thought you were safe
  2244. Why I Like D – Andrea Radaelli
  2245. BenchmarkDotNet 0.13.1
  2246. Things you might not know about CSharp - Duck Typing
  2247. Filling in some gaps in the story of Space Cadet Pinball on 64-bit Windows
  2248. Rust is more portable than C for pngquant/libimagequant
  2249. Records in C# - Code Maze
  2250. How to stop forgetting to await an awaitable call
  2251. My favorite F# code I've written
  2252. Polymorphism in C# - Code Maze
  2253. The joy of building a ray tracer, for fun, in Rust.
  2254. Quantifier predicates - Simple Talk
  2255. Create your own Roslyn Analyzer !! - Super Sharp | A Tech Superhero.
  2256. Compiling a Go program into a native binary for Nintendo Switch™ - Ebiten
  2257. Speculation on the design decisions that led to the common ABI for C++ coroutines
  2258. tvu-compare: rust and zig
  2259. Notes about loading configuration Examples for Play Framework and Spring Boot
  2260. Do We Really Need A Link Step?
  2261. Sciter uses JavaScript from now and on – Terra Informatica Software
  2262. Why the C Language Will Never Stop You from Making Mistakes
  2263. The C++/CX String^ is not an object, even though it wears a hat
  2264. 95644 – [F2018] IEEE_FMA is missing from the IEEE_ARITHMETIC module
  2265. GitHub - sslab-gatech/Rudra: Rust Memory Safety & Undefined Behavior Detection
  2266. You can't copy code with memcpy; code is more complicated than that
  2267. Writing a minimal Lua implementation with a virtual machine from scratch in Rust
  2268. Spectre.Console and String Interpolation
  2269. A Review of the Zig Programming Language (using Advent of Code 2021)
  2270. Ruby 3.1.0 Released
  2271. Code Maze Weekly #107 - Code Maze
  2272. suckless.org software that sucks less
  2273. DNA seen through the eyes of a coder (or, If you are a hammer, everything looks like a nail) - Bert Hubert's writings
  2274. Integration testing and NuGet packaging: Creating a source generator - Part 3
  2275. 0.9.0 Release Notes ⚡ The Zig Programming Language
  2276. LISP with GC in 436 bytes
  2277. GitHub - swc-project/swc: swc is a super-fast compiler written in rust; producing widely-supported javascript from modern standards and typescript.
  2278. Getting Roslyn (C# compiler) and Language versions - Gérald Barré
  2279. String Interpolation Trickery and Magic with C# 10 and .NET 6
  2280. Document your .NET code with DocFX and GitHub Actions
  2281. New LINQ improvements in .NET 6
  2282. Accessing arrays and class fields with .NET profiling APIs
  2283. Why GNU Guix matters
  2284. How not to learn Rust
  2285. F# Good and Bad
  2286. A Holly Jolly Christmas with Hot Chocolate 12.4
  2287. Iteration statements - C# reference
  2288. Partial functions and total functions
  2289. # F# Advent 2021 Dec 08 - Fast data pipelines with F#6
  2290. crawshaw - 2021-12-11
  2291. Using clojure.spec.alpha with babashka
  2292. The three types of development
  2293. Introducing stack graphs | The GitHub Blog
  2294. If you're going to configure a header file, you have to do it before you include the header file
  2295. Writing a simple 16 bit VM in less than 125 lines of C
  2296. Make the Implicit Explicit
  2297. Top Free Extensions for Visual Studio 2022 -- Visual Studio Magazine
  2298. LKML: Miguel Ojeda: [PATCH 00/19] Rust support
  2299. Angular Basics: Introduction to Processes, Threads—Web UI
  2300. You Can't Buy Integration
  2301. Debugging at the Boundaries
  2302. Rust takes a major step forward as Linux's second official language | ZDNet
  2303. Loop Fission
  2304. Cancellation Tokens with IAsyncEnumerable - Code Maze
  2305. Makefile Tools December 2021 Update: Problem Matchers and Compilation Database Generation
  2306. The Liskov Substitution Principle as a profunctor
  2307. GitHub - vzarytovskii/interactive-ilkernel: IL Kernel for .NET Interactive
  2308. C# Language Server Revamps VS 2022 Razor Editor for ASP.NET Core -- Visual Studio Magazine
  2309. Compiler error message metaprogramming: Helping to find the conflicting macro definition
  2310. Fastest way to enumerate a List<T> - Gérald Barré
  2311. Don't Code Tired | What’s New in C# 10: Value Type Records
  2312. Could .NET Source Generator Attacks Be A Danger To Your Code? - Steve Talks Code
  2313. The One with .NET after Saint Nick – Codecamp
  2314. Supercharged high-resolution ocean simulation with JAX | dionhaefner.github.io
  2315. Do we really need Undefined Behavior?
  2316. Behind The Spotify Wrapped API Scenes
  2317. How Rider Hot Reload Works Under the Hood | The .NET Tools Blog
  2318. Introducing the new Razor editor in Visual Studio 2022
  2319. Julia 1.7 Highlights
  2320. GitHub - mrthefakeperson/Excel-Virtual-Machine: C Compiler which targets Excel (MS Office)
  2321. Don't Code Tired | What’s New in C# 10: Take Control of Interpolated String Handling
  2322. Reducing an LTO Linux kernel bug with cvise
  2323. How can my C++/WinRT component pass a std::vector back to the caller?
  2324. 4x smaller, 50x faster · asciinema blog
  2325. The .NET Docs Show - Into the deep end with OpenCV
  2326. Don't Code Tired | What’s New in C# 10: Easier Lambda Expressions
  2327. crawshaw - 2021-11-25
  2328. Jab 0.5.1
  2329. GC progress from JDK 8 to JDK 17
  2330. The New Life of PHP – The PHP Foundation | The PhpStorm Blog
  2331. Modern C# Hello World - NDepend
  2332. [CallerArgumentExpression] and throw helpers: Exploring .NET Core 6 - Part 11
  2333. TypeScript vs JSDoc JavaScript | I CAN MAKE THIS WORK
  2334. Don't Bring a Tree to a Mesh Fight
  2335. Running a .NET 6 Service on a Specific Port
  2336. New Kind of Paper, part 4
  2337. hacspec [![hacspec chat][chat-image]][chat-link]
  2338. The tale of a single register value
  2339. New Toolkit for Writing Visual Studio Extensions (And Where to Find Extensions) -- Visual Studio Magazine
  2340. GitHub - elfshaker/elfshaker: elfshaker stores binary objects efficiently
  2341. Why is my C++/CX ref class forbidden from having public methods that are templates or mention, say, std::vector?
  2342. Where is Ruby Headed in 2021? - Big Nerd Ranch
  2343. Global Usings – A Look at New Language Features in C# 10 | The .NET Tools Blog
  2344. New TypeScript 4.5 Improves Asynchronous Programming -- Visual Studio Magazine
  2345. OCaml compiler development newsletter, issue 4: October 2021 - Community - OCaml
  2346. Zettelkasten #1: Classes in D with betterC
  2347. What does the CompileAsWinRT Visual Studio project option mean?
  2348. Migrate from ASP.NET Core 5.0 to 6.0
  2349. CheerpX: Using WebAssembly to run any programming language in the browser
  2350. Talking to SerenityOS Contributors About Scratch-build C++ Developer’s Playground in Modern C++ | The CLion Blog
  2351. Where Are My Favorite Extensions in Visual Studio 2022?
  2352. [ANN] Fennel 1.0.0 released — sourcehut lists
  2353. How C# 10.0 and .NET 6.0 improve ArgumentExceptions | endjin
  2354. C# 10 new feature CallerArgumentExpression, argument check and more
  2355. The weirdest bug I've ever encountered
  2356. C# 10 new feature CallerArgumentExpression, argument check and more
  2357. Why asynchronous Rust doesn't work
  2358. Atlas
  2359. Dynamic PGO in .NET 6.0.md
  2360. Overriding Sealed Methods in C#
  2361. Why Does x = ++x + x++ Give Me the Wrong Answer?
  2362. C# 10 Falls Just a Bit Short
  2363. Dissecting Interpolated Strings Improvements in C# 10
  2364. How I found a bug in Intel Skylake processors
  2365. Modern, functional Common Lisp: Myths and tips
  2366. Welcome to C# 10
  2367. What’s New for Visual Basic in Visual Studio 2022
  2368. Using The Roslyn C# Compiler
  2369. What's new in F# 6 - F# Guide
  2370. James Randall
  2371. jott - building_stuff_from_source
  2372. Breaking changes in .NET 6 - .NET
  2373. Caller Argument Expressions – A Look at New Language Features in C# 10 | The .NET Tools Blog
  2374. NSwag generated C# client: Open API property name clashes and decimal types rather than double | I CAN MAKE THIS WORK
  2375. A quick review of C# 10 new language features
  2376. What's new in F# 6 - F# Guide
  2377. Caller Argument Expressions – A Look at New Language Features in C# 10 | The .NET Tools Blog
  2378. How can I prevent myself from accessing a lambda captured variable or a parameter after I'm done with it?
  2379. Control flow analysis for destructured discriminated unions by ahejlsberg · Pull Request #46266 · microsoft/TypeScript
  2380. Luau Goes Open-Source
  2381. The tale of a single register value
  2382. Don't Code Tired | ICYMI C# 9 New Features: Create Immutable Objects with Records
  2383. Profunctors
  2384. Type | Treat – Wrap-up
  2385. Type | Treat - Day 5
  2386. Faster Mac Dev Tools with Custom Allocators
  2387. They don't even know the fundamentals
  2388. GitHub - klange/toaruos: A completely-from-scratch hobby operating system: bootloader, kernel, drivers, C library, and userspace including a composited graphical UI, dynamic linker, syntax-highlighting text editor, network stack, etc.
  2389. Security advisory for rustc (CVE-2021-42574) | Rust Blog
  2390. SectorLISP Now Fits in One Sector
  2391. Raspberry Pi 4 achieves Vulkan 1.1 conformance, gets up to 60% GPU performance boost - CNX Software
  2392. File-Scoped Namespaces – A Look at New Language Features in C# 10 | The .NET Tools Blog
  2393. Type | Treat 2021 – Day 4
  2394. Giving a single object multiple COM identities, part 3
  2395. Software Engineer II in Redmond, Washington, United States | Engineering at Microsoft
  2396. F# 6 Introduces Resumable Code, Improvements to Pattern Matching and Tooling, and More
  2397. Giving a single object multiple COM identities, part 2
  2398. How the C# compiler completely changes your code #Shorts
  2399. Records in C# 9
  2400. Making Sense of Common C# Compiler Errors - Kill All Defects
  2401. Immutable C#
  2402. Next.js 12
  2403. Analyzers for ASP.NET Core in .NET 6: Exploring .NET Core 6 - Part 7
  2404. FRI with Bootleproof-IPA Verkle Trees for “non-native” arithmetic and shrinking reference string size - HackMD
  2405. 100 Days of TypeScript (Day 1)
  2406. Functor variance compared to C#'s notion of variance
  2407. C# tip: define Using Aliases to avoid ambiguity - Code4IT
  2408. F# eXchange 2021 | Skills Matter
  2409. New language features since Java 8 to 17
  2410. To Learn a New Language, Read Its Standard Library
  2411. Crates (existentials in F#)
  2412. Signals and Threads | Language Design
  2413. There is no 'printf'.
  2414. Transitioning an existing project to a new edition
  2415. Announcing Rust 1.56.0 and Rust 2021 | Rust Blog
  2416. Why you shouldn't leave your functions?
  2417. GitHub - badamczewski/PowerUp: Collection of productivity tools and utilities
  2418. What’s new in F# 6
  2419. New Code Rules: Too Many .NET Engineers DO NOT Understand How Memory Management Works!
  2420. Version 1.6.0 released
  2421. What to learn
  2422. A Race Condition in .NET Finalization and its Mitigation for C++/CLI
  2423. GitHub - carp-lang/Carp: A statically typed lisp, without a GC, for real-time applications.
  2424. GitHub - valinet/ExplorerPatcher: This project aims to bring back a productive working environment on Windows 11
  2425. As .NET 6 Nears GA, Blazor WebAssembly Can Now Use Native Dependencies -- Visual Studio Magazine
  2426. Everything That Every .NET Developer Needs to Know About Disposable Types: Properly Disposing Objects
  2427. C# Online Compiler | .NET Fiddle
  2428. Overview · Serde
  2429. Mythbusting Julia speed
  2430. What I wish I knew when learning F#
  2431. Local variables are different from parameters in C++ coroutines
  2432. Decyphering method signature with CLR profiling API
  2433. The Tennis kata revisited
  2434. Champion: Simplified parameter null validation code · Issue #2145 · dotnet/csharplang
  2435. 3 TypeScript Tricks I wish I knew when I learned TypeScript
  2436. Hidden IDisposable Issues in Microsoft .NET
  2437. World's Smallest C# Program (featuring `N`)
  2438. Pop-up from Hell: On the growing opacity of web programs
  2439. 101 Smart Contracts and Decentralized Apps in Ethereum
  2440. The road to OCaml 5.0 - Ecosystem - OCaml
  2441. The Old New Thing
  2442. Fundamentals of Computing with .NET
  2443. Why We Moved From Pony To Rust — Wallaroo
  2444. Debugging coroutine handles: The Microsoft Visual C++ compiler, clang, and gcc
  2445. The Insane Innovation of TI Calculator Hobbyists
  2446. GitHub - isometimes/rpi4-osdev: Tutorial: Writing a "bare metal" operating system for Raspberry Pi 4
  2447. I’ve loved Wasmer, I still love Wasmer
  2448. The select story
  2449. YikesScript - John's internet house
  2450. Everything That Every .NET Developer Needs To Know About Disposable Types - Properly Disposing Objects
  2451. Exploring C# 10: Save Space with File-Scoped Namespaces
  2452. Implicit Overflow Considered Harmful (and how to fix it)
  2453. Some lesser-known powers of std::optional
  2454. Word-aligned Bloom filters
  2455. "Static Linking Considered Harmful" Considered Harmful
  2456. Renato Athaydes
  2457. .NET 6 is HERE! 5 Features that will blow your mind 🤯
  2458. The seven programming ur-languages
  2459. Announcing .NET 6 Release Candidate 1
  2460. The value of in-house expertise
  2461. Coding Practice: Learning Rust with Fibonacci Numbers
  2462. Feature #18229: Proposal to merge YJIT - Ruby master
  2463. The Catch Block #76 - So You Fixed a Bug. Now What?
  2464. SizeBench: a new tool for analyzing Windows binary size
  2465. Avoiding Memory Leaks in Visual Studio Editor Extensions
  2466. I fixed a bug. What should I do now? - Gérald Barré
  2467. Keep IDs internal with REST
  2468. C# 10.0 implicit global using directives | endjin
  2469. The Speed of Time
  2470. Improving Software ‘Numbers’
  2471. Stamping Out Overflow Checks in Ruby
  2472. Initial Impressions of Rust
  2473. GitHub - aristocratos/btop: A monitor of resources
  2474. Testing a compiler that can’t even print stuff out
  2475. What Color is Your Function? – journal.stuffwithstuff.com
  2476. Hello World - Introduction to C# interactive C# tutorial
  2477. Pattern Matching Examples in C#
  2478. Notion – The all-in-one workspace for your notes, tasks, wikis, and databases.
  2479. The Bagel Language 🥯 | Brandon's Website
  2480. The long-term consequences of maintainers’ actions – Ariadne's Space
  2481. How JSX (React) Works Under the Hood
  2482. Don't fear the pointer — Bitfield Consulting
  2483. The C++ implicit assignment operator is a non-ref-qualified member, even if the base class's assignment has a ref-qualifier
  2484. Call WinRT COM interop interfaces from .NET 5+ apps - Windows apps
  2485. Swapping two numbers in C#
  2486. Announcing .NET 6 Release Candidate 1
  2487. Announcing .NET 6 Release Candidate 1
  2488. Java 17 / JDK 17: General Availability
  2489. C# For Beginners - Lesson 10: Methods
  2490. Release WebSharper 5.0.0-preview1 · dotnet-websharper/core
  2491. Finding Types at Runtime in .NET Core
  2492. Static Analysis in JavaScriptCore (Part I)
  2493. refactor: port libtransmission to C++ by ckerr · Pull Request #1787 · transmission/transmission
  2494. Write code that's easy to delete, and easy to debug too.
  2495. Constant-time code verification with Memory Sanitizer
  2496. C# 10 is HERE! 5 features that will blow your mind 🤯
  2497. Support type classes or implicits · Issue #243 · fsharp/fslang-suggestions
  2498. in which a laptop defies the trends
  2499. How We Went All In on sqlc/pgx for Postgres + Go
  2500. Proposal: Expression blocks · Issue #3086 · dotnet/csharplang
  2501. The Compiled Future of Front End
  2502. Maintain it With Zig
  2503. What's new in C# 10.0 - C# Guide
  2504. Using Source Generators with Blazor components in .NET 6
  2505. What Is yield and How Does It Work in C#?
  2506. Dealing with Modules, Assemblies and Types with CLR Profiling APIs
  2507. GitHub - koenvzeijl/AspNetCore.SassCompiler: Sass Compiler Library for .NET Core 3.x/5.x without node.
  2508. Introduction to Async Programming in C#
  2509. 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🚀
  2510. Bebop ❤️ Rust | Rainway
  2511. zkMesh: Aug 2021 recap
  2512. Looking at world through __stdcall-colored glasses
  2513. GraphQL & Relay in the Front End
  2514. TypeScript v4.4 Ships, Gets New Home Page -- Visual Studio Magazine
  2515. All about Global Offset Table
  2516. Welcome to Peter's DevLog - Optional value handling in Nim
  2517. on terminal control
  2518. Hell Is Other REPLs
  2519. Use dump files in the debugger - Visual Studio (Windows)
  2520. Summary after Four Months with Ada — Programming with Ada documentation
  2521. Making an OS (x86) Chapter 7 - Cross Compiler, Bootloader, Kernel
  2522. 🏡 Neil's Place
  2523. Announcing TypeScript 4.4
  2524. Linux in a Pixel Shader - A RISC-V Emulator for VRChat
  2525. What's new in C# 10.0 - C# Guide
  2526. Pin, Unpin, and why Rust needs them
  2527. Friendship ended with the garbage collector
  2528. Announcing the New TypeScript Homepage
  2529. A Stupid Little TypeScript Mistake (Part 2)
  2530. Incrementing Vectors
  2531. Patterns in confusing explanations
  2532. Performance Improvements in .NET 6
  2533. The Founder vs. Hired Executive Gap
  2534. 🏡 Neil's Place
  2535. Understanding the cost of C# delegates
  2536. Elm at Rakuten | Rakuten Engineering Blog
  2537. Understanding the cost of C# delegates
  2538. What I Like About C# 9
  2539. Exploring Clang/LLVM optimization on programming horror
  2540. Performance Improvements in .NET 6
  2541. Go 1.17 is released - The Go Blog
  2542. Tutorial
  2543. Beautiful and compact Web APIs revisited – with C# 10 and .NET 6 Preview 7
  2544. Playing with System.Text.Json Source Generators - Steve Gordon - Code with Steve
  2545. Announcing TypeScript 4.4 RC
  2546. Why is Learning Functional Programming So Damned Hard?
  2547. IPv4, IPv6, and a sudden change in attitude
  2548. Resolving the ambiguity when your C++ class inherits from multiple base classes that have the same method
  2549. Mixins in Sass
  2550. I stopped sleeping, then I started hallucinating.
  2551. .NET 6 Preview 7: New Features Done, but Templates with Top-Level Statements Stir Debate -- Visual Studio Magazine
  2552. Looking into Odin and Zig: My notes
  2553. Introducing C# 10: File-scoped namespaces
  2554. String Interpolation in C# 10 and .NET 6
  2555. Preview Features in .NET 6 - Generic Math
  2556. A brief intro to MTL
  2557. A Tale of Two Copies
  2558. Vue 3.2 Released! | The Vue Point
  2559. When Zero Cost Abstractions Aren’t Zero Cost
  2560. Why am I getting a weird error about promise_type when I try to write a coroutine?
  2561. Bite-Size C# 10 - Global Usings
  2562. Looking into Zig
  2563. LÖVR
  2564. Notes about C# records and Nullable Reference Types - Event-Driven.io
  2565. Windows Community Toolkit 7.1: MVVM Source Generators, Identity Authentication, ML APIs -- Visual Studio Magazine
  2566. Bite-Size C# 10 - Null Parameter Checking
  2567. Looking into Zig
  2568. An example of using Windows Runtime interop methods from C++/WinRT: Request­Token­For­Window­Async
  2569. Stringly Typed vs Strongly Typed
  2570. SAML is insecure by design
  2571. GitHub - veorq/cryptocoding: Guidelines for low-level cryptography software
  2572. Dynamic Code Generation in Marten V4
  2573. What is a static Windows Runtime class, how should I express it, and when should I use it?
  2574. Optional Chaining: The ?. Operator in TypeScript
  2575. Full-Time Open Source - CoRecursive Podcast
  2576. TypeScript, abstract classes, and constructors | I CAN MAKE THIS WORK
  2577. GitHub - langjam/langjam
  2578. GitHub - vrtbl/passerine: A small extensible programming language designed for concise expression with little code.
  2579. Is this true? | jordan scales
  2580. Visual Studio Feedback
  2581. Introducing Triton: Open-Source GPU Programming for Neural Networks
  2582. Reconsidering the way I explain programming
  2583. Lessons learned from 15 years of SumatraPDF, an open source Windows app
  2584. What's bad about Julia?
  2585. Ncdu 2: Less hungry and more Ziggy
  2586. Advanced Error Handling in OCaml
  2587. The Catch Block #67- C# 10 Features, .NET 6 Preview 6, and VS 2022 Preview 2
  2588. Conversation about skills and learning
  2589. erikgrinaker/toydb
  2590. Introducing C# 10: Seal overriden ToString() method on records
  2591. Inserting One Billion Rows in SQLite Under A Minute - blag
  2592. Out of the Box Elixir
  2593. Pharo - Pharo 9 Released!
  2594. prathyvsh/pl-catalog
  2595. dotnet/apireviews
  2596. TypeScript 4.4 Beta Boosts Performance, Suggests JavaScript Spelling -- Visual Studio Magazine
  2597. Evolution of An Async LINQ operator
  2598. Low Ceremony, High Value: A Tour of Minimal APIs in .NET 6
  2599. C# Tips to Improve Code Quality and Performance - Code Maze
  2600. TypeScript 4.4 Improves Control Flow Analysis
  2601. Creating reusable build scripts with NUKE components
  2602. Anagrams and Prime Numbers
  2603. Compiling Rust is NP-hard
  2604. On the perils of holding a lock across a coroutine suspension point, part 2: Nonrecursive mutexes
  2605. Do not overuse primitive data types
  2606. Teaching Elixir
  2607. libimobiledevice · A cross-platform FOSS library written in C to communicate with iOS devices natively.
  2608. Software Engineer for Microsoft Technology Center Careers at Intel in San Jose, H
  2609. [PATCH 00/17] Rust support - ojeda
  2610. Realtek WiFi Firmware and a Fully 8051-based Keylogger Using RealWOW Technology
  2611. A type-safe CloudEvent
  2612. musicForProgramming("62: Our Grey Lives");
  2613. C# 10 - Top 5 New Features in the Upcoming C# Version
  2614. Stop Saving to Disk with C# Asynchronous Streams
  2615. C sharp or B flat? Experiments in self-contained native executables in .NET
  2616. Constant-Time Big Numbers: An Introduction
  2617. Announcing TypeScript 4.4 Beta
  2618. Stop Saving to Disk with C# Asynchronous Streams
  2619. Studying linker error messages to find the cause of the unresolved external: Character sets
  2620. C# 9 in-process Azure Functions | I CAN MAKE THIS WORK
  2621. 2021 mid-year link clearance
  2622. What’s New for C# Nullable Reference Types in ReSharper and Rider 2021.2 EAP? | The .NET Tools Blog
  2623. Clojure metadata
  2624. Virtual DOM is pure overhead
  2625. Conditional compilation for ignoring method calls with the ConditionalAttribute
  2626. Async Debugging Part 3
  2627. React 18 and TypeScript | I CAN MAKE THIS WORK
  2628. Let's code a TCP/IP stack, 1: Ethernet & ARP
  2629. MichalStrehovsky/bflat
  2630. The ARM processor (Thumb-2), part 20: Code walkthrough
  2631. microsoft/GDK
  2632. microsoft/GDK
  2633. The ARM processor (Thumb-2), part 19: Common patterns
  2634. 20 Percent Time at Supercede
  2635. ThakeeNathees/pocketlang
  2636. chrisseaton/rhizome
  2637. Julia: faster than Fortran, cleaner than Numpy
  2638. Learning to Love a Rigid and Inflexible Language
  2639. The ARM processor (Thumb-2), part 15: Miscellaneous instructions | The Old New Thing
  2640. Async Debugging Part 2
  2641. Visual Studio 2022 Preview Release Notes
  2642. Nuitka/Nuitka
  2643. Don't Code Tired | ICYMI C# 9 New Features: Top-level Statements
  2644. Cryptography updates in OCaml and MirageOS
  2645. The ARM processor (Thumb-2), part 13: Trampolines | The Old New Thing
  2646. nushell/nushell
  2647. C# 10 - `record struct` Deep Dive & Performance Implications
  2648. Running .NET Core Apps on a Framework other than Compiled Version?
  2649. New tools from Microsoft Research help developers write bug-free code, faster - AI for Business
  2650. I Have No Group, and I Must Scream
  2651. The ARM processor (Thumb-2), part 10: Memory access and alignment | The Old New Thing
  2652. Why is Async code hard to debug?
  2653. Why is Async code hard to debug?
  2654. A Closer Look at 5 New Features in C# 10
  2655. The ARM processor (Thumb-2), part 9: Sign and zero extension | The Old New Thing
  2656. Going Beyond ESLint: Overview Static Analysis in JavaScript
  2657. Low Ceremony, High Value: A Tour of Minimal APIs in .NET 6
  2658. C# Generics Best Practices
  2659. Learn TypeScript Basics in this Beginner's Guide
  2660. Developer Week ’21 | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
  2661. Different ways to check if a value is null in C# - Gérald Barré
  2662. Debugging C# Source Generators with Visual Studio 2019 16.10 - Steve Talks Code
  2663. dotnet/roslyn
  2664. Challenging myself to understand RISC-V
  2665. 0.8.0 Release Notes ⚡ The Zig Programming Language
  2666. The ARM processor (Thumb-2), part 5: Arithmetic | The Old New Thing
  2667. Vitess | A new Protocol Buffers generator for Go
  2668. Tour of our 250k line Clojure codebase
  2669. Distributed cloud builds for everyone
  2670. string vs. String is not a style debate
  2671. Benchmarking 4 reflection methods for calling a constructor in .NET
  2672. GCC drops its copyright-assignment requirement
  2673. Driving with D
  2674. Helix
  2675. Benchmarking 4 reflection methods for calling a constructor in .NET
  2676. The ARM processor (Thumb-2), part 2: Differences between classic ARM and Thumb-2 | The Old New Thing
  2677. The ARM processor (Thumb-2), part 1: Introduction | The Old New Thing
  2678. Adam Storr - Quick Tip - Compiler Directives and Using Aliases to Ignore Tests
  2679. Benchmarking 4 reflection methods for calling a constructor in .NET
  2680. C# 10.0: Introducing Global Usings
  2681. From State tennis to endomorphism
  2682. “True Lies” – or “What LLVM Claims, but Fails to Deliver”
  2683. On the proper care and feeding of the default_overload Windows Runtime attribute | The Old New Thing
  2684. On the proper care and feeding of the default_overload Windows Runtime attribute | The Old New Thing
  2685. Sparkplug — A non-optimizing JavaScript compiler · V8
  2686. Adventures in rustc Forking
  2687. The state of tooling for verifying constant-timeness of cryptographic implementations
  2688. What's New for F# in Visual Studio 16.10 -- Visual Studio Magazine
  2689. Building a Source Generator for C#
  2690. Let’s Build a Regex Engine
  2691. F# and F# tools update for Visual Studio 16.10 | .NET Blog
  2692. ReSharper 2021.2 Roadmap | The .NET Tools Blog
  2693. .NET Basics - Dusted Codes
  2694. In praise of --dry-run | G Research
  2695. Why I prefer making useless stuff
  2696. C is not a serious programming language – keeping simple
  2697. Zig Makes Rust Cross-compilation Just Work · Um, actually...
  2698. Building LLVM in 90 seconds using Amazon Lambda
  2699. Conversation about ready to run | .NET Blog
  2700. Elixir v1.12 released
  2701. Conversation about PGO | .NET Blog
  2702. The blessing of the leading zero | The Old New Thing
  2703. Against consistency
  2704. Sébastien Wilmet - Blog post
  2705. Release Cosmopolitan v1.0 · jart/cosmopolitan
  2706. Updating FloatingGlucose to .NET 5 - Display Nightscout or Dexcom Glucose Values on the Windows Desktop
  2707. Half a million lines of Go
  2708. Async/Await Calls Gotcha with the CSharp ? Null Propagator
  2709. Things you can’t do in Rust (and what to do instead) - LogRocket Blog
  2710. POLAR - Creating a Virtual Machine in .NET
  2711. Mostly harmless: An account of pseudo-normal floating point numbers - Red Hat Developer
  2712. Overview — Programming with Ada documentation
  2713. Patterns - C# reference
  2714. Mercury Brings Visual Basic to Feature Parity with C# and Adds Multiple Platform Support
  2715. Erlang/OTP 24 Highlights
  2716. The Plan for the Rust 2021 Edition | Rust Blog
  2717. The Future of Code Editor
  2718. Introducing csharp 10
  2719. Making eBPF work on Windows - Microsoft Open Source Blog
  2720. Understanding iOS application entry point
  2721. microsoft/ebpf-for-windows
  2722. dotnet/runtimelab
  2723. Apple Silicon Hardware Secrets: SPRR and Guarded Exception Levels (GXF)
  2724. Gleam v0.15 released! – Gleam
  2725. Basic telemetry for the Audacity by crsib · Pull Request #835 · audacity/audacity
  2726. benaadams/Ben.Demystifier
  2727. Non-structural Type Constraints
  2728. Add Simple C# Programs by cartermp · Pull Request #213 · dotnet/designs
  2729. Portability is Reliability
  2730. String.Format Method (System)
  2731. davidfowl/CommunityStandUpMinimalAPI
  2732. facebookincubator/cinder
  2733. Hello World - Introduction to C# interactive C# tutorial
  2734. C++ coroutines: Promise constructors | The Old New Thing
  2735. One thing I miss from Mercury
  2736. Is abstraction killing civilization? | datagubbe.se
  2737. Is the era of reflection-heavy C# libraries at an end?
  2738. .NET News Roundup - Week of April 26th, 2021
  2739. Rosenzweig – Dissecting the Apple M1 GPU, part IV
  2740. The Byte Order Fiasco
  2741. Dream desktop – Sam Squire's personal blog
  2742. LB27 first's line is obsolete from Daniel Bünzli via Unicode on 2020-03-03 (Unicode Mail List Archive)
  2743. The Little Things: everyday efficiencies
  2744. Rust programming language: We want to take it into the mainstream, says Facebook
  2745. Nullable Reference types in C# – Best practices
  2746. noir-lang/noir
  2747. .NET 6 LINQ Improvements
  2748. Uno Platform Uno Platform 3.7 - More WinUI, Project Reunion and Linux support, Wasm performance boost
  2749. Zero-knowledge Virtual Machines, the Polaris License, and Vendor Lock-in
  2750. C++ coroutines: Snooping in on the coroutine body | The Old New Thing
  2751. Introducing DRPC: Our Replacement for gRPC
  2752. Clean Architecture Refactoring: A Case Study - NDepend
  2753. Introducing GraphQLinq - Strongly Typed GraphQL Queries with LINQ to GraphQL. | Giorgi Dalakishvili | Personal Website
  2754. OCaml for the Masses - ACM Queue
  2755. Why does a zero-length stackalloc make the C# compiler happy to allow conditional stackallocs?
  2756. Running Lisp in Production
  2757. Some more C# 9 - Red Hat Developer
  2758. Useful features from C# 7 to 9 with Julien Couvreur
  2759. Introduction
  2760. Parsing Protobuf at 2+GB/s: How I Learned To Love Tail Calls in C
  2761. Rust Language Cheat Sheet
  2762. Setting Up Sass with Blazor
  2763. The Compiler Writer Resource Page
  2764. C++ coroutines: Associating multiple task types with the same promise type | The Old New Thing
  2765. Cerebras’ New Monster AI Chip Adds 1.4 Trillion Transistors - IEEE Spectrum
  2766. Ben.Demystifier 0.4.1
  2767. Conversation about crossgen2 | .NET Blog
  2768. Effectful Effects - Unifying Bidirectional Communication between Software Components
  2769. Node.js 16 available now
  2770. Rust and cryptographic code | Bulletproof TLS Newsletter
  2771. C# 9 init accessors and records - Red Hat Developer
  2772. Introduction to .NET - Learn
  2773. Loop alignment in .NET 6 | .NET Blog
  2774. Rosenzweig – Dissecting the Apple M1 GPU, part III
  2775. Async and Await In C#
  2776. What's in the box? - fasterthanli.me
  2777. Up For Grabs
  2778. My Go Executable Files Are Still Getting Larger (What's New in 2021 and Go 1.16)
  2779. Getting Started With Radare2
  2780. Rust in the Linux kernel
  2781. [PATCH 00/13] [RFC] Rust support
  2782. Why Rust strings seem hard
  2783. What is F#
  2784. [PATCH 00/13] [RFC] Rust support
  2785. Gregory Szorc's Digital Home | Rust is for Professionals
  2786. RAD Basic: a 100% compatible Visual Basic 6 solution
  2787. Visual Studio 2019 v16.10 Preview 2 Releases Today | Visual Studio Blog
  2788. C++ coroutines: Making it impossible to co_await a task twice | The Old New Thing
  2789. The FreeBSD Project | FreeBSD 13.0-RELEASE Release Notes
  2790. C# 9 new features for methods and functions - Red Hat Developer
  2791. A build tool for the rest of us
  2792. One Letter Programming Languages
  2793. C++ coroutines: The lifetime of objects involved in the coroutine function | The Old New Thing
  2794. .NET Foundation Project Spotlight
  2795. zhuowei/nft_ptr
  2796. My Favorite C# Features - Part 3: Nullability
  2797. .NET Internals Cookbook Part 1 — Exceptions, filters and corrupted processes – Random IT Utensils
  2798. The Cursed Computer Iceberg Meme
  2799. mratsim/constantine
  2800. microsoft-sponsorships/microsoft-foss-fund
  2801. C++ coroutines: Managing the reference count of the coroutine state | The Old New Thing
  2802. Microsoft Opens Up C# Standardization Work -- Visual Studio Magazine
  2803. What's Cool in C# 8 and .NET Core 3 -- Visual Studio Magazine
  2804. C++ coroutines: Awaiting the simple_task | The Old New Thing
  2805. C++ coroutines: Accepting types via return_void and return_value | The Old New Thing
  2806. The pain points of C# source generators
  2807. All C++20 core language features with examples
  2808. The Fastest, Safest PNG Decoder in the World
  2809. Eliminating Data Races in Firefox – A Technical Report – Mozilla Hacks - the Web developer blog
  2810. 10 Things I Hate About PostgreSQL
  2811. Announcing Open Source C# standardization | .NET Blog
  2812. Announcing Open Source C# standardization | .NET Blog
  2813. Raspberry Pi GPIO C# LED | C# Tutorials Blog
  2814. The Strange Case Of The Illegal Instruction
  2815. My "shiny future"
  2816. Windows 95 — How Does it Look Today?
  2817. The Exception Model
  2818. XKCP/K12
  2819. signed char lotte
  2820. The compiler will optimize that away
  2821. Autism challenges on the workplace (2021, 2/5) - A disability of trust
  2822. dotnet/csharplang
  2823. A categorized list of all Java and JVM features since JDK 8 to 16
  2824. C++ coroutines: What happens if an exception occurs in my return_value? | The Old New Thing
  2825. Unveiling Gavran: RavenDB re-written in C
  2826. gd/rust - platform/system/bt - Git at Google
  2827. C# 9 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2828. C++ coroutines: The initial and final suspend, and improving our return_value method | The Old New Thing
  2829. C++ coroutines: Basic implementation of a promise type | The Old New Thing
  2830. C# 9 top-level programs and target-typed expressions - Red Hat Developer
  2831. Be careful when mixing ValueTask and Task.Run - Gérald Barré
  2832. C++ coroutines: The mental model for coroutine promises | The Old New Thing
  2833. Pin and suffering - fasterthanli.me
  2834. JonDouglas/score
  2835. C# 8 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2836. Compiler Explorer - C++ (x86-64 clang (assertions trunk))
  2837. Async and Await and what is it actually doing?
  2838. Announcing Rust 1.51.0 | Rust Blog
  2839. A "Better C" Benchmark
  2840. Loop alignment in .NET 6 | .NET Blog
  2841. Julia 1.6 Highlights
  2842. C# 7 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2843. Women of Computing
  2844. C++, Getting Started with the Basics: Working with Dependencies and Linker
  2845. Let's Build a File Watcher
  2846. Linus Torvalds on where Rust will fit into Linux | ZDNet
  2847. Creating a task completion source for a C++ coroutine: Producing a result | The Old New Thing
  2848. Crystal 1.0 - What to expect
  2849. C# 5 and C# 6 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2850. C++, Getting Started with The Basics: Hello World and The Build Pipeline
  2851. How safe is zig?
  2852. git/next/linux-next.git - The linux-next integration testing tree
  2853. Moving from CentOS to Ubuntu
  2854. C# 2, 3 and 4 (Two Decades of C#: A Reference) • Ben Bowen's Blog
  2855. C# 9 records as strongly-typed ids - Part 5: final bits and conclusion
  2856. Episode 72 - Emulating a Video Game System in .NET with Ryujinx
  2857. Loop alignment in .NET
  2858. Visual Basic 16.9 in .NET 5
  2859. ezrosent/frawk
  2860. apple/swift-evolution
  2861. totally_safe_transmute, line-by-line
  2862. Windows APIs Everywhere in .NET
  2863. How C++ Resolves a Function Call
  2864. Introducing PeachPie 1.0.0
  2865. Show Recursion Show
  2866. Is Crossplane the Infrastructure LLVM?
  2867. Speed of Rust vs C
  2868. ASP.NET Community Standup - How to contribute to Blazor
  2869. Interpolating the internet
  2870. 012. I Shipped, Therefore I Am
  2871. mortdeus/legacy-cc
  2872. Zig, Parser Combinators - and Why They're Awesome
  2873. My Favorite C# Features Part 2: LINQ
  2874. netaddr.IP: a new IP address type for Go
  2875. GNU coreutils – MaiZure's Projects
  2876. TypeScript Handbook Revamped as Primary Learning Resource -- Visual Studio Magazine
  2877. What's New in Visual Basic on .NET 5?
  2878. Creating other types of synchronization objects that can be used with co_await, part 2: The basic library | The Old New Thing
  2879. part 1 — Store Halfword Byte-Reverse Indexed
  2880. The .NET Docs Show - Compiler time dependency injection in C# using StrongInject
  2881. New in Visual Studio F# Tooling: .NET 5 Scripting and F# Interactive -- Visual Studio Magazine
  2882. Why asynchronous Rust doesn't work
  2883. On .NET Live - Deep Dive into Microsoft Orleans
  2884. Unexpected finding about “await using var”
  2885. Finding Mona Lisa in the Game of Life
  2886. Everything You Want to Know About the Record Type in .NET 5… But Were Afraid to Ask
  2887. Announcing the New TypeScript Handbook | TypeScript
  2888. reflections on the competing IDEs
  2889. Microsoft Releases Visual Studio 2019 for Mac v8.9
  2890. The trouble with SPIR-V
  2891. eyal0/valgrind-false-positive
  2892. Visual Studio 2019 for Mac v8.9 Ships with .NET 6 Preview 1 Support -- Visual Studio Magazine
  2893. Creating a co_await awaitable signal that can be awaited multiple times, part 4 | The Old New Thing
  2894. Microsoft Releases Visual Studio 2019 v16.9
  2895. F# and F# tools update for Visual Studio 16.9 | .NET Blog
  2896. Creating a co_await awaitable signal that can be awaited multiple times, part 3 | The Old New Thing
  2897. The 8 most missing features in C# – TooSlowException
  2898. Watchy: The Hackable $50 Smartwatch - IEEE Spectrum
  2899. Add proposal for lambda improvements by cston · Pull Request #4451 · dotnet/csharplang
  2900. Visual Studio 2019 version 16.9 Release Notes
  2901. Lotus 1-2-3
  2902. Microsoft Extends Low-Code Push with Power Fx Programming Language -- Visual Studio Magazine
  2903. How to Read Assembly Language
  2904. How to execute an object file: Part 1
  2905. Retrieve compiler flags and metadata reference data as defined in htt… · NuGetPackageExplorer/NuGetPackageExplorer@3bbcfd7
  2906. dotnet/runtime
  2907. Course Review – “Programming Languages” Series on Coursera - Vasil Kosturski
  2908. Strongly-typed Ids using C# Source Generators - Gérald Barré
  2909. 📦 Demystify - com.needle.demystify
  2910. .NET News Roundup - Week of Feb 22th, 2021
  2911. TypeScript Function Syntaxes
  2912. Weird architectures weren't supported to begin with
  2913. C# 9 Is Out
  2914. Microsoft's Tools to Fight Solorigate Attack Are Now Open Source -- Visual Studio Magazine
  2915. Const generics MVP hits beta! | Rust Blog
  2916. Librsvg, Rust, and non-mainstream architectures
  2917. Don't define functions inline in your public headers
  2918. Intention in languages
  2919. Opus Codec
  2920. C#'s Functional Journey
  2921. New TypeScript 4.2 Tweaks Include Project Explainer -- Visual Studio Magazine
  2922. Announcing TypeScript 4.2 | TypeScript
  2923. Teaching Compilers Backward
  2924. Boosting Productivity and Performance with the NVIDIA CUDA 11.2 C++ Compiler | NVIDIA Developer Blog
  2925. Why Discord is switching from Go to Rust
  2926. rui314/mold
  2927. Kowainik - Totality
  2928. Add static PBKDF2 one-shot methods · dotnet/runtime@0c47471
  2929. Reverse engineering a GameBoy Advance game — Complete Guide
  2930. Immediate-Mode-UI/Nuklear
  2931. My Favorite C# Features - Part 1: Strong-types, Implicit-types, Anonymous-types, and Target-types
  2932. A methodical approach to looking at F# compile times · Discussion #11134 · dotnet/fsharp
  2933. The modern packager’s security nightmare – Michał Górny
  2934. GridProtectionAlliance/go2cs
  2935. TeeChart for .NET - BuiltWithDot.Net
  2936. 0 A.D. | A free, open-source game of ancient warfare
  2937. Understanding “reversed” callstacks in Visual Studio and Perfview with async/await code
  2938. Gleam v0.14 released! – Gleam
  2939. Introduction to Mixins in TypeScript
  2940. Cross compiling made easy, using Clang and LLVM · mcilloni's blog
  2941. elixir-nx/nx
  2942. A primer on code generation in Cranelift
  2943. Life, part 38
  2944. The Worst Experience I've Had With an aarch64 MacBook
  2945. OTCC : Obfuscated Tiny C Compiler
  2946. Julia 1.6: what has changed since Julia 1.0?
  2947. Announcing TypeScript 4.2 RC | TypeScript
  2948. For the Love of Macros
  2949. Finding Bugs in C and C++ Compilers using YARPGen
  2950. ratfactor/ziglings
  2951. 3,2 milliards d'emails et de mots de passe fuités ? Impressionnant, mais pas inquiétant - Cyberguerre
  2952. tensorflow/swift
  2953. VS Code C++ Tool Customizes IntelliSense for Target Platforms -- Visual Studio Magazine
  2954. C#/WinRT Authoring Preview Unveiled -- Visual Studio Magazine
  2955. Release v5.0.211103 · dotnet/format
  2956. Announcing Rust 1.50.0 | Rust Blog
  2957. spec: add generic programming using type parameters · Issue #43651 · golang/go
  2958. [Guest Post] Better refactoring for Unity projects using .NET analyzers | Visual Studio Blog
  2959. Cake Frosting: More Maintainable C# DevOps
  2960. From First Principles: Why Scala?
  2961. The Technology of iCircuit 3D
  2962. What's the Difference between Channel<T> and ConcurrentQueue<T> in C#?
  2963. Reverie: An optimized zero-knowledge proof system
  2964. The state of JVM desktop frameworks: Jetpack Compose for Desktop
  2965. Machine Learning Community Standup - Statistics & ML with FSharp.Stats
  2966. Rust Foundation
  2967. An Introduction to Channels in C#
  2968. Writing high performance F# code
  2969. Is abstraction killing civilization? | datagubbe.se
  2970. The problems with the GPL
  2971. On the Missed Opportunities of Static Types
  2972. The .NET Docs Show - Using Source Generators for Fun (and Maybe Profit)
  2973. Compiling DirectShow.Net for use in .NET 5
  2974. rust-analyzer/rust-analyzer
  2975. The spectrum of synchronousness - The Engineering Manager
  2976. Inline caching: quickening
  2977. Working with large .NET 5 solutions in Visual Studio 2019 16.8 | Visual Studio Blog
  2978. Creating Discoverable HTTP APIs with ASP.NET Core 5 Web API | ASP.NET Blog
  2979. Usage patterns for winrt::unbox_value_or | The Old New Thing
  2980. Go (golang) Anonymous Functions - Inlining Code for Goroutines
  2981. Go (golang) Channels - Moving Data Between Concurrent Processes
  2982. Llama Rust SDK preview 0.1.3
  2983. Why I still Lisp (and you should too!)
  2984. C# Nullable reference types – No more null reference exceptions!
  2985. The weirdest compiler bug
  2986. Discover - Pony
  2987. Using fetch with TypeScript
  2988. Using C# Source Generators to create an external DSL | .NET Blog
  2989. PostSharp's Great Reset: Announcing Project "Caravela", a Roslyn-based aspect framework
  2990. Cranelift, Part 2: Compiler Efficiency, CFGs, and a Branch Peephole Optimizer
  2991. Zig Makes Go Cross Compilation Just Work
  2992. dotnet/runtimelab
  2993. VSCode, Dev Containers and Docker: moving software development forward - Sticky Bits - Powered by Feabhas
  2994. Design Draft: First Class Fuzzing
  2995. Visual Studio 2019 v16.9 Preview 3 is Available Today | Visual Studio Blog
  2996. Porting Firefox to Apple Silicon – Mozilla Hacks - the Web developer blog
  2997. Preview: The SQLite Llibrary as a .NET assembly
  2998. Compilers are hard | ShipReq Blog
  2999. Dynamic type systems aren't even simpler - hisham.hm
  3000. Fun with conversion-operator name lookup
  3001. Introducing Textrude - using Scriban to generate code from data
  3002. Julia Update: Adoption Keeps Climbing; Is It a Python Challenger?
  3003. Reducing tail latencies with automatic cooperative task yielding
  3004. DO NOT MERGE: Regex source generator prototype by pgovind · Pull Request #47065 · dotnet/runtime
  3005. @devlead - Mattias Karlsson's Blog - My preferred .NET console stack
  3006. Here's a One-Stop Shop for .NET 5 Improvements -- Visual Studio Magazine
  3007. source.winehq.org Git - wine.git/blob - ANNOUNCE
  3008. Announcing TypeScript 4.2 Beta | TypeScript
  3009. The misleading MIDL error message: MIDL5023: The arguments to the parameterized interface are not valid | The Old New Thing
  3010. Go (golang) Error Handling - A Different Philosophy
  3011. theseus-os/Theseus
  3012. How we quickly refactored with Resharper more than 23.000 calls to Debug.Assert() into more meaningful assertions - NDepend
  3013. pakrym/jab
  3014. How Does .NET 5 Do XAML? By Decoupling It from Windows with WinUI 3, C#/WinRT and More -- Visual Studio Magazine
  3015. Why Haskell is our first choice for building production software systems – Foxhound Systems
  3016. SUCCESS: iPhone 7 with dead NAND netbooting unmodified Ubuntu 20.04 arm64 over usb gadget ethernet
  3017. How did I find the old Windows binaries and compilers for the processor retrospective series? | The Old New Thing
  3018. Go (golang) Loops - A Unified "for"
  3019. Writing your own NES emulator Part 3 - the 6502 CPU
  3020. Rust-GCC/gccrs
  3021. The Architecture of Open Source Applications: LLVM
  3022. Why mmap is faster than system calls
  3023. WinUI 3 Preview 3 | Windows Dev
  3024. Rosenzweig – Dissecting the Apple M1 GPU, part I
  3025. Wasmer 1.0
  3026. Why I'm Learning F# in 2021
  3027. Strongly typing <code>react-query</code>s <code>useQueries</code>
  3028. GRVYDEV/Project-Lightspeed
  3029. The Best Software Every Reverse Engineer Should Have for Cracking Software | PiProgramming
  3030. A half-hour to learn Rust - fasterthanli.me
  3031. osnr/horrifying-pdf-experiments
  3032. State machines are wonderful tools
  3033. I'd like an IUnknown, I know you have many, I'll take any of them | The Old New Thing
  3034. Mac meets Arm64
  3035. Announcing Rust 1.49.0 | Rust Blog
  3036. Glasgow Haskell Compiler 9.0.1-rc1 now available!
  3037. Why are the C and C++ compilers giving me error messages about int when my code doesn't mention int? | The Old New Thing
  3038. What's new in PHP 8 - stitcher.io
  3039. C# A to Z: Prelude
  3040. Cosmopolitan C Library
  3041. Executable PNGs - djhworld
  3042. Some Differences between macOS and Common Unix Systems
  3043. A Complete Guide to LLVM for Programming Language Creators
  3044. New Release: Tor Browser 10.0.7 | Tor Blog
  3045. Why I've Been Merging Microservices Back Into The Monolith At InVision
  3046. Cloudflare Acquires Linc
  3047. Cakelisp: a programming language for games
  3048. C# In Simple Terms - Iterators
  3049. Nullable reference types; CSharp&#39;s very own <code>strictNullChecks</code>
  3050. Arrows born in flight
  3051. C# vs. F# – planetgeek.ch
  3052. The Shape of 1.7M Lines of Code · Stefan-Marr.de
  3053. ollelogdahl/ihct
  3054. .NET 5 Source Generators - MediatR - CQRS
  3055. Playing with C#9 Top-level Programs, Records and Elasticsearch.NET - Steve Gordon - Code with Steve
  3056. What I Wish Someone Had Told Me About Tensor Computation Libraries
  3057. How Tail Call Optimization Works
  3058. ReSharper 2020.3: Support for C# 9 and Source Generators, New Features in Inlay Hints, and Support for Avalonia UI – .NET Tools Blog | JetBrains
  3059. Dynamic Class Creation in C# - Preserving Type Safety in C# with Roslyn
  3060. About Cyberpunk 2077 and AMD CPUs
  3061. These Modern Programming Languages Will Make You Suffer
  3062. Reindeer Secret Santa Assignment Problem
  3063. CS 6120: The Self-Guided Course
  3064. Thread by @StanTwinB on Thread Reader App
  3065. Bebop: An Efficient, Schema-based Binary Serialization Format | Rainway
  3066. r/Kotlin - [OC] Compiler plugins are amazing!
  3067. C# Source Generators - Write Code that Writes Code
  3068. Visual Studio 2019 v16.9 Preview 2 and New Year Wishes Coming to You! | Visual Studio Blog
  3069. What’s New on F#: Q&A With Phillip Carter
  3070. thought leaders and chicken sexers
  3071. Inside the Quantum Katas, part 1 | Q# Blog
  3072. Wiki: TypeScript | Barbarian Meets Coding
  3073. C# 9 and Foreach Extensibility · Lukáš Lánský
  3074. libra/libra
  3075. QBE vs LLVM
  3076. .NET 5 Breaking Changes to the Base Class Library
  3077. Writing Rust the Elixir way
  3078. [Guest Post] Introducing WaveEngine 3.1 based on .NET 5 | .NET Blog
  3079. C# In Simple Terms - String Manipulation and Cultures
  3080. ARM and Lock-Free Programming
  3081. mhx/dwarfs
  3082. Duplex gPRC
  3083. pallada-92/dna-3d-engine
  3084. Yes, I use Nix
  3085. Apple Silicon M1: A Developer’s Perspective
  3086. Going all-in with nullable reference types
  3087. 「Dflat」Structured Data Store for Mobile
  3088. Upgrading ConfigurationManager for .Net 5
  3089. .Net 5 is PERFECT for DevOps
  3090. microsoft/TypeScript
  3091. C# 9 Records as DDD Value Objects
  3092. Why AWS loves Rust, and how we’d like to help | Amazon Web Services
  3093. Compiler Explorer - C
  3094. FSDN
  3095. C# 9 - Improving performance using the SkipLocalsInit attribute - Gérald Barré
  3096. Exotic Programming Ideas: Part 3 (Effect Systems)
  3097. TIL: eBPF is awesome
  3098. A Taste of OCaml's Predictable Performance - Dev.Poga
  3099. In New Releases, Microsoft Lauds .NET Productivity, Visual Studio 2019 Speed -- Visual Studio Magazine
  3100. Enabling C# 9 in Xamarin & .NET Standard Projects
  3101. Eight years at Roblox
  3102. C# in Simple Terms - Attributes and Reflection
  3103. Other uses for the -library flag of the C++/WinRT compiler | The Old New Thing
  3104. What's new in .NET Productivity | .NET Blog
  3105. On combining static libraries that implement C++/WinRT activatable objects | The Old New Thing
  3106. C# Index and Range Operators Explained - NDepend
  3107. Graphics for JVM
  3108. The C Standard Library Is Not Dependency Free
  3109. C# in Simple Terms - Tuples and Anonymous Types
  3110. Bulletproof uniq with TypeScript generics (yay code reviews!)
  3111. xoofx/Broslyn
  3112. A Comparison of Modern Graphics APIs
  3113. ASP.NET Core 5 Model Binding to C# 9 Record Types
  3114. Linux graphics, why sharing code with Windows isn't always a win.
  3115. C# in Simple Terms - Generics
  3116. Why an IDE?
  3117. Running Python on .NET 5
  3118. The Resurgence of Functional Programming - Highlights From QCon Plus
  3119. Visual Studio 2019 v16.8 Ships with Git Turned On by Default -- Visual Studio Magazine
  3120. Announcing F# 5 | .NET Blog
  3121. C# 9: Record Types Introduction & Deep-Dive | Claudio Bernasconi
  3122. OR_GREATER preprocessor symbols for TFMs by terrajobst · Pull Request #164 · dotnet/designs
  3123. The Tao of Programming
  3124. DevDay 2020: Using Roslyn to improve your codebase
  3125. Module Initializers In C# 9
  3126. Multithreading Handbook for Simulation Developers
  3127. My first-time pure functional programming - Sandro Maglione
  3128. Rust vs Go — Bitfield Consulting
  3129. The Turing-Completeness Problem - Alan Language
  3130. Life and Death of a Linux Process
  3131. .NET Live TV | Live developer streams every day
  3132. C# in Simple Terms - Arrays and Collections
  3133. A first look at the JIT
  3134. Modernizing a codebase for C# 9
  3135. Best practice when naming Durable Functions in C#
  3136. Stop compilation after first error
  3137. C#9 - init-only properties are not read-only at runtime - Gérald Barré
  3138. Leaving OCaml
  3139. Are C# 9 records immutable by default?
  3140. C# in Simple Terms - Exceptions and Exception Handling
  3141. Pattern matching in C# 9.0
  3142. Using C# 9 records as strongly-typed ids
  3143. The Man Who Carried Computer Science on His Shoulders – Krzysztof Apt – Inference
  3144. For Complex Applications, Rust is as Productive as Kotlin
  3145. C# 9 The unknown goodies | Miguel Bernard's Blog
  3146. Awaitable/awaiter pattern and logical micro-threading in C#
  3147. Unity 2020.1 is now available
  3148. Pyston v2: 20% faster Python
  3149. A Type of Useless
  3150. Windows Runtime objects are represented by their default interface, so choose your default interface wisely | The Old New Thing
  3151. Splitting Large Interfaces Into Smaller Ones Is Easy
  3152. Surviving disillusionment
  3153. Bytecode Alliance: One year update
  3154. Why we chose Java for our High-Frequency Trading application
  3155. Fast bitmap iteration in C#
  3156. I told the Microsoft Visual C++ compiler not to generate AVX instructions, but it did it anyway! | The Old New Thing
  3157. Standard ML in 2020 | notes.eatonphil.com
  3158. QuickJS Javascript Engine
  3159. Lets Talk .NET 5, with Scott Hunter
  3160. Beautiful and compact Web APIs with C# 9, .NET 5.0 and ASP.NET Core
  3161. C# 8.0 nullable references: defeating the point with empty strings | endjin
  3162. /* You Are Not Expected to Understand This */
  3163. A fucking rant about fucking const vs fucking let
  3164. switch expression - C# reference
  3165. C# support · Issue #156 · github/semantic
  3166. The .NET Foundation Joins the Open Source Initiative's Affiliate Program
  3167. Assorted thoughts on zig (and rust)
  3168. Monomorphic functors
  3169. Why mmap is faster than system calls
  3170. Structure and Interpretation of Computer Programmers
  3171. C# in Simple Terms - Structs and Enums
  3172. Object Detection at 1840 FPS with TorchScript, TensorRT and DeepStream
  3173. Towards sockets and networking in WebAssembly and WASI - radu's blog
  3174. A Highly Biased Review of C# Changes from Version 1.0 to 9.0
  3175. ironcev/awesome-roslyn
  3176. LISP From Nothing - T3X.ORG
  3177. Version 1.4.0 released
  3178. kekyo/IL2C
  3179. MVVM Toolkit Preview 3 & The Journey of an API | PAX - Windows
  3180. C# in Simple Terms - Classes and Members
  3181. A brief introduction to C++ structured binding | The Old New Thing
  3182. C# 8.0 nullable references: prepare today by not misusing 'as' | endjin
  3183. LDM: My Favorite ARM Instruction
  3184. The Importance of Memory | Barnabas Kendall
  3185. What’s New In .Net 5? - Solace Infotech Pvt Ltd
  3186. Use is null/is not null for null checking by marek-safar · Pull Request #43360 · dotnet/runtime
  3187. Async code smells and how to track them down with analyzers - Part I
  3188. [llvm-announce] LLVM 11.0.0 Release
  3189. BinomialLLC/bc7e
  3190. C# in Simple Terms - Methods, Parameters, and Arguments
  3191. In 1979, some software company in Bellevue was hiring | The Old New Thing
  3192. Linux Hardware Reviews, Open-Source Benchmarks & Linux Performance
  3193. The Observation Deck » Rust after the honeymoon
  3194. ymte/metamine
  3195. Adelaide .NET User Group (Adelaide, Australia)
  3196. chsienki/Kittitas
  3197. Llama preview 0.1.2
  3198. Reverse engineering my cable modem and turning it into an SDR
  3199. To The Assembly - CoRecursive Podcast
  3200. .NET code style rule options - .NET
  3201. Announcing Rust 1.47.0 | Rust Blog
  3202. Writing JavaScript tools in other languages – a new trend?
  3203. Error C3867: non-standard syntax; use '&' to create a pointer to member: What it means and how to fix it | The Old New Thing
  3204. Two ways you can take advantage of types in JavaScript (without TypeScript) - The Blinking Caret
  3205. Elixir v1.11 released
  3206. Life, part 36
  3207. What you could steal from the Kakoune code editor right now, and get away with it
  3208. How we ran a Unix-like OS (Xv6), on our home-built CPU with our home-built C compiler
  3209. Wiki - RustStarterKit2020
  3210. LLVM provides no side-channel resistance
  3211. Little gotcha with C++/WinRT iterators: The case of the mutated temporary | The Old New Thing
  3212. rui314/chibicc
  3213. C# in Simple Terms - Casting, Conversion, and Parsing
  3214. A categorized list of all Java and JVM features since JDK 8 to 15
  3215. It Is Never a Compiler Bug Until It Is
  3216. kzu/NuGetizer
  3217. Things I Was Wrong About: Types  — Sympolymathesy, by Chris Krycho
  3218. C# in Simple Terms - Primitive Types, Literals, and Nullables
  3219. Thoughts on Structured Editing: Breaking Away from Syntax
  3220. Zig's New Relationship with LLVM
  3221. Introducing DotNet.SystemCollections.Analyzers
  3222. A tale of two libcs
  3223. A tale of two libcs
  3224. Things Elixir's Phoenix Framework Does Right
  3225. JsonSrcGen + CoreRT = Pure Magic
  3226. ggerganov/wave-share
  3227. How Oodle Kraken and Oodle Texture supercharge the IO system of the Sony PS5
  3228. This is a pretty dire assessment of Mozilla
  3229. C# in Simple Terms - The Type System
  3230. Python behind the scenes #2: how the CPython compiler works
  3231. Firefox usage is down 85% despite Mozilla's top exec pay going up 400%
  3232. How to generate code using Roslyn source generators in real world scenarios
  3233. Introducing Swift on Windows
  3234. Using Disassembly Tool for optimized debugging
  3235. Build Xamarin.iOS apps using iOS 14 and Xcode 12 | Xamarin Blog
  3236. Why not rust for security?
  3237. Introducing C# in Simple Terms!
  3238. Why Not Rust?
  3239. Write Xamarin.Mac Apps With JetBrains Rider
  3240. Why Not Rust?
  3241. evanw/esbuild
  3242. TL;DR Rust
  3243. pin_ptr (C++/CLI)
  3244. Dev Discussions - Isaac Abraham
  3245. Fabulous: Functional App Development | Xamarin Blog
  3246. Release v3.0.0 One Piece · vuejs/vue-next
  3247. I get a weird error about no matching function when I try to use winrt::capture | The Old New Thing
  3248. C# 9.0: Target-typed expression | Miguel Bernard's Blog
  3249. C++ Leads Visual Studio 2019 v16.8 Preview 3 Improvements -- Visual Studio Magazine
  3250. Microsoft announces new Project OneFuzz framework, an open source developer tool to find and fix bugs at scale - Microsoft Security
  3251. CSS isolation in Blazor - Gérald Barré
  3252. Why did I lose the ability to co_await a std::future and concurrency::task? | The Old New Thing
  3253. Zigソフトウェア財団とZenプログラミング言語に関する声明 - News - The Zig Programming Language
  3254. Home
  3255. .NET Adds Latent Bug Discovery Feature
  3256. – Wren
  3257. Disassembly improvements for optimized managed debugging | Visual Studio Blog
  3258. Announcing .NET 5.0 RC 1 | .NET Blog
  3259. DotFest 2020: Using Roslyn to improve your codebase
  3260. What's up with error C4838: a WinRT type cannot be a member of a union, and how can I work around it? | The Old New Thing
  3261. Fabulous: Functional App Development | Xamarin Blog
  3262. The macros for declaring COM interfaces, revisited: C++ implementation | The Old New Thing
  3263. [llvm-dev] [RFC] Machine Function Splitter
  3264. C# 9.0: Improved pattern matching | Miguel Bernard's Blog
  3265. The macros for declaring COM interfaces, revisited: C++ version | The Old New Thing
  3266. The Amazing $1 Microcontroller - Jay Carlson
  3267. C# 9.0: Target-typed New Expressions – Make Your Initialization Code Less Verbose
  3268. The macros for declaring COM interfaces, revisited: C version | The Old New Thing
  3269. How to speed up the Rust compiler one last time – Nicholas Nethercote
  3270. C++/WinRT injects additional constructors into each runtime class | The Old New Thing
  3271. Massacring C Pointers
  3272. What Every C Programmer Should Know About Undefined Behavior #2/3
  3273. Top-level programs in C# 9.0
  3274. samizdatco/skia-canvas
  3275. Rough edges in the when_all coroutine, part 1: Empty parameter list | The Old New Thing
  3276. C# 9.0: Records – Work With Immutable Data Classes
  3277. In Defense of a Switch
  3278. dotnet/roslyn
  3279. chsienki/Kittitas
  3280. Announcing PeachPie 1.0-preview1 @ PeachPie
  3281. Improvements in native code interop in .NET 5.0 | .NET Blog
  3282. New C# Source Generator Samples | .NET Blog
  3283. C# preprocessor directive symbols from the dotnet build command line via DefineConstants
  3284. Azure/bicep
  3285. App Trimming in .NET 5 | .NET Blog
  3286. Supporting Linux kernel development in Rust
  3287. Soatok’s Guide to Side-Channel Attacks
  3288. System Programming in 2k20
  3289. Tips for stable and portable software
  3290. .NET R&D Digest (August, 2020)
  3291. Real-time rendering of water caustics
  3292. Exploring mullender.c - A deep dive into the first IOCCC winner :: LainSystems
  3293. Zero-Knowledge Proofs from Information-Theoretic Proof Systems - Part I | ZKProof Standards
  3294. Objective-Rust
  3295. Linux Hardware Reviews, Open-Source Benchmarks & Linux Performance
  3296. Meet Silq- The First Intuitive High-Level Language for Quantum Computers
  3297. Automatically find latent bugs in your code with .NET 5 | .NET Blog
  3298. C++ with Visual Studio Code on macOS
  3299. Configure VS Code for Clang/LLVM on macOS
  3300. .NET Rocks! vNext
  3301. Is TDD Dead
  3302. The 2020 Virtual LLVM Developers' Meeting Program
  3303. Asynchronous programming - C#
  3304. C# to the max! Continuations, co-routines and Source Generators!
  3305. Thinking about dependencies :: sunshowers
  3306. MSBuild Log Viewer
  3307. Exclude code that follows [DoesNotReturn] from code coverage (per #898) by kevin-montrose · Pull Request #904 · coverlet-coverage/coverlet
  3308. First thoughts on Rust vs OCaml
  3309. davidfowl/CommunityStandUpNet5
  3310. ASP.NET Core 5: Make your options immutable
  3311. Porting a Golang and Rust CLI tool to D
  3312. Kowainik - Haskell mini-patterns handbook
  3313. Introducing C# 9: Native-sized integers
  3314. SSH Considered Harmful – Why You Should Be Using Persistent Sessions
  3315. Hiding messages in x86 binaries using semantic duals
  3316. Code Smell: Concrete Abstraction
  3317. p-j-miller/ya-sprintf
  3318. Frustrated? It's not you, it's Rust - fasterthanli.me
  3319. Write your Own Virtual Machine
  3320. "Rust does not have a stable ABI"
  3321. Equality for free – planetgeek.ch
  3322. Post-Open Source
  3323. Serverless apps on AWS using F# and fable
  3324. Search is too good - A Walk Within Boredom
  3325. Announcing TypeScript 3.1 | TypeScript
  3326. Building a BASIC Interpreter, '80s style
  3327. Let’s implement a Bloom Filter
  3328. How I Modernized My Flash Game
  3329. Why I Can’t Stand the FSF
  3330. Why the C Language Will Never Stop You from Making Mistakes
  3331. Use C# Preprocessor Directives
  3332. Announcing TypeScript 4.0 RC | TypeScript
  3333. Introducing C# 9: Extending Partial Methods
  3334. Introducing Rome
  3335. Hedging tail risk, emigration, keyboard superoptimization
  3336. First Impressions of Rust
  3337. Accelerating Standard C++ with GPUs Using stdpar | NVIDIA Developer Blog
  3338. Merge Extension GetEnumerator into master by 333fred · Pull Request #46573 · dotnet/roslyn
  3339. acidanthera/OpenCorePkg
  3340. Visual Studio 2019 v16.7 and v16.8 Preview 1 Release Today! | Visual Studio Blog
  3341. What is default(object) used for?
  3342. Why are you testing your software?
  3343. Fuzzy.Blazor.FluentRenderTreeBuilder 1.1.0
  3344. Announcing the new TypeScript Website | TypeScript
  3345. Introducing localization support in OpenIddict 3.0 beta3
  3346. The Julia Language
  3347. Best Practices for Regular Expressions in .NET
  3348. What Happened When I Peeked Into My Node_Modules Directory
  3349. Niklaus Wirth was right and that is a problem – bowero
  3350. The Haskell Elephant in the Room
  3351. Learn about the latest .NET Productivity features | .NET Blog
  3352. WasmBoxC: Simple, Easy, and Fast VM-less Sandboxing
  3353. Task asynchronous programming as an IO surrogate
  3354. BenchmarkDotNet 0.12.1
  3355. Writing more succinct C# – in F# (Part 1)!
  3356. adam-mcdaniel/oakc
  3357. froggey/Mezzano
  3358. PostSharp Blog | Thinking beyond Roslyn source generators and aspect-oriented programming
  3359. Dhghomon/easy_rust
  3360. .NET Foundation Projects
  3361. Phillip Carter
  3362. Svelte <3 TypeScript
  3363. How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More | Carol's Blog
  3364. Farmer: Simpler ARM deployments with Octopus Deploy - Octopus Deploy
  3365. I Don't Want to be a Founder and I Don't Think You Do Either | Carol's Blog
  3366. Understanding F# applicatives and custom operators
  3367. lawl/NoiseTorch
  3368. Mainframe workloads supported on Azure
  3369. Compiler Explorer - C (x86-64 clang 10.0.0)
  3370. C# 9: New `and`, `or`, and `not` Keywords for Pattern Matching
  3371. My First PC
  3372. Announcing Rust 1.45.0 | Rust Blog
  3373. C# 9 Deep Dive: Target Typing and Covariant Returns
  3374. All .Net Exceptions List
  3375. How to stop worrying and adopt nullable reference types – Webinar Recording
  3376. Linux kernel in-tree Rust support
  3377. Performance Improvements in .NET 5 | .NET Blog
  3378. Generating the Premier League Table in F#
  3379. Type-Safe Single Page Apps: F# Vs. TypeScript
  3380. The Soul of a New Debugger
  3381. V8 release v8.4 · V8
  3382. Linux kernel in-tree Rust support
  3383. Linux kernel in-tree Rust support
  3384. A deep-dive into WinUI 3 in desktop apps - Windows Developer Blog
  3385. Pwning smart garage door openers
  3386. Martin Björkström - gRPC Server Reflection in the .NET world
  3387. Flatter wait-free hazard pointers - Paul Khuong: some Lisp
  3388. C# 8.0 nullable references: MaybeNull | endjin
  3389. Writing a winning 4K intro in Rust
  3390. A Deep Introduction to JIT Compilers: JITs are not very Just-in-time | Carol's Blog
  3391. Generics for Go
  3392. Desugaring - taking our high-level language and simplifying it!
  3393. About Scaling Model-View-Update
  3394. How Hello World! changed – top level statements and functions
  3395. Misusing C#: Multiple Main() Methods
  3396. protobuf-net/protobuf-net
  3397. Announcing TypeScript 4.0 Beta | TypeScript
  3398. C# 8.0 nullable references: NotNull | endjin
  3399. Why I don't like SemVer anymore
  3400. GNU GCC does not round floating-point divisions to the nearest value
  3401. Building a high performance JSON parser
  3402. F# 5 and F# tools update for June | .NET Blog
  3403. dotnet/core
  3404. Trace 'function enter/leave' events with a .NET profiler + detect StackOverflow. Assembler code included!
  3405. Life, part 18
  3406. TCC : Tiny C Compiler
  3407. Differences between String and string in C# - Code Maze
  3408. IHP is a modern batteries-included Web Framework, built on top of Haskell and Nix.
  3409. What is Zig's “Colorblind” Async/Await?
  3410. Chat Wars
  3411. Reverse Engineering Snapchat (Part II): Deobfuscating the Undeobfuscatable
  3412. Linear types are merged in GHC
  3413. Implementing a brainfuck CPU in Ghidra - part 1: Setup and disassembly
  3414. Semantic highlighting in OmniSharp and C# extension for VS Code
  3415. Converting a hundred million integers to strings per second
  3416. hashcat 6.0.0
  3417. DEVS(show) : The Universe is (not) deterministic. Is it a bootstrapping compiler?
  3418. The Next Step for Generics
  3419. Guix Further Reduces Bootstrap Seed to 25% — 2020 — Blog — GNU Guix
  3420. 3K, 60fps, 130ms: achieving it with Rust | tonari blog
  3421. Generics and Compile-Time in Rust | TiDB
  3422. C# semantic classification with Roslyn
  3423. GitHub to replace "master" with alternative term to avoid slavery references | ZDNet
  3424. How x86_64 addresses memory
  3425. Microsoft: Rust Is the Industry’s ‘Best Chance’ at Safe Systems Programming – The New Stack
  3426. How async should have been
  3427. Develop, Preview, Test
  3428. ECDSA: Handle with Care
  3429. dotnet/pinvoke
  3430. How Do I Think About Async Code?! | Visual Studio Blog
  3431. .NET Today and Tomorrow | Strangelights
  3432. Modernization Story: Windows Forms to .NET Core, XAML Islands and MSIX Core
  3433. 'Escaping Web' Season One Retrospective
  3434. New inline assembly syntax available in nightly | Inside Rust Blog
  3435. NVIDIA/cutlass
  3436. Collapse OS — Why Forth?
  3437. Peeking under the hood of Command & Conquer
  3438. Microsoft.Diagnostics.Runtime 2.0.130507
  3439. milen.me — Distributed Caching & Compilation
  3440. Ruby vs Crystal Performance
  3441. Experimenting with Memory Management for Basil
  3442. julia as a cli calculator
  3443. Why does this lazy sequence work? | Phillippe Siclait
  3444. SQLite Forum: Caution: clang-11.0.0 miscompiles SQLite
  3445. Configuring Errors and Warnings in C#
  3446. Gleam v0.9 released! – by Otter Nonsense
  3447. TypeScript - JavaScript that scales.
  3448. Avalonia UI Framework
  3449. Merge features/function pointers to master by 333fred · Pull Request #44727 · dotnet/roslyn
  3450. ryansolid/solid
  3451. DotNetAnalyzers/DocumentationAnalyzers
  3452. Changes to How We Manage DefinitelyTyped | TypeScript
  3453. The magic of C# closures
  3454. Write high-quality TypeScript code - .NET Tools Blog
  3455. Video Conferencing, Web Conferencing, Webinars, Screen Sharing
  3456. The Dangers of TypeScript Enums | LINQ to Fail
  3457. How to code like the top Programmers at NASA — 10 critical rules - Alt Bulletin
  3458. Nullable Reference Types: Contexts and Attributes – A Look at New Language Features in C# 8 - .NET Tools Blog
  3459. - Miguel de Icaza
  3460. Patrik Svensson - Targeting ARM64 for Windows in Rust
  3461. Idris 2 version 0.2.0 Released
  3462. Why is Idris 2 so much faster than Idris 1?
  3463. Introduction to Functional Programming in F# - Part 10 — Softwarepark
  3464. How It All Started…AKA the Birth of the CLR - CLR, architectures, and stuff - Site Home
  3465. Optimizing for the RDNA Architecture: presentation notes
  3466. Life, part 11
  3467. Welcome to C# 9.0 | .NET Blog
  3468. F# 5 and F# tools update | .NET Blog
  3469. it’s not just the interpreter « kmod's blog
  3470. The Hardest Program I've Ever Written – journal.stuffwithstuff.com
  3471. TypeScript in a Weekend: A Crash Course
  3472. Multi-path cancellation; a tale of two codependent async enumerators
  3473. Coding is Not Computer Science
  3474. PERF: ensure we run full GC on contexts
  3475. Five Years of Rust | Rust Blog
  3476. Don't Code Tired | Reducing Magic Strings with Microsoft Feature Toggles (Microsoft.FeatureManagement)
  3477. Up to 4GB of memory in WebAssembly · V8
  3478. A Quick Look at Impredicativity (Simon Peyton Jones)
  3479. The anatomy of async iterators (aka await, foreach, yield)
  3480. Deno 1.0
  3481. Performance speed limits
  3482. Erlang Programming Language
  3483. Weep for Graphics Programming
  3484. Announcing TypeScript 3.9 | TypeScript
  3485. Performance best practices in C#
  3486. A Story About .csproj, Large Solutions and Memory Usage - .NET Tools Blog
  3487. Demystifying Memory Profilers in C# .NET Part 3: Memory Pressure - Michael's Coding Spot
  3488. SourceHut + Plan 9 = ❤
  3489. Why we at $FAMOUS_COMPANY Switched to $HYPED_TECHNOLOGY
  3490. Swift 5.3 Release Process
  3491. Make LLVM fast again
  3492. The IBM 1401 compiles and runs FORTRAN II
  3493. Cryptology ePrint Archive: Report 2020/529
  3494. ~rabbits/orca - sourcehut git
  3495. GCC 10.1 Released
  3496. Static Constructor Failures and Declaration Order
  3497. Life, part 6
  3498. Popcorn Linux - Home
  3499. 'Re: Integrating "safe" languages into OpenBSD?'
  3500. Xamarin.Forms 4.6 Available Today! | Xamarin Blog
  3501. Announcing TypeScript 3.9 RC | TypeScript
  3502. Introducing C# Source Generators | .NET Blog
  3503. C# interop with C/C++ and Rust in WebAssembly - Uno Platform
  3504. Don’t Use Boolean Arguments, Use Enums
  3505. Do We Have an Obsession with Ducks in Software Development? - Steve Gordon
  3506. Smarter C/C++ inlining with __attribute__((flatten))
  3507. First Release
  3508. First Release
  3509. a-Shell
  3510. Emojicode Documentation · Compile and Run Your First Program
  3511. R 4.0.0 is released
  3512. Announcing Rust 1.43.0 | Rust Blog
  3513. C# 8.0 nullable references: embrace the expressiveness
  3514. Closing the gap: cross-language LTO between Rust and C/C++
  3515. Engineering code quality in the Firefox browser: A look at our tools and challenges – Mozilla Hacks - the Web developer blog
  3516. A Possible New Backend for Rust – Jason Williams
  3517. Nullable Reference Types: Migrating a Codebase – A Look at New Language Features in C# 8 - .NET Tools Blog
  3518. Python 2.7.18, the last release of Python 2
  3519. “Stubs” in the .NET Runtime
  3520. Life, part 2
  3521. Strategies for migrating to TypeScript
  3522. Creating web apps via TypeScript and webpack
  3523. How does TypeScript work? The bird’s eye view
  3524. I Took a COBOL Course and It Wasn't The Worst | Hacker Noon
  3525. Hello, Gleam! - The Gleam Book
  3526. Matt Segal Dev - Nand to Tetris is a great course
  3527. .NET JIT compiler is not type safe – TooSlowException
  3528. Creating CommonJS-based npm packages via TypeScript
  3529. State of Vue Apr 16 2020
  3530. The Computer Scientist Who Can’t Stop Telling Stories
  3531. Augmenting Interfaces in the Global Scope in TypeScript
  3532. 0.6.0 Release Notes · The Zig Programming Language
  3533. A Personal History of Compilation Speed, Part 1
  3534. A very short introduction to COBOL
  3535. Welcome back to C++ - Modern C++
  3536. Stop Making Students Use Eclipse
  3537. Bored? How about trying a Linux speed run?
  3538. Things That Turbo Pascal is Smaller Than
  3539. The Death of Hype: What's Next for Scala
  3540. Godot Engine - C# progress report: iOS and signals as events
  3541. Hybridizer: High-Performance C# on GPUs | NVIDIA Developer Blog
  3542. Why I’m leaving Elm - lukeplant.me.uk
  3543. Swift: Google’s bet on differentiable programming | Tryolabs Blog
  3544. Cross-platform profiling .NET code with BenchmarkDotNet
  3545. Mobius – .NET runtime running on .NET Core – TooSlowException
  3546. Crafting "Crafting Interpreters" – journal.stuffwithstuff.com
  3547. The Svelte Compiler Handbook
  3548. 10 Things I Hate About PostgreSQL
  3549. Version 1.2.0 released
  3550. A crash course in compilers – Increment: Programming Languages
  3551. Content Injection with Response Rewriting in ASP.NET Core
  3552. "C is how the computer works" is a dangerous mindset for C programmers • Steve Klabnik
  3553. ValueTask Restrictions
  3554. Await | Writing an OS in Rust
  3555. Announcing TypeScript 3.9 Beta | TypeScript
  3556. Static analysis in GCC 10 - Red Hat Developer
  3557. The Hardest Program I've Ever Written – journal.stuffwithstuff.com
  3558. New grad vs senior dev
  3559. firefox's low-latency webassembly compiler -- wingolog
  3560. 10 Most(ly dead) Influential Programming Languages • Hillel Wayne
  3561. 10 Most(ly dead) Influential Programming Languages • Hillel Wayne
  3562. Improving non-nullable reference types handling
  3563. How to create a gRPC service ? – Anthony Giretti's .NET blog
  3564. High-performance C#: a test pattern for ref structs
  3565. Running C# Snake inside UEFI
  3566. How I Became a Better Programmer
  3567. Don't Code Tired | Variables? We Don’t Need No Stinking Variables - C# Discards
  3568. A categorized list of all Java and JVM features since JDK 8 to 14
  3569. Catch up on the latest .NET Productivity features | .NET Blog
  3570. `zig cc`: a Powerful Drop-In Replacement for GCC/Clang
  3571. c# Snake in the browser
  3572. Stark - Native Compiler - Prototype 2019
  3573. Introduction to Functional Programming in F# - Part 9 — Softwarepark
  3574. The Reason for Types in JavaScript - CoRecursive Podcast
  3575. DirectX Developer Day Schedule | DirectX Developer Blog
  3576. Announcing DirectX Developer Day | DirectX Developer Blog
  3577. Episode 47: Hacking .NET with Michal Strehovský
  3578. A Digression on Divergence
  3579. Avoid In-Memory Databases for Tests
  3580. Avoiding cache line overlap by replacing one 256-bit store with two 128-bit stores
  3581. Generate Native Executable from .NET Core 3.1 Project
  3582. Async ValueTask Pooling in .NET 5 | .NET Blog
  3583. Fireiron: A Scheduling Language for High-Performance Linear Algebra on GPUs
  3584. [TUHS] The most surprising Unix programs
  3585. Performance Engineering Blog
  3586. C# 8 asynchronous streams - Red Hat Developer
  3587. Some more C# 8 - Red Hat Developer
  3588. My exploration of Rust and .NET
  3589. Making Your Code Faster by Taming Branches
  3590. How I Start: Nix
  3591. Miguel de Icaza
  3592. DuckDuckGo is good enough for regular use | www.bitlog.com
  3593. The Odyssey of Stark and Melody
  3594. Stark - Language And Frontend Compiler - Prototype 2019
  3595. C# 8 nullable reference types - Red Hat Developer
  3596. Scoping in JavaScript: The Basics
  3597. How to write a Roslyn Analyzer | .NET Blog
  3598. Improving list sum function based on head and tail with C# 8
  3599. Class definitions in TypeScript
  3600. C# 8 default interface methods - Red Hat Developer
  3601. C# and .NET Book | Covers C# 6, C# 7, .NET Framework and .NET Core
  3602. Rust Ownership Rules
  3603. When Bloom filters don't bloom
  3604. Clojure: the Lisp that wants to spread
  3605. runtime: non-cooperative goroutine preemption · Issue #24543 · golang/go
  3606. A half-hour to learn Rust
  3607. Switching back to the UI thread in WPF/UWP, in modern C#
  3608. Hundred year mistakes
  3609. Learning Blazor Components: The Definitive Guide
  3610. Working with IWebHostEnvironment and IHostingEnvironment in dual targeted ASP.NET Core Projects
  3611. React Context with TypeScript: Part 2 - Complex context with function components
  3612. Just In Time Hooking #
  3613. Securing Firefox with WebAssembly – Mozilla Hacks - the Web developer blog
  3614. Announcing TypeScript 3.8 | TypeScript
  3615. EA and Visual Studio’s Linux Support | C++ Team Blog
  3616. SharpLab
  3617. C# 8 asynchronous streams - Red Hat Developer
  3618. TypeScript 3.8 Adds Private Fields and Top-Level Await
  3619. dotnet/runtime
  3620. dotnet/runtime
  3621. VSTS build failed with nuget buildwebcompiler · Issue #354 · madskristensen/WebCompiler
  3622. William J. Bowman, Ph.D. | Home
  3623. Part 1 - Introduction and Setting up the REPL
  3624. Learning Rust With Entirely Too Many Linked Lists
  3625. Debugging Wednesday — Cancel this task!
  3626. ASP.NET Core middleware with Roslyn Analyzers - Part 1
  3627. Compiler Explorer - C (x86-64 clang 9.0.0)
  3628. Fixing Random, part 22
  3629. Compiler Explorer - C (x86-64 clang 9.0.0)
  3630. Fixing Random, part 19
  3631. NVIDIA/cutlass
  3632. Home
  3633. Document EF Core architecture and internal technical details · Issue #1920 · dotnet/EntityFramework.Docs
  3634. Fixing Random, part 20
  3635. Security Scanning Your .NET Core Applications
  3636. Removed Method Group conversions, more additions to equality. by Mrnikbobjeff · Pull Request #1030 · xamarin/Essentials
  3637. Decompile .NET code while debugging - Visual Studio
  3638. Code review red flag: Where is the missing code?
  3639. joshfree - Overview
  3640. Does register selection matter to performance on x86 CPUs?
  3641. PeachPie | PHP compiler to .NET
  3642. Type-Driven Development with Idris
  3643. From DotNet Run to Hello World - .NET Oxford - January 2020
  3644. Jakub Míšek - Compiling and Running a PHP on .NET Core - Dotnetos Conference 2019
  3645. Hello World - Introduction to C# interactive C# tutorial
  3646. Announcing speakers for 2020 : C++ On Sea
  3647. Working with expression trees in C# | Alexey Golub
  3648. Working with expression trees in C# | Alexey Golub
  3649. dotnet/runtime
  3650. Evil Eval() Vol. 2 @ PeachPie | PHP compiler to .NET
  3651. dotnet/runtime
  3652. Cake - Home
  3653. Research based on the .NET Runtime
  3654. maharmstone/quibble
  3655. Performance traps of ref locals and ref returns in C# | Premier Developer
  3656. extern alias - C# Reference
  3657. marcpaq/b1fipl
  3658. Building C# 8.0 | .NET Blog
  3659. Designing a build system for .NET solutions with Cake - 2: The Cake build tool and convention-based builds
  3660. 5 things to be aware of with F# anonymous records | Compositional IT
  3661. Getting Started with Asynchronous Programming in .NET
  3662. Train ML models on large images and 3D volumes with spatial partitioning on Cloud TPUs | Google Cloud Blog
  3663. William J. Bowman, Ph.D. | Home
  3664. Cake - Home
  3665. Software optimization resources. C++ and assembly. Windows, Linux, BSD, Mac OS X
  3666. tock/tock
  3667. Cliff Click's answer to What interesting optimizations can a JIT do that a compiler cannot do? - Quora
  3668. Get CoreRT Hello World selfcontained binary under 1 MB by MichalStrehovsky · Pull Request #7962 · dotnet/corert
  3669. Fast, parallel applications with WebAssembly SIMD · V8
  3670. MoonScript, a language that compiles to Lua
  3671. Train ML models on large images and 3D volumes with spatial partitioning on Cloud TPUs | Google Cloud Blog
  3672. Ryujinx - Nintendo Switch Emulator
  3673. KnightOS was an interesting operating system
  3674. The Throw Keyword was a Mistake
  3675. Autofac 5.0 Released
  3676. libreoffice/core - main, development code repository
  3677. dotnet/runtime
  3678. The frustrating state of tails calls in .NET · Issue #2191 · dotnet/runtime
  3679. .NET coding convention settings For EditorConfig - Visual Studio
  3680. Tools for Exploring .NET Internals
  3681. Showtime | BenchmarkDotNet
  3682. .NET everywhere apparently also means Windows 3.11 and DOS - Scott Hanselman
  3683. Getting Dependencies by Name or Key using the .NET Core Container (Part 2) - Steve Talks Code
  3684. NYAN Conference
  3685. Add Mono to the repository by akoeplinger · Pull Request #1912 · dotnet/runtime
  3686. Analyzing a nullability example · Curiosity is bliss
  3687. VS 16.5 Tooling Performance · Issue #8255 · dotnet/fsharp
  3688. C# 8.0: Understanding Using Declarations - Steve Gordon
  3689. Optimistic allocation of objects on the stack · Issue #1661 · dotnet/runtime
  3690. Containerized builds for Rust on the ESP32 - DEV Community 👩‍💻👨‍💻
  3691. Basic Instruction Scheduling (and Software Pipelining)
  3692. Optimizing string.Count all the way from LINQ to hardware accelerated vectorized instructions
  3693. GrantRi's WebLog [MS] : The problem with being second
  3694. Chris Brumme
  3695. Tracing .NET Core applications - Red Hat Developer
  3696. Cheap USB Host Microcontroller [CH559, ESP32, HID]
  3697. pornin/curve9767
  3698. Building a self-contained game in C# under 8 kilobytes
  3699. Build your own WebAssembly Compiler
  3700. “Stack Walking” in the .NET Runtime
  3701. Building a new Win 3.1 app in 2019 Part 1: Slack client
  3702. Suppress emitting of localsinit flag. · Issue #1738 · dotnet/csharplang
  3703. Initial implementation of two field span. · dotnet/coreclr@0bedde3
  3704. .NET documentation what's new?
  3705. Clr Heap Allocation Analyzer - Visual Studio Marketplace
  3706. apple/llvm-project
  3707. What interesting optimizations can a JIT do that a compiler cannot do? - Quora
  3708. dotnet/runtime
  3709. Creating Common Intermediate Language projects with .NET SDK | StrathWeb. A free flowing web tech monologue.
  3710. dotnet/runtime
  3711. William J. Bowman, Ph.D. | Home
  3712. ConfigureAwait FAQ | .NET Blog
  3713. Debugging 3rd Party .NET Code without symbols in Visual Studio - Michael's Coding Spot
  3714. C# Digest #287 for December 02, 2019 | Weekly C# Newsletter
  3715. To Null, or not to Null?!?
  3716. Compiler Explorer - C++ (x86-64 clang 7.0.0)
  3717. Compiler Explorer - C++ (x86-64 clang 9.0.0)
  3718. Library Changes: Removing jQuery by NickCraver · Pull Request #442 · MiniProfiler/dotnet
  3719. Embracing nullable reference types | .NET Blog
  3720. plasma-umass/coz
  3721. .NET Framework Internals: How the CLR Creates Runtime Objects
  3722. r/dotnet - Microsoft (devs, pm-s etc): thank you all for Net Core 3 and Xamarin!
  3723. .NET Talks at MFF UK in Prague [EN]
  3724. New release – PeachPie Sdk 0.9.600 @ PeachPie | PHP compiler to .NET
  3725. Use C# 8 In Any .NET Project Today
  3726. Hacking CoreCLR on Linux with CLion
  3727. Using Rust in Windows - Microsoft Security Response Center
  3728. How Swift Achieved Dynamic Linking Where Rust Couldn't
  3729. Facebook Libra is Architecturally Unsound
  3730. Compiler support for @oneventname:preventDefault and @oneventname:stopPropagation · Issue #14517 · dotnet/aspnetcore
  3731. Research based on the .NET Runtime
  3732. A First Look at Java Inline Classes
  3733. 63 Cores Blocked by Seven Instructions
  3734. Stack Overflow
  3735. Karel Zikmund - Events
  3736. Add 64 bits support to Array underlying storage · Issue #12221 · dotnet/runtime
  3737. The Aggregate Magic Algorithms
  3738. Terra
  3739. Static constructor broken (not always executed) · Issue #13036 · dotnet/runtime
  3740. AWS’ sponsorship of the Rust project | Amazon Web Services
  3741. danielmarbach/Async.Netcore
  3742. Anonymous classes and generics limit in .NET/C#? | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
  3743. PeachPie | PHP compiler to .NET
  3744. What’s the maximum number of generic parameters for a class in .NET/C#? | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
  3745. Oldpug/Bfi
  3746. dotnet/coreclr
  3747. What is the difference between ToArray and ToList?
  3748. “Stubs” in the .NET Runtime
  3749. CLR Method Internals (.NET 2.0)
  3750. The Future of C++/CLI and .NET Core 3 | C++ Team Blog
  3751. dotnet/docs
  3752. Announcing F# 4.7 | .NET Blog
  3753. This is how you get rid of null reference exceptions forever
  3754. Demystifying Tail Call Optimization - DEV Community 👩‍💻👨‍💻
  3755. Throwing null literal | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
  3756. GitHub
  3757. Introduction to Functional Programming in F# — Softwarepark
  3758. Introduction to Compilers and Language Design
  3759. Compilers
  3760. CSEP501: Compiler Construction
  3761. ChocoPy: A Programming Language for Compilers Courses
  3762. Idea: Extension/derivation of sealed classes · Issue #13345 · dotnet/runtime
  3763. How to add an optimization for C# to RyuJIT
  3764. Home
  3765. Compiler Explorer - CUDA (NVCC 10.1 Update 1)
  3766. LLBLGen Pro | Blog: 16 years of LLBLGen Pro!
  3767. Availability of nullable attributes outside of Core 3.0 · Issue #30493 · dotnet/runtime
  3768. Navigating the .NET Ecosystem
  3769. Utf8String design proposal · Issue #2350 · dotnet/corefxlab
  3770. Split the big jit files to allow better GitHub experience. · Issue #13359 · dotnet/runtime
  3771. Static TypeScript: An Implementation of a Static Compiler for the TypeScript Language - Microsoft Research
  3772. Static analysis for .NET 5 · Issue #30740 · dotnet/runtime
  3773. The Baseline Interpreter: a faster JS interpreter in Firefox 70 – Mozilla Hacks - the Web developer blog
  3774. Improving performance of GraalVM native images with profile-guided optimizations
  3775. Age of JIT Compilation. Part 1. Genesis
  3776. Simon Peyton Jones how GHC type inference engine actually works
  3777. Prefer ValueTask to Task, always; and don't await twice
  3778. Visual Studio Tips and Tricks: Increasing your Productivity for .NET | .NET Blog
  3779. What's new in C# 8.0 - C# Guide
  3780. Introduction to Svelte
  3781. Tailcall optimization doesn't work with netcoreapp3.0 runtime · Issue #13255 · dotnet/runtime
  3782. areller/RediSharp
  3783. .NET Analyzers
  3784. Fuzzing the .NET JIT Compiler
  3785. Tiered compilation for Mono runtime · Issue #16018 · mono/mono
  3786. Geting 4x Speedup With .NET Core 3.0 SIMD Intrinsics
  3787. Huawei announces HarmonyOS, an open-source platform for every device
  3788. New features in 0.9.45 @ PeachPie | PHP compiler to .NET
  3789. Stack Overflow handling in HotSpot JVM
  3790. Try out Nullable Reference Types | .NET Blog
  3791. dotnet/csharplang
  3792. Here’s what’s in the brand-new Unity 2019.2 - Unity Technologies Blog
  3793. Fixing Random, part 40 of 40
  3794. Fix issue with out-of-scope GCFrame in Frame list by janvorli · Pull Request #25795 · dotnet/coreclr
  3795. Advanced .NET Debugging - PDBs and Symbol Stores
  3796. Request: a solution that allows us to not have to write 6500 different delegates & overloads · Issue #2668 · dotnet/csharplang
  3797. .NEXT 2.x | .NEXT
  3798. dotnet/coreclr
  3799. Clarke's Third Law Exception - Step by Step
  3800. VB Casing behavior difference between VS 2013 and Roslyn · Issue #2909 · dotnet/roslyn
  3801. Benchmarks are hard · jbd.dev
  3802. PooledAwait
  3803. dotnet/docs
  3804. mgravell/PooledAwait
  3805. C#: [Obsolete] on an extension method? Also remove ‘this’
  3806. gokrazy - a pure-Go userland for your Raspberry Pi 3 appliances
  3807. .NET Core Example - With simple Kestrel WebHost | C# Online Compiler | .NET Fiddle
  3808. Lowering in C#: What's really going on in your code? - David Wengier
  3809. google/robotstxt
  3810. Peephole optimizations in C++ and C# | Egor Bogatov — Developer at Microsoft
  3811. Yes silver bullet
  3812. Build fails if Java Runtime (not SDK) is installed · Issue #11731 · dotnet/aspnetcore
  3813. Versioning limitations in .NET
  3814. What’s new for the .NET Native Compiler and Runtime in Visual Studio 2015 Update 2 | .NET Blog
  3815. terrajobst/minsk
  3816. #124 Mads Torgersen, C# 8 | no dogma podcast
  3817. What does debugging a program look like? - Julia Evans
  3818. Avoiding instruction cache misses
  3819. dotnet/roslyn
  3820. What’s up with my branch on GPU?
  3821. dotnet/coreclr
  3822. dotnet/diagnostics
  3823. Announcing .NET Core 3.0 Preview 6 | .NET Blog
  3824. An Experimental Floating-Point Scalar Evolution :: Duskborn — Duskborn Labs is where Neil ‘@sheredom‘ Henning writes up things of interest.
  3825. directive_attributes.md
  3826. Building a C# Interactive shell in a browser with Blazor (WebAssembly) and Roslyn | StrathWeb. A free flowing web tech monologue.
  3827. Tiered Compilation Preview in .NET Core 2.1 | .NET Blog
  3828. jeanqasaur/dsl-syllabus-fall-2016
  3829. C# reference
  3830. Tiered Jit Benchmarking · Issue #1125 · dotnet/BenchmarkDotNet
  3831. ltrzesniewski/LocalsInit.Fody
  3832. Candidate Features For C# 9
  3833. Expose top-level nullability information from reflection · Issue #29723 · dotnet/runtime
  3834. Rust: A Language for the Next 40 Years - Carol Nichols
  3835. PHP on .NET Core 3.0 @ PeachPie | PHP compiler to .NET
  3836. Christmas Compiler Speed-Up, part 2
  3837. dotnet/llilc
  3838. Top 10 Things You Can Do With GraalVM
  3839. The F# development home on GitHub is now dotnet/fsharp | .NET Blog
  3840. typeof(TSecret) - the secret magic behind .NET generics
  3841. Markdown + .NET = Interactive docs?
  3842. T1
  3843. Create Interactive .NET Documentation with Try .NET | .NET Blog
  3844. A few words about data and concurrency
  3845. The unknown Type in TypeScript
  3846. SharpFuzz: Bringing the power of afl-fuzz to .NET platform
  3847. Performance Improvements in .NET Core 3.0 | .NET Blog
  3848. Overview of nullability analysis · Curiosity is bliss
  3849. Use pattern matching features to extend data types
  3850. Decoupling Algorithms from the Organization of Computation for High-Performance Graphics & Imaging
  3851. Announcing .NET Core 3.0 Preview 5 | .NET Blog
  3852. Introducing .NET 5 | .NET Blog
  3853. Compile time marshalling | devops.lol
  3854. Fight the global warming: compile your C# apps ahead of time
  3855. terrajobst/minsk
  3856. dotnet/corert
  3857. Get Some Sass Into Your Blazor App
  3858. 2019 EuroLLVM Developers’ Meeting: Mehdi & Vasilache & Zinenko “Building a Compiler with MLIR”
  3859. CppCon 2017: Teresa Johnson “ThinLTO: Scalable and Incremental Link-Time Optimization”
  3860. Add ZIO & Scalaz to community builds · Issue #896 · scala/community-build
  3861. gpakosz/PPK_ASSERT
  3862. Compute Shader - OpenGL Wiki
  3863. The LLVM Compiler Infrastructure Project
  3864. 2019 EuroLLVM Developers’ Meeting: T. Shpeisman & C. Lattner “MLIR: Multi-Level Intermediate Repr..”
  3865. Expose a BigInteger.Builder to help avoid so many copies/allocations · Issue #29378 · dotnet/runtime
  3866. ASCII Art in .NET Code
  3867. Visual Studio 2019 version 16.1 Preview 2 | Visual Studio Blog
  3868. Twisted Oak
  3869. Dev Tip #158: Strongly Typed IDs
  3870. Rust's 2019 roadmap | Rust Blog
  3871. ericsink/wasm2cil
  3872. Running WebAssembly and WASI with .NET
  3873. April Update for WPF on .NET Core 3.0 · Issue #607 · dotnet/wpf
  3874. ispc/ispc
  3875. jmcgrew / zilf / wiki / Home — Bitbucket
  3876. Presentations and Talks covering ‘.NET Internals’
  3877. fsharp/fslang-design
  3878. davidsh - Overview
  3879. Reactive approach to FSAC design - discussion · Issue #1 · Krzysztof-Cieslak/notes
  3880. Non Obvious PE Parsers – the .NET runtime – Part 1
  3881. Performance analysis and tuning contest #2. | Easyperf
  3882. Unintended interactions of SerializationGuard and other features · Issue #29212 · dotnet/runtime
  3883. Lies, darn lies and sampling bias
  3884. Functional Scala: Next Level by John A. De Goes (LambdaConf Edition)
  3885. Using, using, using with C# 8
  3886. C#88: The Original C#
  3887. fsharp/fslang-design
  3888. dotnet/corefx
  3889. string vs. String is not a style debate
  3890. A balancing act
  3891. Compiler Explorer
  3892. MSVC hidden flags
  3893. .NET API browser
  3894. /diagnostics (Compiler diagnostic options)
  3895. ITHare/obf
  3896. Building Components Manually via RenderTreeBuilder
  3897. Compiler Explorer - C++ (x86-64 clang 8.0.0)
  3898. BenchmarkDotNet v0.11.5 | BenchmarkDotNet
  3899. Is making a struct readonly a breaking change?
  3900. Rename Razor Components back to server-side Blazor · Issue #8931 · dotnet/aspnetcore
  3901. Announcing Lucet: Fastly's native WebAssembly compiler and runtime
  3902. Proposal: Dependency Injection / Service Locator as a Language Feature · Issue #1690 · dotnet/csharplang
  3903. cloudflare/boringtun
  3904. Behind the burst compiler | xoofx
  3905. Machine code layout optimizations. | Easyperf
  3906. Ionide — A New Hope
  3907. How to Debug Rust with Visual Studio Code
  3908. materialx/MaterialX
  3909. GameTechDev/GTS-GamesTaskScheduler
  3910. [Question] CoreRT future plans · Issue #7200 · dotnet/corert
  3911. microsoft/perfview
  3912. Intel OSPRay
  3913. Non-idiomatic F#
  3914. Explaining Code using ASCII Art – Embedded in Academia
  3915. When pigs fly: optimising bytecode interpreters
  3916. GameTechDev/IntelShaderAnalyzer
  3917. Writing A Compiler In Go | Thorsten Ball
  3918. Writing An Interpreter In Go | Thorsten Ball
  3919. Core support for object pooling · Issue #12296 · dotnet/runtime
  3920. Port AMSI scanning for assembly loads by elinor-fung · Pull Request #23231 · dotnet/coreclr
  3921. Megacity | Unity
  3922. Fixes to support scala 2.11 by ahoy-jon · Pull Request #650 · zio/zio
  3923. Go 1.12 Release Notes - The Go Programming Language
  3924. zeux/meshoptimizer
  3925. Open Source .NET – 4 years later
  3926. Floating-Point Reference Sheet for Intel® Architecture
  3927. Perf regression for Math.Min and Math.Max · Issue #12159 · dotnet/runtime
  3928. Open source is only ajar without inclusion – Internet Citizen
  3929. pwaller/go2ll-talk
  3930. Async Enumerables with Cancellation · Curiosity is bliss
  3931. Tic Toc Games - A Unity Developer Case Study
  3932. Cats instances taking the environmental parameter by gvolpe · Pull Request #593 · zio/zio
  3933. Floating-Point Parsing and Formatting improvements in .NET Core 3.0 | .NET Blog
  3934. Hardware intrinsic in .NET Core 3.0 - Introduction
  3935. Inline IL ASM in C# with Roslyn | xoofx
  3936. CensoredUsername/dynasm-rs
  3937. Is C# a low-level language?
  3938. Paper: Hyperscan: A Fast Multi-pattern Regex Matcher for Modern CPUs
  3939. Building C# 8.0 | .NET Blog
  3940. dotnet/docs
  3941. Announcing TypeScript 3.1 | TypeScript
  3942. Strict bind, call, and apply methods on functions by ahejlsberg · Pull Request #27028 · microsoft/TypeScript
  3943. Combining iterator blocks and async methods in C# | Premier Developer
  3944. Compiler Explorer
  3945. MuniHac 2018: Keynote: A low-latency garbage collector for GHC
  3946. Emscripten’s embind  |  Web  |  Google Developers
  3947. Background compilation · V8
  3948. Compiler Explorer
  3949. hundredrabbits/Orca-c
  3950. The current state of my compiler project | sergio
  3951. serge-rgb/compiler
  3952. microsoft/microsoft-pdb
  3953. Game Designer+Artist or Game Designer+Programmer
  3954. LLVM on Windows now supports PDB Debug Info
  3955. Machine Learning to Detect Software Vulnerabilities - Schneier on Security
  3956. How to get clang++ to find link.exe
  3957. llvm-mirror/clang
  3958. Lambda Days 2018 - Heather Miller - We're Building On Hollowed Foundations (...)
  3959. Compiler Explorer - C++
  3960. Project Tiny Preview Package is here! - Unity Technologies Blog
  3961. Unity Careers
  3962. Unite Los Angeles 2018 - Day 2 Livestream
  3963. Haxe Roundup № 468
  3964. Go 1.12 Release Notes - The Go Programming Language
  3965. The Go Programming Language Blog
  3966. google/randen
  3967. djbsort: Changes
  3968. djbsort: Intro
  3969. Introducing HacSpec
  3970. NASM Manual
  3971. Tech Note: Shader Snippets for Efficient 2D Dithering | Oculus
  3972. pervognsen/bitwise
  3973. compiletime.md
  3974. clion.md
  3975. research!rsc: Using Uninitialized Memory for Fun and Profit
  3976. asan_clang_cl.md
  3977. Compiler Explorer
  3978. Undefined Behavior Is Really Undefined
  3979. A whirlwind introduction to dataflow graphs
  3980. Modern garbage collection
  3981. Whats next after Burst
  3982. C++, C# and Unity
  3983. C++ Modules Might Be Dead-on-Arrival
  3984. The 7 Best Robotic Arm Kits Under $100
  3985. google/schism
  3986. What I Learned Making My Own JIT Language
  3987. The story of ispc: origins (part 1)
  3988. » TADS The Digital Antiquarian
  3989. RemedyBG by remedybg
  3990. On DOTS: C++ & C# - Unity Technologies Blog
  3991. dotnet/coreclr
  3992. lemire/simdjson
  3993. Tuning a Runtime for Both Productivity and Performance
  3994. [C#] Have some fun with .net core startup hooks
  3995. RyanLamansky/dotnet-webassembly
  3996. Do more with patterns in C# 8.0 | .NET Blog
  3997. Take C# 8.0 for a spin | .NET Blog
  3998. Microsoft's Orleans Distributed App Framework Is Now Cross Platform - The New Stack
  3999. Containing Null with C# 8 Nullable References
  4000. Learning about .NET Core futures by poking around at David Fowler's GitHub - Scott Hanselman
  4001. Discards - C# Guide
  4002. WP.NET | WordPress on .NET Core – WordPress running on .NET Core
  4003. PeachPie.io - The PHP compiler & runtime under NET Core | Product Hunt