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'
5 Years of Compiler Jobs — Matthew Gaudet
Go's Weird Little Iterators · mcyoung
How I Made My SIMD Code 1700x Faster Without Writing Any Intrinsics
Building blogmate.io: Recursive Phoenix Components
Wiki - SurveyOfSystemLanguages2024
Let's CRUNCH! | More magic
Go Protobuf: The new Opaque API - The Go Programming Language
Fast, Constrained Optimization in the Browser with SCIP
Fast LLM Inference From Scratch
Your First day on the team = releasing Your first feature
All Your Codebase
Zero to CMake | Fred's Blog
Common Misconceptions about Compilers
Using the YamlDotNet source generator for Native AOT
Tree Calculus
Memory-safe PNG decoders now vastly outperform C PNG libraries
Ways to use torch.compile : ezyang’s blog
Defining All Undefined Behavior and Leveraging Compiler Transformation APIs
Having fun with ValueTuple
runtime/docs/design/specs/runtime-async.md at main · dotnet/runtime
Making Computer Faster: a Deep Dive into Dynamic Dispatch (part 1)
You can use C-Reduce for any language
You have built an Erlang
Apache NuttX and small systems - Hello, World !
Functional programming self-affirmations
Static, Dynamic, Mergeable, oh, my!
Unsafe for work
What I wished I knew when learning C
Dear friend, you have built a Kubernetes
Mirror: An LLM-powered programming-by-example programming language
Learning LLVM (Part-1) - Writing a simple LLVM pass
Keeping it small: helping the compiler to remove unused code in OCaml
An Unreachable Hidden XKCD Easter Egg inside CPython
On "Safe" C++
How to Build a Chess Engine and Fail
Context aware compilation - Gleam
n times faster than C, Arm edition · Luna’s Blog
The only computer science book worth reading twice?
Stop Making Me Memorize The Borrow Checker
‘Reflections on Trusting Trust’, but completely by accident this time
Calling methods is easier and faster with C# 13 params collections - .NET Blog
Zig Reproduced Without Binaries - Motiejus Jakštys Public Record
What's new in F# 9 - F# Guide - .NET
Top 5 Language Features in C# 12 - Coding Sonata
MVVM Toolkit v8.4: Custom Access Modifiers for Partial Properties – How To
How dotnet.exe resolves and loads the hostfxr library - Exploring the .NET muxer - Steve Gordon - Code with Steve
Where web components shine
Notes from the Carbon panel session at EuroLLVM 2024
Clean Architecture: The Missing Chapter
Verifying code against architecture with Metalama
Jia Tanning Go code
Golang developers should try Odin
What’s New in POSIX 2024 – XCU
GitHub - aartaka/pretty.c: Making C Look ✨Pretty✨and Lua/Lisp/Python-esque
GPGPU Compute Concepts
Self-documenting Code
Zig is everything I want C to be
Free Productive C# Webinar - Meta-Programming in C# with Metalama (October 23)
svelte
2 JVM problems Clojure has to handle
Good tools are worth paying for • Dylan Fitzgerald
Announcing Rust 1.82.0 | Rust Blog
When should I use String vs &str?
how-i-think-of-the-expression-problem - Chad Nauseam Home
Every bug/quirk of the Windows resource compiler (rc.exe), probably
Let's run some NFAs — 0xd34df00d.me
C# 6.0 Overview
C# Nullable reference types – No more null reference exceptions!
My negative views on Rust
Engineering the Scalable Vector Extension in .NET - .NET Blog
Revisiting the DOS memory models
.NET 9 Performance Improvements Summary
Avoiding Repetitive Code With Metalama
What’s New In Python 3.13
6 years with Gleam
SYCL: A Portable Alternative to CUDA - Sasank's Blog
Critical Social Infrastructure for Zig Communities
An Introduction to Filament
Pledging $300,000 to the Zig Software Foundation
Migrating from AWS to Self-Hosting ⚡ Zig Programming Language
C Until It Is No Longer C
Tour of Hell
On leaving my last job
How DWARF Works: Table of Contents and Introduction
Rewriting Rust
Whence ' '? – Casey Rodarmor's Blog
Tune Llama3 405B on AMD MI300x (our journey) - Felafax Blog - Obsidian Publish
Optimizing Guile Scheme — dthompson
What cpu context switch and cache pollution are and how do they impact performance
Ratchets in software development
Announcing Swift 6
Vector math library codegen in Debug · Aras' website
Safe C++
Porting SBCL to the Nintendo Switch
Arrays of Wisdom of the Ancients
Performance Improvements in .NET 9 - .NET Blog
The First HTML LSP That Reports Syntax Errors
What’s in an e-graph?
An ideology-induced bug in Mypy
Why I Prefer Exceptions to Error Values
Just for Fun. No, Really.
What is the best pointer tagging method?
Why is F# code so robust and reliable? - .NET Blog
LINQ Joins on multiple columns in Entity Framework
Clojure - Clojure 1.12.0
Debugging a memory leak in a Clojure service
Async Rust can be a pleasure to work with (without `Send + Sync + 'static`)
The Fundamental Law Of Software Dependencies
gRPC: 5 Years Later, Is It Still Worth It?
Behavior Sanitizers in Elixir
On the strange status of wchar_t in classic MIDL - The Old New Thing
Understanding Angular AOT vs. JIT Compilations
All Aboard the Bootstrap Transpiler Express
live-bootstrap/parts.rst at master · fosslinux/live-bootstrap
Why am I writing a Rust compiler in C?
Fluid Simulation and Web Assembly
GitHub - dpjudas/SurrealEngine: Unreal Tournament Engine Reimplementation
State of Generics and Collections
PyTorch is dead. Long live JAX.
Instead of putting a hash in the Portable Executable timestamp field, why not create a separate field for the hash? - The Old New Thing
Keeping Production Observable with rising costs
STD Doesn't Have to Abstract OS IO
An introduction to auto-vectorization with LLVM
You should make a new programming language
You should make a new programming language
Building static binaries in Nix — kokada
Quote-unquote "macros"
async2 - The .NET Runtime Async experiment concludes
csharplang/proposals/TypeUnions.md at 18a527bcc1f0bdaf542d8b9a189c50068615b439 · dotnet/csharplang
First impressions of Gleam: lots of joys and some rough edges
Tony Hawk's Pro Strcpy
Debugging a rustc segfault on illumos :: sunshowers
The difference between undefined behavior and ill-formed C++ programs - The Old New Thing
Adding Serilog to ASP.NET Core: a practical guide
Porting Lean to the ESP32-C3 RISC-V microcontroller
cppfront: Midsummer update
How to compress out interior padding in a std::pair and why you don't want to - The Old New Thing
Avalonia 11.1: A Quantum Leap in Cross-Platform UI Development
Bril: An Intermediate Language for Teaching Compilers
Evolving Languages Faster with Type Tailoring
strlcpy and how CPUs can defy common sense
In my Visual Studio project, I set my Conformance mode to permissive, but it's still not permissive - The Old New Thing
Mapping symbols: rethinking for efficiency
How conditional breakpoints work 🐢
The state machine in C# with async/await
Migrating .NET APIs with Obsolete Attribute
An interactive guide to x86-64 assembly - moving data
My first program ever coded
Rockin’ the Code World Season 4: Wisdom from the Trenches: Navigating Career Longevity in Software Engineering
Pin
Adding Serilog to ASP.NET Core: a practical guide
How To Fix .NET Nullability Warnings For Guarded Members
Free .NET 8 Web API Live Stream's
Fastest C# Enum to String - NDepend Blog
SCALE documentation
How not to benchmark!
The missing parts in Cargo
Beating the compiler
ASP.NET Core Basics: 12 Questions and Answers for Beginners
Introducing wlhc: wayland hot corners
neotraverse: unbloating traverse | Puru Vijay
dut
Creating an already-completed asynchronous activity in C++/WinRT, part 2 - The Old New Thing
C# 13: Explore the latest preview features - .NET Blog
Always Optimize the Feedback Loop
(modal)
Scan HTML faster with SIMD instructions: .NET/C# Edition – Daniel Lemire's blog
I Have No Constructor, and I Must Initialize
The Snapdragon X Elite’s Adreno iGPU
Beating NumPy’s matrix multiplication in 150 lines of C code
How do I produce a Windows Runtime asynchronous activity from C#? - The Old New Thing
A Type for Overload Set
GitHub - vslavik/diff-pdf: A simple tool for visually comparing two PDF files
How to output a SARIF file from a .NET project - Gérald Barré
Writing GUI apps for Windows is painful | Samuel Tulach
The Great Database Migration
Industrial macros
Skip and Kotlin Multiplatform
Why Google Sheets ported its calculation worker from JavaScript to WasmGC | web.dev
Writing a remove_all_pointers type trait, part 1 - The Old New Thing
What's New in React 19
You probably wrote half a monad by accident
Profiling with Ctrl-C
Extension methods make code harder to read, actually
Exploring How Cache Memory Really Works
Learning Machine Learning in Elixir | zacksiri.dev
Announcing TypeScript 5.5 - TypeScript
Announcing the Pre-Scheme Restoration — Pre-Scheme
How to convert between different types of counted-string string types - The Old New Thing
The postmodern build system
On the sadness of treating counted strings as null-terminated strings - The Old New Thing
Code Style for Better Productivity - Tips and Tools from the Metalama Team | The .NET Tools Blog
Static arrays are the best vectors
Spending too much time optimizing for loops
My experience crafting an interpreter with Rust
TypeScript 5.5 Adds ECMAScript Set Support
Elixir v1.17 released: set-theoretic types in patterns, calendar durations, and Erlang/OTP 27 support
My very first production bug
BCC to libbpf conversion guide
Apple blocks PC emulator from being available in iOS App Store and third-party app stores - 9to5Mac
Announcing TypeScript 5.5 RC - TypeScript
The Rise of Groq: Slow, then Fast
0.13.0 Release Notes ⚡ The Zig Programming Language
What's the deal with std::type_identity? - The Old New Thing
Test-Driving HTML Templates
Speeding up rustc by being lazy
MSTest 3.4 is here with WinUI support and new analyzers! - .NET Blog
Vulkan 1.3 on the M1 in 1 month
A DSL for Implementing Math Functions
DuckDB isn't just fast
Fast and Compact Structured Logging in C# Using String Interpolation
Refactor your code using alias any type - .NET Blog
More on harmful overuse of std::move - The Old New Thing
A graphical depiction of the steps in building a C++ executable, basics - The Old New Thing
Icing or Cake? — dthompson
A graphical depiction of the steps in building a C++ executable, with XAML and packaging - The Old New Thing
Test-Driving HTML Templates
Compilers | Rasheed Starlet
Lessons learned on building an app from job seekers (in tech)
Zig's New CLI Progress Bar Explained
A graphical depiction of the steps in building a C++ executable, enhanced for classic Win32 - The Old New Thing
Weakly and strongly typed values in .NET
Middleware doesn't belong in the router
F# developer stories: how we've finally fixed a 9-year-old performance issue - .NET Blog
A graphical depiction of the steps in building a C++ executable, basics - The Old New Thing
Continuous delivery without a CI server
How to test a Roslyn analyzer - Gérald Barré
Evolution of the ELF object file format
Writing a Unix clone in about a month
The Space Quest II Master Disk Blunder
Creating a prepopulated Windows Runtime Vector from C++/WinRT without going through an explicit std::vector - The Old New Thing
Authenticode in 2024
If you have to create a Windows Runtime Vector from C++/WinRT, do it as late as possible - The Old New Thing
Unwind considered harmful? · baby steps
Test-Driving HTML Templates
vu128: Efficient variable-length integers
Quantifying the Impact of Styled Components on Server Response Times
Meta Releases Open Source React Compiler
How to Deal With NullReferenceException? Object reference not set to an instance of an object.
Fundamentals
Runtime code generation and execution in Go: Part 1
Dapper And Strongly Typed IDs – How To Dynamically Register Mappings
Compilers for free with weval
Using Source Generators to Validate IOptions in ASP.NET Core - Code Maze
Computers
on hoot, on boot — wingolog
Why can't I find the injected name of a templated class's templated base class? - The Old New Thing
XUnit–Improve type safety
The .NET Generic Math Library - NDepend Blog
Localizing a .NET console or desktop application
References are like jumps
Exploring the c4... compiler?
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
Setting up Doom Emacs for Astro Development
GitHub - Hirrolot/datatype99: Algebraic data types for C99
Refactor your code with C# collection expressions - .NET Blog
Awaiting a set of handles with a timeout, part 6: Capturing the handles efficiently - The Old New Thing
Pair Your Compilers At The ABI Café - Faultlore
Boosting Productivity with Analyzers
100x faster sorted array intersections
With PowerPC, Windows CE and the WiiN-PAD slate, everyone's a WiiN-er (except Data General)
GitHub - skeeto/hash-prospector: Automated integer hash function discovery
Making a 3D Modeler, in C, in a Week
On Programming Languages
Thoughts on Zig
Some more C# 12 | Red Hat Developer
Working with Rust Libraries from C# .NET Applications
GitHub - borgo-lang/borgo: Borgo is a statically typed language that compiles to Go.
Borgo Programming Language
Ruby's Complex Branching Options
TypeScript compiler trick
basysKom GmbH | How To Use Modern QML Tooling in Practice
What Computers Cannot Do: The Consequences of Turing-Completeness
No Web Without Women
Memory Management Every Programmer Should Know
Announcing TypeScript 5.5 Beta - TypeScript
Switch expression for void methods
[SOLVED]: node_modules/metro-hermes-compiler/src/emhermesc.js:77 throw ex; Error: EMFILE: too many open files
LogLog Games
Implementing a functionality with GitHub Copilot for Visual Studio
C# 13 Params Collections
Type pattern matching in C# and TypeScript
Ruby might be faster than you think
Thoughts on Primary Constructors in C#
How quickly can you break a long string into lines? – Daniel Lemire's blog
C isn’t a Hangover; Rust isn’t a Hangover Cure
C# 12: Collection expressions and primary constructors | Red Hat Developer
Does readonly make your code faster?
I Wrote My Own Editor
Adventures In Rust: Bringing Exchange Support To Thunderbird
The Real C++ Killers (Not You, Rust)
0.12.0 Release Notes ⚡ The Zig Programming Language
LLVM is Smarter Than Me
Invariance, Contravariance, and Covariance in C# Generics - Code Maze
Gleam version v1.1 – Gleam
How to build an in-memory Message Bus in TypeScript - Event-Driven.io
Fluent API to await multiple calls and get their respective results
Go performance from version 1.0 to 1.22
Implementing an SHA transformer by hand
GCC version 14 coming soon – and will drop Itanium support
Lennon McLean
Fractals in Pure Lambda Calculus
YETI programming language
The server chose violence - Cliffle
Discrete logic network card
Integer overflow vulnerabilities in .NET
Intel’s Ambitious Meteor Lake iGPU
Thoughts on the xz backdoor: an lzma-rs perspective | Blog | Guillaume Endignoux
smeso - MIPS stacktrace: an unexpected journey
How to use Comments to Prompt GitHub Copilot for Visual Studio - Visual Studio Blog
Overview of webpack, a JavaScript bundler | johnnyreilly
Equip 3rd party types with a deconstructor
Primary Constructor and Logging Don't Mix
pkgsrc on macOS: still works
IntelliJ IDEA 2024.1 Is Out! | The IntelliJ IDEA Blog
xz backdoor and autotools insanity
Self Modifying Code
The Video That Inspired Me To Create Odin
Measuring your system’s performance using software (Go edition) – Daniel Lemire's blog
Oneiblog
Toll-free Bridging in Kotlin Native - Alex DeLorenzo
Testing Your Native AOT Applications - .NET Blog
The Sweet Spot - Maximizing Llama Energy Efficiency · Jacques Mattheij
Lattice now compiles to .NET IL — John Austin
Top level internal is unnecessary
The ancient world before computers had stacks or heaps - The Old New Thing
Pattern matching and the compiler can be surprising
Type Inference Was a Mistake
Reverse Mode Differentiation is Kind of Like a Lens II
xorvoid
Porting the GCLC to the web
Why x86 Doesn’t Need to Die
Hello eBPF: Auto Layouting Structs (7) - Mostly nerdless
I'm A Developer Not A Compiler
Collection Expressions – Using C# 12 in Rider and ReSharper | The .NET Tools Blog
.NET Framework - March 2024 Cumulative Update Preview - .NET Blog
What Computers Cannot Do: The Consequences of Turing-Completeness
Write OpenAPI with TypeSpec
On the future of computer science
Notes on debugging HotSpot’s JIT compilation
Why isn't C++ using my default parameter to deduce a template type? - The Old New Thing
Code It Any Way You Want: Performance of Out Variable Declaration
C# 13: Allow ref and unsafe in iterators and async
Build time is a collective responsibility
Cranelift code generation comes to Rust
Zig defer Patterns
static vs dynamic types
How to use Comments as Prompts in GitHub Copilot for Visual Studio
Eio 1.0 Release: Introducing a new Effects-Based I/O Library for OCaml
🔬 Rustls: Continuous Benchmarking Case Study
GoblinTools - Neil Turner's Blog
Look ma, I wrote a new JIT compiler for PostgreSQL – Pinaraf's website
Compiling With Constraints
Core Guidelines are not Rules - Simplify C++!
GitHub - albertan017/LLM4Decompile: Reverse Engineering: Decompiling Binary Code with Large Language Models
A Scalable Framework for Folding-based SNARKs
The Return of the Frame Pointers
Zig, Rust, and other languages
Nix is a better Docker image builder than Docker's image builder - Xe Iaso
How well does WRL ComPtr support class template argument deduction (CTAD)? - The Old New Thing
NumPy vs BLAS: Losing 90% of Throughput
How well does ATL CComPtr support class template argument deduction (CTAD)? - The Old New Thing
csharplang/proposals/params-collections.md at main · dotnet/csharplang
10 years in Open Source
How well does MFC IPTR/CIP support class template argument deduction (CTAD)? - The Old New Thing
C# 12: Primary Constructors
Release Bebop v3.0.4 · betwixt-labs/bebop
How well does _com_ptr_t support class template argument deduction (CTAD)? - The Old New Thing
How to Automatically Cast Between Types in C#
C and C++ Prioritize Performance over Correctness
smeso - Memory ordering and atomic operations synchronization
Why is Everybody Talking about Groq?
A Primer On Randomness
RAII all the things?
How can I force a copy of a C++ value? - The Old New Thing
Zama's homomorphic encryption tech lands it $73M on a valuation of nearly $400M | TechCrunch
Optimizing Rabin-Karp Hashing · Pardon the Interrupt
Proverbs
Experimental C# Interceptors: AOT & Performance for free | .NET Conf 2023
GitHub - NilsIrl/dockerc: container image to single executable compiler
Autogenerating a Book Series From Three Years of iMessages
C# Language Features vs. Target Frameworks
Convert ANY Of Your C# Types Without Casting Using Implicit Operators
Let's not over-hype rust.
Typesafety in xUnit with TheoryData<T>
Optional parameters may appear in the middle of the parameter list - Gérald Barré
The Future That Never Was
Is shadowing a member variable from a base class a bad thing? Maybe, but maybe not. - The Old New Thing
Gleam version 1 – Gleam
Implicit Operators in C#: How To Simplify Type Conversions
CS 6120: The Self-Guided Course
C++/WinRT performance trap: Switching to Windows Runtime too soon - The Old New Thing
You’ve just inherited a legacy C++ codebase, now what?
Marc Kerbiquet's Website
Introduction To Low Latency Programming: Minimize Branching And Jumping
Does this 8088 code in the Leisure Suit Larry 2 game actually do anything?
EF Core - Cannot convert from 'string' to 'System.FormattableString'
Lock statement patterns
What if best practices were the norm?
.NET JsonElement Error Handling | endjin
Language Checklist
Things I Used to Care About
foojay – 12 Lessons Learned From Doing The 1BRC Challenge
Extracting data from a small CSV file with Haskell
Release Notes for February 15, 2024
Soft Skills in Software Engineering
Linting away manipulation of raw pointers with C++20
Blazor Basics: HTML Forms and Capturing User Data
Changing TypeScript library functions while keeping backwards compatibility
Keywords for Top 10 Languages
Conformant OpenGL 4.6 on the M1
Antithesis – autonomous testing
New Features in C# 12
AMD Zen 5 Compiler Support Posted For GCC - Confirms New AVX Features & More
What Is the Difference Between Properties and Fields in C# - Code Maze
Building the DirectX shader compiler better than Microsoft?
Why Bloat Is Still Software’s Biggest Vulnerability
Django, SQLite, and the Database is Locked Error
How to Get the Number of Files in a Folder With C# - Code Maze
A Splendid Scala Journey
Calling System Functions in a JIT
Comparing for and foreach Loops in C# - Code Maze
Building a HIP environment from scratch
Go 1.22 Release Notes - The Go Programming Language
Microsoft Migrates a Real-Time Service to .NET Core for Performance Gains
Security policies in open source software | Red Hat Developer
Finding New Mountains to Climb
How I learned Haskell in just 15 years
Statically and dynamically typed scripts
.NET R&D Digest (January, 2024)
Exploring the Code World: dotNetDave Inquires About Guests’ Hobbies and Pastimes – Part 1
F# tips weekly #4: Record types
A minimal, complete and correct ELF file
Probabilistic Programming in C# With Infer.NET - Code Maze
How is a binary executable organized? Let's explore it!
Why Test-Driven Development? (Part 2) - Simple Talk
Make Invalid States Unrepresentable
The undercover generalist
In the Debugger's Spotlight: A Year in Review - Visual Studio Blog
Relational Databases Aren't Paying Off In Payments
A Year of C++ Improvements in Visual Studio - Visual Studio Blog
The C Bounded Model Checker: Criminally Underused
Colored Functions Are Good, Actually
How to Properly Create Message Templates for Logging in C# - Code Maze
Error categories and category errors
Checking if a collection is empty in C# - Gérald Barré
F# 8: accessing properties without fuss
Arend van Beelen jr.
Woven Memories - Subroutines
My Impressions of Hare
Safe Manual Memory Management with Coeffects
Common Language Runtime (CLR) overview - .NET
S6E10 - The .NET Trilogy and Learning .NET with Mark J Price
GitHub - FractalFir/rustc_codegen_clr: This rust compiler backend emmits valid CIL (.NET IR), enabling you to use Rust in .NET projects
My experience working on rustc_codegen_clr
Microsoft Office's RTC (Real-Time Channel) migration to modern .NET - .NET Blog
Cake Build Tool Updated to .NET 8 in v4.0.0
SourceGear Rust - Visual Studio Marketplace
Blazor Basics: Component Parameters and State Management
How we made an animated movie in 8kB - Ctrl-Alt-Test
4 reasons to try Mozilla’s new Firefox Linux package for Ubuntu and Debian derivatives | The Mozilla Blog
Rockin’ the Code World Season 4: Special Guest Jared Parsons
A Range kata implementation in C#
Understanding how top-down operator precedence parsing works
C23: a slightly better C
GitHub - QuantGeekDev/lmaolang: 👏🏼A👏🏼brand👏🏼new👏🏼way👏🏼to👏🏼write👏🏼HTML👏🏼
Ben Carlsson / Effective English
lmaolang/README.md at main · QuantGeekDev/lmaolang
DIY: your own Dependency Injection library!
How to Escape Curly Brackets and Special Characters in C# - Code Maze
Should you, could you AOT?
How to Design an ISA
Why Optimize Code for Performance
Getting a strong reference from the this pointer too soon - The Old New Thing
Some Memories of Niklaus Wirth
Perfecting Protocol Parsing (Probably) with eBPF
The architecture behind Alma – An experimental playground for generative graphics
How to Escape the Backslash Character in C# - Code Maze
A Range kata implementation in F#
Going Native
Between Art and Algorithms
I'm A Developer Not A Compiler
.NET Continuous Profiler: Under the Hood
Jonas Hietala: Exploring the Gleam FFI
Memory Safe C Compiler
How to Distribute Roslyn Analyzers via NuGet
Const strings are not so const after all
What Does yield Do In C#: A Simplified View For Beginners
What's New in F# 8.0: Simpler, Enhanced Uniformity, and Improved Performance
Python 3.13 gets a JIT
How do I prevent my C++/WinRT implementation class from participating in COM aggregation? - The Old New Thing
Making primary constructor parameters read-only - Gérald Barré
Programming as Theory Building - Peter Naur
RIP: Software design pioneer Niklaus Wirth
AoE is written in Assembly - is this actually TRUE?! :O
scheme modules vs whole-program compilation: fight — wingolog
Common Setup and Teardown in dotnet tests without test framework magic
Is Objective-C <code>BOOL</code> a boolean type? It depends
Speed up your code: don't pass structs bigger than 16 bytes on AMD64
What We Got Right, What We Got Wrong
Coding Stories: Me vs. The VNC Guy
[Oberon] Niklaus Wirth 15.2.1934 - 1.1.2024
What I did in 2023
Maestro - Introduction
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
Building a self-contained game in C# under 2 kilobytes
This year in LLVM (2023)
How do I prevent my ATL class from participating in COM aggregation? DECLARE_NOT_AGGREGATABLE didn't work - The Old New Thing
How to Initialize Parameters of a Record in C# - Code Maze
Bringing .NET to the Edge: How to Run Your CLI Applications on Cloudflare Workers with WASI
Part 0: The Start
Gentoo goes Binary! – Gentoo Linux
terminal smooth scrolling
Default Values for Lambda Expressions in C# - Code Maze
Cold-blooded software
Safer recursion in F# - .NET Blog
The IDEs we had 30 years ago... and we lost
4 billion if statements
Getting started with OCaml and Functional Programming | Sandro Maglione
4 billion if statements
A new lock type in .NET 9
What does it mean when the compiler says that it can't convert something to itself? - The Old New Thing
Nintendo Switch’s iGPU: Maxwell Nerfed Edition
Challenging projects every programmer should try
std::print in C++23
Cray 1 Supercomputer Performance Comparisons With Home Computers Phones and Tablets
Ruby 3.3.0 Released
Never delete tests
I Wrote 2K+ Lines of Brainfuck. Here's What I've Learned
Memory Safety is a Red Herring
Writing Worse Code For Better Maintainability – My Own Blog
Release dotnet-1.0.1 · microsoft/semantic-kernel
Introducing Route Generator for .NET
Validating appsettings becomes much faster with .NET 8
Validate NuGet packages before publishing from GitHub Actions
Discriminated Unions in C#
Progress toward a GCC-based Rust compiler
The best things and stuff of 2023
What Is String Interpolation In C# – What You Need To Know
Advancements in machine learning for machine learning
A curiously recurring lifetime issue
C#– Record types copy constructor
V8 is Faster and Safer than Ever! · V8
How do I specify an optional parameter to a Windows Runtime method? - The Old New Thing
How can I work around the absence of default parameters in the Windows Runtime? - The Old New Thing
File Access Modifier in C# - Code Maze
Serializing restaurant tables in Haskell
Non-Send Futures When?
Building a React F# UI for an Embedded System
Choosing Elegance: The Case for F# in Application Development
Write Your Own Retro Compiler
Non-Send Futures When?
Searching Strings [Pt 6] | C# for Beginners
Sep with me on The Modern .NET Show
Improving programming language performance
Unveiling secrets of the ESP32: creating an open-source MAC Layer
My TypeScript Skills Improving and Best Practices
Dissecting C# Ranges
Building a Text Editor: the Gap Buffer
Inline Snapshot testing in .NET - Gérald Barré
MyOwnDB v2: tech lessons applied
Let’s learn how modern JavaScript frameworks work by building one
clang now makes binaries an original Pi B+ can't run
.NET 8 and C# 12 — Inline Arrays
A Decade of Developing a Programming Language: A Response Response
Private fields with or without underscore
Turbo Pascal turns 40
.NET 8 and C# 12 — ref readonly Parameters
How to make libraries compatible with native AOT - .NET Blog
GitHub - Mozilla-Ocho/llamafile: Distribute and run LLMs with a single file.
Rust: Memory Management
.NET 8 and C# 12 — Experimental Attribute
A journey about the new interceptors of .NET 8
GitHub - federico-busato/Modern-CPP-Programming: Modern C++ Programming Course (C++11/14/17/20)
What's New in TypeScript 5.3 -- Visual Studio Magazine
C# 12 (Complete C# Quick Reference) • Ben Bowen's Blog
on safepoints -- wingolog
On harmful overuse of std::move - The Old New Thing
C3 Documentation
Primary Constructors – Using C# 12 in Rider and ReSharper | The .NET Tools Blog
Racket Beyond Languages | Nikhil's blog
.NET 8 and C# 12 — Primary Constructors
Hixie's Natural Log
Plonky 3 / Valida October Review
Top 3 whole program optimizations for AOT in .NET 8
Things Programmers Can Do in One Week | Blog | build-your-own.org
Typst: Compose papers faster
Announcing TypeScript 5.3 - TypeScript
Improvements & Changes in Android resource generation in .NET 8 - .NET Blog
Things Programmers Can Do in One Week | Blog | build-your-own.org
Berkeley Mono Typeface
Announcing Rust 1.74.0 | Rust Blog
What's New in C# 12: Primary Constructors, Collection Expressions, and More
Linus Torvalds on C++
Aaron Schlesinger's Personal Site
InternalsVisibleToAttribute Class (System.Runtime.CompilerServices)
Why does calling a coroutine allocate a lot of stack space even though the coroutine frame is on the heap? - The Old New Thing
Announcing F# 8 - .NET Blog
Announcing C# 12 - .NET Blog
CC golf
Yes, Ubuntu Is Withholding Security Patches for Some Software
Getting Started
What's new in C# 12
How to Use Interceptors in C# 12
C#–Declaring attributes on positional record types
Trip report: Autumn ISO C++ standards meeting (Kona, HI, USA)
Cancellation and Async State Machines
Removing allocations by reducing closure scopes using local variables - Gérald Barré
How to dig into the CLR
CLion Nova Explodes onto the C and C++ Development Scene | The CLion Blog
Don’t Build AI Products The Way Everyone Else Is Doing It
A quick look at destination-driven code generation
Switching to Elixir
Faster compilation with the parallel front-end in nightly | Rust Blog
Read and Write Windows Registry in C# - Code Maze
Hare aims to become a 100-year programming language
The 'eu' in eucatastrophe – Why SciPy builds for Python 3.12 on Windows are a minor miracle
Officially Qualified - Ferrocene
Discovering The Features Of DotNetFiddle – How To Compile C# Online
Speed up a program for the 50 years old processor by 180000% – Blog about my engineering projects
What's New in Microsoft's F# Language for Functional-First Programming -- Visual Studio Magazine
Announcing TypeScript 5.3 RC - TypeScript
Impressions of .NET Developer Days 2023 Conference
Building a high performance JSON parser
GitHub - xoreaxeaxeax/movfuscator: The single instruction C compiler
Choosing diagnostic IDs - C#
Dunfield Development Services
A new way to bring garbage collected programming languages efficiently to WebAssembly · V8
Visual Studio 2022 17.8 Preview 3: Structured Diagnostics, SQL Server Data Tools Upgrade and More
Circuit Simulator: Compiling a bitmap
A new F# compiler feature: graph-based type-checking - .NET Blog
Beginner’s CSharp Switch Statement Tutorial: How To Properly Use A Switch Statement
GitHub - GaijinEntertainment/DagorEngine: Dagor Engine and Tools source code from Gaijin Games KFT
Porting a ClojureScript project to Squint
Cosmopolitan Third Edition
Breaking change: BinaryFormatter disabled across most project types - .NET
Blazor Basics: Blazor Event Callbacks
The Role of the Control Flow Graph in Static Analysis
Why does code die so soon?
.NET 8 Performance Improvements in .NET MAUI - .NET Blog
Things I like about Gleam's Syntax
Microsoft Cranks Out Weekly Visual Studio 2022 17.8 Previews as GA Nears -- Visual Studio Magazine
Oracle unveils Java development extension for Visual Studio Code
Craig Stuntz - On Learning Compilers and Creating Programming Languages
Source Code Generators, DIY
Was Rust Worth It?
axo blog - System dependencies are hard (so we made them easier)
Metalama Source Code Available | PostSharp Blog
C# Record Explained - NDepend Blog
.NET 8 Top 10 New Features - NDepend Blog
Customizing the behavior of record copy constructors - Gérald Barré
Getting started with gRPC Service with .NET 7
He Who Gives Up Correctness for Performance Deserves Neither
Zig is now also a Windows resource compiler
The 5 Levels of Readable Code
Hash Tables
A programming system
Oracle Offers Java Language Server Tool for VS Code -- Visual Studio Magazine
Wrathmark: An Interesting Compute Workload (Part 1)
Which Interpreters are Faster, AST or Bytecode?
A Look at Tailwind CSS
TypeScript Compiler Explained - CodeJourney.net
At the boundaries, static types are illusory
C Is Not a Low-level Language
Why async Rust? - Without boats, dreams dry up
How Can I Write Code On My Phone? – Unlock Potential For Mobile-First Coders
LSP could have been better
GitHub - CherniakYura/tccurl: Implement include header files over https
How to compare signed and unsigned integers in C++20?
Fast(er) JavaScript on WebAssembly: Portable Baseline Interpreter and Future Plans
Overhauled F# code fixes in Visual Studio - .NET Blog
What Is DotNetFiddle? - A How To Guide on Using C# Anywhere
Announcing .NET 8 RC2 - .NET Blog
How To Use Embedded Resources in .NET
Visual Studio 2022 17.8 Preview 3 is here! - Visual Studio Blog
LLM’s reasoning and other abilities – Second Sight
Multi-language integration testing made easy with Bazel
Soft Orders of Magnitude
Bare-metal Rust in Android
How LinkedIn Adopted Protocol Buffers to Reduce Latency by 60%
Why is Debian the way it is?
Microservices without reason
Thriving in the age of AI
Build a Console App in .NET Core Like a Pro!
Padding for Overlaid Structs
Open Sourcing Ferrocene
Strong static typing, a hill I'm willing to die on...
How to Design a Practical Type System to Maximize Reliability, Maintainability, and Productivity in Software Development Projects / Part 1: What, Why, and How?
Announcing TypeScript 5.3 Beta - TypeScript
.NET R&D Digest (September, 2023)
If Conversion Within .NET - Part 1
Rolling Forward to Major Versions in .NET
Build simple fuzzer - part 6
A shallow survey of OLAP and HTAP query engines
Easing tradeoffs with profiles · baby steps
Chasing the Myth of Zero-Overhead Memory Safety (plus pictures of mythical birds!)
Beginning CMake : Quick Getting Started with CMake
Include interactive Clojure/script code snippets in a web page with SCI & friends
Template meta-programming: Avoiding saying a type before it is complete - The Old New Thing
Was Javascript really made in 10 days?
an aborted experiment with server swift
We Need More DSLs in the Database
ROCm Is AMD’s No. 1 Priority, Exec Says - EE Times
Exploring Linux command-line space time
Reading notes from Performance Improvements in .NET 8 - Kristoffer Strube’s Blog
Using a Discard Variable in C# - Code Maze
Performance Improvements in .NET 8
Internal Affairs
How to be a Good Programmer
Less boilerplate code with the new primary constructor in C# 12
Build reliable and secure C++ programs
64-Bit Bank Balances ‘Ought to be Enough for Anybody’? | TigerBeetle
Inside New Query Engine of MongoDB
Introducing runes
Why does my C++/WinRT project get unresolved externals for constructors? - The Old New Thing
EI029: Data Processing Service (Part 1)
Stability without stressing the !@#! out · baby steps
What's new in System.Text.Json in .NET 8 - .NET Blog
Do ORMs reduce the need for mapping?
When Zig Outshines Rust - Memory Efficient Enum Arrays
Discriminated Unions in C#
Accessing private members without reflection in C# - Gérald Barré
Synchronization Mechanisms - Volatile vs Interlocked vs lock in C# - Code Maze
GitHub - CatalaLang/catala: Programming language for literate programming law specification
Strange Loop's greatest hits
How does the Linux Kernel start a Process
GitHub - jonathanpeppers/dotnes: .NET for the NES game console
Performance Improvements in .NET 8 - .NET Blog
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.
Hidings Symbols Of Elf Files
Developing OCaml with Nix
Refusing TypeScript is a signal that you don't care about code quality
Beyond TypeScript: Differences Between Typed Languages
Async Rust Is A Bad Language
Null conditional await
Let's Read the Turbo Source: What Happens When You Click a Link?
Closures in C# demystified
OSS Power-Ups: bUnit – Webinar Recording | The .NET Tools Blog
Writing a C compiler in 500 lines of Python
Tail recursion
Can you use a class in C? · On the Joy of Problems
GameRoy: JIT compilation in High-Accuracy Game Boy Emulation
Turn on Nullability checks by default
Use explicit Lambdas with LINQ
Introduction to TDD
Reasoning Task, Async & Await in .NET
JUXT Blog: Clojure in Banking: Griffin
Compiling Rust for .NET, using only tea and stubbornness!
How to Not Build a React App (Part V)
Ruby Outperforms C: Breaking the Catch-22
Modern High Performance C# 2023 Edition
Run My Code! (code injection on Windows)
Elijah Potter
Premature Optimization: Universally Misunderstood
Readonly Modifier in C# - Code Maze
Initial Impressions of Microsoft Olive
You like Circom but you find it confusing? Introducing Circomscribe
How SNARKs fall short for FHE
How to Mark Methods as Deprecated in C# - Code Maze
5 New ASP net core features in dotnet 8 You'll Love this Year - Doumer's Blog
The first conformant M1 GPU driver
NonEmpty catamorphism
Compile-time type-checked truth tables
ASP.NET Community Standup - ASP.NET Architecture Series: AOT in .NET 8
The Problem with Friendly C – Embedded in Academia
Metaphors for thinking about LLMs
Why Do You Have to Return "Task" Whenever You "await" Something in a Method in C#?
.NET 8 Interceptors
Breaking The Mutant Language's "Encryption"
The Scourge of 00UB | Gavin D. Howard
C# 11 (Complete C# Quick Reference) • Ben Bowen's Blog
Targeting Multiple Frameworks in a .NET Project - Code Maze
Microsoft Open Sources 'ONNX Script' for Python Machine Language Models -- Visual Studio Magazine
What it means when you convert between different shared_ptrs - The Old New Thing
Inside STL: The shared_ptr constructor and enable_shared_from_this - The Old New Thing
Bare Metal Space Invaders
Rachit Nigam | PhD Candidate, Cornell University
Differences Between Const and Readonly in C# - Code Maze
Backward Compatibility, Go 1.21, and Go 2 - The Go Programming Language
Software Engineering at Google
GitHub - valida-xyz/valida: A STARK-based VM focused on code reuse, performance, and modularity
Can you use a class in C? · Effective program synthesis
Primary Constructors for Classes and Structs - Code Maze
Corrode Rust Consulting
Let's Co-Create! Your Voice Matters - Visual Studio Blog
Go 1.21 Release Notes - The Go Programming Language
GitHub - huggingface/candle: Minimalist ML framework for Rust
Raku: A Language for Gremlins • Buttondown
Inside STL: The map, set, multimap, and multiset - The Old New Thing
Should we stop writing functions?
Why it is hard to generate beautiful HTML emails (from Markdown)
IBM, Red Hat and Free Software: An old maddog’s view
Verifiable encryption on the Blockchain
0.11.0 Release Notes ⚡ The Zig Programming Language
Implicit Operators – Clean Code Secrets Or Buggy Nightmare?
Source Generators in C# - Code Maze
A Gentle Introduction to LLVM IR · mcyoung
Why your GPU can (and probably should) do real function calls
New C# 12 Preview Features Available
Run Llama 2 on your own Mac using LLM and Homebrew
.NET R&D Digest (July, 2023)
Nim v2.0 released
Inside STL: The pair and the compressed pair - The Old New Thing
Using C# source generation for enhanced logging - Bruno Sonnino
Polyfills in .NET to ease multi-targeting - Gérald Barré
How to Use TypeScript Generics with Functional React Components
What's up, Python? The GIL removed, a new compiler, optparse deprecated...
Cap'n Proto: Cap'n Proto 1.0
Beyond the Basics: XAML Compilation in .NET MAUI
Advanced Performance Extensions (APX)
Perfect forwarding forwards objects, not braced things that are trying to become objects - The Old New Thing
Microsoft Improves Natural Language UI for LLMs with Open Source TypeChat -- Visual Studio Magazine
GitHub - PRQL/prql: PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
Common pitfalls in Go benchmarking
Thriving in the dynamically type-checked hell scape of Clojure
7 Tips to Boost .NET MAUI Mobile App Performance
jaspervdj - Lazy Layout
Empathetic tools | Software and puns
GitHub - KTStephano/StratusGFX: Realtime 3D rendering engine
JuMP, GAMS, and the IJKLM model
Announcing TypeScript 3.0 - TypeScript
Totality
GitHub - erhant/zkbrainfuck: A Brainfuck zkVM with Circom.
The RyuJIT transition is complete! - .NET Blog
Announcing the .NET Framework 4.7.1 - .NET Blog
Best Practices for Regular Expressions in .NET
Should We Use Records or Classes or Structs in C# - Code Maze
Introducing TypeChat - TypeChat
.NET MAUI 8 Preview 6: Visual Studio Code Extension, Bug Fixes & Native AOT for iOS
Creating a Roslyn Analyzer to ensure that no duplicate values are added at compile time
csharplang/proposals/collection-expressions.md at main · dotnet/csharplang
How to clone a Windows Runtime map in the face of possible concurrent modification, part 1 - The Old New Thing
.NET Framework 4.8 to .NET 6 migration
Why the “Null” Lifetime Does Not Exist
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 4 - The Old New Thing
What's new in C# 12 - C# Guide
Micro-optimization: Concatenating a string with a char using string.Concat - Gérald Barré
Extended C# Support in ReSharper and Rider 2023.2 EAP 9 | The .NET Tools Blog
GitHub - amis92/csharp-source-generators: A list of C# Source Generators (not necessarily awesome) and associated resources: articles, talks, demos.
Prompt Design
tinygrad + rusticl + aco: why not?
Required Parameters in Blazor WebAssembly - Code Maze
Patching GCC to build Actually Portable Executables
How to clone a Windows Runtime vector in the face of possible concurrent modification, part 2 - The Old New Thing
Put a Pin on That
Five Years of Rhovas
New C# 12 preview features - .NET Blog
MemoryExtensions.Split Method (System)
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
Compare Byte Arrays in .NET - Code Maze
10x Performance with SIMD Vectorized Code in C#/.NET | xoofx
Finding Your Mojo – Mike Innes
WebAssembly and replayable functions
How small is the smallest .NET Hello World binary?
TypeScript 5.1: declaring JSX element types | johnnyreilly
Parsing in Python: all the tools and libraries you can use
Matcheroni, a tiny C++20 header library for building lexers/parsers
Overload resolution in C#
{n} times faster than C
How to wait for multiple C++ coroutines to complete before propagating failure, finding the awaiter - The Old New Thing
Episode 126 - Slimming Down .NET: The Unofficial Experiments of Michal Strehovský
7 Things about C#: If Statements
How to wait for multiple C++ coroutines to complete before propagating failure, preallocating the coroutine frame - The Old New Thing
Debugging xUnit Tests Using Reflection
GitHub - zksecurity/noname: Noname: a programming language to write zkapps
The Tragic Death of Inheritance
How to wait for multiple C++ coroutines to complete before propagating failure, memory allocation failure - The Old New Thing
40 Years of Computing (Part 1: The First 20 Years)
Roslyn Compiler and Analyzers in .NET - Introduction
How to wait for multiple C++ coroutines to complete before propagating failure, symmetric transfer - The Old New Thing
Fastest Branchless Binary Search
Hashtable in C#
FP pattern - list of TODOs
How to wait for multiple C++ coroutines to complete before propagating failure, custom promise - The Old New Thing
Programming Languages Going Above and Beyond
7 Things about C#: Console I/O
How to wait for multiple C++ coroutines to complete before propagating failure, false hope - The Old New Thing
Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022
csharplang/proposals/inline-arrays.md at main · dotnet/csharplang
How to wait for multiple C++ coroutines to complete before propagating failure, unhelpful lambda - The Old New Thing
A case for ClojureScript 2.0
Missing Stack trace when eliding the await keyword
Value Objects in C# - Code Maze
Dart Sass and Hugo Themes
7 Things about C#: Running Apps
Get ready for fsharpConf 2023! - .NET Blog
The case of the make_shared on a C++/WinRT type - The Old New Thing
Why I started (and stopped) making games
Why am I being told about a signed/unsigned comparison, and why only sometimes, and how can I fix it? - The Old New Thing
Differences Between ExpandoObject, DynamicObject and dynamic
fsharpConf: The F# Community Virtual Conference
Ultimate Guide: NextJS, NestJS & TRPC Monorepo [Updated 2023]
Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection
The case of the invalid handle despite being managed by an RAII type - The Old New Thing
The C# Meta Programming Roadmap
Collatz sequences by function composition
What is WASI?
A note on Metal shader converter
The move constructor that you have to declare, even though you don't want anyone to actually call it - The Old New Thing
Debian -- News -- Debian 12 "bookworm" released
Introducing C# 12: Primary constructor on classes and struct
Derived Instances Can Break Smart Constructors, Too
sort-research-rs/text.md at main · Voultapher/sort-research-rs
Virtual Methods in C# - Code Maze
To Save C, We Must Save ABI
F# is the .NET Rust
Span / Memory / ReadOnlySequence in C#
More Unit Testing with Less Code - Combinatorial Unit Testing
Bounds Safety: Avoiding Death by a Thousand Constructors
Demystifying WebAssembly: What Beginners Need to Know
ASP.NET Community Standup - ASP.NET Architecture Series: AOT
Release Blink 1.0 · jart/blink
graydon2 | The Rust I Wanted Had No Future
It's great that you provide operator overloads, but it's also nice to have names - The Old New Thing
Tree Borrows
Hugo and Tailwind: peace at last (maybe) | BryceWray.com
ZK app developers should be able to see down to the constraints
JuLox: What I Learned Building a Lox Interpreter in Julia
ASP.NET Community Standup - ASP.NET Architecture Series: AOT
Announcing Rust 1.70.0 | Rust Blog
New Features in Generally Available TypeScript 5.1 -- Visual Studio Magazine
What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
I think Zig is hard...but worth it
Cloud, why so difficult? 🤷♀️ | Wing
alexw.nyc -- duskos-1.html
Language Pragmatics Engineering
Keeping software soft
Favour flat code file folders
Domain modelling with State Machines and TypeScript by Carlton Upperdine
nameof get's a bit better in C# 12
Building a baseline JIT for Lua automatically
I Am No Longer Speaking at RustConf 2023
xorvoid
The obvious final step
.NET Rocks! PHP and WebAssembly with Jakub Míšek
the tiny corp raised $5.1M
17 Amazing Community Packages for .NET Developers - Claudio Bernasconi
The Importance of Removing Unnecessary Expression Values in Code in Microsoft .NET
On creating (and using) a transforming iterator - The Old New Thing
Compress-a-Palooza: Unpacking 5 Billion Varints in only 4 Billion CPU Cycles
The Ultimate .NET Version Guide
Object Initializers in C# - Code Maze
Hot Reload Supports Modifying Generics! - .NET Blog
.NET Rocks! Immutable Architectures with Michael Perry
Building a Dynamic Logical Expression Builder in C#
Bitwise Binary Search: Elegant and Fast
Summary of the duck-typing requirements of C++ COM wrappers - The Old New Thing
Folders versus namespaces
Introducing Deopt Explorer - TypeScript
Language Tooling Antipatterns
Single Abstract Method Traits · mcyoung
Learning Homebrew Game Boy Game Development in Assembly
[PATCH 00/32] bcachefs - a new COW filesystem
Init Only Setters in C# - Code Maze
What are the duck-typing requirements of ATL CComPtr? - The Old New Thing
Myths about F#: F#’s strict ordering is dumb! No, it’s great for taming dependencies.
Increase MAX_MOVES to prevent buffer overflow and stack corruption by ZealanL · Pull Request #4558 · official-stockfish/Stockfish
TypeScript 5: importsNotUsedAsValues replaced by ESLint consistent-type-imports | johnnyreilly
Implementing Vale's Region Borrowing, and its Unexpected Quest
Announcing CheerpJ 3.0: a JVM replacement in HTML5 and WebAssembly to run Java applications (and applets) on modern browsers - Leaning Technologies
Learn Unison | 💡 The big idea · Unison programming language
On Custom-Width Integer Types
What are the duck-typing requirements of _com_ptr_t? - The Old New Thing
.NET Community Toolkit 8.2: MVVM Toolkit Attributes, Performance Enhancements, and More
Why does XAML complain that none of the overloads of winrt::to_hstring could be used? - The Old New Thing
Myths about F#: F# is slow! No, F# can be really fast.
Driving Compilers
What is Type-Level Programming? - sulami's blog
Error handling patterns
Binary data version migration
VerificationException in .NET Framework when using structs
Using sizeof() Operator in C# - Code Maze
Generic Efficient Accumulation/Folding for Special Sound Protocols
Using modern decorators in TypeScript - LogRocket Blog
Virtual DOM: Back in Block | Million.js
Deborah Kurata's Favorite 'New-ish' C# Feature: Pattern Matching -- Visual Studio Magazine
Maybe you should store passwords in plaintext.
How to lock orientation at runtime on iOS 16 with .NET MAUI and Xamarin.Forms
Verifying your DI Container
Microsoft is rewriting core Windows libraries in Rust
How to Start a .NET Project in 2023
Just Works For Me
Beautiful Branchless Binary Search
Using Crates.io with Buck
Announcing .NET Community Toolkit 8.2! Faster generators, code fixers, performance improvements and more! - .NET Blog
What's up with this new memory_order_consume memory order? - The Old New Thing
Building from source all the way down — 2023 — Blog — GNU Guix
RPC over Websockets [or TCP]
Deterministic Finalization in C#: IDisposable and Best Practices | C# Tutorials Blog
Why is std::hardware_destructive_interference_size a compile-time constant instead of a run-time value? - The Old New Thing
Introduction to gRPC with Fiddler Everywhere
Automating HTML Validation for a Happier Life
Static Methods vs. Non-Static Methods in C#
Revisiting The Fast Inverse Square Root - Is It Still Useful?
Michael Tsai - Blog - Price Increases for Developer Tools
Announcing Rust 1.69.0 | Rust Blog
Working with Sass in an ASP.NET Core application
No Code, Clean Performance
Where's my feedback loop?
Web API Updates with .NET 8
Generalized Macros
Welcome to Peter's DevLog - Wrapping C libraries in Nim
How can I find the invalid class when C++/WinRT tells me that the class may not be final? - The Old New Thing
KotlinConf 2023: A Look at the Opening Keynote | The Kotlin Blog
Using buck to build Rust projects
Building the Linux kernel in under 10 seconds with Firebuild - Obsessed with reality
Converting Strings to .NET Objects – IParsable and ISpanParsable
touchHLE in depth, part 1: a day in the life of a function call
Upcasting and Downcasting in C# - Code Maze
C-styel print debug in golang
Why Janet?
How to Round Down a Number to a Nearest Integer in C#
Six Labors : Announcing ImageSharp.Web 3.0.0
Debugging native memory issues in a C# application
Can You Trust a Compiler to Optimize Your Code?
Towards a Nova-based ZK VM
C# 11.0 new features: Span<char> pattern matching | endjin
Monorepos, fast maps, and more – Gleam
Using Unpoly with Django — /var/
Mindset shifts for Functional Programming (with Clojure)
All you need is data and functions
Should you adopt .NET 7 or wait for .NET 8?
Looking at C# 12 Proposals and Beyond
Staff Software Engineer, Copilot IDE
Riding & Driving in Washington
C++17 creates a practical use of the backward array index operator - The Old New Thing
Asynchronous C# programming using async and await keywords | C# Tutorials Blog
Does OpenTelemetry in .NET Cause Performance Degradation?
Why Clean Code was (and still is) important?
Julia's latency: Past, present and future
What is this [uuid(...)] in front of my C++ class declaration? - The Old New Thing
Episode 119 - Comparers with Stephen Cleary
ReSharper IL Viewer and Low-Level C# | The .NET Tools Blog
Type system of Fortnite's Verse language
How can I box a std::optional into a C++/WinRT IInspectable? - The Old New Thing
Nix Turns 20. What the Hell Is It?
The Perils of Polishing (LONG!)
C++ Initialization Story in Print
Primary Constructors with C#
Zig And Rust Mar 26, 2023
C# Source Generators: How to get build information?
Building a DOS ChatGPT client in 2023
Introducing Kotlin/Wasm
On being bored as a tech enthusiast
How to add a Clojure REPL to a web page
The AsyncIterator interface - Without boats, dreams dry up
Fascination of AWK
JVM Performance Comparison for JDK 17
Why am I getting a weird error about promise_type when I try to write a coroutine? part 2 - The Old New Thing
GitHub - typst/typst: A new markup-based typesetting system that is powerful and easy to learn.
TypeScript 5.0: 'Smaller, Simpler and Faster' -- Visual Studio Magazine
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
Betraying vim for the IDEs of March
SuperWord (Auto-Vectorization) - An Introduction
GitHub - SimonCropp/Polyfill: Source only package that exposes newer .net and C# features to older runtimes.
Announcing TypeScript 5.0 - TypeScript
The birth of a package manager
Mind your C++/WinRT namespaces - The Old New Thing
How Async/Await Really Works in C# - .NET Blog
fastGPT: Faster than PyTorch in 300 lines of Fortran
Patterns & Abstractions - Without boats, dreams dry up
Metaprogramming in Lean
System.Text.Json Serializing Hierarchical Data
Partial Classes In C# And How to Use Them - Code Maze
A Guide For New Programmers on C# Basics
RazorSlices 0.3.0
GitHub - DamianEdwards/RazorSlices: Lightweight Razor-based templates for ASP.NET Core without MVC, Razor Pages, or Blazor.
What is the expression language used by the Resource Compiler for non-preprocessor expressions? - The Old New Thing
Disambiguating Arm, Arm ARM, Armv9, ARM9, ARM64, Aarch64, A64, A78, ...
What a good debugger can do
Taking Full Advantage of NoSideEffects, Or What's It Like To Be An Obsessional Researcher
School, Home
TypeScript's Migration to Modules - TypeScript
What's new for the WinForms Visual Basic Application Framework - .NET Blog
Visual Basic language strategy - Visual Basic
When Zig is safer and faster than Rust
How To Use The yield break Statement In C#? - Code Maze
EF Core Mapping with Generic Types, Value Conversion, and JSON Columns
Required Keyword, Checked Operators, nameof Operator Scope – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
Warnings-as-errors friction
My Hardest Bug Ever
Signals vs Streams, in terms of backpressure (2023)
Nix Quickstart
csharplang/primary-constructors.md at main · dotnet/csharplang
Write a First Person Game in 2KB With Rust
The World's Smallest Hash Table
Open-Source COBOL .NET Compiler Otterkit Reaches Alpha
Delegates
bryan garza
Journey Through Freedreno
What Are the Enduring Innovations of Lisp?
Announcing TypeScript 5.0 RC - TypeScript
Dealing with the unknown
.NET R&D Digest (February, 2023)
Difference Between Returning and Awaiting a Task in C#
How to develop un-analyzable PL
"Clean" Code, Horrible Performance
Annileen Devlog #2 - C++20 and Modules
How to integrate your Roslyn Analyzer project with SonarQube
Raw Strings, UTF-8 Strings, and Multiline Interpolations – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
F# language strategy
Making Go telemetry opt-in is a mistake
How to contribute to a project you have no idea about
Programming Will Always Use Text
GCC Gets a New Frontend for Rust - Slashdot
Different Types of Comments in C# and Should We Use Them
Bean Machine Retrospective, part 8
Updated Modern Code Generation for WinForm's InitializeComponent - .NET Blog
Writing a bare-metal RISC-V application in D
C# "var" with a Reference Type is Always Nullable
Re-thinking the Visitor Pattern with the Double-Dispatch Approach
Resolving the Call Is Ambiguous Error While Using LINQ
GitHub - MichalStrehovsky/sizegame: Compare binary sizes of canonical Hello World in different languages
C# 11–The scoped keyword
.NET 8 Preview 1: Native AOT Upgrade and the New 'Blazor United' -- Visual Studio Magazine
roslyn/source-generators.cookbook.md at main · dotnet/roslyn
GitHub - o-oconnell/minixfromscratch: Development and compilation setup for the book version of MINIX (3.1.0) on QEMU
List and Span Pattern Matching – Using C# 11 in Rider and ReSharper | The .NET Tools Blog
Welcome to Peter's DevLog - Dynamic libraries in Nim
The case of the mysterious "out of bounds" error from CreateUri and memmove - The Old New Thing
Few lesser known tricks, quirks and features of C
They are here
What Austral Proves (Crash Lime)
Errors are Not Failures
BenchmarkDotNet v0.13.5 | BenchmarkDotNet
Languages & Runtime Community Standup - Otterkit: an OSS COBOL compiler for .NET
What happens if you co_await a std::future, and why is it a bad idea? - The Old New Thing
Why is building a UI in Rust so hard?
Visual Studio 2022 17.5 Preview 3 Build Acceleration
Making Sense of Acquire-Release Semantics
Exploring maven incremental builds with maven-build-cache-extension | miguel codes
.NET Managed languages strategy - .NET
Google’s Fully Homomorphic Encryption Compiler — A Primer
Whatever happened to Elm, anyway?
My Time At The Recurse Center
What is .NET, and why should you choose it?
Non-nullable properties in C# 11
Digging Into Nullable Reference Types in C#
Beware of fast-math
Lean BDD and Code Generation
The unsafe language doom principle
Scala Resurrection
Context-dependant code is better than its reputation
User or *User - Do We Need Struct Pointers Everywhere?
Asynchronous Programming Patterns in .NET
Lowering in C#: What's really going on in your code? - David Wengier
Lowering in C#: What's really going on in your code? - David Wengier
C# Source Generators - Write Code that Writes Code
Sydney ALT.NET August - Roslyn Code Generators and CoRoutines with C#
C# Source Generators - Write code that writes code - David Wengier
Porting Custom Controls from Xamarin Forms to Uno Platform
C#11 – Records Demystified
Zig Meta Programming
Bean Machine Retrospective, part 7
C#11 - Immutable Object and Defensive Copy
Languages & Runtime Community Standup - Otterkit: an OSS COBOL compiler for .NET
IEnumerable in C# – A Simplified Beginners Guide - Dev Leader
Comparing the Same Project in Rust, Haskell, C++, Python, Scala and OCaml
Everything You Wanted to Know About Multiline Strings - Dev Leader
A Linking Adventure - nsnotes
Type inference that sticks | Jared Forsyth.com
Weird things I learned while writing an x86 emulator
Static and non-static interface member calls in .NET: they are not the same
Names can be so much more
The names of birds, part 4
Python’s “Disappointing” Superpowers
Inside C++/WinRT: Coroutine completions: Avoiding reentrant completion
.NET R&D Digest (January, 2023)
Checksum mismatches on .tar.gz files · Discussion #45830 · community
Opinionated tools are better
Announcing TypeScript 5.0 Beta
How Austral’s Linear Type Checker Works
Cyber - Fast and concurrent scripting.
C in WASM
Announcing Rust 1.67.0 | Rust Blog
Hello World - Introduction to C# interactive C# tutorial
C# Lowering
Languages & Runtime Community Standup - Dive into C# internals
Nullable reference types–Using the required keyword in C# 11
Agilean
Static libraries
Nim Meta Programming
What's inside a .EXE File?
Dear Retro Community, Stop Writing Tools in C
Required Members in C# - Code Maze
How I learned to learn as a developer
It’s 2023, You Should Be Using Typescript!
A Rough Debut for Visual Studio Spell Checker Preview -- Visual Studio Magazine
Native AOT Overview
Announcing .NET Community Toolkit 8.1! Better, faster MVVM source generators, .NET 7 support, and more!
C# 12: Primary Constructors
Software testing, and why I'm unhappy about it
reduce() is a Left Fold, But reduceRight() Isn't a Right Fold
GitHub - otterkit/otterkit: Otterkit COBOL Compiler
C# Online Compiler | .NET Fiddle
Boxing and Unboxing in C# - Code Maze
Supporting the Use of Rust in the Chromium Project
Machine Learning in .NET with F# and ML.NET 2.0
Visual Studio 2022 Release Notes
Getting rid of warnings with nullable reference types and JSON object models in C#
5 new advanced features improving C# 11 | Red Hat Developer
Directly Access Your Physical Memory (dev/mem)
What's New in Ruby 3.2
What does it mean when I get a mismatch from MSVC for _COROUTINE_ABI?
Executing async operations onchange in Blazor
A Zig Diary
You should write React in F#
SDL2 common mistakes and how to avoid them
Is coding in Rust as bad as in C++?
Microfeatures I'd like to see in more languages
Historical Source Code That Every Developer Should See
Machine Learning in .NET with F# and ML.NET 2.0
Bean Machine Retrospective, part 6
The faker's guide to reading (x86) assembly language
100R — weathering software winter
C# 11 List Patterns - Create compatible types - Gérald Barré
Impress your colleagues with your knowledge about..the PrintMembers method
Oly/README.md at main · TIHan/Oly
bflat - C# as you know it but with Go-inspired tooling
Give your strings context with StringSyntaxAttribute
experiments with BPF programs performance · Erthalion's blog
Learning OCaml in 2023 | sancho.dev
Misleading geometric mean | Andrey Akinshin
C# 12: Default Parameters in Lambdas
Introducing Austral: A Systems Language with Linear Types and Capabilities
ReadOnlySpan<char> and strings - How not to compare them
After importing a TLB, how do I convert from one type of _com_ptr_t to another?
Default Interface Method in C# And When to Use It - Code Maze
50 Years of Wow- I lived through 5 decades of computing milestones
2022 APFS Advent Challenge Day 17 - Blazingly Fast Checksums with SIMD
Go is modern PHP
IEnumerable in C# - Code Maze
Challenging algorithms and data structures every programmer should try
Introduction to MVVM Source Generators for C# .NET
Optimizing Symmetric Quadratic Form
What are the biggest reasons newcomers give up on OCaml?
What are the biggest reasons newcomers give up on OCaml?
Functional error-handling with stack traces
On the large number of ways of expressing Microsoft Visual C++ compiler versions
Ref-structs are technically obsolete - Turnerj (aka. James Turner)
OCaml 5.0.0 is out!
If we must, let's talk about safety
I want toast
A Neat XOR Trick
Baby Steps With TypeScript
C# 11: pattern matching and static abstract interfaces | Red Hat Developer
C# 11 – File Scoped Types
The best things and stuff of 2022
Nullable Types in C# - Code Maze
What does it mean when the compiler tells me that promise_type: is not a member of coroutine_traits<void>?
Releases · bflattened/bflat
At Least Assert Your Serialisation Roundtrips
The limited utility of the phrase “GNU/Linux”
RC Week 12: What's Next, and Speedrunning Crafting Interpreters
Bean Machine Retrospective, part 4
Goodbye to the C++ Implementation of Zig ⚡ Zig Programming Language
Apple GPU drivers now in Asahi Linux - Asahi Linux
Atari Dev Studio - Visual Studio Marketplace
C# 11–Generic Attributes
Bean Machine Retrospective, part 3
Reminder: If you intend to use a C++/WinRT namespace, you must include that namespace's header file
GitHub Copilot preliminary experience report
Technique: Recursive variants and boxes
JIT in ClickHouse
Bean Machine Retrospective, part 2
Managing CSS Scope With Razor Components
Our journey to F#: C#-F# Interop – planetgeek.ch
Twenty five thousand dollars of funny money
Enoch - Using Neovim as a Fennel Compiler
Introducing C# 11: Numeric IntPtr and UIntPtr
How to enumerate through a StringBuilder
Bean Machine Retrospective, part 1
Introducing C#11: Required properties
C++ template parlor tricks: Using a type before it is defined
.NET 7 - The StringSyntaxAttribute
Memory Safe Languages in Android 13
How much does Rust's bounds checking actually cost?
out-of-bounds memory access bug
C# 11: Raw strings, required members, and auto-default structs | Red Hat Developer
A long expected update
How To Easily Understand TypeScript Generics
[Apply by 12/08] Introducing our fellowship program
C# 11 Strings in the Raw
A Mostly Complete Guide to C# 11’s Final Features
Why Only Type-hints?
I/O is no longer the bottleneck?
Using Rust at a startup: A cautionary tale
C# String Interpolation - Code Maze
Using Rust at a startup: A cautionary tale
Building the fastest Lua interpreter.. automatically!
Sometimes perfect forwarding can be too perfect: Lazy conversion is lazy
C# 11 Improvements for Strings, List Patterns and Object Creation
.NET Serialization Roundup 2022
Relocatable linking
Building the fastest Lua interpreter.. automatically!
Little Languages Are The Future Of Programming
Quest for my perfect watch.
Zero-Cost Memory Safety with Vale Regions (Preview)
.NET 7.0's Performance Improvements with Dynamic PGO are Incredible
Considering C99 for curl | daniel.haxx.se
C# 11 and .NET 7 Bring Generic Parsing
Clojure's typing "problem"
Why won't C++/WinRT let me co_await a CoreDispatcher or DispatcherQueue?
Announcing TypeScript 4.9
C# 11 required members - NDepend
STAThread and async Main gotcha
How to Use the “Using Static” Feature in C# - Code Maze
Introducing the C# 11 Required Keyword
Why middleware may not be the right abstraction for your data policies.
How to Return null From a Generic Method in C#? - Code Maze
Immutability: Dart vs. F#
Array short-circuiting
The one about Lisp interactivity
Gorillas (video game) - Wikipedia
Twelve C# 11 Features
How static application security testing improves software security | Red Hat Developer
Why don't Windows functions begin with a pointless MOV EDI,EDI instruction on x86-64?
C Isn't A Programming Language Anymore - Faultlore
Traits in Rust
Arm64 Visual Studio is officially here!
Announcing F# 7
TypeScript for React Developers – Why TypeScript is Useful and How it Works
Marking API's as obsolete or as experimental
Mutable value types are evil! Sort of...
Announcing TypeScript 4.9 RC
GitHub - dotnet/razor: Compiler and tooling experience for Razor ASP.NET Core apps in Visual Studio, Visual Studio for Mac, and VS Code.
C++ is the next C++
Everything you need to know about the OpenSSL 3.0.7 Patch (CVE-2022-3602 & CVE-2022-3786) - MalwareTech
0.10.0 Release Notes ⚡ The Zig Programming Language
local functions vs lambda expressions
C# 11 File Scoped Types - NDepend
PGO: Add new tiers by EgorBo · Pull Request #70941 · dotnet/runtime
A Team at Microsoft is Helping Make Python Faster
GitHub Copilot may steer Microsoft into a copyright lawsuit
Constructor Overloading in C# - Code Maze
Zig Is Self-Hosted Now, What's Next?
On Scala 3's Optional Braces
Episode 1: A basic expression evaluator
An argument for self-modifying applications
With Java 19, VS Code Now Does Virtual Threads While Debugging -- Visual Studio Magazine
bliki: ConwaysLaw
How Trying New Programming Languages Helped Me Grow as a Software Engineer
That Time I Tried Porting Zig to SerenityOS
That Shouldn't Happen - UnreachableException in .NET 7
When is a slice of any not a slice of any?
Simon Peyton Jones
Writing An Incremental Typesetting Engine | Laurenz's Blog
Cursed C# - Doing shenanigans in C#
Modern C# Techniques, Part 3: Generic Code Generation
C# UI and .NET Hot Reload - A Match Made in .NET MAUI
Boosting Performance With Sealed Classes in .NET - Code Maze
GitHub - clemedon/Makefile_tutor: This project aims to create a crystal clear tutorial on a cryptic looking topic.
The 4th year of SerenityOS
Zig-style generics are not well-suited for most languages
GitHub - woodrush/lambda-8cc: x86 C compiler written in untyped lambda calculus
My Personal Tech Limbo (and Elixir vs Rust)
Modern C# Techniques, Part 2: Value Records
Thread by @LinaAsahi on Thread Reader App
Introduction to WebApplicationFactory
git/torvalds/linux.git - Linux kernel source tree
Microsoft Claims Reduction in Cloud Cost from Migrating Internal Services to .NET 6
Pitfalls with eager loading of collections in EF Core
An elegy for GNU and RMS
Ten Years of TypeScript
Django 4 form rendering using Tailwind without Node or crispy
x86 vs x64 in .NET
Debugging coroutine handles: Looking for the source of a one-byte memory corruption
Peter Ritchie's Blog - By Reference in C#
Ken Thompson Really Did Launch His "Trusting Trust" Trojan Attack in Real Life
Getting started with OpenTelemetry Metrics in .NET. Part 2: Instrumenting the BookStore API
Linus Torvalds: Rust will go into Linux 6.1
What does the C++ error "A pointer to a bound function may only be used to call the function" mean?
the sad state of debug performance in c++
Mainlining Nexus 9: First Boot
CCPS, a Capcom CPS-1 SDK
Compiler Optimizations Are Hard Because They Forget - Faultlore
Announcing TypeScript 4.9 Beta
The road to Zettalinux
reading through the OCaml compiler: Part 1
GitHub - rochus-keller/LeanQt: LeanQt is a stripped-down Qt version easy to build from source and to integrate with an application.
Announcing Rust 1.64.0 | Rust Blog
The impossible case of pitching rust in a web dev shop
reading through the OCaml compiler: Part 1
Get Up To Date with the Latest Features of C# 11
Workflow for 3.12 cycle · faster-cpython/ideas Wiki
What is NullReferenceException in C#? - Code Maze
Rust is coming to the Linux kernel
When to refactor
csharplang/file-local-types.md at main · dotnet/csharplang
Why load fs:[0x18] into a register and then dereference that, instead of just going for fs:[n] directly?
Writing unsafe .NET code without the unsafe keyword - Gérald Barré
C# 11 - Top 5 Features in the new C# Version | Rubik's Code
GCC's new fortification level: The gains and costs | Red Hat Developer
GitHub - hsutter/cppfront: A personal experimental C++ Syntax 2 -> Syntax 1 compiler
Working Iteratively
It pays to be Circomspect
We Need Simpler Types
Architecture of a .NET Application: Case Studies - NDepend
ZeroBanana – Senior Engineers are Living in the Future
A pair of Rust kernel modules
C# Lambda Discards | endjin
Tutorial on using LLVM to JIT PyTorch fx graphs to native code (x86/arm/risc-v/wasm) (Part I – Scalars)
Writing a compiler. Bytecode finale
Writing a compiler. Bytecode finale
Arm64 Performance Improvements in .NET 7
OCaml By Example | <fun>
GitHub - meienberger/runtipi: ⛺️ Tipi is a homeserver for everyone! One command setup, one click installs for your favorites self-hosted apps. ✨
Byte Magazine Volume 08 Number 08 - The C Language : Free Download, Borrow, and Streaming : Internet Archive
The Case for Use.GPU
Security of ZK Systems
Episode 104 - C# with Mads Torgersen
Zig, the small language
TailwindCSS Tip: Arbitrary Values in Utility Classes
Formal Verification of ZK Constraint Systems
Using Go generics to pass struct slices for interface slices - Dusted Codes
Tips to Get Started with Cosmopolitan Libc
Arti 1.0.0 is released: Our Rust Tor implementation is ready for production use. | Tor Project
Simplicity and Survival
Security of ZK Systems
Why am I getting a null pointer crash when trying to call a method on my C++/WinRT object?
Infrequent, Pragmatic, Lambda Blog - Cognitive Loads in Programming
Performance Improvements in .NET 7
The x86-64 processor (aka amd64, x64): Whirlwind tour
Turning Methods Into Benchmarks
Refactor code to use new C# language features | The .NET Tools Blog
Visual Studio Build Tools Licensing Eased for Open Source C++ Projects -- Visual Studio Magazine
The AArch64 processor (aka arm64), part 25: The ARM64EC ABI
Writing a .NET profiler in C# - Part 1
OCaml at First Glance
New IKVM 8.2 & MavenReference for .NET projects
C# 11 Raw String Literals Explained - NDepend
The AArch64 processor (aka arm64), part 24: Code walkthrough
Using Generics in C# - Code Maze
On Caching Elixir Beam files · Anantha Kumaran
Generalizing Dijkstra's Algorithm — Monday Morning Haskell
The AArch64 processor (aka arm64), part 23: Common patterns
Tips for Using TypeScript With React in a Large Code Base
Running darktable on RISC-V
Stop saying 10x developer
We Deserve Better Than BEM
Inside the Pinecone | Pinecone
Strongly Typed Middleware in ASP.NET Core
The AArch64 processor (aka arm64), part 21: Classic function prologues and epilogues
Typescipt is terrible for library developers
A Peek at Latest C# 11 Features Coming in November with .NET 7 -- Visual Studio Magazine
How to Create a Class Dynamically in C#? - Code Maze
Can types replace validation?
C# 11 preview: generic math, required members, and more
The AArch64 processor (aka arm64), part 19: Miscellaneous instructions
Using TypeScript With React and KendoReact Components
Ekaitz's tech blog
Unix is not Linux
Self Hosted Compiler Upgrade Guide · ziglang/zig Wiki
The AArch64 processor (aka arm64), part 18: Return address protection
How I Learned to Stop Worrying and Love Macros
I Built a Ruby Compiler
It wasn't for nothing - Grasping gexps
jank programming language - Clojure/LLVM/Gradual Typing
What's New in Visual Studio 2022 17.4 Preview 1
GitHub - norvig/paip-lisp: Lisp code for the textbook "Paradigms of Artificial Intelligence Programming"
GitHub - oasislinux/oasis: a small statically-linked linux system
The AArch64 processor (aka arm64), part 14: Barriers
Choosing a .NET Memory Profiler in Visual Studio - part 1
C# 11: Preview of features for .NET 7
Microsoft Releases .NET Community Toolkit 8 with Automatic Source Generation
Tools I use: Eclipse — bayindirh
The AArch64 processor (aka arm64), part 11: Loading addresses
The Story of Mel
The AArch64 processor (aka arm64), part 10: Loading constants
That time I 10x’d a TI-84 emulator’s speed by replacing a switch-case
C23 is Finished: Here is What is on the Menu
Weird Expressions and Where to Find Them
So Zero It's ... Negative? (Zero-Copy #3)
DreamWorks Animation to Release MoonRay as Open Source
Type Checking and Type Casting in C# - Code Maze
How generics were added to .NET
C99 doesn't need function bodies, or 'VLAs are Turing complete'
Customizing TypeScript String Types with Template Literal Types and Utility Types
Rider 2022.2 Comes With More C# 11 Features, Performance Improvements, and Extended Unreal Engine Support | The .NET Tools Blog
ReSharper 2022.2 Comes With C# 11 Support, Solution-Wide Analysis Optimizations, and Virtual Formatter | The .NET Tools Blog
Go 1.19 Release Notes - The Go Programming Language
Release Notes for August 1, 2022
Invariant functors
Effective TypeScript › What's TypeScript compiling? Use a treemap to find out.
Running Zig with WASI on Cloudflare Workers
Linux 5.19 [LWN.net]
Linux 5.19
Domenico Luciani - Misleading Pair Programming
Why the Windows Registry sucks … technically
TypeScript Bytecode Interpreter / Runtime Types · Issue #47658 · microsoft/TypeScript
TypeScript: Typechecker-Assisted Runtime Data Validation
Logging Source Code Generators
Union types in C# - Event-Driven.io
What are Minimal APIs in ASP.NET Core 6 - Code Rethinked
Twenty years of Valgrind
Transitional Apps with Phoenix and Svelte
Templates in C
What they don't teach you about sockets
ZpqrtBnk
finally. #embed
~icefox/garnet - sourcehut hg
Some Thoughts on Zig — Sympolymathesy, by Chris Krycho
Don't Code Tired | Support Multiple Versions of .NET From A Single Class Library (.NET multi-targeting)
Why use the Bazel build system?
Meet Bun: A JavaScript Runtime for the Whole Dev Lifecycle
GitHub - carbon-language/carbon-lang: Carbon language specification and documentation.
ZpqrtBnk
Engineers on brink of extinction threaten entire ecosystems
Catering to Desktop & Mobile with .NET MAUI
System.CommandLine 2.0.0-beta4.22272.1
Native AOT deployment overview - .NET
Null Conditional Operators in C# - ?. and ?[]
Crystal is a Surprise | akos.ma
Nullability in C# - What It Is and What It Is Not
How I went about learning Rust
Lessons from Writing a Compiler
Compiler and Composability in ZKP
Integrate generator times into /reportAnalyzer by jaredpar · Pull Request #61661 · dotnet/roslyn
Learn a language by writing too many Forths
Build an LVGL Touchscreen App with Zig
Rust front-end
Unsafe Code in C# (unsafe keyword) - Code Maze
Succinct FSharp
Understanding the Stack and Heap in C# | endjin
Pernicious Nulls - using and abusing nulls in C#
Proebsting's Law
Scaling our Spreadsheet Engine from Thousands to Billions of Cells - The Causal Blog
What’s New In Python 3.11 — Python 3.11.0b3 documentation
How Clojure works for you
IKVM 8.2.0
GitHub - MeViMo/youbit: Using YouTube as a free file hosting service
I can’t believe that I can prove that it can sort
Another Update On The Bagel Language
Performance: Crystal vs Ruby
IKVM 8.2.0 : r/dotnet
IKVM 8.2.0 : r/dotnet
About the Crytal programming language
Using Graphs to Search for Code · Nick Gregory
Turns out gcc has imperative argument handling - hisham.hm
Another Open Source Group Blasts GitHub Copilot, Advocates Leaving GitHub -- Visual Studio Magazine
Challenge: Find the stack smash bug… – answer
Brian Robert Callahan
The Cell Programming Language
Binary Ninja - Introducing Tantō: Slicing Functions for Faster Finds
C# vNext - What could come
Give Up GitHub: The Time Has Come!
Linear Address Spaces - ACM Queue
Render Emails Using Razor Templating
Learning HTML was too hard so I made a compiler instead
Improve Git monorepo performance with a file system monitor | The GitHub Blog
Testimonials | The F# Software Foundation
Lambda Expressions in C# - Code Maze
What is Razor Templating, really?
csharplang/low-level-struct-improvements.md at main · dotnet/csharplang
How to Use Span in C# to Improve Application Performance - Code Maze
Nondestructive Mutation and Records in C#
haibane_tenshi's blog - Obscure Rust: reborrowing is a half-baked feature
Remove Duplicates From a List in C# - Code Maze
Pair Programming
Remove Duplicates From a List in C# - Code Maze
Undefined behavior in C is a reading error. – keeping simple
QBE - Compiler Backend
Crafting Interpreters: A Review
Gleam v0.22 released! – Gleam
C# 11 - Top 5 Features in the new C# Version | Rubik's Code
V Language Review (2022)
Ante
GitHub - dspinellis/unix-history-repo: Continuous Unix commit history from 1970 until today
C# 11 static abstract members - NDepend
My other database is a compiler
⚡️ The computers are fast, but you don't know it
csharplang/required-members.md at main · dotnet/csharplang
C# Warning Waves Hint at New Keywords in the Future
Method Overloading In C# - Code Maze
Eurocrypt 2022 program
Visual Studio 2022 17.3 Preview 2 Is First Native Arm64 Release -- Visual Studio Magazine
Creating, Inspecting and Decompiling the World's Smallest C# Program - Steve Gordon - Code with Steve
Debug Driven Development
Arm64 Visual Studio
What is the difference between C#, .NET, IL and JIT?
Explaining TypeScript
The Perils of Combining Multicast Delegates with Tasks in C# | endjin
Multiple Precision Arithmetic: A Recreational Project
Quantum Development Kits adopts .NET6 and supports Visual Studio 2022
Data Race Patterns in Go
ZpqrtBnk
Delegate, Action, Func, Lamdba expression - What the heck!?
What Makes a Good Research Proposal?
Cranelift, Part 4: A New Register Allocator
Linux on A7-A8X
Overview of eBPF procfs kernel parameters
GitHub - ClueLang/Clue: C/Rust like programming language that compiles into Lua code
Runtime C# Code Compilation Revisited for Roslyn
Performance tricks I learned from contributing to open source .NET packages
How Effective Abstractions Are Opinionated | 8th Light
Go vs C#, Part 3: Compiler, Runtime, Type System, Modules, and Everything Else
(async) Rust doesn't have to be hard
The Misery of Mainstream Programming
Comparing Exceptions and Errors in D
Zig on RISC-V BL602: Quick Peek with Apache NuttX RTOS
#164 Jared Parsons, The C# Compiler, Part 2 | no dogma podcast
Stack in C# - Code Maze
Async destructors, async genericity and completion futures
The Appeal of Static Typing
Getting Functional with C#
8 things about Records in C# you probably didn't know - Code4IT
sdk/Microsoft.PackageDependencyResolution.targets at 22c4860dcb2cf6b123dd641cc4a87a50380759d5 · dotnet/sdk
The Lazy monad
Anonymous Types in C# - Code Maze
Thoughts on Clojurescipt and BigDecimal
We Already Have Go 2
Remove Duplicates From a C# Array - Code Maze
Writing JIT Compiler on the Plane
How I think about C99 strict aliasing rules
Modern programming languages require generics
[Last Week in .NET #90] – Optimizing Cryware
How Uber Uses Zig - Motiejus Jakštys Public Record
Performance: Lambda Expressions, Method Groups, and delegate caching - Gérald Barré
Happy 10th Birthday Compiler Explorer! — Matt Godbolt’s blog
Visual Debugging Now!
Lotus 1-2-3 For Linux
Memory safety for SerenityOS
Unusual optimizations; ref foreach and ref returns
wtf is Clojure inlining anyway
Tips for Moving Your Xamarin Library to .NET MAUI
Laurence Tratt: Static Integer Types
A real life use-case for generics in Go: API for client-side pagination
Calculating type sets is harder than you think
Thorsten Ball - Professional Programming: The First 10 Years
The Identity monad
Remembering Buildtool - Julio Merino (jmmv.dev)
Operator precedence by textual substitution
Regular Expression Improvements in .NET 7
Structure and Organize .NET Projects with Rider | The .NET Tools Blog
Earn $200K by fuzzing for a weekend: Part 1
Converting Integers to Floats Using Hyperfocus
Embedding Truffle Languages - Kevin Menard's Weblog
Announcing Entity Framework 7 Preview 4
Check if a Number is a Power of 2 in C# - Code Maze
Auto-Regenerating API Client for Your Open API Project
EProgrammerNotFound exception in Delphi?
Unix command line conventions over time
Why Ballerina is a language
Case Study: How many colors are too many colors for Windows Terminal?
You Probably Don't Need to Worry About MediatR
.NET R&D Digest (April, 2022)
Implementing a ZK-focused authenticated-encryption scheme
Techniques and tools to update your C# project - Migrating to nullable reference types - Part 4
Semantic Versioning for TypeScript Types
Nvidia sees trillion-dollar future in open and parallel code
Set C# Language Version for All the Projects in a Solution - Code Maze
Experience Report: 6 months of Go
Welcome to a World of OCaml
Update SDK and use 'u8' string literals by BrennanConroy · Pull Request #41449 · dotnet/aspnetcore
Release 3.7.10 · fable-compiler/Fable
Learning JAX by Learning to Learn
Tutorial: Build gRPC & OData in ASP.NET Core
Lies we tell ourselves to keep using Golang
#163 Jared Parsons, The C# Compiler, Part 1 | no dogma podcast
Inform 7 v10.1.0 is now open-source - Authoring / Inform 7 - The Interactive Fiction Community Forum
Brian Robert Callahan
Create .NET Objects without Calling The Constructor
5 Software Engineering Foot-guns - Ken Kantzer's Blog
The Maybe monad
Protocol Buffers | Google Developers
Announcing the Hare programming language
Why LSP?
Annotating your C# code - Migrating to nullable reference types - Part 3
2fsharp/csharp2fsharp.md at master · knocte/2fsharp
Chris Lattner Interview Transcript — Accidental Tech Podcast
Why must JSX expressions have only ONE parent element? - Dillion's Blog
Celebrating 40 years of ZX Spectrum ❤️ 💛 💚 💙 | GitHub
C++ For C# Developers: Part 1 – Introduction
Async and Async Void Event Handling in WPF
GitHub - janestreet/magic-trace: magic-trace collects and displays high-resolution traces of what a process is doing
Azure DevOps Podcast: Mark Seemann: Code That Fits In Your Head - Episode 189
Python’s “Type Hints” are a bit of a disappointment to me
TypeScript Basics: How Generic Types Work - DZone Web Dev
C# async await explained - NDepend
Fundamentals
Changing std::sort at Google’s Scale and Beyond
.NET Community Toolkit v8.0 Preview 3 Tweaks MVVM Source Generators -- Visual Studio Magazine
Internals of C# nullable reference types - Migrating to nullable reference types - Part 2
C# 11 Preview Updates - Raw string literals, UTF-8 and more!
Richard Stallman - "The state of the Free Software movement" - April 13, 2022
Make self hosted compiler capable of building itself by Vexu · Pull Request #11442 · ziglang/zig
How To Build an Evil Compiler
Do You Really Code? · It Will Never Work in Theory
Value types and exceptions in .NET profiling
Introducing .NET Annotations Lambda Framework (Preview) | Amazon Web Services
How EEx Turns Your Template Into HTML
Try-Catch Block in C# - Code Maze
Using the Roslyn APIs to Analyse a .NET Solution - Steve Gordon - Code with Steve
What's New in IntelliJ IDEA - 2022.1
Deconstructing programs for compiler fuzzing · Comby
Sorry, Wrong Number: Debugging a Crash under Wine
Keeping up with .NET: learning about new features and APIs
Introduction to the Node.js reference architecture, Part 8: TypeScript | Red Hat Developer
Warning on lower case type names in C# 11
Nullable reference types in C# - Migrating to nullable reference types - Part 1
Announcing .NET Community Toolkit v8.0.0 Preview 3
Inline Assembly Miscompilation.md
Matt Roelle | Fennel: The Practical Lisp
How To Prevent Bugs
tsup
Announcing Rust 1.60.0 | Rust Blog
GitHub - nebuly-ai/nebullvm: Easy-to-use library to boost AI inference leveraging multiple DL compilers
Answer: Why is this code broken?
Use Git tactically
Clojure isnt for me
Pharo - Pharo 10 Released!
C# Pattern Matching Explained - NDepend
Can You Name Top C# IDEs Provided by Microsoft? I Couldn't -- Visual Studio Magazine
A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
csharplang/checked-user-defined-operators.md at main · dotnet/csharplang
csharplang/auto-default-structs.md at main · dotnet/csharplang
Handling date strings in TypeScript - LogRocket Blog
03.30.2022 - TypeScript/How some utility types are implemented
Handling null: optional and nullable types
csharplang/utf8-string-literals.md at main · dotnet/csharplang
Managing RavenDB indexes in production, a DevOps guide
Introduction
Enable QJFL and OSR by default for x64 and arm64 by AndyAyersMS · Pull Request #65675 · dotnet/runtime
[RFC] Lifetime annotations for C++ - Clang Frontend - LLVM Discussion Forums
Lessons learned with Elm | 20Y
Episode 95 - Avalonia UI with Dan Walmsley
Generics can make your Go code slower
OCaml 4.14.0 is released - Ecosystem - OCaml
CVE-2022-1015,CVE-2022-1016 in nf_tables cause privilege escalation, information leak [LWN.net]
Monads
Convenience is King and Polish is quality
Discovering basic blocks
Remix: The Yang to React's Yin
The Dependencies' Reckoning - Considerations when selecting third-party software
Performance of Discriminated Unions and Active Patterns
Remixing React Router
On the importance of trusting trust
Zhenghao
How Side Effects Work in FP
Go To Definition improvements for external source in Roslyn
Lanai, the mystery CPU architecture in LLVM
Hooks Considered Harmful
Error handling across different languages
SendilKumarN
Brian Robert Callahan
Performance benefits of sealed class in .NET - Gérald Barré
Building a gRPC Client in .NET - Sahan Serasinghe - Personal Blog
Optimizing Julia code
Rust's Unsafe Pointer Types Need An Overhaul - Faultlore
C# Source Generators - Write Code that Writes Code
A year on Windows: System debugging - Julio Merino (jmmv.dev)
roslyn-analyzers/PublicApiAnalyzers.Help.md at main · dotnet/roslyn-analyzers
C Isn't A Programming Language Anymore - Faultlore
Reducing WebAssembly size by exploring all executions in LLVM
Go 1.18 Release Notes - The Go Programming Language
Writing a device driver for Unix V6
Swapping two numbers in C#
A Mostly Complete Guide to C# 11’s Future Features
C# 11 Features Now Previewing in Visual Studio: Generic Attributes and More -- Visual Studio Magazine
Contributing to Complex Projects
Writing IL according to the specification
C# 10 New Features - Code Maze
GitHub - Cogmasters/concord: C library for handling the Discord API
Creating a Compiler with Raku – Andrew Shitov
Software Engineer - F# tools team in Prague, Prague, Czech Republic | Engineering at Microsoft
How to Add Parameters to a String in C# - Code Maze
Zhenghao
Things I hate about Rust, redux
A Proposal For Type Syntax in JavaScript
Racing the Hardware: 8-bit Division
Bugs in Hello World
Custom Attributes in .NET - Code Maze
A type-safe DI Container as a tuple
csharplang/pattern-match-span-of-char-on-string.md at main · dotnet/csharplang
What’s the maximum number of arguments for method in C# and in .NET?
I Can No Longer Compile My First Flash Game
Part 2: Improving crypto code in Rust using LLVM’s optnone
Part 1: The life of an optimization barrier
Working with untyped structured data in C# · Discussion #5863 · dotnet/csharplang
Sharing code between ASP.NET and ASP.NET Core
Difference Between Task.Run and Task.Factory.StartNew - Code Maze
proposal/generics-implementation-dictionaries-go1.18.md at master · golang/proposal
Use a cached delegate for method group conversion · Issue #5835 · dotnet/roslyn
Minimal APIs in .NET 6 - Code Maze
Parameter Null Checking in C#11 and optimising throw methods
Using Zig As Cross Platform C Toolchain
Linus Torvalds prepares to move the Linux kernel to modern C | ZDNet
Zig Build System Internals
Debugging C# in Visual Studio - Code Maze
Gödel's Incompleteness Theorem, in Bash
Moving the kernel to modern C
Announcing Rust 1.59.0 | Rust Blog
C++ exceptions are becoming more and more problematic
GitHub - sbp/hedgehog: Concise implementation of a lisp-like language for low-end and embedded devices
These violent delights
Early peek at C# 11 features
rust-analyzer joins the Rust organization! | Rust Blog
Params Keyword in C# - Code Maze
System.CommandLine 2.0.0-beta3.22114.1
ASP.NET Core on .NET 7.0 - Roadmap, preview 1 and file upload in minimal APIs
How to Convert Int to String in C# - Code Maze
Nix: An Idea Whose Time Has Come
Build tool requirements
Year 2038 problem is still alive and well
GitHub - mustafaquraish/cup: simple, C-like programming language
GitHub - yoav-lavi/melody: Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable
Twenty years of .NET - Yay! — robmiles.com
The right thing for the wrong reasons: FLOSS doesn't imply security
Why We Use Julia, 10 Years Later
A Practical Guide to Dapper - Simple Talk
C# Nullable Features thru the times
Type You An Actor Runtime For Greater Good! (with Java 17, records, switch expressions and JBang)
Announcing TypeScript 4.6 RC - TypeScript
Kimchi: The latest update to Mina’s proof system
Question: How is !! envisaged to be used? · Discussion #5735 · dotnet/csharplang
Attacking an Ethereum L2 with Unbridled Optimism
Different Ways to Initialize Arrays in C# - Code Maze
Diagnosing and Fixing MediatR Container Issues
Writing native WinDbg extensions in C#
C# 10.0 improves handling of nullable references in generic types - no more AllowNull | endjin
Initial roll out of !! by stephentoub · Pull Request #64720 · dotnet/runtime
Improvements and Optimizations for Interpolated Strings – A Look at New Language Features in C# 10 | The .NET Tools Blog
Visitor Design Pattern in C# - Code Maze
Why Windows isn't ready for Arm developers | ZDNet
On finding the average of two unsigned integers without overflow - The Old New Thing
Debug attributes in .NET
On Building 30K Debian Packages
Using Zig to Build Native Lua Scripts
An advanced, composable, reactive model-view-viewmodel framework
The Story of Mel
Compiler Explorer - C# (.NET 6.0.101)
Go performance from version 1.2 to 1.18
AdaCore and Ferrous Systems Joining Forces to Support Rust
WebVM: server-less x86 virtual machines in the browser
Piped
Welcome to My Site!
WebVM: Client side X86 virtual machines in the browser
Pay attention to WebAssembly
[Last Week in .NET #79] – Space Newts
Destroy All Values: Designing Deinitialization in Programming Languages
Game Performance Optimization - A Practical Example From Industry Idle
OCaml - Generalized algebraic datatypes
In defense of NIR
Difference Between ValueTuple and Tuple in C# - Code Maze
Writing an open source GPU driver – without the hardware
Sometimes, rewriting in another language works
GitHub - dzautner/Sel: A compiler for thin Symbolic Expressions abstraction layer over Lambda calculus.
Hey Ethereum, Let's Break Solidity's Composability!
Machine readable specifications at scale
Raising Coding Standards with .NET 6.0 Code Analyzers | endjin
Devblog of @kdy1
Solving the source generator 'marker attribute' problem - Part 1: Creating a source generator - Part 7
No one cares that you’re right
Type-level DI Container prototype
GitHub - max-sixty/prql: PRQL is a modern language for transforming data — a simpler and more powerful SQL
Implementing a file pager in Zig: Pages, buffers and metadata, oh my!
Awaiting an async void method in .NET - Gérald Barré
Top-Level Statements in C# - Code Maze
Announcing TypeScript 4.6 Beta
In defense of complicated programming languages
Surgical programming
Structure and Interpretation of Computer Programs
C# 10 (Two Decades of C#: A Reference) • Ben Bowen's Blog
Underjord | My Elm Experience
Seven Days of OCaml
How safe is zig?
The mystery of the crash that seems to be on a std::move operation
Introduction to .NET Framework | Pro Code Guide
Execute Program
Why Static Languages Suffer From Complexity
GitHub - water111/jak-project
Mastering mapped types in TypeScript - LogRocket Blog
Enumerate Wordle combinations with an applicative functor
Failing to Learn Zig via Advent of Code - ForrestTheWoods
Saving source generator output in source control: Creating a source generator - Part 6
Catch Multiple Exceptions in C# - Code Maze
Parameterized xUnit Tests with F#
GitHub - ForNeVeR/Cesium: C compiler for the CLI platform
Resolving confusion over how to return from a C++ coroutine - The Old New Thing
Rethinking errors, warnings, and lints
Cache the delegate for static method group conversions. by pawchen · Pull Request #58288 · dotnet/roslyn
Announcing Rust 1.58.0 | Rust Blog
5.5 mm in 1.25 nanoseconds
Nullable reference types
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
Flow control in C# | endjin
Announcing Parcel CSS: A new CSS parser, compiler, and minifier written in Rust!
Standing on the shoulders of giants: Let the compiler tell you what the ABI is - The Old New Thing
Implementing a file pager in Zig: Reclaiming memory
Why non-defaultable value types are needed in C#
Rachit Nigam | PhD Candidate, Cornell University
Merge pull request #10831 from ocaml-multicore/multicore-pr · ocaml/ocaml@001997e
Why your Typescript compiles when you thought you were safe
Why I Like D – Andrea Radaelli
BenchmarkDotNet 0.13.1
Things you might not know about CSharp - Duck Typing
Filling in some gaps in the story of Space Cadet Pinball on 64-bit Windows
Rust is more portable than C for pngquant/libimagequant
Records in C# - Code Maze
How to stop forgetting to await an awaitable call
My favorite F# code I've written
Polymorphism in C# - Code Maze
The joy of building a ray tracer, for fun, in Rust.
Quantifier predicates - Simple Talk
Create your own Roslyn Analyzer !! - Super Sharp | A Tech Superhero.
Compiling a Go program into a native binary for Nintendo Switch™ - Ebiten
Speculation on the design decisions that led to the common ABI for C++ coroutines
tvu-compare: rust and zig
Notes about loading configuration Examples for Play Framework and Spring Boot
Do We Really Need A Link Step?
Sciter uses JavaScript from now and on – Terra Informatica Software
Why the C Language Will Never Stop You from Making Mistakes
The C++/CX String^ is not an object, even though it wears a hat
95644 – [F2018] IEEE_FMA is missing from the IEEE_ARITHMETIC module
GitHub - sslab-gatech/Rudra: Rust Memory Safety & Undefined Behavior Detection
You can't copy code with memcpy; code is more complicated than that
Writing a minimal Lua implementation with a virtual machine from scratch in Rust
Spectre.Console and String Interpolation
A Review of the Zig Programming Language (using Advent of Code 2021)
Ruby 3.1.0 Released
Code Maze Weekly #107 - Code Maze
suckless.org software that sucks less
DNA seen through the eyes of a coder (or, If you are a hammer, everything looks like a nail) - Bert Hubert's writings
Integration testing and NuGet packaging: Creating a source generator - Part 3
0.9.0 Release Notes ⚡ The Zig Programming Language
LISP with GC in 436 bytes
GitHub - swc-project/swc: swc is a super-fast compiler written in rust; producing widely-supported javascript from modern standards and typescript.
Getting Roslyn (C# compiler) and Language versions - Gérald Barré
String Interpolation Trickery and Magic with C# 10 and .NET 6
Document your .NET code with DocFX and GitHub Actions
New LINQ improvements in .NET 6
Accessing arrays and class fields with .NET profiling APIs
Why GNU Guix matters
How not to learn Rust
F# Good and Bad
A Holly Jolly Christmas with Hot Chocolate 12.4
Iteration statements - C# reference
Partial functions and total functions
# F# Advent 2021 Dec 08 - Fast data pipelines with F#6
crawshaw - 2021-12-11
Using clojure.spec.alpha with babashka
The three types of development
Introducing stack graphs | The GitHub Blog
If you're going to configure a header file, you have to do it before you include the header file
Writing a simple 16 bit VM in less than 125 lines of C
Make the Implicit Explicit
Top Free Extensions for Visual Studio 2022 -- Visual Studio Magazine
LKML: Miguel Ojeda: [PATCH 00/19] Rust support
Angular Basics: Introduction to Processes, Threads—Web UI
You Can't Buy Integration
Debugging at the Boundaries
Rust takes a major step forward as Linux's second official language | ZDNet
Loop Fission
Cancellation Tokens with IAsyncEnumerable - Code Maze
Makefile Tools December 2021 Update: Problem Matchers and Compilation Database Generation
The Liskov Substitution Principle as a profunctor
GitHub - vzarytovskii/interactive-ilkernel: IL Kernel for .NET Interactive
C# Language Server Revamps VS 2022 Razor Editor for ASP.NET Core -- Visual Studio Magazine
Compiler error message metaprogramming: Helping to find the conflicting macro definition
Fastest way to enumerate a List<T> - Gérald Barré
Don't Code Tired | What’s New in C# 10: Value Type Records
Could .NET Source Generator Attacks Be A Danger To Your Code? - Steve Talks Code
The One with .NET after Saint Nick – Codecamp
Supercharged high-resolution ocean simulation with JAX | dionhaefner.github.io
Do we really need Undefined Behavior?
Behind The Spotify Wrapped API Scenes
How Rider Hot Reload Works Under the Hood | The .NET Tools Blog
Introducing the new Razor editor in Visual Studio 2022
Julia 1.7 Highlights
GitHub - mrthefakeperson/Excel-Virtual-Machine: C Compiler which targets Excel (MS Office)
Don't Code Tired | What’s New in C# 10: Take Control of Interpolated String Handling
Reducing an LTO Linux kernel bug with cvise
How can my C++/WinRT component pass a std::vector back to the caller?
4x smaller, 50x faster · asciinema blog
The .NET Docs Show - Into the deep end with OpenCV
Don't Code Tired | What’s New in C# 10: Easier Lambda Expressions
crawshaw - 2021-11-25
Jab 0.5.1
GC progress from JDK 8 to JDK 17
The New Life of PHP – The PHP Foundation | The PhpStorm Blog
Modern C# Hello World - NDepend
[CallerArgumentExpression] and throw helpers: Exploring .NET Core 6 - Part 11
TypeScript vs JSDoc JavaScript | I CAN MAKE THIS WORK
Don't Bring a Tree to a Mesh Fight
Running a .NET 6 Service on a Specific Port
New Kind of Paper, part 4
hacspec [![hacspec chat][chat-image]][chat-link]
The tale of a single register value
New Toolkit for Writing Visual Studio Extensions (And Where to Find Extensions) -- Visual Studio Magazine
GitHub - elfshaker/elfshaker: elfshaker stores binary objects efficiently
Why is my C++/CX ref class forbidden from having public methods that are templates or mention, say, std::vector?
Where is Ruby Headed in 2021? - Big Nerd Ranch
Global Usings – A Look at New Language Features in C# 10 | The .NET Tools Blog
New TypeScript 4.5 Improves Asynchronous Programming -- Visual Studio Magazine
OCaml compiler development newsletter, issue 4: October 2021 - Community - OCaml
Zettelkasten #1: Classes in D with betterC
What does the CompileAsWinRT Visual Studio project option mean?
Migrate from ASP.NET Core 5.0 to 6.0
CheerpX: Using WebAssembly to run any programming language in the browser
Talking to SerenityOS Contributors About Scratch-build C++ Developer’s Playground in Modern C++ | The CLion Blog
Where Are My Favorite Extensions in Visual Studio 2022?
[ANN] Fennel 1.0.0 released — sourcehut lists
How C# 10.0 and .NET 6.0 improve ArgumentExceptions | endjin
C# 10 new feature CallerArgumentExpression, argument check and more
The weirdest bug I've ever encountered
C# 10 new feature CallerArgumentExpression, argument check and more
Why asynchronous Rust doesn't work
Atlas
Dynamic PGO in .NET 6.0.md
Overriding Sealed Methods in C#
Why Does x = ++x + x++ Give Me the Wrong Answer?
C# 10 Falls Just a Bit Short
Dissecting Interpolated Strings Improvements in C# 10
How I found a bug in Intel Skylake processors
Modern, functional Common Lisp: Myths and tips
Welcome to C# 10
What’s New for Visual Basic in Visual Studio 2022
Using The Roslyn C# Compiler
What's new in F# 6 - F# Guide
James Randall
jott - building_stuff_from_source
Breaking changes in .NET 6 - .NET
Caller Argument Expressions – A Look at New Language Features in C# 10 | The .NET Tools Blog
NSwag generated C# client: Open API property name clashes and decimal types rather than double | I CAN MAKE THIS WORK
A quick review of C# 10 new language features
What's new in F# 6 - F# Guide
Caller Argument Expressions – A Look at New Language Features in C# 10 | The .NET Tools Blog
How can I prevent myself from accessing a lambda captured variable or a parameter after I'm done with it?
Control flow analysis for destructured discriminated unions by ahejlsberg · Pull Request #46266 · microsoft/TypeScript
Luau Goes Open-Source
The tale of a single register value
Don't Code Tired | ICYMI C# 9 New Features: Create Immutable Objects with Records
Profunctors
Type | Treat – Wrap-up
Type | Treat - Day 5
Faster Mac Dev Tools with Custom Allocators
They don't even know the fundamentals
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.
Security advisory for rustc (CVE-2021-42574) | Rust Blog
SectorLISP Now Fits in One Sector
Raspberry Pi 4 achieves Vulkan 1.1 conformance, gets up to 60% GPU performance boost - CNX Software
File-Scoped Namespaces – A Look at New Language Features in C# 10 | The .NET Tools Blog
Type | Treat 2021 – Day 4
Giving a single object multiple COM identities, part 3
Software Engineer II in Redmond, Washington, United States | Engineering at Microsoft
F# 6 Introduces Resumable Code, Improvements to Pattern Matching and Tooling, and More
Giving a single object multiple COM identities, part 2
How the C# compiler completely changes your code #Shorts
Records in C# 9
Making Sense of Common C# Compiler Errors - Kill All Defects
Immutable C#
Next.js 12
Analyzers for ASP.NET Core in .NET 6: Exploring .NET Core 6 - Part 7
FRI with Bootleproof-IPA Verkle Trees for “non-native” arithmetic and shrinking reference string size - HackMD
100 Days of TypeScript (Day 1)
Functor variance compared to C#'s notion of variance
C# tip: define Using Aliases to avoid ambiguity - Code4IT
F# eXchange 2021 | Skills Matter
New language features since Java 8 to 17
To Learn a New Language, Read Its Standard Library
Crates (existentials in F#)
Signals and Threads | Language Design
There is no 'printf'.
Transitioning an existing project to a new edition
Announcing Rust 1.56.0 and Rust 2021 | Rust Blog
Why you shouldn't leave your functions?
GitHub - badamczewski/PowerUp: Collection of productivity tools and utilities
What’s new in F# 6
New Code Rules: Too Many .NET Engineers DO NOT Understand How Memory Management Works!
Version 1.6.0 released
What to learn
A Race Condition in .NET Finalization and its Mitigation for C++/CLI
GitHub - carp-lang/Carp: A statically typed lisp, without a GC, for real-time applications.
GitHub - valinet/ExplorerPatcher: This project aims to bring back a productive working environment on Windows 11
As .NET 6 Nears GA, Blazor WebAssembly Can Now Use Native Dependencies -- Visual Studio Magazine
Everything That Every .NET Developer Needs to Know About Disposable Types: Properly Disposing Objects
C# Online Compiler | .NET Fiddle
Overview · Serde
Mythbusting Julia speed
What I wish I knew when learning F#
Local variables are different from parameters in C++ coroutines
Decyphering method signature with CLR profiling API
The Tennis kata revisited
Champion: Simplified parameter null validation code · Issue #2145 · dotnet/csharplang
3 TypeScript Tricks I wish I knew when I learned TypeScript
Hidden IDisposable Issues in Microsoft .NET
World's Smallest C# Program (featuring `N`)
Pop-up from Hell: On the growing opacity of web programs
101 Smart Contracts and Decentralized Apps in Ethereum
The road to OCaml 5.0 - Ecosystem - OCaml
The Old New Thing
Fundamentals of Computing with .NET
Why We Moved From Pony To Rust — Wallaroo
Debugging coroutine handles: The Microsoft Visual C++ compiler, clang, and gcc
The Insane Innovation of TI Calculator Hobbyists
GitHub - isometimes/rpi4-osdev: Tutorial: Writing a "bare metal" operating system for Raspberry Pi 4
I’ve loved Wasmer, I still love Wasmer
The select story
YikesScript - John's internet house
Everything That Every .NET Developer Needs To Know About Disposable Types - Properly Disposing Objects
Exploring C# 10: Save Space with File-Scoped Namespaces
Implicit Overflow Considered Harmful (and how to fix it)
Some lesser-known powers of std::optional
Word-aligned Bloom filters
"Static Linking Considered Harmful" Considered Harmful
Renato Athaydes
.NET 6 is HERE! 5 Features that will blow your mind 🤯
The seven programming ur-languages
Announcing .NET 6 Release Candidate 1
The value of in-house expertise
Coding Practice: Learning Rust with Fibonacci Numbers
Feature #18229: Proposal to merge YJIT - Ruby master
The Catch Block #76 - So You Fixed a Bug. Now What?
SizeBench: a new tool for analyzing Windows binary size
Avoiding Memory Leaks in Visual Studio Editor Extensions
I fixed a bug. What should I do now? - Gérald Barré
Keep IDs internal with REST
C# 10.0 implicit global using directives | endjin
The Speed of Time
Improving Software ‘Numbers’
Stamping Out Overflow Checks in Ruby
Initial Impressions of Rust
GitHub - aristocratos/btop: A monitor of resources
Testing a compiler that can’t even print stuff out
What Color is Your Function? – journal.stuffwithstuff.com
Hello World - Introduction to C# interactive C# tutorial
Pattern Matching Examples in C#
Notion – The all-in-one workspace for your notes, tasks, wikis, and databases.
The Bagel Language 🥯 | Brandon's Website
The long-term consequences of maintainers’ actions – Ariadne's Space
How JSX (React) Works Under the Hood
Don't fear the pointer — Bitfield Consulting
The C++ implicit assignment operator is a non-ref-qualified member, even if the base class's assignment has a ref-qualifier
Call WinRT COM interop interfaces from .NET 5+ apps - Windows apps
Swapping two numbers in C#
Announcing .NET 6 Release Candidate 1
Announcing .NET 6 Release Candidate 1
Java 17 / JDK 17: General Availability
C# For Beginners - Lesson 10: Methods
Release WebSharper 5.0.0-preview1 · dotnet-websharper/core
Finding Types at Runtime in .NET Core
Static Analysis in JavaScriptCore (Part I)
refactor: port libtransmission to C++ by ckerr · Pull Request #1787 · transmission/transmission
Write code that's easy to delete, and easy to debug too.
Constant-time code verification with Memory Sanitizer
C# 10 is HERE! 5 features that will blow your mind 🤯
Support type classes or implicits · Issue #243 · fsharp/fslang-suggestions
in which a laptop defies the trends
How We Went All In on sqlc/pgx for Postgres + Go
Proposal: Expression blocks · Issue #3086 · dotnet/csharplang
The Compiled Future of Front End
Maintain it With Zig
What's new in C# 10.0 - C# Guide
Using Source Generators with Blazor components in .NET 6
What Is yield and How Does It Work in C#?
Dealing with Modules, Assemblies and Types with CLR Profiling APIs
GitHub - koenvzeijl/AspNetCore.SassCompiler: Sass Compiler Library for .NET Core 3.x/5.x without node.
Introduction to Async Programming in C#
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🚀
Bebop ❤️ Rust | Rainway
zkMesh: Aug 2021 recap
Looking at world through __stdcall-colored glasses
GraphQL & Relay in the Front End
TypeScript v4.4 Ships, Gets New Home Page -- Visual Studio Magazine
All about Global Offset Table
Welcome to Peter's DevLog - Optional value handling in Nim
on terminal control
Hell Is Other REPLs
Use dump files in the debugger - Visual Studio (Windows)
Summary after Four Months with Ada — Programming with Ada documentation
Making an OS (x86) Chapter 7 - Cross Compiler, Bootloader, Kernel
🏡 Neil's Place
Announcing TypeScript 4.4
Linux in a Pixel Shader - A RISC-V Emulator for VRChat
What's new in C# 10.0 - C# Guide
Pin, Unpin, and why Rust needs them
Friendship ended with the garbage collector
Announcing the New TypeScript Homepage
A Stupid Little TypeScript Mistake (Part 2)
Incrementing Vectors
Patterns in confusing explanations
Performance Improvements in .NET 6
The Founder vs. Hired Executive Gap
🏡 Neil's Place
Understanding the cost of C# delegates
Elm at Rakuten | Rakuten Engineering Blog
Understanding the cost of C# delegates
What I Like About C# 9
Exploring Clang/LLVM optimization on programming horror
Performance Improvements in .NET 6
Go 1.17 is released - The Go Blog
Tutorial
Beautiful and compact Web APIs revisited – with C# 10 and .NET 6 Preview 7
Playing with System.Text.Json Source Generators - Steve Gordon - Code with Steve
Announcing TypeScript 4.4 RC
Why is Learning Functional Programming So Damned Hard?
IPv4, IPv6, and a sudden change in attitude
Resolving the ambiguity when your C++ class inherits from multiple base classes that have the same method
Mixins in Sass
I stopped sleeping, then I started hallucinating.
.NET 6 Preview 7: New Features Done, but Templates with Top-Level Statements Stir Debate -- Visual Studio Magazine
Looking into Odin and Zig: My notes
Introducing C# 10: File-scoped namespaces
String Interpolation in C# 10 and .NET 6
Preview Features in .NET 6 - Generic Math
A brief intro to MTL
A Tale of Two Copies
Vue 3.2 Released! | The Vue Point
When Zero Cost Abstractions Aren’t Zero Cost
Why am I getting a weird error about promise_type when I try to write a coroutine?
Bite-Size C# 10 - Global Usings
Looking into Zig
LÖVR
Notes about C# records and Nullable Reference Types - Event-Driven.io
Windows Community Toolkit 7.1: MVVM Source Generators, Identity Authentication, ML APIs -- Visual Studio Magazine
Bite-Size C# 10 - Null Parameter Checking
Looking into Zig
An example of using Windows Runtime interop methods from C++/WinRT: RequestTokenForWindowAsync
Stringly Typed vs Strongly Typed
SAML is insecure by design
GitHub - veorq/cryptocoding: Guidelines for low-level cryptography software
Dynamic Code Generation in Marten V4
What is a static Windows Runtime class, how should I express it, and when should I use it?
Optional Chaining: The ?. Operator in TypeScript
Full-Time Open Source - CoRecursive Podcast
TypeScript, abstract classes, and constructors | I CAN MAKE THIS WORK
GitHub - langjam/langjam
GitHub - vrtbl/passerine: A small extensible programming language designed for concise expression with little code.
Is this true? | jordan scales
Visual Studio Feedback
Introducing Triton: Open-Source GPU Programming for Neural Networks
Reconsidering the way I explain programming
Lessons learned from 15 years of SumatraPDF, an open source Windows app
What's bad about Julia?
Ncdu 2: Less hungry and more Ziggy
Advanced Error Handling in OCaml
The Catch Block #67- C# 10 Features, .NET 6 Preview 6, and VS 2022 Preview 2
Conversation about skills and learning
erikgrinaker/toydb
Introducing C# 10: Seal overriden ToString() method on records
Inserting One Billion Rows in SQLite Under A Minute - blag
Out of the Box Elixir
Pharo - Pharo 9 Released!
prathyvsh/pl-catalog
dotnet/apireviews
TypeScript 4.4 Beta Boosts Performance, Suggests JavaScript Spelling -- Visual Studio Magazine
Evolution of An Async LINQ operator
Low Ceremony, High Value: A Tour of Minimal APIs in .NET 6
C# Tips to Improve Code Quality and Performance - Code Maze
TypeScript 4.4 Improves Control Flow Analysis
Creating reusable build scripts with NUKE components
Anagrams and Prime Numbers
Compiling Rust is NP-hard
On the perils of holding a lock across a coroutine suspension point, part 2: Nonrecursive mutexes
Do not overuse primitive data types
Teaching Elixir
libimobiledevice · A cross-platform FOSS library written in C to communicate with iOS devices natively.
Software Engineer for Microsoft Technology Center Careers at Intel in San Jose, H
[PATCH 00/17] Rust support - ojeda
Realtek WiFi Firmware and a Fully 8051-based Keylogger Using RealWOW Technology
A type-safe CloudEvent
musicForProgramming("62: Our Grey Lives");
C# 10 - Top 5 New Features in the Upcoming C# Version
Stop Saving to Disk with C# Asynchronous Streams
C sharp or B flat? Experiments in self-contained native executables in .NET
Constant-Time Big Numbers: An Introduction
Announcing TypeScript 4.4 Beta
Stop Saving to Disk with C# Asynchronous Streams
Studying linker error messages to find the cause of the unresolved external: Character sets
C# 9 in-process Azure Functions | I CAN MAKE THIS WORK
2021 mid-year link clearance
What’s New for C# Nullable Reference Types in ReSharper and Rider 2021.2 EAP? | The .NET Tools Blog
Clojure metadata
Virtual DOM is pure overhead
Conditional compilation for ignoring method calls with the ConditionalAttribute
Async Debugging Part 3
React 18 and TypeScript | I CAN MAKE THIS WORK
Let's code a TCP/IP stack, 1: Ethernet & ARP
MichalStrehovsky/bflat
The ARM processor (Thumb-2), part 20: Code walkthrough
microsoft/GDK
microsoft/GDK
The ARM processor (Thumb-2), part 19: Common patterns
20 Percent Time at Supercede
ThakeeNathees/pocketlang
chrisseaton/rhizome
Julia: faster than Fortran, cleaner than Numpy
Learning to Love a Rigid and Inflexible Language
The ARM processor (Thumb-2), part 15: Miscellaneous instructions | The Old New Thing
Async Debugging Part 2
Visual Studio 2022 Preview Release Notes
Nuitka/Nuitka
Don't Code Tired | ICYMI C# 9 New Features: Top-level Statements
Cryptography updates in OCaml and MirageOS
The ARM processor (Thumb-2), part 13: Trampolines | The Old New Thing
nushell/nushell
C# 10 - `record struct` Deep Dive & Performance Implications
Running .NET Core Apps on a Framework other than Compiled Version?
New tools from Microsoft Research help developers write bug-free code, faster - AI for Business
I Have No Group, and I Must Scream
The ARM processor (Thumb-2), part 10: Memory access and alignment | The Old New Thing
Why is Async code hard to debug?
Why is Async code hard to debug?
A Closer Look at 5 New Features in C# 10
The ARM processor (Thumb-2), part 9: Sign and zero extension | The Old New Thing
Going Beyond ESLint: Overview Static Analysis in JavaScript
Low Ceremony, High Value: A Tour of Minimal APIs in .NET 6
C# Generics Best Practices
Learn TypeScript Basics in this Beginner's Guide
Developer Week ’21 | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
Different ways to check if a value is null in C# - Gérald Barré
Debugging C# Source Generators with Visual Studio 2019 16.10 - Steve Talks Code
dotnet/roslyn
Challenging myself to understand RISC-V
0.8.0 Release Notes ⚡ The Zig Programming Language
The ARM processor (Thumb-2), part 5: Arithmetic | The Old New Thing
Vitess | A new Protocol Buffers generator for Go
Tour of our 250k line Clojure codebase
Distributed cloud builds for everyone
string vs. String is not a style debate
Benchmarking 4 reflection methods for calling a constructor in .NET
GCC drops its copyright-assignment requirement
Driving with D
Helix
Benchmarking 4 reflection methods for calling a constructor in .NET
The ARM processor (Thumb-2), part 2: Differences between classic ARM and Thumb-2 | The Old New Thing
The ARM processor (Thumb-2), part 1: Introduction | The Old New Thing
Adam Storr - Quick Tip - Compiler Directives and Using Aliases to Ignore Tests
Benchmarking 4 reflection methods for calling a constructor in .NET
C# 10.0: Introducing Global Usings
From State tennis to endomorphism
“True Lies” – or “What LLVM Claims, but Fails to Deliver”
On the proper care and feeding of the default_overload Windows Runtime attribute | The Old New Thing
On the proper care and feeding of the default_overload Windows Runtime attribute | The Old New Thing
Sparkplug — A non-optimizing JavaScript compiler · V8
Adventures in rustc Forking
The state of tooling for verifying constant-timeness of cryptographic implementations
What's New for F# in Visual Studio 16.10 -- Visual Studio Magazine
Building a Source Generator for C#
Let’s Build a Regex Engine
F# and F# tools update for Visual Studio 16.10 | .NET Blog
ReSharper 2021.2 Roadmap | The .NET Tools Blog
.NET Basics - Dusted Codes
In praise of --dry-run | G Research
Why I prefer making useless stuff
C is not a serious programming language – keeping simple
Zig Makes Rust Cross-compilation Just Work · Um, actually...
Building LLVM in 90 seconds using Amazon Lambda
Conversation about ready to run | .NET Blog
Elixir v1.12 released
Conversation about PGO | .NET Blog
The blessing of the leading zero | The Old New Thing
Against consistency
Sébastien Wilmet - Blog post
Release Cosmopolitan v1.0 · jart/cosmopolitan
Updating FloatingGlucose to .NET 5 - Display Nightscout or Dexcom Glucose Values on the Windows Desktop
Half a million lines of Go
Async/Await Calls Gotcha with the CSharp ? Null Propagator
Things you can’t do in Rust (and what to do instead) - LogRocket Blog
POLAR - Creating a Virtual Machine in .NET
Mostly harmless: An account of pseudo-normal floating point numbers - Red Hat Developer
Overview — Programming with Ada documentation
Patterns - C# reference
Mercury Brings Visual Basic to Feature Parity with C# and Adds Multiple Platform Support
Erlang/OTP 24 Highlights
The Plan for the Rust 2021 Edition | Rust Blog
The Future of Code Editor
Introducing csharp 10
Making eBPF work on Windows - Microsoft Open Source Blog
Understanding iOS application entry point
microsoft/ebpf-for-windows
dotnet/runtimelab
Apple Silicon Hardware Secrets: SPRR and Guarded Exception Levels (GXF)
Gleam v0.15 released! – Gleam
Basic telemetry for the Audacity by crsib · Pull Request #835 · audacity/audacity
benaadams/Ben.Demystifier
Non-structural Type Constraints
Add Simple C# Programs by cartermp · Pull Request #213 · dotnet/designs
Portability is Reliability
String.Format Method (System)
davidfowl/CommunityStandUpMinimalAPI
facebookincubator/cinder
Hello World - Introduction to C# interactive C# tutorial
C++ coroutines: Promise constructors | The Old New Thing
One thing I miss from Mercury
Is abstraction killing civilization? | datagubbe.se
Is the era of reflection-heavy C# libraries at an end?
.NET News Roundup - Week of April 26th, 2021
Rosenzweig – Dissecting the Apple M1 GPU, part IV
The Byte Order Fiasco
Dream desktop – Sam Squire's personal blog
LB27 first's line is obsolete from Daniel Bünzli via Unicode on 2020-03-03 (Unicode Mail List Archive)
The Little Things: everyday efficiencies
Rust programming language: We want to take it into the mainstream, says Facebook
Nullable Reference types in C# – Best practices
noir-lang/noir
.NET 6 LINQ Improvements
Uno Platform Uno Platform 3.7 - More WinUI, Project Reunion and Linux support, Wasm performance boost
Zero-knowledge Virtual Machines, the Polaris License, and Vendor Lock-in
C++ coroutines: Snooping in on the coroutine body | The Old New Thing
Introducing DRPC: Our Replacement for gRPC
Clean Architecture Refactoring: A Case Study - NDepend
Introducing GraphQLinq - Strongly Typed GraphQL Queries with LINQ to GraphQL. | Giorgi Dalakishvili | Personal Website
OCaml for the Masses - ACM Queue
Why does a zero-length stackalloc make the C# compiler happy to allow conditional stackallocs?
Running Lisp in Production
Some more C# 9 - Red Hat Developer
Useful features from C# 7 to 9 with Julien Couvreur
Introduction
Parsing Protobuf at 2+GB/s: How I Learned To Love Tail Calls in C
Rust Language Cheat Sheet
Setting Up Sass with Blazor
The Compiler Writer Resource Page
C++ coroutines: Associating multiple task types with the same promise type | The Old New Thing
Cerebras’ New Monster AI Chip Adds 1.4 Trillion Transistors - IEEE Spectrum
Ben.Demystifier 0.4.1
Conversation about crossgen2 | .NET Blog
Effectful Effects - Unifying Bidirectional Communication between Software Components
Node.js 16 available now
Rust and cryptographic code | Bulletproof TLS Newsletter
C# 9 init accessors and records - Red Hat Developer
Introduction to .NET - Learn
Loop alignment in .NET 6 | .NET Blog
Rosenzweig – Dissecting the Apple M1 GPU, part III
Async and Await In C#
What's in the box? - fasterthanli.me
Up For Grabs
My Go Executable Files Are Still Getting Larger (What's New in 2021 and Go 1.16)
Getting Started With Radare2
Rust in the Linux kernel
[PATCH 00/13] [RFC] Rust support
Why Rust strings seem hard
What is F#
[PATCH 00/13] [RFC] Rust support
Gregory Szorc's Digital Home | Rust is for Professionals
RAD Basic: a 100% compatible Visual Basic 6 solution
Visual Studio 2019 v16.10 Preview 2 Releases Today | Visual Studio Blog
C++ coroutines: Making it impossible to co_await a task twice | The Old New Thing
The FreeBSD Project | FreeBSD 13.0-RELEASE Release Notes
C# 9 new features for methods and functions - Red Hat Developer
A build tool for the rest of us
One Letter Programming Languages
C++ coroutines: The lifetime of objects involved in the coroutine function | The Old New Thing
.NET Foundation Project Spotlight
zhuowei/nft_ptr
My Favorite C# Features - Part 3: Nullability
.NET Internals Cookbook Part 1 — Exceptions, filters and corrupted processes – Random IT Utensils
The Cursed Computer Iceberg Meme
mratsim/constantine
microsoft-sponsorships/microsoft-foss-fund
C++ coroutines: Managing the reference count of the coroutine state | The Old New Thing
Microsoft Opens Up C# Standardization Work -- Visual Studio Magazine
What's Cool in C# 8 and .NET Core 3 -- Visual Studio Magazine
C++ coroutines: Awaiting the simple_task | The Old New Thing
C++ coroutines: Accepting types via return_void and return_value | The Old New Thing
The pain points of C# source generators
All C++20 core language features with examples
The Fastest, Safest PNG Decoder in the World
Eliminating Data Races in Firefox – A Technical Report – Mozilla Hacks - the Web developer blog
10 Things I Hate About PostgreSQL
Announcing Open Source C# standardization | .NET Blog
Announcing Open Source C# standardization | .NET Blog
Raspberry Pi GPIO C# LED | C# Tutorials Blog
The Strange Case Of The Illegal Instruction
My "shiny future"
Windows 95 — How Does it Look Today?
The Exception Model
XKCP/K12
signed char lotte
The compiler will optimize that away
Autism challenges on the workplace (2021, 2/5) - A disability of trust
dotnet/csharplang
A categorized list of all Java and JVM features since JDK 8 to 16
C++ coroutines: What happens if an exception occurs in my return_value? | The Old New Thing
Unveiling Gavran: RavenDB re-written in C
gd/rust - platform/system/bt - Git at Google
C# 9 (Two Decades of C#: A Reference) • Ben Bowen's Blog
C++ coroutines: The initial and final suspend, and improving our return_value method | The Old New Thing
C++ coroutines: Basic implementation of a promise type | The Old New Thing
C# 9 top-level programs and target-typed expressions - Red Hat Developer
Be careful when mixing ValueTask and Task.Run - Gérald Barré
C++ coroutines: The mental model for coroutine promises | The Old New Thing
Pin and suffering - fasterthanli.me
JonDouglas/score
C# 8 (Two Decades of C#: A Reference) • Ben Bowen's Blog
Compiler Explorer - C++ (x86-64 clang (assertions trunk))
Async and Await and what is it actually doing?
Announcing Rust 1.51.0 | Rust Blog
A "Better C" Benchmark
Loop alignment in .NET 6 | .NET Blog
Julia 1.6 Highlights
C# 7 (Two Decades of C#: A Reference) • Ben Bowen's Blog
Women of Computing
C++, Getting Started with the Basics: Working with Dependencies and Linker
Let's Build a File Watcher
Linus Torvalds on where Rust will fit into Linux | ZDNet
Creating a task completion source for a C++ coroutine: Producing a result | The Old New Thing
Crystal 1.0 - What to expect
C# 5 and C# 6 (Two Decades of C#: A Reference) • Ben Bowen's Blog
C++, Getting Started with The Basics: Hello World and The Build Pipeline
How safe is zig?
git/next/linux-next.git - The linux-next integration testing tree
Moving from CentOS to Ubuntu
C# 2, 3 and 4 (Two Decades of C#: A Reference) • Ben Bowen's Blog
C# 9 records as strongly-typed ids - Part 5: final bits and conclusion
Episode 72 - Emulating a Video Game System in .NET with Ryujinx
Loop alignment in .NET
Visual Basic 16.9 in .NET 5
ezrosent/frawk
apple/swift-evolution
totally_safe_transmute, line-by-line
Windows APIs Everywhere in .NET
How C++ Resolves a Function Call
Introducing PeachPie 1.0.0
Show Recursion Show
Is Crossplane the Infrastructure LLVM?
Speed of Rust vs C
ASP.NET Community Standup - How to contribute to Blazor
Interpolating the internet
012. I Shipped, Therefore I Am
mortdeus/legacy-cc
Zig, Parser Combinators - and Why They're Awesome
My Favorite C# Features Part 2: LINQ
netaddr.IP: a new IP address type for Go
GNU coreutils – MaiZure's Projects
TypeScript Handbook Revamped as Primary Learning Resource -- Visual Studio Magazine
What's New in Visual Basic on .NET 5?
Creating other types of synchronization objects that can be used with co_await, part 2: The basic library | The Old New Thing
part 1 — Store Halfword Byte-Reverse Indexed
The .NET Docs Show - Compiler time dependency injection in C# using StrongInject
New in Visual Studio F# Tooling: .NET 5 Scripting and F# Interactive -- Visual Studio Magazine
Why asynchronous Rust doesn't work
On .NET Live - Deep Dive into Microsoft Orleans
Unexpected finding about “await using var”
Finding Mona Lisa in the Game of Life
Everything You Want to Know About the Record Type in .NET 5… But Were Afraid to Ask
Announcing the New TypeScript Handbook | TypeScript
reflections on the competing IDEs
Microsoft Releases Visual Studio 2019 for Mac v8.9
The trouble with SPIR-V
eyal0/valgrind-false-positive
Visual Studio 2019 for Mac v8.9 Ships with .NET 6 Preview 1 Support -- Visual Studio Magazine
Creating a co_await awaitable signal that can be awaited multiple times, part 4 | The Old New Thing
Microsoft Releases Visual Studio 2019 v16.9
F# and F# tools update for Visual Studio 16.9 | .NET Blog
Creating a co_await awaitable signal that can be awaited multiple times, part 3 | The Old New Thing
The 8 most missing features in C# – TooSlowException
Watchy: The Hackable $50 Smartwatch - IEEE Spectrum
Add proposal for lambda improvements by cston · Pull Request #4451 · dotnet/csharplang
Visual Studio 2019 version 16.9 Release Notes
Lotus 1-2-3
Microsoft Extends Low-Code Push with Power Fx Programming Language -- Visual Studio Magazine
How to Read Assembly Language
How to execute an object file: Part 1
Retrieve compiler flags and metadata reference data as defined in htt… · NuGetPackageExplorer/NuGetPackageExplorer@3bbcfd7
dotnet/runtime
Course Review – “Programming Languages” Series on Coursera - Vasil Kosturski
Strongly-typed Ids using C# Source Generators - Gérald Barré
📦 Demystify - com.needle.demystify
.NET News Roundup - Week of Feb 22th, 2021
TypeScript Function Syntaxes
Weird architectures weren't supported to begin with
C# 9 Is Out
Microsoft's Tools to Fight Solorigate Attack Are Now Open Source -- Visual Studio Magazine
Const generics MVP hits beta! | Rust Blog
Librsvg, Rust, and non-mainstream architectures
Don't define functions inline in your public headers
Intention in languages
Opus Codec
C#'s Functional Journey
New TypeScript 4.2 Tweaks Include Project Explainer -- Visual Studio Magazine
Announcing TypeScript 4.2 | TypeScript
Teaching Compilers Backward
Boosting Productivity and Performance with the NVIDIA CUDA 11.2 C++ Compiler | NVIDIA Developer Blog
Why Discord is switching from Go to Rust
rui314/mold
Kowainik - Totality
Add static PBKDF2 one-shot methods · dotnet/runtime@0c47471
Reverse engineering a GameBoy Advance game — Complete Guide
Immediate-Mode-UI/Nuklear
My Favorite C# Features - Part 1: Strong-types, Implicit-types, Anonymous-types, and Target-types
A methodical approach to looking at F# compile times · Discussion #11134 · dotnet/fsharp
The modern packager’s security nightmare – Michał Górny
GridProtectionAlliance/go2cs
TeeChart for .NET - BuiltWithDot.Net
0 A.D. | A free, open-source game of ancient warfare
Understanding “reversed” callstacks in Visual Studio and Perfview with async/await code
Gleam v0.14 released! – Gleam
Introduction to Mixins in TypeScript
Cross compiling made easy, using Clang and LLVM · mcilloni's blog
elixir-nx/nx
A primer on code generation in Cranelift
Life, part 38
The Worst Experience I've Had With an aarch64 MacBook
OTCC : Obfuscated Tiny C Compiler
Julia 1.6: what has changed since Julia 1.0?
Announcing TypeScript 4.2 RC | TypeScript
For the Love of Macros
Finding Bugs in C and C++ Compilers using YARPGen
ratfactor/ziglings
3,2 milliards d'emails et de mots de passe fuités ? Impressionnant, mais pas inquiétant - Cyberguerre
tensorflow/swift
VS Code C++ Tool Customizes IntelliSense for Target Platforms -- Visual Studio Magazine
C#/WinRT Authoring Preview Unveiled -- Visual Studio Magazine
Release v5.0.211103 · dotnet/format
Announcing Rust 1.50.0 | Rust Blog
spec: add generic programming using type parameters · Issue #43651 · golang/go
[Guest Post] Better refactoring for Unity projects using .NET analyzers | Visual Studio Blog
Cake Frosting: More Maintainable C# DevOps
From First Principles: Why Scala?
The Technology of iCircuit 3D
What's the Difference between Channel<T> and ConcurrentQueue<T> in C#?
Reverie: An optimized zero-knowledge proof system
The state of JVM desktop frameworks: Jetpack Compose for Desktop
Machine Learning Community Standup - Statistics & ML with FSharp.Stats
Rust Foundation
An Introduction to Channels in C#
Writing high performance F# code
Is abstraction killing civilization? | datagubbe.se
The problems with the GPL
On the Missed Opportunities of Static Types
The .NET Docs Show - Using Source Generators for Fun (and Maybe Profit)
Compiling DirectShow.Net for use in .NET 5
rust-analyzer/rust-analyzer
The spectrum of synchronousness - The Engineering Manager
Inline caching: quickening
Working with large .NET 5 solutions in Visual Studio 2019 16.8 | Visual Studio Blog
Creating Discoverable HTTP APIs with ASP.NET Core 5 Web API | ASP.NET Blog
Usage patterns for winrt::unbox_value_or | The Old New Thing
Go (golang) Anonymous Functions - Inlining Code for Goroutines
Go (golang) Channels - Moving Data Between Concurrent Processes
Llama Rust SDK preview 0.1.3
Why I still Lisp (and you should too!)
C# Nullable reference types – No more null reference exceptions!
The weirdest compiler bug
Discover - Pony
Using fetch with TypeScript
Using C# Source Generators to create an external DSL | .NET Blog
PostSharp's Great Reset: Announcing Project "Caravela", a Roslyn-based aspect framework
Cranelift, Part 2: Compiler Efficiency, CFGs, and a Branch Peephole Optimizer
Zig Makes Go Cross Compilation Just Work
dotnet/runtimelab
VSCode, Dev Containers and Docker: moving software development forward - Sticky Bits - Powered by Feabhas
Design Draft: First Class Fuzzing
Visual Studio 2019 v16.9 Preview 3 is Available Today | Visual Studio Blog
Porting Firefox to Apple Silicon – Mozilla Hacks - the Web developer blog
Preview: The SQLite Llibrary as a .NET assembly
Compilers are hard | ShipReq Blog
Dynamic type systems aren't even simpler - hisham.hm
Fun with conversion-operator name lookup
Introducing Textrude - using Scriban to generate code from data
Julia Update: Adoption Keeps Climbing; Is It a Python Challenger?
Reducing tail latencies with automatic cooperative task yielding
DO NOT MERGE: Regex source generator prototype by pgovind · Pull Request #47065 · dotnet/runtime
@devlead - Mattias Karlsson's Blog - My preferred .NET console stack
Here's a One-Stop Shop for .NET 5 Improvements -- Visual Studio Magazine
source.winehq.org Git - wine.git/blob - ANNOUNCE
Announcing TypeScript 4.2 Beta | TypeScript
The misleading MIDL error message: MIDL5023: The arguments to the parameterized interface are not valid | The Old New Thing
Go (golang) Error Handling - A Different Philosophy
theseus-os/Theseus
How we quickly refactored with Resharper more than 23.000 calls to Debug.Assert() into more meaningful assertions - NDepend
pakrym/jab
How Does .NET 5 Do XAML? By Decoupling It from Windows with WinUI 3, C#/WinRT and More -- Visual Studio Magazine
Why Haskell is our first choice for building production software systems – Foxhound Systems
SUCCESS: iPhone 7 with dead NAND netbooting unmodified Ubuntu 20.04 arm64 over usb gadget ethernet
How did I find the old Windows binaries and compilers for the processor retrospective series? | The Old New Thing
Go (golang) Loops - A Unified "for"
Writing your own NES emulator Part 3 - the 6502 CPU
Rust-GCC/gccrs
The Architecture of Open Source Applications: LLVM
Why mmap is faster than system calls
WinUI 3 Preview 3 | Windows Dev
Rosenzweig – Dissecting the Apple M1 GPU, part I
Wasmer 1.0
Why I'm Learning F# in 2021
Strongly typing <code>react-query</code>s <code>useQueries</code>
GRVYDEV/Project-Lightspeed
The Best Software Every Reverse Engineer Should Have for Cracking Software | PiProgramming
A half-hour to learn Rust - fasterthanli.me
osnr/horrifying-pdf-experiments
State machines are wonderful tools
I'd like an IUnknown, I know you have many, I'll take any of them | The Old New Thing
Mac meets Arm64
Announcing Rust 1.49.0 | Rust Blog
Glasgow Haskell Compiler 9.0.1-rc1 now available!
Why are the C and C++ compilers giving me error messages about int when my code doesn't mention int? | The Old New Thing
What's new in PHP 8 - stitcher.io
C# A to Z: Prelude
Cosmopolitan C Library
Executable PNGs - djhworld
Some Differences between macOS and Common Unix Systems
A Complete Guide to LLVM for Programming Language Creators
New Release: Tor Browser 10.0.7 | Tor Blog
Why I've Been Merging Microservices Back Into The Monolith At InVision
Cloudflare Acquires Linc
Cakelisp: a programming language for games
C# In Simple Terms - Iterators
Nullable reference types; CSharp's very own <code>strictNullChecks</code>
Arrows born in flight
C# vs. F# – planetgeek.ch
The Shape of 1.7M Lines of Code · Stefan-Marr.de
ollelogdahl/ihct
.NET 5 Source Generators - MediatR - CQRS
Playing with C#9 Top-level Programs, Records and Elasticsearch.NET - Steve Gordon - Code with Steve
What I Wish Someone Had Told Me About Tensor Computation Libraries
How Tail Call Optimization Works
ReSharper 2020.3: Support for C# 9 and Source Generators, New Features in Inlay Hints, and Support for Avalonia UI – .NET Tools Blog | JetBrains
Dynamic Class Creation in C# - Preserving Type Safety in C# with Roslyn
About Cyberpunk 2077 and AMD CPUs
These Modern Programming Languages Will Make You Suffer
Reindeer Secret Santa Assignment Problem
CS 6120: The Self-Guided Course
Thread by @StanTwinB on Thread Reader App
Bebop: An Efficient, Schema-based Binary Serialization Format | Rainway
r/Kotlin - [OC] Compiler plugins are amazing!
C# Source Generators - Write Code that Writes Code
Visual Studio 2019 v16.9 Preview 2 and New Year Wishes Coming to You! | Visual Studio Blog
What’s New on F#: Q&A With Phillip Carter
thought leaders and chicken sexers
Inside the Quantum Katas, part 1 | Q# Blog
Wiki: TypeScript | Barbarian Meets Coding
C# 9 and Foreach Extensibility · Lukáš Lánský
libra/libra
QBE vs LLVM
.NET 5 Breaking Changes to the Base Class Library
Writing Rust the Elixir way
[Guest Post] Introducing WaveEngine 3.1 based on .NET 5 | .NET Blog
C# In Simple Terms - String Manipulation and Cultures
ARM and Lock-Free Programming
mhx/dwarfs
Duplex gPRC
pallada-92/dna-3d-engine
Yes, I use Nix
Apple Silicon M1: A Developer’s Perspective
Going all-in with nullable reference types
「Dflat」Structured Data Store for Mobile
Upgrading ConfigurationManager for .Net 5
.Net 5 is PERFECT for DevOps
microsoft/TypeScript
C# 9 Records as DDD Value Objects
Why AWS loves Rust, and how we’d like to help | Amazon Web Services
Compiler Explorer - C
FSDN
C# 9 - Improving performance using the SkipLocalsInit attribute - Gérald Barré
Exotic Programming Ideas: Part 3 (Effect Systems)
TIL: eBPF is awesome
A Taste of OCaml's Predictable Performance - Dev.Poga
In New Releases, Microsoft Lauds .NET Productivity, Visual Studio 2019 Speed -- Visual Studio Magazine
Enabling C# 9 in Xamarin & .NET Standard Projects
Eight years at Roblox
C# in Simple Terms - Attributes and Reflection
Other uses for the -library flag of the C++/WinRT compiler | The Old New Thing
What's new in .NET Productivity | .NET Blog
On combining static libraries that implement C++/WinRT activatable objects | The Old New Thing
C# Index and Range Operators Explained - NDepend
Graphics for JVM
The C Standard Library Is Not Dependency Free
C# in Simple Terms - Tuples and Anonymous Types
Bulletproof uniq with TypeScript generics (yay code reviews!)
xoofx/Broslyn
A Comparison of Modern Graphics APIs
ASP.NET Core 5 Model Binding to C# 9 Record Types
Linux graphics, why sharing code with Windows isn't always a win.
C# in Simple Terms - Generics
Why an IDE?
Running Python on .NET 5
The Resurgence of Functional Programming - Highlights From QCon Plus
Visual Studio 2019 v16.8 Ships with Git Turned On by Default -- Visual Studio Magazine
Announcing F# 5 | .NET Blog
C# 9: Record Types Introduction & Deep-Dive | Claudio Bernasconi
OR_GREATER preprocessor symbols for TFMs by terrajobst · Pull Request #164 · dotnet/designs
The Tao of Programming
DevDay 2020: Using Roslyn to improve your codebase
Module Initializers In C# 9
Multithreading Handbook for Simulation Developers
My first-time pure functional programming - Sandro Maglione
Rust vs Go — Bitfield Consulting
The Turing-Completeness Problem - Alan Language
Life and Death of a Linux Process
.NET Live TV | Live developer streams every day
C# in Simple Terms - Arrays and Collections
A first look at the JIT
Modernizing a codebase for C# 9
Best practice when naming Durable Functions in C#
Stop compilation after first error
C#9 - init-only properties are not read-only at runtime - Gérald Barré
Leaving OCaml
Are C# 9 records immutable by default?
C# in Simple Terms - Exceptions and Exception Handling
Pattern matching in C# 9.0
Using C# 9 records as strongly-typed ids
The Man Who Carried Computer Science on His Shoulders – Krzysztof Apt – Inference
For Complex Applications, Rust is as Productive as Kotlin
C# 9 The unknown goodies | Miguel Bernard's Blog
Awaitable/awaiter pattern and logical micro-threading in C#
Unity 2020.1 is now available
Pyston v2: 20% faster Python
A Type of Useless
Windows Runtime objects are represented by their default interface, so choose your default interface wisely | The Old New Thing
Splitting Large Interfaces Into Smaller Ones Is Easy
Surviving disillusionment
Bytecode Alliance: One year update
Why we chose Java for our High-Frequency Trading application
Fast bitmap iteration in C#
I told the Microsoft Visual C++ compiler not to generate AVX instructions, but it did it anyway! | The Old New Thing
Standard ML in 2020 | notes.eatonphil.com
QuickJS Javascript Engine
Lets Talk .NET 5, with Scott Hunter
Beautiful and compact Web APIs with C# 9, .NET 5.0 and ASP.NET Core
C# 8.0 nullable references: defeating the point with empty strings | endjin
/* You Are Not Expected to Understand This */
A fucking rant about fucking const vs fucking let
switch expression - C# reference
C# support · Issue #156 · github/semantic
The .NET Foundation Joins the Open Source Initiative's Affiliate Program
Assorted thoughts on zig (and rust)
Monomorphic functors
Why mmap is faster than system calls
Structure and Interpretation of Computer Programmers
C# in Simple Terms - Structs and Enums
Object Detection at 1840 FPS with TorchScript, TensorRT and DeepStream
Towards sockets and networking in WebAssembly and WASI - radu's blog
A Highly Biased Review of C# Changes from Version 1.0 to 9.0
ironcev/awesome-roslyn
LISP From Nothing - T3X.ORG
Version 1.4.0 released
kekyo/IL2C
MVVM Toolkit Preview 3 & The Journey of an API | PAX - Windows
C# in Simple Terms - Classes and Members
A brief introduction to C++ structured binding | The Old New Thing
C# 8.0 nullable references: prepare today by not misusing 'as' | endjin
LDM: My Favorite ARM Instruction
The Importance of Memory | Barnabas Kendall
What’s New In .Net 5? - Solace Infotech Pvt Ltd
Use is null/is not null for null checking by marek-safar · Pull Request #43360 · dotnet/runtime
Async code smells and how to track them down with analyzers - Part I
[llvm-announce] LLVM 11.0.0 Release
BinomialLLC/bc7e
C# in Simple Terms - Methods, Parameters, and Arguments
In 1979, some software company in Bellevue was hiring | The Old New Thing
Linux Hardware Reviews, Open-Source Benchmarks & Linux Performance
The Observation Deck » Rust after the honeymoon
ymte/metamine
Adelaide .NET User Group (Adelaide, Australia)
chsienki/Kittitas
Llama preview 0.1.2
Reverse engineering my cable modem and turning it into an SDR
To The Assembly - CoRecursive Podcast
.NET code style rule options - .NET
Announcing Rust 1.47.0 | Rust Blog
Writing JavaScript tools in other languages – a new trend?
Error C3867: non-standard syntax; use '&' to create a pointer to member: What it means and how to fix it | The Old New Thing
Two ways you can take advantage of types in JavaScript (without TypeScript) - The Blinking Caret
Elixir v1.11 released
Life, part 36
What you could steal from the Kakoune code editor right now, and get away with it
How we ran a Unix-like OS (Xv6), on our home-built CPU with our home-built C compiler
Wiki - RustStarterKit2020
LLVM provides no side-channel resistance
Little gotcha with C++/WinRT iterators: The case of the mutated temporary | The Old New Thing
rui314/chibicc
C# in Simple Terms - Casting, Conversion, and Parsing
A categorized list of all Java and JVM features since JDK 8 to 15
It Is Never a Compiler Bug Until It Is
kzu/NuGetizer
Things I Was Wrong About: Types — Sympolymathesy, by Chris Krycho
C# in Simple Terms - Primitive Types, Literals, and Nullables
Thoughts on Structured Editing: Breaking Away from Syntax
Zig's New Relationship with LLVM
Introducing DotNet.SystemCollections.Analyzers
A tale of two libcs
A tale of two libcs
Things Elixir's Phoenix Framework Does Right
JsonSrcGen + CoreRT = Pure Magic
ggerganov/wave-share
How Oodle Kraken and Oodle Texture supercharge the IO system of the Sony PS5
This is a pretty dire assessment of Mozilla
C# in Simple Terms - The Type System
Python behind the scenes #2: how the CPython compiler works
Firefox usage is down 85% despite Mozilla's top exec pay going up 400%
How to generate code using Roslyn source generators in real world scenarios
Introducing Swift on Windows
Using Disassembly Tool for optimized debugging
Build Xamarin.iOS apps using iOS 14 and Xcode 12 | Xamarin Blog
Why not rust for security?
Introducing C# in Simple Terms!
Why Not Rust?
Write Xamarin.Mac Apps With JetBrains Rider
Why Not Rust?
evanw/esbuild
TL;DR Rust
pin_ptr (C++/CLI)
Dev Discussions - Isaac Abraham
Fabulous: Functional App Development | Xamarin Blog
Release v3.0.0 One Piece · vuejs/vue-next
I get a weird error about no matching function when I try to use winrt::capture | The Old New Thing
C# 9.0: Target-typed expression | Miguel Bernard's Blog
C++ Leads Visual Studio 2019 v16.8 Preview 3 Improvements -- Visual Studio Magazine
Microsoft announces new Project OneFuzz framework, an open source developer tool to find and fix bugs at scale - Microsoft Security
CSS isolation in Blazor - Gérald Barré
Why did I lose the ability to co_await a std::future and concurrency::task? | The Old New Thing
Zigソフトウェア財団とZenプログラミング言語に関する声明 - News - The Zig Programming Language
Home
.NET Adds Latent Bug Discovery Feature
– Wren
Disassembly improvements for optimized managed debugging | Visual Studio Blog
Announcing .NET 5.0 RC 1 | .NET Blog
DotFest 2020: Using Roslyn to improve your codebase
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
Fabulous: Functional App Development | Xamarin Blog
The macros for declaring COM interfaces, revisited: C++ implementation | The Old New Thing
[llvm-dev] [RFC] Machine Function Splitter
C# 9.0: Improved pattern matching | Miguel Bernard's Blog
The macros for declaring COM interfaces, revisited: C++ version | The Old New Thing
The Amazing $1 Microcontroller - Jay Carlson
C# 9.0: Target-typed New Expressions – Make Your Initialization Code Less Verbose
The macros for declaring COM interfaces, revisited: C version | The Old New Thing
How to speed up the Rust compiler one last time – Nicholas Nethercote
C++/WinRT injects additional constructors into each runtime class | The Old New Thing
Massacring C Pointers
What Every C Programmer Should Know About Undefined Behavior #2/3
Top-level programs in C# 9.0
samizdatco/skia-canvas
Rough edges in the when_all coroutine, part 1: Empty parameter list | The Old New Thing
C# 9.0: Records – Work With Immutable Data Classes
In Defense of a Switch
dotnet/roslyn
chsienki/Kittitas
Announcing PeachPie 1.0-preview1 @ PeachPie
Improvements in native code interop in .NET 5.0 | .NET Blog
New C# Source Generator Samples | .NET Blog
C# preprocessor directive symbols from the dotnet build command line via DefineConstants
Azure/bicep
App Trimming in .NET 5 | .NET Blog
Supporting Linux kernel development in Rust
Soatok’s Guide to Side-Channel Attacks
System Programming in 2k20
Tips for stable and portable software
.NET R&D Digest (August, 2020)
Real-time rendering of water caustics
Exploring mullender.c - A deep dive into the first IOCCC winner :: LainSystems
Zero-Knowledge Proofs from Information-Theoretic Proof Systems - Part I | ZKProof Standards
Objective-Rust
Linux Hardware Reviews, Open-Source Benchmarks & Linux Performance
Meet Silq- The First Intuitive High-Level Language for Quantum Computers
Automatically find latent bugs in your code with .NET 5 | .NET Blog
C++ with Visual Studio Code on macOS
Configure VS Code for Clang/LLVM on macOS
.NET Rocks! vNext
Is TDD Dead
The 2020 Virtual LLVM Developers' Meeting Program
Asynchronous programming - C#
C# to the max! Continuations, co-routines and Source Generators!
Thinking about dependencies :: sunshowers
MSBuild Log Viewer
Exclude code that follows [DoesNotReturn] from code coverage (per #898) by kevin-montrose · Pull Request #904 · coverlet-coverage/coverlet
First thoughts on Rust vs OCaml
davidfowl/CommunityStandUpNet5
ASP.NET Core 5: Make your options immutable
Porting a Golang and Rust CLI tool to D
Kowainik - Haskell mini-patterns handbook
Introducing C# 9: Native-sized integers
SSH Considered Harmful – Why You Should Be Using Persistent Sessions
Hiding messages in x86 binaries using semantic duals
Code Smell: Concrete Abstraction
p-j-miller/ya-sprintf
Frustrated? It's not you, it's Rust - fasterthanli.me
Write your Own Virtual Machine
"Rust does not have a stable ABI"
Equality for free – planetgeek.ch
Post-Open Source
Serverless apps on AWS using F# and fable
Search is too good - A Walk Within Boredom
Announcing TypeScript 3.1 | TypeScript
Building a BASIC Interpreter, '80s style
Let’s implement a Bloom Filter
How I Modernized My Flash Game
Why I Can’t Stand the FSF
Why the C Language Will Never Stop You from Making Mistakes
Use C# Preprocessor Directives
Announcing TypeScript 4.0 RC | TypeScript
Introducing C# 9: Extending Partial Methods
Introducing Rome
Hedging tail risk, emigration, keyboard superoptimization
First Impressions of Rust
Accelerating Standard C++ with GPUs Using stdpar | NVIDIA Developer Blog
Merge Extension GetEnumerator into master by 333fred · Pull Request #46573 · dotnet/roslyn
acidanthera/OpenCorePkg
Visual Studio 2019 v16.7 and v16.8 Preview 1 Release Today! | Visual Studio Blog
What is default(object) used for?
Why are you testing your software?
Fuzzy.Blazor.FluentRenderTreeBuilder 1.1.0
Announcing the new TypeScript Website | TypeScript
Introducing localization support in OpenIddict 3.0 beta3
The Julia Language
Best Practices for Regular Expressions in .NET
What Happened When I Peeked Into My Node_Modules Directory
Niklaus Wirth was right and that is a problem – bowero
The Haskell Elephant in the Room
Learn about the latest .NET Productivity features | .NET Blog
WasmBoxC: Simple, Easy, and Fast VM-less Sandboxing
Task asynchronous programming as an IO surrogate
BenchmarkDotNet 0.12.1
Writing more succinct C# – in F# (Part 1)!
adam-mcdaniel/oakc
froggey/Mezzano
PostSharp Blog | Thinking beyond Roslyn source generators and aspect-oriented programming
Dhghomon/easy_rust
.NET Foundation Projects
Phillip Carter
Svelte <3 TypeScript
How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More | Carol's Blog
Farmer: Simpler ARM deployments with Octopus Deploy - Octopus Deploy
I Don't Want to be a Founder and I Don't Think You Do Either | Carol's Blog
Understanding F# applicatives and custom operators
lawl/NoiseTorch
Mainframe workloads supported on Azure
Compiler Explorer - C (x86-64 clang 10.0.0)
C# 9: New `and`, `or`, and `not` Keywords for Pattern Matching
My First PC
Announcing Rust 1.45.0 | Rust Blog
C# 9 Deep Dive: Target Typing and Covariant Returns
All .Net Exceptions List
How to stop worrying and adopt nullable reference types – Webinar Recording
Linux kernel in-tree Rust support
Performance Improvements in .NET 5 | .NET Blog
Generating the Premier League Table in F#
Type-Safe Single Page Apps: F# Vs. TypeScript
The Soul of a New Debugger
V8 release v8.4 · V8
Linux kernel in-tree Rust support
Linux kernel in-tree Rust support
A deep-dive into WinUI 3 in desktop apps - Windows Developer Blog
Pwning smart garage door openers
Martin Björkström - gRPC Server Reflection in the .NET world
Flatter wait-free hazard pointers - Paul Khuong: some Lisp
C# 8.0 nullable references: MaybeNull | endjin
Writing a winning 4K intro in Rust
A Deep Introduction to JIT Compilers: JITs are not very Just-in-time | Carol's Blog
Generics for Go
Desugaring - taking our high-level language and simplifying it!
About Scaling Model-View-Update
How Hello World! changed – top level statements and functions
Misusing C#: Multiple Main() Methods
protobuf-net/protobuf-net
Announcing TypeScript 4.0 Beta | TypeScript
C# 8.0 nullable references: NotNull | endjin
Why I don't like SemVer anymore
GNU GCC does not round floating-point divisions to the nearest value
Building a high performance JSON parser
F# 5 and F# tools update for June | .NET Blog
dotnet/core
Trace 'function enter/leave' events with a .NET profiler + detect StackOverflow. Assembler code included!
Life, part 18
TCC : Tiny C Compiler
Differences between String and string in C# - Code Maze
IHP is a modern batteries-included Web Framework, built on top of Haskell and Nix.
What is Zig's “Colorblind” Async/Await?
Chat Wars
Reverse Engineering Snapchat (Part II): Deobfuscating the Undeobfuscatable
Linear types are merged in GHC
Implementing a brainfuck CPU in Ghidra - part 1: Setup and disassembly
Semantic highlighting in OmniSharp and C# extension for VS Code
Converting a hundred million integers to strings per second
hashcat 6.0.0
DEVS(show) : The Universe is (not) deterministic. Is it a bootstrapping compiler?
The Next Step for Generics
Guix Further Reduces Bootstrap Seed to 25% — 2020 — Blog — GNU Guix
3K, 60fps, 130ms: achieving it with Rust | tonari blog
Generics and Compile-Time in Rust | TiDB
C# semantic classification with Roslyn
GitHub to replace "master" with alternative term to avoid slavery references | ZDNet
How x86_64 addresses memory
Microsoft: Rust Is the Industry’s ‘Best Chance’ at Safe Systems Programming – The New Stack
How async should have been
Develop, Preview, Test
ECDSA: Handle with Care
dotnet/pinvoke
How Do I Think About Async Code?! | Visual Studio Blog
.NET Today and Tomorrow | Strangelights
Modernization Story: Windows Forms to .NET Core, XAML Islands and MSIX Core
'Escaping Web' Season One Retrospective
New inline assembly syntax available in nightly | Inside Rust Blog
NVIDIA/cutlass
Collapse OS — Why Forth?
Peeking under the hood of Command & Conquer
Microsoft.Diagnostics.Runtime 2.0.130507
milen.me — Distributed Caching & Compilation
Ruby vs Crystal Performance
Experimenting with Memory Management for Basil
julia as a cli calculator
Why does this lazy sequence work? | Phillippe Siclait
SQLite Forum: Caution: clang-11.0.0 miscompiles SQLite
Configuring Errors and Warnings in C#
Gleam v0.9 released! – by Otter Nonsense
TypeScript - JavaScript that scales.
Avalonia UI Framework
Merge features/function pointers to master by 333fred · Pull Request #44727 · dotnet/roslyn
ryansolid/solid
DotNetAnalyzers/DocumentationAnalyzers
Changes to How We Manage DefinitelyTyped | TypeScript
The magic of C# closures
Write high-quality TypeScript code - .NET Tools Blog
Video Conferencing, Web Conferencing, Webinars, Screen Sharing
The Dangers of TypeScript Enums | LINQ to Fail
How to code like the top Programmers at NASA — 10 critical rules - Alt Bulletin
Nullable Reference Types: Contexts and Attributes – A Look at New Language Features in C# 8 - .NET Tools Blog
- Miguel de Icaza
Patrik Svensson - Targeting ARM64 for Windows in Rust
Idris 2 version 0.2.0 Released
Why is Idris 2 so much faster than Idris 1?
Introduction to Functional Programming in F# - Part 10 — Softwarepark
How It All Started…AKA the Birth of the CLR - CLR, architectures, and stuff - Site Home
Optimizing for the RDNA Architecture: presentation notes
Life, part 11
Welcome to C# 9.0 | .NET Blog
F# 5 and F# tools update | .NET Blog
it’s not just the interpreter « kmod's blog
The Hardest Program I've Ever Written – journal.stuffwithstuff.com
TypeScript in a Weekend: A Crash Course
Multi-path cancellation; a tale of two codependent async enumerators
Coding is Not Computer Science
PERF: ensure we run full GC on contexts
Five Years of Rust | Rust Blog
Don't Code Tired | Reducing Magic Strings with Microsoft Feature Toggles (Microsoft.FeatureManagement)
Up to 4GB of memory in WebAssembly · V8
A Quick Look at Impredicativity (Simon Peyton Jones)
The anatomy of async iterators (aka await, foreach, yield)
Deno 1.0
Performance speed limits
Erlang Programming Language
Weep for Graphics Programming
Announcing TypeScript 3.9 | TypeScript
Performance best practices in C#
A Story About .csproj, Large Solutions and Memory Usage - .NET Tools Blog
Demystifying Memory Profilers in C# .NET Part 3: Memory Pressure - Michael's Coding Spot
SourceHut + Plan 9 = ❤
Why we at $FAMOUS_COMPANY Switched to $HYPED_TECHNOLOGY
Swift 5.3 Release Process
Make LLVM fast again
The IBM 1401 compiles and runs FORTRAN II
Cryptology ePrint Archive: Report 2020/529
~rabbits/orca - sourcehut git
GCC 10.1 Released
Static Constructor Failures and Declaration Order
Life, part 6
Popcorn Linux - Home
'Re: Integrating "safe" languages into OpenBSD?'
Xamarin.Forms 4.6 Available Today! | Xamarin Blog
Announcing TypeScript 3.9 RC | TypeScript
Introducing C# Source Generators | .NET Blog
C# interop with C/C++ and Rust in WebAssembly - Uno Platform
Don’t Use Boolean Arguments, Use Enums
Do We Have an Obsession with Ducks in Software Development? - Steve Gordon
Smarter C/C++ inlining with __attribute__((flatten))
First Release
First Release
a-Shell
Emojicode Documentation · Compile and Run Your First Program
R 4.0.0 is released
Announcing Rust 1.43.0 | Rust Blog
C# 8.0 nullable references: embrace the expressiveness
Closing the gap: cross-language LTO between Rust and C/C++
Engineering code quality in the Firefox browser: A look at our tools and challenges – Mozilla Hacks - the Web developer blog
A Possible New Backend for Rust – Jason Williams
Nullable Reference Types: Migrating a Codebase – A Look at New Language Features in C# 8 - .NET Tools Blog
Python 2.7.18, the last release of Python 2
“Stubs” in the .NET Runtime
Life, part 2
Strategies for migrating to TypeScript
Creating web apps via TypeScript and webpack
How does TypeScript work? The bird’s eye view
I Took a COBOL Course and It Wasn't The Worst | Hacker Noon
Hello, Gleam! - The Gleam Book
Matt Segal Dev - Nand to Tetris is a great course
.NET JIT compiler is not type safe – TooSlowException
Creating CommonJS-based npm packages via TypeScript
State of Vue Apr 16 2020
The Computer Scientist Who Can’t Stop Telling Stories
Augmenting Interfaces in the Global Scope in TypeScript
0.6.0 Release Notes · The Zig Programming Language
A Personal History of Compilation Speed, Part 1
A very short introduction to COBOL
Welcome back to C++ - Modern C++
Stop Making Students Use Eclipse
Bored? How about trying a Linux speed run?
Things That Turbo Pascal is Smaller Than
The Death of Hype: What's Next for Scala
Godot Engine - C# progress report: iOS and signals as events
Hybridizer: High-Performance C# on GPUs | NVIDIA Developer Blog
Why I’m leaving Elm - lukeplant.me.uk
Swift: Google’s bet on differentiable programming | Tryolabs Blog
Cross-platform profiling .NET code with BenchmarkDotNet
Mobius – .NET runtime running on .NET Core – TooSlowException
Crafting "Crafting Interpreters" – journal.stuffwithstuff.com
The Svelte Compiler Handbook
10 Things I Hate About PostgreSQL
Version 1.2.0 released
A crash course in compilers – Increment: Programming Languages
Content Injection with Response Rewriting in ASP.NET Core
"C is how the computer works" is a dangerous mindset for C programmers • Steve Klabnik
ValueTask Restrictions
Await | Writing an OS in Rust
Announcing TypeScript 3.9 Beta | TypeScript
Static analysis in GCC 10 - Red Hat Developer
The Hardest Program I've Ever Written – journal.stuffwithstuff.com
New grad vs senior dev
firefox's low-latency webassembly compiler -- wingolog
10 Most(ly dead) Influential Programming Languages • Hillel Wayne
10 Most(ly dead) Influential Programming Languages • Hillel Wayne
Improving non-nullable reference types handling
How to create a gRPC service ? – Anthony Giretti's .NET blog
High-performance C#: a test pattern for ref structs
Running C# Snake inside UEFI
How I Became a Better Programmer
Don't Code Tired | Variables? We Don’t Need No Stinking Variables - C# Discards
A categorized list of all Java and JVM features since JDK 8 to 14
Catch up on the latest .NET Productivity features | .NET Blog
`zig cc`: a Powerful Drop-In Replacement for GCC/Clang
c# Snake in the browser
Stark - Native Compiler - Prototype 2019
Introduction to Functional Programming in F# - Part 9 — Softwarepark
The Reason for Types in JavaScript - CoRecursive Podcast
DirectX Developer Day Schedule | DirectX Developer Blog
Announcing DirectX Developer Day | DirectX Developer Blog
Episode 47: Hacking .NET with Michal Strehovský
A Digression on Divergence
Avoid In-Memory Databases for Tests
Avoiding cache line overlap by replacing one 256-bit store with two 128-bit stores
Generate Native Executable from .NET Core 3.1 Project
Async ValueTask Pooling in .NET 5 | .NET Blog
Fireiron: A Scheduling Language for High-Performance Linear Algebra on GPUs
[TUHS] The most surprising Unix programs
Performance Engineering Blog
C# 8 asynchronous streams - Red Hat Developer
Some more C# 8 - Red Hat Developer
My exploration of Rust and .NET
Making Your Code Faster by Taming Branches
How I Start: Nix
Miguel de Icaza
DuckDuckGo is good enough for regular use | www.bitlog.com
The Odyssey of Stark and Melody
Stark - Language And Frontend Compiler - Prototype 2019
C# 8 nullable reference types - Red Hat Developer
Scoping in JavaScript: The Basics
How to write a Roslyn Analyzer | .NET Blog
Improving list sum function based on head and tail with C# 8
Class definitions in TypeScript
C# 8 default interface methods - Red Hat Developer
C# and .NET Book | Covers C# 6, C# 7, .NET Framework and .NET Core
Rust Ownership Rules
When Bloom filters don't bloom
Clojure: the Lisp that wants to spread
runtime: non-cooperative goroutine preemption · Issue #24543 · golang/go
A half-hour to learn Rust
Switching back to the UI thread in WPF/UWP, in modern C#
Hundred year mistakes
Learning Blazor Components: The Definitive Guide
Working with IWebHostEnvironment and IHostingEnvironment in dual targeted ASP.NET Core Projects
React Context with TypeScript: Part 2 - Complex context with function components
Just In Time Hooking #
Securing Firefox with WebAssembly – Mozilla Hacks - the Web developer blog
Announcing TypeScript 3.8 | TypeScript
EA and Visual Studio’s Linux Support | C++ Team Blog
SharpLab
C# 8 asynchronous streams - Red Hat Developer
TypeScript 3.8 Adds Private Fields and Top-Level Await
dotnet/runtime
dotnet/runtime
VSTS build failed with nuget buildwebcompiler · Issue #354 · madskristensen/WebCompiler
William J. Bowman, Ph.D. | Home
Part 1 - Introduction and Setting up the REPL
Learning Rust With Entirely Too Many Linked Lists
Debugging Wednesday — Cancel this task!
ASP.NET Core middleware with Roslyn Analyzers - Part 1
Compiler Explorer - C (x86-64 clang 9.0.0)
Fixing Random, part 22
Compiler Explorer - C (x86-64 clang 9.0.0)
Fixing Random, part 19
NVIDIA/cutlass
Home
Document EF Core architecture and internal technical details · Issue #1920 · dotnet/EntityFramework.Docs
Fixing Random, part 20
Security Scanning Your .NET Core Applications
Removed Method Group conversions, more additions to equality. by Mrnikbobjeff · Pull Request #1030 · xamarin/Essentials
Decompile .NET code while debugging - Visual Studio
Code review red flag: Where is the missing code?
joshfree - Overview
Does register selection matter to performance on x86 CPUs?
PeachPie | PHP compiler to .NET
Type-Driven Development with Idris
From DotNet Run to Hello World - .NET Oxford - January 2020
Jakub Míšek - Compiling and Running a PHP on .NET Core - Dotnetos Conference 2019
Hello World - Introduction to C# interactive C# tutorial
Announcing speakers for 2020 : C++ On Sea
Working with expression trees in C# | Alexey Golub
Working with expression trees in C# | Alexey Golub
dotnet/runtime
Evil Eval() Vol. 2 @ PeachPie | PHP compiler to .NET
dotnet/runtime
Cake - Home
Research based on the .NET Runtime
maharmstone/quibble
Performance traps of ref locals and ref returns in C# | Premier Developer
extern alias - C# Reference
marcpaq/b1fipl
Building C# 8.0 | .NET Blog
Designing a build system for .NET solutions with Cake - 2: The Cake build tool and convention-based builds
5 things to be aware of with F# anonymous records | Compositional IT
Getting Started with Asynchronous Programming in .NET
Train ML models on large images and 3D volumes with spatial partitioning on Cloud TPUs | Google Cloud Blog
William J. Bowman, Ph.D. | Home
Cake - Home
Software optimization resources. C++ and assembly. Windows, Linux, BSD, Mac OS X
tock/tock
Cliff Click's answer to What interesting optimizations can a JIT do that a compiler cannot do? - Quora
Get CoreRT Hello World selfcontained binary under 1 MB by MichalStrehovsky · Pull Request #7962 · dotnet/corert
Fast, parallel applications with WebAssembly SIMD · V8
MoonScript, a language that compiles to Lua
Train ML models on large images and 3D volumes with spatial partitioning on Cloud TPUs | Google Cloud Blog
Ryujinx - Nintendo Switch Emulator
KnightOS was an interesting operating system
The Throw Keyword was a Mistake
Autofac 5.0 Released
libreoffice/core - main, development code repository
dotnet/runtime
The frustrating state of tails calls in .NET · Issue #2191 · dotnet/runtime
.NET coding convention settings For EditorConfig - Visual Studio
Tools for Exploring .NET Internals
Showtime | BenchmarkDotNet
.NET everywhere apparently also means Windows 3.11 and DOS - Scott Hanselman
Getting Dependencies by Name or Key using the .NET Core Container (Part 2) - Steve Talks Code
NYAN Conference
Add Mono to the repository by akoeplinger · Pull Request #1912 · dotnet/runtime
Analyzing a nullability example · Curiosity is bliss
VS 16.5 Tooling Performance · Issue #8255 · dotnet/fsharp
C# 8.0: Understanding Using Declarations - Steve Gordon
Optimistic allocation of objects on the stack · Issue #1661 · dotnet/runtime
Containerized builds for Rust on the ESP32 - DEV Community 👩💻👨💻
Basic Instruction Scheduling (and Software Pipelining)
Optimizing string.Count all the way from LINQ to hardware accelerated vectorized instructions
GrantRi's WebLog [MS] : The problem with being second
Chris Brumme
Tracing .NET Core applications - Red Hat Developer
Cheap USB Host Microcontroller [CH559, ESP32, HID]
pornin/curve9767
Building a self-contained game in C# under 8 kilobytes
Build your own WebAssembly Compiler
“Stack Walking” in the .NET Runtime
Building a new Win 3.1 app in 2019 Part 1: Slack client
Suppress emitting of localsinit flag. · Issue #1738 · dotnet/csharplang
Initial implementation of two field span. · dotnet/coreclr@0bedde3
.NET documentation what's new?
Clr Heap Allocation Analyzer - Visual Studio Marketplace
apple/llvm-project
What interesting optimizations can a JIT do that a compiler cannot do? - Quora
dotnet/runtime
Creating Common Intermediate Language projects with .NET SDK | StrathWeb. A free flowing web tech monologue.
dotnet/runtime
William J. Bowman, Ph.D. | Home
ConfigureAwait FAQ | .NET Blog
Debugging 3rd Party .NET Code without symbols in Visual Studio - Michael's Coding Spot
C# Digest #287 for December 02, 2019 | Weekly C# Newsletter
To Null, or not to Null?!?
Compiler Explorer - C++ (x86-64 clang 7.0.0)
Compiler Explorer - C++ (x86-64 clang 9.0.0)
Library Changes: Removing jQuery by NickCraver · Pull Request #442 · MiniProfiler/dotnet
Embracing nullable reference types | .NET Blog
plasma-umass/coz
.NET Framework Internals: How the CLR Creates Runtime Objects
r/dotnet - Microsoft (devs, pm-s etc): thank you all for Net Core 3 and Xamarin!
.NET Talks at MFF UK in Prague [EN]
New release – PeachPie Sdk 0.9.600 @ PeachPie | PHP compiler to .NET
Use C# 8 In Any .NET Project Today
Hacking CoreCLR on Linux with CLion
Using Rust in Windows - Microsoft Security Response Center
How Swift Achieved Dynamic Linking Where Rust Couldn't
Facebook Libra is Architecturally Unsound
Compiler support for @oneventname:preventDefault and @oneventname:stopPropagation · Issue #14517 · dotnet/aspnetcore
Research based on the .NET Runtime
A First Look at Java Inline Classes
63 Cores Blocked by Seven Instructions
Stack Overflow
Karel Zikmund - Events
Add 64 bits support to Array underlying storage · Issue #12221 · dotnet/runtime
The Aggregate Magic Algorithms
Terra
Static constructor broken (not always executed) · Issue #13036 · dotnet/runtime
AWS’ sponsorship of the Rust project | Amazon Web Services
danielmarbach/Async.Netcore
Anonymous classes and generics limit in .NET/C#? | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
PeachPie | PHP compiler to .NET
What’s the maximum number of generic parameters for a class in .NET/C#? | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
Oldpug/Bfi
dotnet/coreclr
What is the difference between ToArray and ToList?
“Stubs” in the .NET Runtime
CLR Method Internals (.NET 2.0)
The Future of C++/CLI and .NET Core 3 | C++ Team Blog
dotnet/docs
Announcing F# 4.7 | .NET Blog
This is how you get rid of null reference exceptions forever
Demystifying Tail Call Optimization - DEV Community 👩💻👨💻
Throwing null literal | tabs ↹ over ␣ ␣ ␣ spaces by Jiří {x2} Činčura
GitHub
Introduction to Functional Programming in F# — Softwarepark
Introduction to Compilers and Language Design
Compilers
CSEP501: Compiler Construction
ChocoPy: A Programming Language for Compilers Courses
Idea: Extension/derivation of sealed classes · Issue #13345 · dotnet/runtime
How to add an optimization for C# to RyuJIT
Home
Compiler Explorer - CUDA (NVCC 10.1 Update 1)
LLBLGen Pro | Blog: 16 years of LLBLGen Pro!
Availability of nullable attributes outside of Core 3.0 · Issue #30493 · dotnet/runtime
Navigating the .NET Ecosystem
Utf8String design proposal · Issue #2350 · dotnet/corefxlab
Split the big jit files to allow better GitHub experience. · Issue #13359 · dotnet/runtime
Static TypeScript: An Implementation of a Static Compiler for the TypeScript Language - Microsoft Research
Static analysis for .NET 5 · Issue #30740 · dotnet/runtime
The Baseline Interpreter: a faster JS interpreter in Firefox 70 – Mozilla Hacks - the Web developer blog
Improving performance of GraalVM native images with profile-guided optimizations
Age of JIT Compilation. Part 1. Genesis
Simon Peyton Jones how GHC type inference engine actually works
Prefer ValueTask to Task, always; and don't await twice
Visual Studio Tips and Tricks: Increasing your Productivity for .NET | .NET Blog
What's new in C# 8.0 - C# Guide
Introduction to Svelte
Tailcall optimization doesn't work with netcoreapp3.0 runtime · Issue #13255 · dotnet/runtime
areller/RediSharp
.NET Analyzers
Fuzzing the .NET JIT Compiler
Tiered compilation for Mono runtime · Issue #16018 · mono/mono
Geting 4x Speedup With .NET Core 3.0 SIMD Intrinsics
Huawei announces HarmonyOS, an open-source platform for every device
New features in 0.9.45 @ PeachPie | PHP compiler to .NET
Stack Overflow handling in HotSpot JVM
Try out Nullable Reference Types | .NET Blog
dotnet/csharplang
Here’s what’s in the brand-new Unity 2019.2 - Unity Technologies Blog
Fixing Random, part 40 of 40
Fix issue with out-of-scope GCFrame in Frame list by janvorli · Pull Request #25795 · dotnet/coreclr
Advanced .NET Debugging - PDBs and Symbol Stores
Request: a solution that allows us to not have to write 6500 different delegates & overloads · Issue #2668 · dotnet/csharplang
.NEXT 2.x | .NEXT
dotnet/coreclr
Clarke's Third Law Exception - Step by Step
VB Casing behavior difference between VS 2013 and Roslyn · Issue #2909 · dotnet/roslyn
Benchmarks are hard · jbd.dev
PooledAwait
dotnet/docs
mgravell/PooledAwait
C#: [Obsolete] on an extension method? Also remove ‘this’
gokrazy - a pure-Go userland for your Raspberry Pi 3 appliances
.NET Core Example - With simple Kestrel WebHost | C# Online Compiler | .NET Fiddle
Lowering in C#: What's really going on in your code? - David Wengier
google/robotstxt
Peephole optimizations in C++ and C# | Egor Bogatov — Developer at Microsoft
Yes silver bullet
Build fails if Java Runtime (not SDK) is installed · Issue #11731 · dotnet/aspnetcore
Versioning limitations in .NET
What’s new for the .NET Native Compiler and Runtime in Visual Studio 2015 Update 2 | .NET Blog
terrajobst/minsk
#124 Mads Torgersen, C# 8 | no dogma podcast
What does debugging a program look like? - Julia Evans
Avoiding instruction cache misses
dotnet/roslyn
What’s up with my branch on GPU?
dotnet/coreclr
dotnet/diagnostics
Announcing .NET Core 3.0 Preview 6 | .NET Blog
An Experimental Floating-Point Scalar Evolution :: Duskborn — Duskborn Labs is where Neil ‘@sheredom‘ Henning writes up things of interest.
directive_attributes.md
Building a C# Interactive shell in a browser with Blazor (WebAssembly) and Roslyn | StrathWeb. A free flowing web tech monologue.
Tiered Compilation Preview in .NET Core 2.1 | .NET Blog
jeanqasaur/dsl-syllabus-fall-2016
C# reference
Tiered Jit Benchmarking · Issue #1125 · dotnet/BenchmarkDotNet
ltrzesniewski/LocalsInit.Fody
Candidate Features For C# 9
Expose top-level nullability information from reflection · Issue #29723 · dotnet/runtime
Rust: A Language for the Next 40 Years - Carol Nichols
PHP on .NET Core 3.0 @ PeachPie | PHP compiler to .NET
Christmas Compiler Speed-Up, part 2
dotnet/llilc
Top 10 Things You Can Do With GraalVM
The F# development home on GitHub is now dotnet/fsharp | .NET Blog
typeof(TSecret) - the secret magic behind .NET generics
Markdown + .NET = Interactive docs?
T1
Create Interactive .NET Documentation with Try .NET | .NET Blog
A few words about data and concurrency
The unknown Type in TypeScript
SharpFuzz: Bringing the power of afl-fuzz to .NET platform
Performance Improvements in .NET Core 3.0 | .NET Blog
Overview of nullability analysis · Curiosity is bliss
Use pattern matching features to extend data types
Decoupling Algorithms from the Organization of Computation for High-Performance Graphics & Imaging
Announcing .NET Core 3.0 Preview 5 | .NET Blog
Introducing .NET 5 | .NET Blog
Compile time marshalling | devops.lol
Fight the global warming: compile your C# apps ahead of time
terrajobst/minsk
dotnet/corert
Get Some Sass Into Your Blazor App
2019 EuroLLVM Developers’ Meeting: Mehdi & Vasilache & Zinenko “Building a Compiler with MLIR”
CppCon 2017: Teresa Johnson “ThinLTO: Scalable and Incremental Link-Time Optimization”
Add ZIO & Scalaz to community builds · Issue #896 · scala/community-build
gpakosz/PPK_ASSERT
Compute Shader - OpenGL Wiki
The LLVM Compiler Infrastructure Project
2019 EuroLLVM Developers’ Meeting: T. Shpeisman & C. Lattner “MLIR: Multi-Level Intermediate Repr..”
Expose a BigInteger.Builder to help avoid so many copies/allocations · Issue #29378 · dotnet/runtime
ASCII Art in .NET Code
Visual Studio 2019 version 16.1 Preview 2 | Visual Studio Blog
Twisted Oak
Dev Tip #158: Strongly Typed IDs
Rust's 2019 roadmap | Rust Blog
ericsink/wasm2cil
Running WebAssembly and WASI with .NET
April Update for WPF on .NET Core 3.0 · Issue #607 · dotnet/wpf
ispc/ispc
jmcgrew / zilf / wiki / Home — Bitbucket
Presentations and Talks covering ‘.NET Internals’
fsharp/fslang-design
davidsh - Overview
Reactive approach to FSAC design - discussion · Issue #1 · Krzysztof-Cieslak/notes
Non Obvious PE Parsers – the .NET runtime – Part 1
Performance analysis and tuning contest #2. | Easyperf
Unintended interactions of SerializationGuard and other features · Issue #29212 · dotnet/runtime
Lies, darn lies and sampling bias
Functional Scala: Next Level by John A. De Goes (LambdaConf Edition)
Using, using, using with C# 8
C#88: The Original C#
fsharp/fslang-design
dotnet/corefx
string vs. String is not a style debate
A balancing act
Compiler Explorer
MSVC hidden flags
.NET API browser
/diagnostics (Compiler diagnostic options)
ITHare/obf
Building Components Manually via RenderTreeBuilder
Compiler Explorer - C++ (x86-64 clang 8.0.0)
BenchmarkDotNet v0.11.5 | BenchmarkDotNet
Is making a struct readonly a breaking change?
Rename Razor Components back to server-side Blazor · Issue #8931 · dotnet/aspnetcore
Announcing Lucet: Fastly's native WebAssembly compiler and runtime
Proposal: Dependency Injection / Service Locator as a Language Feature · Issue #1690 · dotnet/csharplang
cloudflare/boringtun
Behind the burst compiler | xoofx
Machine code layout optimizations. | Easyperf
Ionide — A New Hope
How to Debug Rust with Visual Studio Code
materialx/MaterialX
GameTechDev/GTS-GamesTaskScheduler
[Question] CoreRT future plans · Issue #7200 · dotnet/corert
microsoft/perfview
Intel OSPRay
Non-idiomatic F#
Explaining Code using ASCII Art – Embedded in Academia
When pigs fly: optimising bytecode interpreters
GameTechDev/IntelShaderAnalyzer
Writing A Compiler In Go | Thorsten Ball
Writing An Interpreter In Go | Thorsten Ball
Core support for object pooling · Issue #12296 · dotnet/runtime
Port AMSI scanning for assembly loads by elinor-fung · Pull Request #23231 · dotnet/coreclr
Megacity | Unity
Fixes to support scala 2.11 by ahoy-jon · Pull Request #650 · zio/zio
Go 1.12 Release Notes - The Go Programming Language
zeux/meshoptimizer
Open Source .NET – 4 years later
Floating-Point Reference Sheet for Intel® Architecture
Perf regression for Math.Min and Math.Max · Issue #12159 · dotnet/runtime
Open source is only ajar without inclusion – Internet Citizen
pwaller/go2ll-talk
Async Enumerables with Cancellation · Curiosity is bliss
Tic Toc Games - A Unity Developer Case Study
Cats instances taking the environmental parameter by gvolpe · Pull Request #593 · zio/zio
Floating-Point Parsing and Formatting improvements in .NET Core 3.0 | .NET Blog
Hardware intrinsic in .NET Core 3.0 - Introduction
Inline IL ASM in C# with Roslyn | xoofx
CensoredUsername/dynasm-rs
Is C# a low-level language?
Paper: Hyperscan: A Fast Multi-pattern Regex Matcher for Modern CPUs
Building C# 8.0 | .NET Blog
dotnet/docs
Announcing TypeScript 3.1 | TypeScript
Strict bind, call, and apply methods on functions by ahejlsberg · Pull Request #27028 · microsoft/TypeScript
Combining iterator blocks and async methods in C# | Premier Developer
Compiler Explorer
MuniHac 2018: Keynote: A low-latency garbage collector for GHC
Emscripten’s embind | Web | Google Developers
Background compilation · V8
Compiler Explorer
hundredrabbits/Orca-c
The current state of my compiler project | sergio
serge-rgb/compiler
microsoft/microsoft-pdb
Game Designer+Artist or Game Designer+Programmer
LLVM on Windows now supports PDB Debug Info
Machine Learning to Detect Software Vulnerabilities - Schneier on Security
How to get clang++ to find link.exe
llvm-mirror/clang
Lambda Days 2018 - Heather Miller - We're Building On Hollowed Foundations (...)
Compiler Explorer - C++
Project Tiny Preview Package is here! - Unity Technologies Blog
Unity Careers
Unite Los Angeles 2018 - Day 2 Livestream
Haxe Roundup № 468
Go 1.12 Release Notes - The Go Programming Language
The Go Programming Language Blog
google/randen
djbsort: Changes
djbsort: Intro
Introducing HacSpec
NASM Manual
Tech Note: Shader Snippets for Efficient 2D Dithering | Oculus
pervognsen/bitwise
compiletime.md
clion.md
research!rsc: Using Uninitialized Memory for Fun and Profit
asan_clang_cl.md
Compiler Explorer
Undefined Behavior Is Really Undefined
A whirlwind introduction to dataflow graphs
Modern garbage collection
Whats next after Burst
C++, C# and Unity
C++ Modules Might Be Dead-on-Arrival
The 7 Best Robotic Arm Kits Under $100
google/schism
What I Learned Making My Own JIT Language
The story of ispc: origins (part 1)
» TADS The Digital Antiquarian
RemedyBG by remedybg
On DOTS: C++ & C# - Unity Technologies Blog
dotnet/coreclr
lemire/simdjson
Tuning a Runtime for Both Productivity and Performance
[C#] Have some fun with .net core startup hooks
RyanLamansky/dotnet-webassembly
Do more with patterns in C# 8.0 | .NET Blog
Take C# 8.0 for a spin | .NET Blog
Microsoft's Orleans Distributed App Framework Is Now Cross Platform - The New Stack
Containing Null with C# 8 Nullable References
Learning about .NET Core futures by poking around at David Fowler's GitHub - Scott Hanselman
Discards - C# Guide
WP.NET | WordPress on .NET Core – WordPress running on .NET Core
PeachPie.io - The PHP compiler & runtime under NET Core | Product Hunt