C++ on Karpoke - Just Another Blog

C++ Documentary is Now Available

Fri, 05 Jun 2026 12:00:00 +0100

The Story of C++: The World’s Most Consequential Programming Language is now available for free on YouTube.

» Paul Thurrott | thurrott.com

Bjarne Stroustrup, padre de C++: "Solo hay dos tipos de lenguajes de programación: aquellos de los que la gente se queja y los que nadie usa"

Wed, 01 Apr 2026 12:00:00 +0100

Blog sobre informática, tecnología y seguridad con manuales, tutoriales y documentación sobre herramientas y programas

» Blog elhacker.NET | blog.elhacker.net

46 Stories To Learn About C

Wed, 12 Apr 2023 16:13:04 +0100

Learn everything you need to know about C via these 46 free HackerNoon stories.

» hackernoon.com | hackernoon.com

Why We Need Build Systems

Mon, 07 Jun 2021 11:00:18 +0100

Build systems were developed to simplify and automate running the compiler and linker and are an essential part of modern software development. This blog post is a precursor to future posts discussing our experiences refactoring the training projects to use the CMake build…

» Martin Bond | blog.feabhas.com

Threat hunting (VIII): cazando sin salir de casa. Creación de procesos (II)

Thu, 26 Nov 2020 16:10:54 +0100

Threat hunting (VIII): cazando sin salir de casa. Creación de procesos (II)

» securityartwork.es | securityartwork.es

How Do We Get a Balanced Binary Tree?

Tue, 01 Sep 2020 22:28:34 +0100

A binary tree can be empty, implying zero nodes in the tree. The cool thing about binary trees is that they are recursive structures.

» DEV Community | dev.to

The Rule of The Big Three (and a half) – Resource Management in C++

Sun, 18 Jan 2015 10:59:00 +0100

The dynamic creation and destruction of objects was always one of the bugbears of C. It required the programmer to (manually) control the allocation of memory for the object, handle the object’s initialisation then ensure that the object was safely cleaned-up after use and its memory returned to the heap. Because many C programmers weren’t educated in the potential problems (or were just plain lazy or delinquent in their programming) C got a reputation in some quarters for being an unsafe, memory-leaking language.

Indian Developers Redesigning Linux Kernel With OOP, C++ Support

Sun, 05 Oct 2014 11:36:00 +0100

DOS Lab IIT Madras and CDAC Chennai out of India are aiming to redesign the Linux kernel as MOOL, or the Minimalistic Object Oriented Linux. The project site explains, ”MOOL (Minimalistic Object Oriented Linux) aims at redesigning the Linux kernel to reduce coupling and increase maintainability by means of OO (Object Oriented) abstractions. Excessive common coupling prevails in existing kernel. Studies have shown that common coupling is increasing in successive versions of Linux. This will make maintainability of Linux difficult in coming years. As a starting step we have tried to reduce the number of global variables of the kernel. Some global variables are used only by two or three kernel modules. These are passed as function arguments. The performance of the modified kernel is measured with the standard performance analysis tools. The modified kernel performs almost same as original. MOOL features a device driver framework to write drivers in C++ and insert them as loadable kernel modules.”

An Introduction to Lock-Free Programming

Wed, 27 Jun 2012 23:58:00 +0100

Lock-free programming is a challenge, not just because of the complexity of the task itself, but because of how difficult it can be to penetrate the subject in the first place. I was fortunate in that my first introduction to lock-free (also known as lockless) programming was Bruce Dawson’s excellent and comprehensive white paper, Lockless Programming Considerations. And like many, I’ve had the occasion to put Bruce’s advice into practice developing and debugging lock-free code on platforms such as the Xbox 360. Since then, a lot of good material has been written, ranging from abstract theory and proofs of correctness to practical examples and hardware details. I’ll leave a list of references in the footnotes. At times, the information in one source may appear orthogonal to other sources: For instance, some material assumes sequential consistency, and thus sidesteps the memory ordering issues which typically plague lock-free C/C++ code. The new C++11 atomic library standard throws another wrench into the works, challenging the way many of us express lock-free algorithms. In this post, I’d like to re-introduce lock-free programming, first by defining it, then by distilling most of the information down to a few key concepts. I’ll show how those concepts relate to one another using flowcharts, then we’ll dip our toes into the details a little bit. At a minimum, any programmer who dives into lock-free programming should already understand how to write correct multithreaded code using mutexes, and other high-level synchronization objects such as semaphores and events.