Tagged articles
capacity
13 articles · Page 1 of 1
The article explains that manufacturers label storage using decimal units (KB = 1000 B) while operating systems report using binary units (KiB = 1024 B), creating a roughly 7% discrepancy that makes a 1 TB disk appear as 931 GB, and shows that the same issue affects USB drives, phones, and SD cards.
DecimalIECKB
0 likes · 6 min read

This article demystifies Go's slice implementation by revealing its underlying struct, shared‑array hazards, the runtime's append expansion algorithm, common pitfalls with concrete code examples, and practical best‑practice guidelines for writing safe and high‑performance slice code.
appendcapacitygolang
0 likes · 8 min read

The article investigates Go 1.22’s claim that simple type casting []byte(str) can replace unsafe‑based string‑to‑byte conversions, presents four implementation variants, runs detailed benchmarks on macOS M2 and Linux amd64, analyses compiler inlining and escape behavior, and explains the hidden pitfalls of capacity and mutability in the k8s shortcut.
GoUnsafebenchmark
0 likes · 16 min read
![Why Go 1.22’s []byte(str) Conversion Beats Unsafe: Benchmarks and Deep Dive](https://wsrv.nl/?url=https%3A%2F%2Fmmbiz.qpic.cn%2Fmmbiz_jpg%2F0qAgGEpTiazFkfxZp5EpheUIPVgsaAKugqmDTQvuGcG9iap7wJtUPHtl26ESJv0LBiahUjCv6PRbLBxvTTm3KZddQ%2F0%3Fwx_fmt%3Djpeg)
A whimsical yet technical dialogue among Go, C++, Python, Java, and C# representatives reveals the storage structures, collision‑resolution strategies, hash‑to‑index mapping techniques, and resizing policies used in their hash table implementations, highlighting trade‑offs and design choices.
capacitycollision-resolutiondata structure
0 likes · 9 min read

An imaginative conference narrates how various programming language implementations—Go's map, C++'s unordered_map, Java's HashMap, Python's dict, and C#'s HashTable—discuss storage structures, collision‑resolution strategies, hash‑to‑index mapping, and initial capacity and resizing policies, highlighting their differing algorithms and trade‑offs.
capacitycollision-resolutionhash function
0 likes · 9 min read

This article provides a comprehensive overview of RAID technology, explaining disk groups, virtual disks, detailed characteristics of RAID 0, 1, 1ADM, 5, 6, 10, 10ADM, 1E, 50, and 60, and compares their fault tolerance, I/O performance, and storage capacity considerations.
RAIDStoragecapacity
0 likes · 26 min read

This article provides a comprehensive SRE guide covering senior role definitions, monitoring objectives and implementation, core metric selection, link and event monitoring, capacity planning and mitigation strategies, a real‑world health‑code outage case, and change‑management best practices to improve reliability and efficiency.
SREcapacitychange management
0 likes · 9 min read

Given a SATA disk capacity M and a sequence of blockchain file sizes, the task is to find the largest sum of a contiguous subsequence whose total does not exceed M, using an O(N) sliding‑window algorithm with O(1) extra space.
Algorithmarraycapacity
0 likes · 5 min read

This article explains why specifying an initial capacity for Java's HashMap matters, illustrates common misuse cases, walks through the source code to show how capacity and resizing thresholds are calculated, and provides guidelines for choosing the correct capacity to avoid unnecessary rehashing.
BackendHashMapcapacity
0 likes · 7 min read

Architects should treat system capacity like a pre‑flight checklist, using this comprehensive guide to monitor resource usage across services, databases, and queues, and to define business metrics and state‑machine indicators that reveal bottlenecks and guide scaling decisions.
MetricsOperationsarchitecture
0 likes · 5 min read

Exploring the fundamentals of the maximum flow problem, this article explains network flow concepts, outlines the three core properties of flow models, and demonstrates their application with an oil‑pipeline case study solved using NetworkX, concluding with key insights and a reference.
Algorithmcapacitymaximum flow
0 likes · 4 min read

This article explains Go slice fundamentals, covering how to create slices with make, the relationship between length and capacity, the behavior of append, why zero values appear, the automatic growth mechanism, and how to safely copy slices using the copy function, illustrated with code examples and diagrams.
COPYGoappend
0 likes · 8 min read

This article explains the fundamental differences between Go arrays and slices, describes their memory layout and value semantics, illustrates various slice declaration forms, and details the rules governing slice capacity growth with example code and visual diagrams.
GoMemory Layoutarray
0 likes · 6 min read
