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