1. Violation of Liskov Substitution Principle?

  2. Should I create seperate interfaces as a way to centralize annotation?

  3. Rich Domain Models -- how, exactly, does behavior fit in?

  4. Composition and callits its part methods

  5. Question(s) about PHP PDO connections

  6. Explanation of the definition of interface inheritance as described in GoF book
  7. Is it a good idea to load all user data on top of each file including sensitive information?

  8. The finer points of HMVC

  9. What is control abstraction in the context of functional programming?

  10. What differentiates function objects from poltergeists?

  11. What is the principle of least astonishment?

  12. Communication between decoupled components using events

  13. The difference between product scenarios and requirement's Use cases in Software Specifications

  14. OOP, SRP, and Checkers
  15. Modeling web scraper
  16. what can go wrong in context of functional programming if my object is mutable?
  17. Implementing a strategy pattern with dependency injection

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

  19. Best way to code actions and their criteria/checks

  20. Injecting data processing logic into class
  21. Inside a non-static non-virtual method, if it just use a few non-static members, should I turn it into static methods with parameters?
  22. Separating functionalities in a food delivery app

  23. DDD: Identifying aggregate root in a simple example application domain

  24. How to apply rules/constraints on UI

  25. In Go when to write a function with or without a receiver?

  26. Explanation on how "Tell, Don't Ask" is considered good OO

  27. Accessing properties of composited classes without breaking encapsulation

  28. How to implement M-N relationship to reflect the domain correctly
  29. Refactoring of a client API for avoid duplicated code and unclear passage of parameters
  30. Manage the Lifetime of GUI States

  31. Separated implementations or one with all functionalities

  32. Calculated properties in OOP

  33. How to make method calls more generic when dealing with multiple class types?

  34. What's the difference between a Mixin and a Trait?

  35. The concept of linking objects and classes
  36. How to Model below Hiearchy with OOP
  37. Does increase of number of classes have impact for performance

  38. Declaration Types in OOP

  39. Should complex return objects be wrapped in a helper class?

  40. Is an Enum changing the behaviour of an Entity bad?

  41. Class that does not represent anything - is it correct?

  42. Pattern for modulating an object based on a variable

  43. Are there flavours of OOP where some or all of the SOLID principles are antithetical to clean code?
  44. How to incorporate external entity models in conceptual model?
  45. Why is unit testing harder in Object Oriented programming compared to Functional programming?

  46. OO Class Design for ATM card
  47. Object oriented immutability: final classes or final methods

  48. What is a software architecture and how to represent it?

  49. Defining a lot of attributes in a class

  50. Understanding UML composition better
  51. Handling different versions of a program and benchmarking with OO

  52. Does a deprecated class in particular version of Spring projects ever get undeprecated in the later version for any particular reason?

  53. Sample code to explain Banana Monkey Jungle problem by Joe Armstrong

  54. How to interface with very badly written code in Python?

  55. How to verify that every object responsible for Itself

  56. Should I avoid private methods if I perform TDD?

  57. Where and how to store URLs in a web module?

  58. Does MVC pattern negate other design patterns?

  59. Clarify the Open/Closed Principle

  60. What are a few arguments against SOLID principles?

  61. OOP PHP: How to avoid each class for each table situation
  62. Abstraction of VAOs, VBOs and Models

  63. Creating a modified copy of an instance of an abstract interface
  64. Design patterns for creating objects that have a list of objects that also have a list of objects

  65. PHP User, Customer, Business Relationship
  66. How to pass a variable to class used by a service in DI?

  67. How inject a collaborator who needs a back reference into a constructor

  68. When constructor chaining, which constructor should the others call?
  69. Managing IRC Mode Objects

  70. When are Getters and Setters Justified

  71. Microservices with OOP and Functional Programming

  72. Ripple Effect Analysis using coupling metrics
  73. Trait and Implementation vs just Implementation
  74. Is it feasible to use User Stories and Use Cases in the same team?
  75. Hierarchy in ER and OO Model

  76. How should I pass a restricted class instance

  77. Keeping track of an object's status

  78. Sum Types vs Polymorphism

  79. Send records to messaging queue using either of one policy

  80. How to design classes in php in respository pattern?
  81. Can we really use immutability in OOP without losing all key OOP features?

  82. If a method in class A needs extra dependency but not every client uses it, should I move it out of A?

  83. A DLL as an IO module in C++
  84. Applying SOLID principles

  85. Struct + Functions that operate on the struct vs. OOP objects
  86. Where to put domain classes in a component structure and diagram?

  87. Can the circle-ellipse problem be solved by reversing the relationship?
  88. Should I split a single class into multiple classes to reduce dependency if possible?

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

  90. Are Python mixins an anti-pattern?

  91. Is inserting service logic in its own class considered bad?
  92. Feedback on inheritance assignment

  93. Clean Code and the Principle of Least Astonishment

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

  95. Exceptions in DDD
  96. What's the general option on passing a boolean parameter in a method or constructor in OOP languages?

  97. Method grouping other methods of the same family and how to call any of these separately

  98. How does "Composition Root" DI apply to Domain Driven Design?
  99. How do you avoid endlessly iterating through equally sub-optimal designs?

  100. What is a proper use of downcasting?