The Curious Engineer

All blogs / C++

Simplify C++!

arne-mertz.de

Write clean and maintainable C++

C++Software / engineering practiceDev tools / editors / IDEs

’15’16’17’18’19’20’21’22’23’24’25’26
Posts
202 from 4 Jan 2015 to 24 May 2024
Posting
quiet since 2024
Kind
personal blog
Feed
https://arne-mertz.de/feed/

2024 2

  1. PayloadOffset_t: A small type design challenge
  2. Core Guidelines are not Rules

2021 11

  1. [fix dev diary] Week 6-7: Description and Issue ID
  2. isValid()? Establish invariants and avoid zombie objects
  3. [fix dev diary] Week 5: std::expected
  4. [fix dev diary] Week 4: Closing in on core domain code
  5. [fix dev diary] Week 3: create command and application service
  6. [fix dev diary] Week 2: Foundation of the CLI App
  7. [fix dev diary] Week 1: Preparations
  8. Old new Project: Fix
  9. Docker4c: portable C++ development environment
  10. Rebooting the blog
  11. Colony – A brief history of timing

2019 8

  1. Constexpr FizzBuzz – An Exercise in Compile-Time Calculations
  2. plf::list and the Disassembly of Time Complexity
  3. Multiple dispatch over covariant functions
  4. algorithms and the KISS principle
  5. Macro Evil in C++ Code
  6. Cpp On Sea 2019 Trip Report
  7. Reduce Compilation Times With extern template
  8. The pImpl Idiom

2018 37

  1. Simple data structures
  2. std::string is not a Container for Raw Data
  3. C++ Quizzes and Trick Questions – Do we Have to Know the Answers?
  4. Calling C Code from C++ With ‘extern “C”‘
  5. std::make_shared vs. the Normal std::shared_ptr Constructor
  6. Same, same, but different: when different values compare equal
  7. Modern C++ Features – Quality-of-Life Features
  8. “Modern C++” != “New(est) Standard”
  9. In the name of Elegance
  10. CMake – Properties and Options
  11. Reproducible build: environments and scripts
  12. Functions of Variants are Covariant
  13. “Builds on my machine!” – About local build
  14. CMake Project Structure
  15. Modern C++ Features – std::optional
  16. CMake – Another Target and the Project
  17. Hello CMake!
  18. Overload: Build a Variant Visitor on the Fly
  19. Modern C++ Features – std::variant and std::visit
  20. Trailing Return Types, East Const, and Code Style Consistency
  21. ACCUConf 2018 Trip Report
  22. How to Perform Unit Testing Native C++ Code in Visual Studio
  23. Tailor Standard Containers to Your Needs
  24. Raw Pointers Are Gonna Stay!
  25. Raw Pointers Are Gone!
  26. The Dark Side of Error Logging
  27. Code of Conduct – why I Insist
  28. Forward-declaring Templates and Enums
  29. Forward Declarations to Reduce Compiletime Dependencies
  30. #include – Don’t get fancy
  31. Terseness: how little is too much?
  32. Complexity Theory, Relativity and The Theory of Everything
  33. Design Patterns in Real Life
  34. Clean Code Generation
  35. Code Reviews – The Human Aspect (Part 5)
  36. Code Reviews – How? (Part 4)
  37. Code Reviews – Preparation (Part 3)

2017 30

  1. Code Reviews – What? (Part 2)
  2. Code Reviews – Why? (Part 1)
  3. Meeting C++ 2017 Trip Report
  4. Mutable
  5. Refactoring Support in Cevelop
  6. Code Smells – a Short List
  7. Approaching an Unknown Code Base
  8. Taking Notes About Work in Progress
  9. Generated Code
  10. Source File Organization for C++ Projects Part 3: Dependent Repositories and Generated Code
  11. What’s Ubiquitous Language and Why You Should Care
  12. reinterpret_cast vs. constant expression
  13. Basic Refactoring Steps
  14. Modern C++ Features – Class Template Argument Deduction
  15. C++ Online Compilers
  16. Continuous integration with Travis CI
  17. Final Classes
  18. Dialing back
  19. Smelly std::pair and std::tuple
  20. Prefixed Names
  21. Constexpr Additions in C++17
  22. Implementing Array Access for Tuple
  23. Emerging Patterns – Refactoring Session #4
  24. Lambda Overdose
  25. Refactoring Basics
  26. Implementation-Inspired Tests
  27. Modern C++ Features – decltype and std::declval
  28. Refactoring Session #3 – from JSON to a Proper Class.
  29. Ranges: the STL to the Next Level
  30. “YAY, Two Years!” and Guest Posts

2016 52

  1. Modern C++ Features – Attributes
  2. Return early and clearly
  3. BDD for C++ Projects – With Python and Behave
  4. Weakly Typed Data
  5. Trailing return types everywhere
  6. Prototypes: to test or not to test, that’s the question
  7. More About Variadic Templates
  8. Modern C++ Features – Variadic Templates
  9. Use Stronger Types!
  10. Modern C++ Features – User-Defined Literals
  11. Passkey Idiom: More Useful Empty Classes
  12. Tag Dispatch: Useful Empty Classes
  13. Large C++ Legacy Applications: Tools
  14. Large Legacy Applications: Tests and Modularization
  15. Large C++ Legacy Applications: Planned Refactoring
  16. Clean up Large C++ Legacy Applications
  17. Starting With the Poco Libraries
  18. Design for Testability: Separate I/O layers
  19. Does Const Imply Thread Safety?
  20. Using Conan for Third Party Libraries
  21. The “4C” Development Environment
  22. New Project: Fix – Why, What and How
  23. Const Correctness
  24. Refactoring – Don’t get Carried Away
  25. Refactoring Session #2b: Matrix Calculation – Extract Class
  26. Refactoring Session #2a: Matrix Calculation – Code Smells
  27. Source File Organization for C++ Projects Part 2: Directories and Namespaces
  28. Source File Organization for C++ Projects Part 1: Headers and Sources
  29. Modern C++ Features – constexpr
  30. Compile Time Constants Part 2: Compile Time Calculations
  31. Compile Time Constants Part 1: Why We Need Them
  32. Clean Documentation
  33. RAII versus Exceptions
  34. Development Environment: Make the Setup Simple
  35. Covariance with Smart Pointers
  36. Visitor Pattern Part 2 – the enum based visitor
  37. Visitor Pattern Part 1- the Object Oriented Way
  38. Enum vs. Class Hierarchies
  39. Strings vs. Enumerators
  40. Refactoring Session #1: Statements, Lists and Inheritance
  41. More About Adopting Scripting Languages
  42. Scripting Languages and C++
  43. Do Domain Specific Languages add Complexity to Plain C++?
  44. Use a static analyzer or two
  45. Compiler Warnings Part 2 – Tune the Compiler
  46. Compiler Warnings Part 1 – Treat Them Right
  47. Modern C++ features – in-place construction
  48. Get rid of those cheat sheets!
  49. Constructor Failures
  50. Avoid Invalid State
  51. C++ Object Lifetimes
  52. Modern C++ Features – keyword `noexcept`

2015 62

  1. Levels of Exception Safety
  2. Modern C++ Features – nullptr
  3. Modern C++ Features – override and final
  4. shared_ptr Versus unique_ptr in Factory Functions
  5. Don’t Believe What They Say
  6. Who are we Writing Code for?
  7. Clean up the Build
  8. Lambdas Part 2: Capture Lists and Stateful Closures
  9. Modern C++ features – lambdas
  10. Testing as a Developer
  11. rvalue References Wrap Up
  12. Modern C++ Features – templated rvalue References and std::forward
  13. Managing Object Ownership
  14. Modern C++ Features – Rvalue References
  15. Modern C++ Features – Move Constructor and Move Assignment
  16. Modern C++ Features – Move Semantics
  17. Modern C++ Features – auto for Functions
  18. Encapsulating APIs
  19. Modern C++ Features – Inherited and Delegating Constructors
  20. Modern C++ Features – Default Initializers for Member Variables
  21. Unit Tests are not Friends
  22. C++ is not an object oriented language
  23. Modern C++ Features – std::begin/end and range based for loops
  24. Modern C++ Features – auto for variables
  25. Modern C++ Features – Uniform Initialization and initializer_list
  26. Half a year of blogging
  27. The State of C++ – Is it Back or Not?
  28. Passing containers as out-parameters
  29. Domain Specific Languages in C++ – Part 2: External DSLs
  30. Domain Specific Languages in C++ – Part 1: Embedded DSLs
  31. Everything In A Class? – C++ Is Not Java!
  32. Properties of Unit Tests
  33. Purposes of Unit Tests
  34. Comments Mean Failure
  35. The Perfect Code
  36. Evolving a Framework
  37. Singletons – What’s the Deal?
  38. Audience
  39. Simple and Clean Code vs. Performance
  40. Making Yourself at Home in Legacy Code, Part 3: Getting the Team on Board
  41. Making Yourself at Home in Legacy Code, Part 2: Refactoring
  42. Making Yourself at Home in Legacy Code, Part 1: Options
  43. One Hour of Unittests?
  44. Fun with(out) keyword explicit
  45. Operator Overloading – Introduction to Boost.Operators, Part 3
  46. Operator Overloading – Introduction to Boost.Operators, Part 2
  47. Operator Overloading – Introduction to Boost.Operators, Part 1
  48. Type Deduction and Braced Initializers
  49. Plain Pointers as Function Parameters
  50. Uses of Inheritance
  51. The Rule of Zero revisited: The Rule of All or Nothing
  52. Adherence to Design Patterns
  53. Know your libraries
  54. First month’s restrospect
  55. Helper Classes Deserve Some Care, Too
  56. Over-generalization
  57. A Casting Show
  58. Don’t Try Too Hard! – Exception Handling
  59. Operator Overloading: Common Practice
  60. Operator Overloading: The Basics
  61. Heap allocation of local variables
  62. Hello Blog