Training
Founder and Partner
-
Recent Posts
I Blog About
- abstraction
- blogging
- code design
- cohesion
- composition
- coupling
- course
- data
- data access
- deferred execution
- Dependency Injection
- dependency inversion principle
- design
- design patterns
- Design Practices
- DI
- DIP
- Disposable
- encapsulation
- enforce consistency
- Entity Framework
- globalization
- internationalization
- Inversion of Control
- itcamp14 conference Cluj Microsoft
- job
- LINQ
- localization
- Object Oriented Design Principles
- ORM
- Patterns
- presentation
- public speaking
- QA
- quality
- Queryable
- refactor
- refactoring
- references
- Repository
- separation of concerns
- Service Locator
- SOLID
- tdd
- Testing
- training
- translation
- Unit of Work
- unit testing
- Unity
My Tweets
- Call for Speakers for ITCamp 2020 is open and I've just submitted a session! sessionize.com/itcamp-2020------------------------------------------------ 22 hours ago
- RT @EisenbergEffect: Anyone have a positive experience with or recommendation of a JavaScript database? I'm looking for something like Mong…------------------------------------------------ 4 days ago
- RT @alexnmoldovan: This image describes very well the level of privilege developers enjoy in #cluj https://t.co/4VDTXSgRnP------------------------------------------------ 4 days ago
- Lera Boroditsky: How language shapes the way we think ted.com/talks/lera_bor…------------------------------------------------ 2 weeks ago
Posts Categories
Posts Archives
Category Archives: Technical
Concurrent Unit Tests with Service Locator
My talk at Microsoft Summit created a nice discussion with some of the participants about writing isolated unit tests when using the Service Locator. It started from the part where I was showing how the AppBoot helps in dependencies management by … Continue reading
Posted in .NET, Design, Technical, Unit Testing
Tagged code design, Dependency Injection, Service Locator, tdd, unit testing
Leave a comment
Crosscutting Concerns
The Crosscutting Concerns are the areas in which high-impact mistakes are most often made when designing an application. There are common causes that lead to this and there are common practices that can help to avoid such mistakes. In this post I … Continue reading
Posted in Design, Technical
Tagged abstraction, code design, crosscutting concerns, Design Practices, encapsulation
Leave a comment
DRY vs Coupling
While reviewing my previous post another great discussion, which may arise from paying attention to your references, came to my mind: Don’t Repeat Yourself (DRY) vs Coupling. Each time you add a new reference it means that you want to … Continue reading
Posted in .NET, Design, Technical
Tagged abstraction, code design, coupling, design, Design Practices, DRY, duplication, Object Oriented Design Principles
Leave a comment
Using ReSharper for Assembly References Diagrams
A few posts back I talked about how we can use the assembly references to enforce consistency and separation of concerns (here and here are the old posts). I argue there that if we derive from the architecture the assemblies of … Continue reading
Posted in .NET, Design, Technical
Tagged abstraction, code design, design, Design Practices, DIP, enforce consistency, references, separation of concerns
Leave a comment
Localization Concern
Localization (also known as internationalization) is one of the concerns that is most of the times overlooked when we design an application. We almost never find it through the requirements, and if we do or if we ask about it, … Continue reading
Posted in .NET, Design, Technical
Tagged code design, design, globalization, internationalization, localization, translation
Leave a comment
Dependency Inversion and Assemblies References
In my last posts I have talked about using assembly references to preserve critical design aspects. In Enforce Consistency with Assemblies References I talk about how we can use references to outline the allowed dependencies in code and how to … Continue reading
Enforce Consistency with Assembly References
In this post I’ll describe some key aspects that I consider when designing the assemblies that build a system. When we structure our code into assemblies (generally named binaries, libraries or packages in other platforms than .NET) we are reasoning about three main … Continue reading
Posted in .NET, Design, Technical, Training
Tagged code design, composition, enforce consistency, separation of concerns
Leave a comment
Unit Testing on Top of Entity Framework DbContext
When writing unit tests one of the challenges is to isolate your tests from everything. To isolate them from the code that is not in their target and also from the other tests. As Roy Osherove puts it in his … Continue reading
Posted in .NET, Technical, Unit Testing
Tagged code design, data access, Entity Framework, quality, Repository
Leave a comment
Repository Implementations
In my previous post I have presented a way to separate your data access from the business logic, when a relational database is used. I have shown another implementation of the well-known Repository pattern. Since Martin Fowler described it in … Continue reading
Posted in .NET, Design, Technical
Tagged abstraction, code design, data, data access, design, Entity Framework, ORM, Repository, Unit of Work
Leave a comment
Separating Data Access Concern
In our days most of the applications that have a relational database as storage, use an ORM to access the data. The ORM (Entity Framework, Hibernate, etc.) does most of the data access implementation. Many of them have a modern … Continue reading
Posted in .NET, Design, Technical
Tagged abstraction, code design, data, data access, design, encapsulation, Entity Framework, ORM, Repository, separation of concerns, Unit of Work
Leave a comment
