👩💻 Software Engineer | Backend Development
🎓 Junior Bachelor's Degree in Computer Science
- Visual Studio — IDE for .NET and C# development
- Visual Studio Code — code editor for web development and multiple languages
- IntelliJ IDEA — Java development
- Postman — API testing
- Git — version control
- Docker — containerization
- JetBrains IDEs — development tools
- DRY — Don't Repeat Yourself: avoid duplicating the same knowledge or logic.
- KISS — Keep It Simple, Stupid: prefer simple and understandable solutions.
- YAGNI — You Aren't Gonna Need It: do not implement functionality until it is actually needed.
- S — Single Responsibility Principle: a class should have one reason to change.
- O — Open/Closed Principle: software entities should be open for extension but closed for modification.
- L — Liskov Substitution Principle: subtypes should be usable wherever their base types are expected.
- I — Interface Segregation Principle: clients should not depend on methods they do not use.
- D — Dependency Inversion Principle: depend on abstractions rather than concrete implementations.
- Separation of Concerns (SoC): separate different responsibilities into distinct components.
- Composition over Inheritance: prefer composing objects and delegating behavior when appropriate instead of relying on deep inheritance hierarchies.
- High Cohesion: keep the responsibilities of a module closely related to one clear purpose.
- Low Coupling: minimize dependencies between modules and concrete implementations.
- Fail Fast: detect invalid states and errors as early as possible.
- Principle of Least Knowledge (Law of Demeter): minimize knowledge of and dependence on the internal structure of other objects.
- Encapsulation
- Abstraction
- Inheritance
- Polymorphism
- Association
- Aggregation
- Composition
- Anemic Domain Model
- Fat Controller
- God Object
- Hierarchy Explosion
- Tight Coupling
- Spaghetti Code
- Copy-Paste Programming
- Lava Flow
- Golden Hammer
- Big Ball of Mud
- Poltergeist
- Yo-Yo Problem
- Overengineering
- Speculative Generality
- Premature Optimization
- Circular Dependency
- Duplicate Code
- Magic Numbers
- Magic Strings
- Shotgun Surgery
- Inappropriate Intimacy
- Feature Envy
- Data Clumps
- Middle Man
- Dead Code
- Temporal Coupling
- Abstract Factory
- Builder
- Factory Method
- Prototype
- Singleton
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
- Chain of Responsibility
- Command
- Interpreter
- Iterator
- Mediator
- Memento
- Observer
- State
- Strategy
- Template Method
- Visitor
- MVC — Model-View-Controller
- MVVM — Model-View-ViewModel
- Repository Pattern
- Dependency Injection (DI)
- Layered Architecture
- Client-Server Architecture
- Event-Driven Architecture
- Clean Architecture
- REST API Design
- HTTP Methods & Status Codes
- API Testing with Postman
- Process Monitoring
- Logging & Error Handling