Develpreneur: Become a Better Developer and Entrepreneur

The second part of our interviews with Trevor Ewen focuses on the value of a technical MBA.  We discuss the benefits of the degree, the program, and the network it can build.  This discussion is a must for those that are considering taking that step. A Little Background Trevor is an experienced software engineer, project manager, and real estate investor. He has overseen full-stack teams in clean...

We wrap up the Trevor Ewen interview series with a discussion of building libraries and extending code.  While this is often a necessity, there are different ways it can be done to help separate your code from the core or to safely build on it.  Your desired approach will vary by application and the customers involved. Extending Code Safely There is often a right way and a wrong way to extend code...

The third of our series of discussion episodes with Trevor Ewen touches on a  functional core and imperative shell .  This is an approach to building software that uses a strong core to extend to custom solutions.  We provide some options for building on your previous solutions in the modern world of software frameworks, libraries, and open-source. Functional Core The underlying theme in this appr...

We start a new season of episodes full of interviews in a discussion with Trevor Ewen.  Building software is an underlying theme of this part of our multi-part series of discussions with him.  This also includes the introduction to Trevor and a setup for part 2. A Little Background Trevor is an experienced software engineer, project manager, and real estate investor. He has overseen full-stack tea...

We wrap up the season with a focus on the design process.  There is a cost to doing this, as with most things of value.  However, you will find that the benefits in tighter, easier to maintain, and higher quality code are worth the investment.  We can use the tools and frameworks we have to take shortcuts to an object-oriented solution or be better by spending time on design. Object-Oriented Desig...

Software developers are known for many traits.  Unfortunately, one of those is ignoring the keep it simple philosophy.  We tend to "show off" our prowess through complex designs and implementations.  However, those rarely are the best ones in terms of maintainability and even performance.  Simplicity has its benefits. Keep It Simple - Direct Is Better While there is a value in the "scenic route" w...

An often overlooked facet of object-oriented design is how to leverage your language to speed development.  Every coding language has features and strengths to make your design or implementation better.  We should not design to a language initially.  However, we can tailor our implementation and detailed design to take advantage of these features. Leverage Your Language to Boost The Implementation...

There are many areas of life where moderation is required.  Object-oriented design complexity is one of those situations.  We can create a solution that is highly granular and flexible or one that is monolithic and simple.  However, as is often the case, the best solutions find some middle ground that keeps our application flexible and limits complexity. A Balanced Object-Oriented Design Every sol...

It is hard to think of a facet of software development that programmers dislike more than documentation.  This task is almost always pushed to the end, and shortcuts are used wherever possible.  However, we also are quick to complain about a lack of documentation when we pick up others' code.  Maybe we need to give so we can get.  that is the focus of this episode. Documentation Begins With A Sign...

Testing and Design are often at opposite ends of the software development life-cycle.  However, test-driven development is an excellent way to drive our design.  It can help us build better classes and improve re-use.  This episode focuses on TDD and how it can point us to full-featured classes with better error handling and messages. Test-Driven Development For Design We previously looked at unit...

We have spent a lot of time on the core concepts of object-oriented design and programming.  However, testing object-oriented code is at least as essential to our practical approach.  We need to ensure that our code is written with a quality that makes it worth re-using.  Otherwise, it is a better use of time to write new code instead of wrangle low-quality code with the idea of re-use.  We have a...

When we get to the end of our use of a class instance, we need to clean up after ourselves.  This is where destructors come into play.  They are similar to constructors in a mirror fashion.  While a constructor creates an instance, a destructor removes an instance. Destructors And Resource Release Many languages have a default destructor, much as they have a default constructor.  These methods lik...

When we create an instance of a class, we often need to do some initialization.  Constructors and initializers achieve this goal.  These are two different ways to get our data into an instance and are an essential part of our design.  In this episode, we examine the design decisions we need to make as we decide how to use these common methods. Constructors And Initializers - The Distinction A cons...

In this episode, we look at how to use static attributes and methods in our class design. These are important but can be over-used.  They can even be a supported way to break the object-oriented nature of our program.  We can "static" our way into a design that can not be extended.  Therefore, we need to use these sparingly and with consideration about how they may limit our solution. Static Attri...

We have spent a few episodes looking at cohesion and coupling.  Now it is time to find balance in these two software design approaches.  Each approach has strengths and weaknesses.  Therefore, our best approach is to combine the strengths while offsetting the weaknesses.  This best-fit approach is not as difficult to achieve as it may seem. Cache The Main Data The large object approach allows us t...

In object-oriented software, we talk about the concept of coupling.  Put simply; this is a small object approach to our solution.  It is the opposite end of the spectrum from large-object, or monolithic, designs.  In my experience, a developer's bias towards cohesion or coupling often comes from their background.  Those that have come from functional languages and platforms are more comfortable wi...

This episode focuses on cohesion and the idea of using fewer large objects to solve a problem.  This approach is often considered the opposite of using more smaller objects.  We will find out that there are ways to combine these two different approaches as a best-fit method. Cohesion Strengths We have already defined and provided a summary of cohesion.  Therefore, we can dive right into some speci...

Cohesion and coupling are options that are often discussed in object-oriented design circles.  They are two ways to approach a solution.  On the one hand, the solution can be a larger, self-contained approach.  On the other hand, the solution can be a core that uses several "helpers" to achieve the objective(s).  These are important options for us to consider as part of the overall OOD discussion....

One of the most prevalent topics of consideration in an object-oriented system is property design.  We can keep them simple or create more classes.  The first approach is simpler and faster to implement.  However, we can use objects to provide hooks we extensibility and scaling out our features.  There are trade-offs to be aware of, but we can use some guidelines to shorten the design process. Pro...

Our language can blur the distinctions of class relationships in designing our solution.  The "has-a" determination is often confused by how the English language can translate those words.  We also have to keep a context for assigning a class.  Likewise, reality allows for data to be multiple classes in some cases, so we need to examine how those might be a hierarchy of some sort. Class Relationsh...

The ideas of "is a" and "has a" are often discussed as part of object-oriented design.  These concepts may seem simple and obvious.  However, they can often be confused, and complex systems can blur the lines between them.  We start a multi-part episode going over these concepts focused on how "is a" relationships work. Is A and Has A Defined These concepts boil down to simple grammar.  For two ob...

The ideas of cohesion and coupling point us to paths that either place functionality in smaller or larger classes.  We discuss granular interfaces in this episode as an introduction to those "right-sizing" discussions.  Not all OO designs are created equal. Granular Interfaces - Bricks or Sand The best example I have come across in considering how to approach our design's granularity is comparing...

We switch gears in this episode and start to look at inheritance.  This is a core feature of object-oriented design and the most recognizable attribute.  Child classes are utilized through polymorphic support.  Thus, we have a natural transition into this popular usage of object-oriented solutions. A Lowest Common Denominator We have discussed the idea of building on methods where possible.  When...

This episode, we look at interfaces.  These are not supported by all languages.  However, when they are supported, they are very useful.  The interface specification allows us to provide language-based constraints for our method signatures.  It also is an excellent way to enforce consistancy. Interfaces As A Tool For Consistancy The most important result of using interfaces is that they enforce a...

One of the essential concepts to understand is flexibility in OOP.  A good design requires the ability to extend it.  There are ways to do this.  However, they require us to incorporate mechanisms for validation and growth.  That means we need to find a balance between the core to our functionality and what can be altered as an enhancement. Flexibility in OOP - Many Options There are multiple ways...