Description
Course info
Rating
(268)
Level
Intermediate
Updated
Oct 6, 2014
Duration
2h 8m
Description

Abstraction is awesome. And abstraction is awful. Too little, and our applications are hard to maintain. Too much, and our applications are hard to maintain. This course focuses on getting the level of abstraction "just right" for our applications.

About the author
About the author

Jeremy Clark is an application developer, technical speaker, and Microsoft MVP with over 13 years of experience in all aspects of the development lifecycle. After hours, he puts together demos and technical articles for JeremyBytes.com, a website focusing on .NET technologies.

More from the author
Practical Reflection in .NET
Intermediate
3h 23m
21 Nov 2013
Dependency Injection On-Ramp
Intermediate
2h 38m
21 Oct 2013
More courses by Jeremy Clark
Section Introduction Transcripts
Section Introduction Transcripts

Understanding Your Nature
We've taken a look at some of the good and bad of abstraction, but now it's time to take a look at ourselves. We want to discover our default state, our natural tendencies towards using abstraction. Once we understand our nature, we can use it to our advantage. And let's remember why we're here. Abstractions are very compelling, but they do have drawbacks. Our default state often gets in the way. We want to try to understand this a bit better. And even though no one solution solves all of our problems, there are some principles to help us along the way. During this part of our journey, we'll spend a bit of time to better understand ourselves. By nature we are either over-abstractors or under-abstractors. With a bit of introspection, you'll discover which one you are.

Practical Advice
We've learned a little about ourselves and have considered our environment. Now it's time to look at some practical advice, specific principles that we can use to get our level of abstraction just right. And let's remember why we're here. Abstractions are very compelling, but they do have drawbacks. As we've seen, our default state as an over-abstractor or under-abstractor can get in the way of getting things just right. And even though no one solution solves all our problems, there are principles to help us along the way. Now that we know our nature, we can take a look at some practical advice for overcoming those natural tendencies. We'll look at specific principles that we can use for guidance while being careful not to go too far in the other direction. We'll look at principles for over-abstractors and principles for under-abstractors. Now you may be tempted to only pay attention to the techniques that relate to your nature, but we really need to pay attention to all of them. This is because of the pendulum effect, where we start out as an over-abstractor and end up as an under-abstractor. So all of these techniques are relevant to us. Many of these principles are simply best practices-- things we might have heard about in different contexts, such as when dealing with clean code or the solid principles of object-oriented design. And I would highly recommend taking the Pluralsight courses on those topics for a deeper dive. But here we're looking at them specifically to help us get the level of abstraction in our applications just right. I'm a fan of best practices. This is based on my experience and often doing things the wrong way. This isn't to say that we should always follow these practices. We still need to consider whether they are appropriate for our particular situation, but they are definitely a good place to start.

Getting Things Right
We've spent quite a bit of time learning about ourselves and principles that can help us get abstraction just right. Now we'll put some of those principles into action to get a better understanding of how they work. And let's remember why we're here. Abstractions are very compelling, but they do have drawbacks. Our default state often gets in the way and there's no single answer that lies to every situation. But there is hope. We've looked at some various types of abstractions and seen both the benefits and the drawbacks. We've taken a look internally to better understand ourselves. We've gone through a set of principles to help both over-abstractors and under-abstractors and we've seen some examples of how abstractions leak. Now it's time for us to put everything together to see how they can help us get things just right.