Tagged articles
visibility
21 articles · Page 1 of 1
This article explains how Java's final keyword ensures cross-thread visibility of final fields through the JMM's freeze action at constructor end, provided the this reference does not escape during construction, demonstrating with a code example that shows a race condition when this escapes and the correct behavior when final fields are properly frozen.
ConcurrencyJMMJava
0 likes · 7 min read

The article explains why Java concurrency is difficult by showing that two threads each incrementing an int ten thousand times may not produce twenty thousand, then explores the motivations for multithreading, the differences between concurrency and parallelism, and the three core challenges of visibility, atomicity, and ordering.
ConcurrencyJavaMultithreading
0 likes · 23 min read

The article argues that a tech leader's greatest danger is becoming invisible to management, which can lead to budget cuts, talent loss, and strategic blind spots, and proposes a four‑layer visualization framework with stability, efficiency, cost, and risk dimensions to make technical value measurable and communicable.
DORAFinOpsMetrics
0 likes · 9 min read

This article reveals four counterintuitive career strategies for IT engineers to break out of the 'code tool' trap: specialize deeply instead of chasing full-stack breadth, make technical value visible to decision-makers, learn from senior leaders rather than competing with peers, and continuously evolve skills to match business stages.
IT careercareer growthcontinuous learning
0 likes · 13 min read

This article explains why operations teams must showcase their work to clients, offering practical ways to turn routine reports and meetings into compelling evidence of value, so that stability is recognized as a result of visible effort rather than taken for granted.
IT managementOperationscommunication
0 likes · 6 min read

The author reflects on possessing solid DevOps skills yet remaining unnoticed, discovers that visibility—not just technical ability—is key, and shares practical steps like posting experiences, using GitHub as a portfolio, and embracing authentic personal branding to advance a DevOps career.
DevOpspersonal brandingvisibility
0 likes · 6 min read

This article explores the purpose and implementation of UIKIT_EXTERN and related macros in iOS, explaining how they manage global constants, control symbol visibility across dynamic libraries, and provide practical examples of extern, static, and const usage for compilation optimization and conflict resolution.
MacrosUIKIT_EXTERNconst
0 likes · 12 min read

This article explains Go's package system, covering package declaration, classification, import mechanics, identifier visibility, the init function, and how to manage dependencies using Go Modules from Go 1.11 onward.
GoGo modulesimport
0 likes · 4 min read

This article compares Java classes with Go structs, covering how each language handles state and behavior, inheritance versus composition, and visibility rules, while providing concrete code examples to illustrate the practical differences for developers.
GoInheritanceJava
0 likes · 6 min read

The article explains how the Java Memory Model addresses concurrency challenges by defining visibility, ordering, and atomicity guarantees through mechanisms such as volatile, synchronized, cache coherence, memory barriers, CAS operations, and happens‑before relationships, enabling correct and portable multi‑threaded programming.
CASConcurrent ProgrammingHappens-Before
0 likes · 25 min read

This article explains the Java Memory Model, distinguishes main memory from thread-local memory, and demonstrates how visibility, ordering, and atomicity affect concurrent programs through code examples, volatile and synchronized keywords, double‑checked locking, and the Happens‑Before rules.
ConcurrencyJMMJava
0 likes · 18 min read

This article explains the purpose, syntax, and underlying principles of UIKIT_EXTERN and related macros such as extern, static, and const in iOS, demonstrates how __attribute__ and visibility modifiers affect symbol linkage, and outlines practical scenarios and extensions for safer, more efficient code across dynamic libraries.
MacrosUIKIT_EXTERNconst
0 likes · 11 min read

This article provides a comprehensive guide to Java's volatile keyword, covering its pronunciation, purpose, three core properties, interaction with the Java Memory Model, visibility and atomicity examples, instruction reordering, memory barriers, and practical usage such as double‑checked locking and when to prefer volatile over heavier synchronization mechanisms.
Javaatomicityinstruction reordering
0 likes · 18 min read

This article explains Java thread safety by defining it, breaking down atomicity, visibility, and ordering, illustrating core concepts with AtomicInteger and AtomicStampedReference examples, and detailing the underlying CAS mechanisms, JMM rules, and the ABA problem.
CASConcurrencyJava
0 likes · 10 min read

This article explains the Java memory model, how variables are stored in main and working memory, and why concurrency issues like dirty reads, non‑atomic operations, and instruction reordering occur, while detailing the roles of volatile, synchronized, locks, and atomic classes in ensuring visibility, ordering, and atomicity.
ConcurrencyJavaatomicity
0 likes · 21 min read

This article explains the Java Memory Model, covering how it validates reads, the distinction between shared and exclusive memory areas, data‑race scenarios with example code, visibility challenges, and the JMM‑based solutions such as volatile, synchronized, and memory barriers to prevent harmful reordering.
Data RaceJavaReordering
0 likes · 8 min read

This article breaks down the Java Memory Model, detailing how atomicity, visibility, and ordering work in multithreaded programs, illustrating the impact of instruction reordering, and showing how synchronized, volatile, and happens‑before rules ensure correct concurrent behavior.
ConcurrencyHappens-BeforeJava
0 likes · 13 min read

This article explores how CPU, memory, and I/O speed differences create concurrency bugs, detailing the three core issues of visibility, atomicity, and ordering in Java's memory model and showing practical code examples and solutions.
Javaatomicitymemory model
0 likes · 11 min read

This article explains the Java volatile keyword, covering its memory‑visibility and ordering guarantees, how it interacts with the Java Memory Model, why it does not ensure atomicity, and demonstrates typical interview‑style examples and code snippets such as flag signaling and double‑checked locking.
ConcurrencyJavaatomicity
0 likes · 16 min read

This concise summary explains the Java Memory Model’s definition of thread‑memory interaction, covering atomicity, visibility, ordering, the happens‑before principle, compiler/processor reordering constraints, and sequential consistency, while also listing key reference articles and further reading.
ConcurrencyHappens-BeforeJava
0 likes · 7 min read

The article presents a Java program where 100 threads each increment a volatile int 1,000 times, showing that the final value may be less than the expected 100,000, and explains that volatile only guarantees visibility, not atomicity, making it unsuitable for concurrent modifications.
ConcurrencyJavaatomicity
0 likes · 2 min read
