C# ReadOnlySpan<T> for High-Performance String Parsing Without Allocations
Learn how ReadOnlySpan<T> enables zero-allocation string slicing in C# for high-performance parsing of large datasets without GC pressure.
Loading…
ReadMeFeed / Community knowledge
#memory-management
Real questions. Useful conversations. Find the people who know your stack.
csharp
dotnetOptimizing OpenCL Memory: Choosing Between Global, Constant, and Local Storage
Learn how to choose between Global, Constant, and Local memory in OpenCL to eliminate memory latency bottlenecks and optimize kernel throughput using tiling and coalescing.
openclStop Calling delete: A Practical Guide to unique_ptr and shared_ptr in Modern C++
Raw delete calls are one exception away from a leak. Here's how to choose between unique_ptr, shared_ptr, and weak_ptr — with working code, the cycle trap, and a sanitizer check.
cppNim's ARC/ORC: Deterministic Memory Management Without the GC Pauses
Nim 2.0's ARC/ORC memory management gives you deterministic deallocation without GC pauses. This blog covers ownership semantics, cycle collection, migration friction, and a worked cyclic-list example—plus the trade-offs you'll hit in production.
Implementing Zero‑Copy Buffer Sharing in OpenCL with CL_MEM_USE_HOST_PTR
Step‑by‑step guide to enable zero‑copy buffer sharing in OpenCL using CL_MEM_USE_HOST_PTR, including allocation, synchronization, verification, and cleanup.
Weak or Strong? A Practical Guide to Objective-C Ownership Under ARC
ARC handles retain/release for you, but ownership qualifiers are still your decision. A practical rule for __weak vs __strong, a safe delegate example, the weak-strong dance for blocks, and how to verify with Instruments.
Designing Stata Workflows Around Its Memory‑Resident Architecture
Stata loads entire datasets into RAM, giving fast access but imposing a hard memory ceiling. Learn how to size data, use frames, and safeguard integrity when working near RAM limits.
stataVala's owned and unowned keywords: letting the compiler write your refcount calls
Vala's owned and unowned annotations turn GObject reference counting into a compile-time contract. Here's how ownership transfer works, how to inspect the generated C, and where the model breaks down.
valaEliminating Heap Allocations with ReadOnlySpan<T> Slicing in C#
Learn how to use ReadOnlySpan<T> to eliminate unnecessary heap allocations during string parsing in C#, reducing GC pressure and improving application latency.