dev 311

• Implicit string conversions to booleans Nov 13, 2024
• Use std::span instead of C-style arrays Nov 6, 2024
• (When) performance is not about algorithmic complexity Oct 30, 2024
• Different aspects of software performance Oct 23, 2024
• Working in uncertainty? Oct 9, 2024
• So shall we use static or dynamic linking? Oct 2, 2024
• Binary size: should we use static or dynamic linking? Sep 25, 2024
• Do it right or do the right thing: The Alignment Trap Sep 18, 2024
• The limits of a portfolio job Sep 11, 2024
• Structs and constructors Sep 4, 2024
• Wrapping up our Airbnb host experience Aug 28, 2024
• What is std::ref? Aug 21, 2024
• The rule of 5 and inheritance Aug 7, 2024
• Once more about the rule of 5 Jul 31, 2024
• What to do if you don't want a default constructor? Jul 17, 2024
• C++23: further small changes Jul 3, 2024
• Member ordering and binary sizes Jun 26, 2024
• Did you do what I asked for or not? Jun 19, 2024
• Limit the number of library dependencies Jun 12, 2024
• The limits of `[[maybe_unused]]` Jun 5, 2024
• C++23: chrono related changes May 29, 2024
• Do engineering teams really resemble sports teams? May 22, 2024
• Two cases when forward declaring is not enough May 15, 2024
• Quo vadis this blog? May 8, 2024
• When and how variables are initialized? - Part 4 May 1, 2024
• When and how variables are initialized? - Part 3 Apr 24, 2024
• When and how variables are initialized? - Part 2 Apr 17, 2024
• When and how variables are initialized? - Part 1 Apr 10, 2024
• Upgrading the compiler: undefined behaviour uncovered Apr 3, 2024
• Should we move from fundamental types? Mar 27, 2024
• C++23: Encoding related changes Mar 20, 2024
• Three key philosophies behind C++ Mar 13, 2024
• My late discovery of std::filesystem - Part II Mar 6, 2024
• My late discovery of std::filesystem - Part I Feb 28, 2024
• How to write unit tests in C++ relying on non-code files? Feb 21, 2024
• C++23: More small changes Feb 7, 2024
• C++23 likes to move it! Jan 31, 2024
• C++23: bitwise operations Jan 17, 2024
• C++23: Allocator related changes Jan 10, 2024
• Late discovery of std::filesystem - Part I Jan 3, 2024
• DR20 - The Equality Operator You Are Looking For Jan 3, 2024
• How to use your namespaces to their best Dec 13, 2023
• C++23: The rise of new streams Dec 6, 2023
• C++23: Growing unicode support Nov 29, 2023
• Struct initialization Nov 22, 2023
• C++: The most important complexities Nov 15, 2023
• Extern templates to reduce binary size Nov 8, 2023
• C++23: Removing garbage collection support Nov 1, 2023
• My battle against signed/unsigned comparison: the worst violations Oct 25, 2023
• My battle against signed/unsigned comparison: the most usual violations Oct 18, 2023
• How to compare signed and unsigned integers in C++20? Oct 11, 2023
• Trip report: Dev Talks Cluj 2023 Oct 4, 2023
• Be a good gardener of your scripts Sep 27, 2023
• Once more about clean code Sep 20, 2023
• Constexpr functions for smaller binary size? Sep 13, 2023
• C++23: some changes related to templates Sep 6, 2023
• C++23: compatibility with C Aug 23, 2023
• C++23: mdspan Aug 15, 2023
• C++23: multidimensional operator[] Aug 9, 2023
• C++23: static operator() and static operator[] Jul 26, 2023
• Binary sizes and compiler flags Jul 19, 2023
• C++23: Alias declarations in for loop init-statements Jul 12, 2023
• Fold expressions in C++ Jun 14, 2023
• C++23: two additional noexcept functions May 31, 2023
• C++23: Even more constexpr May 24, 2023
• Are we - developers - spoiled or abused? May 17, 2023
• Is this dynamic_cast needed? May 10, 2023
• Variadic functions vs variadic templates May 3, 2023
• Without RTTI your code will be cleaner Apr 26, 2023
• Vectors and unique pointers Apr 12, 2023
• Binary sizes and passing functions to functions Apr 5, 2023
• Binary size and exceptions Mar 29, 2023
• Can we find a compromise? Mar 22, 2023
• The observer pattern and binary sizes Mar 15, 2023
• The decorator pattern and binary sizes Mar 8, 2023
• Binary sizes and RTTI Mar 1, 2023
• What's the easiest way to add custom code to your WordPress site without breaking it? Feb 27, 2023
• 4 different ways I've worked remotely Feb 22, 2023
• The evolution of enums Feb 15, 2023
• Virtual functions and binary sizes Feb 8, 2023
• Special functions and binary sizes Feb 1, 2023
• Deep vs shallow modules Jan 25, 2023
• Object initialization and binary sizes Jan 18, 2023
• What's an executable and how is it structured Jan 11, 2023
• The run-time, compile-time, binary size triangle Jan 4, 2023
• Class templates versus constructor templates Dec 21, 2022
• Non-coding roles or something you like? Nov 19, 2022
• C++23: The <expected> header; expect the unexpected Nov 16, 2022
• 3 Things MongoDB Can Help You With Nov 5, 2022
• The evolution of statements with initializers in C++ - part 2 Nov 2, 2022
• The evolution of statements with initializers in C++ Oct 26, 2022
• I'm leaving Amadeus after 9 years Oct 19, 2022
• Should you use static code analyzers as gatekeepers? Oct 12, 2022
• C++23: flat_map, flat_set, et al. Oct 5, 2022
• 5 tips to find your next job Sep 28, 2022
• C++23: The stacktrace library Sep 21, 2022
• Don't feel bad because of failed interviews, just keep learning! Sep 14, 2022
• C++23: Preprocessing directives Sep 7, 2022
• Should you really memorize algorithm complexities? Aug 31, 2022
• The Template Method Pattern and the Non-Virtual Idiom Aug 24, 2022
• 3 ways to stay motivated when you are leaving your job Aug 17, 2022
• The copy and swap idiom in C++ Aug 10, 2022
• Price's law and 3 things to do if you're underpaid Aug 3, 2022
• Trip report: C++ On Sea 2022 Jul 27, 2022
• 6 C++23 features improving string and string_view Jul 20, 2022
• What are string_views and why should we use them? Jul 13, 2022
• Won't extend it more than once! Jul 6, 2022
• C++: standardized Jun 29, 2022
• Bitwise enumerations Jun 22, 2022
• C++23: Narrowing contextual conversions to bool Jun 15, 2022
• Smart pointers and their deleters Jun 8, 2022
• C++23: Consteval if to make compile time programming easier Jun 1, 2022
• C++23: Literal suffix for (signed) size_t May 25, 2022
• Tipi, a new solution to build C++ projects easier May 9, 2022
• Make declaration order layout mandated May 4, 2022
• The 4 use of using in C++ Apr 27, 2022
• The infamous bug of range-based for loops Apr 20, 2022
• Use strong types instead of bool parameters Apr 6, 2022
• Storing references of pointers in containers in C++ Mar 30, 2022
• The Employee-Company triangle Mar 23, 2022
• C++ basics: Pointers vs iterators Mar 16, 2022
• Mocking non-virtual and free functions with gMock Mar 9, 2022
• Mocking virtual functions with gMock Mar 2, 2022
• The big STL Algorithms tutorial: wrapping up Feb 23, 2022
• C++23: Deducing this Feb 16, 2022
• 5 types of communication a senior developer does Feb 9, 2022
• The big STL Algorithms tutorial: the memory header Feb 2, 2022
• 3 piece of advice for junior developers Jan 26, 2022
• The big STL Algorithms tutorial: *numeric* scans Jan 19, 2022
• Top 3 reasons to let people change teams within your organization Jan 12, 2022
• The big STL Algorithms tutorial: more numeric algorithms Jan 5, 2022
• What is the most vexing parse? Dec 22, 2021
• Trip Report: CPPP 2021 Dec 15, 2021
• Top 7 reasons to join another team Dec 8, 2021
• I broke production 3 times in 3 weeks - Part II Dec 1, 2021
• I broke production 3 times in 3 weeks - Part I Nov 24, 2021
• Trip Report: Meeting C++ 2021 Nov 17, 2021
• The big STL Algorithms tutorial: permutation operations Nov 10, 2021
• 5 sources of success: how not to lose confidence after a promotion? Nov 3, 2021
• Functions to be called only once in C++ Oct 27, 2021
• The big STL Algorithms tutorial: reduce operations Oct 20, 2021
• C++ Concepts and the Core Guidelines Oct 13, 2021
• Bring some fresh AIR and write effective code review comments Oct 6, 2021
• Replace std::find_if in 80% of the cases Sep 29, 2021
• The big STL Algorithms tutorial: comparison operations Sep 22, 2021
• Top 6+1 responsibilities of a developer Sep 15, 2021
• Do we correctly calculate min and max? Sep 8, 2021
• The big STL Algorithms tutorial: Minimum/maximum operations Sep 1, 2021
• const rvalue references Aug 18, 2021
• Stand up for yourself and for your values Aug 14, 2021
• The big STL Algorithms tutorial: heap operations Aug 4, 2021
• How much revenue do you generate? Jul 28, 2021
• const and smart pointers Jul 21, 2021
• The big STL Algorithms tutorial: set operations Jul 14, 2021
• 2 ways to use static with functions in C++ Jul 7, 2021
• The big STL Algorithms tutorial: merge and inplace_merge Jun 23, 2021
• Multiple destructors with C++ concepts Jun 16, 2021
• Live like a monk - the key to success May 26, 2021
• The big STL Algorithms tutorial: binary_search et al. May 19, 2021
• 3 types of people in software development without skin in the game May 12, 2021
• C++ Concepts and logical operators May 5, 2021
• What kind of developer are you? Apr 21, 2021
• How to use type traits? Apr 14, 2021
• My code is not shipped! Should I care? Mar 31, 2021
• C++ concepts in real life Mar 24, 2021
• How to write your own C++ concepts? Part II. Mar 17, 2021
• You have to ask for it! Mar 13, 2021
• How to write your own C++ concepts? Part I. Mar 10, 2021
• Concepts shipped with the C++ standard library Mar 3, 2021
• C++ concepts with classes Feb 24, 2021
• 4 ways to use C++ concepts in functions Feb 17, 2021
• How to turn failures into growth in 5 steps? Feb 13, 2021
• The concept behind C++ concepts Feb 10, 2021
• The big STL Algorithms tutorial: sorting operations Feb 3, 2021
• Can virtual functions have default arguments? Jan 27, 2021
• Passion leads to specialization! Jan 23, 2021
• The big STL Algorithms tutorial: partitioning operations Jan 20, 2021
• Three ways to use the = delete specifier in C++ Jan 6, 2021
• What is virtual inheritance in C++ and when should you use it? Dec 23, 2020
• Santa's Christmas Wishlist Dec 19, 2020
• A story of nasty a bug: AWS DynamoDB UI special character escaping Dec 16, 2020
• The big STL Algorithms tutorial: modifying sequence operations - rotate functions Dec 9, 2020
• Read to boost your career! Dec 5, 2020
• The most important git practice Dec 2, 2020
• Emergent Design: The Evolutionary Nature of Professional Software Development by Scott Bain Nov 28, 2020
• When to use const in C++? Part IV: parameters Nov 25, 2020
• When to use const in C++? Part III: return types Nov 18, 2020
• What do you want from a job, that is the question Nov 15, 2020
• When to use const in C++? Part II: member variables Nov 11, 2020
• When to use const in C++? Part I: functions and local variables Nov 4, 2020
• Sharpen your axe and chop down the tree quickly Oct 31, 2020
• Confessions of an addict: Just a few lines... Oct 28, 2020
• User-defined literals in C++ Oct 21, 2020
• Strong types for containers Oct 14, 2020
• DevReads to fill up your reading list Oct 7, 2020
• Cmake Project Creator at your disposal Sep 30, 2020
• How to share data in Jenkins? Sep 23, 2020
• Happy International Programmers' Day Sep 12, 2020
• The big STL Algorithms tutorial: modifying sequence operations - how to get distinct elements Sep 8, 2020
• Let me introduce Daily Cpp Interview Sep 2, 2020
• Covariant return types Aug 19, 2020
• The big STL Algorithms tutorial: modifying sequence operations - rotate functions Aug 12, 2020
• Virtual Trip Report: C++ On Sea 2020 Jul 29, 2020
• Why should we always catch exceptions by reference? Jul 22, 2020
• The big STL Algorithms tutorial: modifying sequence operations - turn things around Jul 15, 2020
• Try-catch everything without macros Jun 24, 2020
• Occupying a seat vs. show me your skill! Jun 10, 2020
• The big STL Algorithms tutorial: modifying sequence operations - remove calls Jun 3, 2020
• Loops are bad, algorithms are good! Aren't they? May 13, 2020
• The 4 Different Levels of Autonomy Apr 29, 2020
• The big STL Algorithms tutorial: replace N elements Apr 22, 2020
• The quest of private inheritance in C++ Apr 1, 2020
• The seniority trap Mar 18, 2020
• The big STL Algorithms tutorial: modifying sequence operations - fill and generate Mar 11, 2020
• Immediately invoked lambda functions Feb 19, 2020
• What makes a training advanced? Feb 5, 2020
• The big STL Algorithms tutorial: modifying sequence operations - replace* Jan 29, 2020
• I went to DevOps D-Day #5 Jan 15, 2020
• Default Member Initializers in C++ Jan 8, 2020
• The big STL Algorithms tutorial: transform's undefined behaviour Dec 18, 2019
• Does this string declaration compile? Nov 27, 2019
• My DEV birthday gift for you: DEV.to Analytics! Nov 20, 2019
• The big STL Algorithms tutorial: transform Nov 6, 2019
• The brand new assignment expression of Python 3.8 Oct 16, 2019
• The big STL Algorithms tutorial: modifying sequence operations - move and swap Sep 25, 2019
• What's wrong with this person?! No! What's wrong with you? Sep 18, 2019
• The dead singleton and three ways to overcome it Sep 4, 2019
• Why clean code is not the norm? Aug 28, 2019
• The big STL Algorithms tutorial: modifying sequence operations - copy et al. Aug 14, 2019
• Forty and still a dev? Aug 7, 2019
• The big STL Algorithms tutorial: the rest of non-modifying sequence operations Jul 24, 2019
• RivieraDev 2019 - the gastronomical dev conference Jul 16, 2019
• The C++ Standard Library: A Tutorial and Reference by Nicolai Josuttis Jul 10, 2019
• How do you prepare your commits? Jul 3, 2019
• Travel report: CPPP 2019 Jun 26, 2019
• Take the lead! Jun 12, 2019
• The Slow Birth of a Developer Jun 6, 2019
• It's - not - so easy May 22, 2019
• The big STL Algorithms tutorial: find et al. May 15, 2019
• Be severe only with yourself May 1, 2019
• Parameterized testing with GTest Apr 24, 2019
• Lesson of a booking: Don't trust the system! Apr 10, 2019
• The big STL Algorithms tutorial: for_each Apr 3, 2019
• Production code as a playground? Mar 20, 2019
• The Curiously Recurring Template Pattern (CRTP) Mar 13, 2019
• Do your job Feb 27, 2019
• The big STL Algorithms tutorial: all_of, any_of, none_of Feb 20, 2019
• The big STL Algorithms tutorial: Introduction Jan 30, 2019
• Who should be the master? Jan 16, 2019
• The Three Laws of Objects Jan 8, 2019
• Professional learners we are Dec 26, 2018
• Lambda Expressions in C++ Dec 19, 2018
• Reconquering my job in 15 steps Dec 5, 2018
• How to use ampersands in C++ Nov 25, 2018
• A few words about team buildings Nov 14, 2018
• How do you declare a function in C++? Nov 7, 2018
• Live with your results Oct 24, 2018
• How I set up my Git Oct 17, 2018
• Are you a fraud? Oct 3, 2018
• How not to quit Sep 26, 2018
• It's not your job! Sep 5, 2018
• Deliberate practice and memory management Aug 29, 2018
• Stop reading! Aug 15, 2018
• Gilded Rose kata revisited Aug 8, 2018
• The cost of CPU operations Jul 25, 2018
• How to grow antifragile as a developer Jul 11, 2018
• Why to use the override specifier in C++ 11? Jul 5, 2018
• I went to RivieraDEV 2018 Jun 1, 2018
• How to automatically format your C++ code regardless the IDE you use May 30, 2018
• The 7 worst things a manager can do to a newcomer May 4, 2018
• Class initialization and nasty cores Apr 11, 2018
• Sane office environment with code review guidelines Mar 28, 2018
• How to choose your first programming language Mar 21, 2018
• Design Stamina Hypothesis Mar 6, 2018
• Briefly about Mutation Testing Feb 14, 2018
• Practice with a timer! Feb 6, 2018
• How Wine-Disco is progressing? Jan 25, 2018
• Briefly about Mutation Testing Jan 11, 2018
• New year, a new beginning Jan 3, 2018
• Briefly about Chaos Engineering Dec 20, 2017
• Demistify stars in Python Dec 13, 2017
• Cypher tutorial: Relationships with a varying length Dec 6, 2017
• Cypher tutorial: OPTIONAL MATCH Nov 22, 2017
• Cypher tutorial: the RETURN keyword Nov 8, 2017
• Ramping up a new team: let's mob Nov 1, 2017
• Cypher tutorial: the MATCH keyword Oct 25, 2017
• Reflections on the dojo I facilitated at Soiree du Test Logiciel Oct 18, 2017
• Cypher tutorial: the CREATE keyword Oct 11, 2017
• Introduction to cypher Oct 4, 2017
• CodinGame at Amadeus Sep 29, 2017
• Programming on rails: Railway Oriented Programming! Sep 27, 2017
• Upcoming coding dojo about graph databases Sep 15, 2017
• Introduction to graph databases Sep 6, 2017
• What can you use for visualizing a graph? Aug 24, 2017
• How to use rules in JUnit Aug 8, 2017
• Are you a monogamous or a polygamous developer? Jul 25, 2017
• Naming conventions for interfaces in Java Jul 18, 2017
• Meet Neo4j again Jul 11, 2017
• I made my first open source contribution Jun 27, 2017
• Test driven development with Spring Jun 22, 2017
• Horror with Maven - dependency management vs dependencies Jun 20, 2017
• Getting familiar with Kafka Jun 15, 2017
• A new app Jun 12, 2017
• TDD as if you meant it Jun 7, 2017
• Attending my first IT conference May 16, 2017
• Looking for challenges in open source Mar 12, 2017
• Story of a failure Mar 5, 2017
• My latest user story is about being a consultant Feb 22, 2017
• Tooling is great! Jan 24, 2017
• Refactor Knuth's Prime Printer Jan 17, 2017
• The Hashtag Square Jan 6, 2017