The main principles of DevOps are explained by the CAMS Model, which was created by Damon Edwards and John Willis. C.A.M.S. stands for Culture, Automation, Measurement, and Sharing. Let’s look at these four DevOps principles in detail in order to understand what each entails. https://www.youtube.com/watch?v=VySUutlo91E

Performance is one of the chief reasons why many C++ programmers love the language. In the past, Moore's Law meant that our programs ran faster every year. Now that Dennard scaling has ended, C++ programmers have to work harder to get high performance for their applications. In this talk, I'll first discuss some of the significant and surprising challenges facing C++ programmers trying to achieve high performance on modern hardware platforms: performance is far less stable and predictable than you might think! I'll present some experimental evidence that strongly suggests we can't count on compiler optimizations to help us out of this hole: in particular, I'll show — using a new experimental methodology — that the difference between clang's -O2 and -O3 optimization levels is essentially indistinguishable from noise. Since compiler optimizations have run out of steam, we need better profiling support, especially for modern concurrent, multi-threaded applications. I'll talk about a new approach to profiling, which I call "causal profiling". Causal profiling lets programmers optimize for throughput or latency, and which pinpoints and accurately predicts the impact of optimizations. It works by running performance experiments, based on the idea of "virtual speedups". We've built a causal profiler called Coz, which now ships as part of standard Linux distros, and which also works for C++ and Rust (there's even a Java version). Using it, we find that Coz can unlock previously unknown optimization opportunities. Guided by Coz, we improved the performance of Memcached (9%), SQLite (25%), and accelerated six other applications by as much as 68%; in most cases, this involved modifying less than 10 lines of code and took under half an hour (without any prior understanding of the programs!). PUBLICATION PERMISSIONS:
CppCon Organizer provided Coding Tech with the permission to republish CppCon tech talks. CREDITS:
CppCon YouTube channel: https://www.youtube.com/user/CppCon/videos https://www.youtube.com/watch?v=VzyhpbrC2Bs

Halide is an open-source, domain-specific language for optimizing image processing, machine learning, and general array processing. It is used by major companies like Google, Adobe, and Qualcomm to optimize performance-critical software. It processes every photo taken with a Pixel phone, composites layers in every Photoshop document, and handles video processing at scale at YouTube. We will explore how Halide achieves top-tier performance in a fraction of the development time by separating the algorithm (what to compute) from the schedule (how to optimize it). Halide's schedules determine trade-offs between parallelism, vectorization, cache locality, and memory management in a simple, modular way. Programmers can easily target different CPUs and GPUs by writing multiple schedules. Halide integrates tightly with C++ and provides both a JIT and a C++ compatible ahead-of-time compiler. PUBLICATION PERMISSIONS:
CppCon Organizer provided Coding Tech with the permission to republish the CppCon Tech talks. CREDITS:
CppCon YouTube channel: https://www.youtube.com/channel/UCMlGfpWw-RUdWX_JbLCukXg https://www.youtube.com/watch?v=93-bfnKCb8E