1. Keeping track of an object's status
  2. Sum Types vs Polymorphism
  3. Send records to messaging queue using either of one policy

  4. How to design classes in php in respository pattern?

  5. Can we really use immutability in OOP without losing all key OOP features?

  6. If a method in class A needs extra dependency but not every client uses it, should I move it out of A?
  7. A DLL as an IO module in C++
  8. Applying SOLID principles
  9. Struct + Functions that operate on the struct vs. OOP objects

  10. Where to put domain classes in a component structure and diagram?

  11. Understanding UML composition better
  12. Can the circle-ellipse problem be solved by reversing the relationship?
  13. Composition and callits its part methods
  14. Should I split a single class into multiple classes to reduce dependency if possible?
  15. Question(s) about PHP PDO connections

  16. Is it anti-pattern to alter domain model on front end?

  17. The finer points of HMVC
  18. Are Python mixins an anti-pattern?
  19. Is inserting service logic in its own class considered bad?
  20. Feedback on inheritance assignment

  21. Clean Code and the Principle of Least Astonishment

  22. Can you Improve your programming skills by learning other language paradigms?

  23. Exceptions in DDD

  24. What's the general option on passing a boolean parameter in a method or constructor in OOP languages?
  25. Method grouping other methods of the same family and how to call any of these separately

  26. How does "Composition Root" DI apply to Domain Driven Design?

  27. Do you put business logic in your service implementation ? <comment on my design>

  28. How do you avoid endlessly iterating through equally sub-optimal designs?

  29. What is a proper use of downcasting?

  30. Single responsibility: how does this code cause problems?

  31. Injecting data processing logic into class
  32. One Single Table or Two Smaller Tables

  33. What should a constructor contain?

  34. Which class should have the `intersects` method?
  35. Refactoring of a client API for avoid duplicated code and unclear passage of parameters
  36. Pass result in API Chaining

  37. Why does Qt consider disconnectNotify as violating the modularity of OOP?
  38. Where should I put the database access method in a treeview environment
  39. How to handle the methods that have been added for subtypes in the context of polymorphism?

  40. How to update a model with dependencies

  41. Finite state machine menu design
  42. Return considered harmful? Can code be functional without it?

  43. Should we avoid object creation in Java?

  44. How can I copy and alter object with unique_ptr in it?

  45. Classes as parameters
  46. Generic repository pattern +EF and unit of work
  47. Hierarchy in ER and OO Model

  48. design pattern/oop for large validation rule set
  49. Java - Access to methods of objects fields

  50. Recommended pattern to affect other Classes on instantiation/method calls

  51. Design of Stateless class with partial modification
  52. Should I group related data fields and views together, or wrap all data fields (as well as views) into a single class?
  53. Are we abusing static methods?

  54. In object oriented languages, when should objects do operations on themselves and when should operations be done on objects?

  55. Is it good practice to wrap a related set of properties into its own struct/class?

  56. Does this class design violate the single responsibility principle?
  57. Tight class cohesion metric, all or just public methods?

  58. Should I always use the MVC pattern (or similar) for big, graphical and professional applications?
  59. OOP in Java - What can getters be used for?

  60. Does making a method static save memory on a class you'll have many instances of?
  61. When is it okay to use Parallel Arrays?

  62. Best strategy for reporting progress to the UI - how should the callback happen?

  63. Managing widgets in a simple GUI framework

  64. Should I wrap library data structures?

  65. Object oriented vs vector based programming
  66. How Dependency inversion is an extension of OCP?

  67. Think of a better method name or create separate functions for a possible single responsibility?

  68. Software design strategy for a functionality that depends on a temporal situation
  69. Making public methods virtual to ease testability
  70. DDD: Identifying aggregate root in a simple example application domain
  71. Are there flavours of OOP where some or all of the SOLID principles are antithetical to clean code?

  72. Argument contravariance, real world purpose and usage?

  73. Can the RxJava class Flowable legitimately have 460 methods?
  74. What is the name given to the practice/pattern of exposing properties of properties as immediate properties?

  75. Achieving Liskov-compliant contravariance in method arguments in C#
  76. How can I manage the code base of significantly complex software?

  77. Object To Be Used By Service Layer

  78. Read Only Generic data access layer Best practice

  79. Polymorphism factor and code maintainability

  80. Is it a code smell to set a flag in a loop to use it later?
  81. Importance of storage in c++
  82. Is the Entity Component System architecture object oriented by definition?
  83. Liskov principle: subclasses can have stronger invariants. How could it work?
  84. Creating a modified copy of an instance of an abstract interface

  85. Is it a violation of the Open-Closed Principle to update a constant representing a real-world value?

  86. Does OOP fulfill the promise of code reuse? What alternatives are there to achieve code reuse?

  87. Thick viewmodel results in thin model

  88. Are Spring beans declared as static a poor design choice?

  89. Use OOP approach for organize the business rules instead of SOA in a small project. Excluding DDD, is there some strategy to do this?

  90. Documenting my code using generic Design Patterns interfaces

  91. Mediator pattern or facade or ...?
  92. Why are functional-style chained map operations considered hard to read?

  93. OOP: Concerns about extensible design based on Interfaces

  94. Is it feasible to use User Stories and Use Cases in the same team?
  95. Why do we need private variables?

  96. Design patterns for creating objects that have a list of objects that also have a list of objects

  97. Liskov Substitution principle - strengthening preconditions
  98. Event-driven architecture avoid getters
  99. Send records using async or sync way

  100. What is the difference between the Command and Mediator patterns?