I’ve decided I don’t like goals. I like plans. I like direction. I like learning, growing, and accomplishing things. Here’s what I don’t like about goals: They often overemphasize a preconceived notion of a destination that is lacking input from the journey, because at the time we construct the idea of the destination, that input is undefined.
Implementing a self-directed transition to software required a deep dive into my goal setting and decision making processes. I’m currently finding parallels between life planning and the idea of interfaces and design by contract. We use these tools as programmers to provide structure for how critical interactions in an application will occur. Their use requires thinking about shapes of inputs and outputs and clarifying expectations. They help to clarify which expectations are optional and which are required. They identify elements that could be unknown or nonexistent. We build on that by defining which violations will be fatal, only provide warnings, or even ignored. When we set out, we have ideas about what the inputs could or should look like. We are also aware that that is often not exhaustive, especially in the early stages of design.
How might we apply good approaches to interface design to life and career planning? It starts by figuring out what the key touch points are for the aspects of life’s journey. The next step is working to define for myself and those I interact with what the critical and/or recommended terms of those interactions are. For me, this helps to provide ‘freedom within the form’ - a paradigm that has resonated with me in many aspects of my life. Freedom within the form is about identifying what’s critical, what’s recommended, and what’s unknown. This abstract structure provides navigational aids to free up our mental, emotional, and spiritual bandwidth for dealing with the variable elements that require the most attention. Our journey as programmers, humans, creators, and destroyers, is an ongoing evolution with new and unexpected inputs added all the time. There is great merit in thinking about the rules and expectations we apply to ourselves and our lives in much the same way we would think about what makes for a good user interface or a good abstract interface in our code.
A brief browse of some expert opinions on what those traits might be according to books and the internet:
Key Charactersitics of Good UI Design:
- Intuitive
- Familiar
- Responsive
- Consistent and Clear
- Empathetic
- Transparent
- Minimalistic
- Inclusive
Some commonly espoused principals of Object Oriented Design1 include:
- Encapsulate what varies
- Composition over Inheritance
- Program to Interfaces not Implementations
- Strive for loosely coupled design between objects
- Depend upon abstractions, not concrete implementations.
In trying to learn and grow as a programmer and a human, these same principals can provide a roadmap for how we approach life’s problem spaces. When we interface with the world around us, intuition, empathy, clarity, transparency, and inclusivity are all vital to good collaboration, communication, and personal development. When faced with challenges which feel foreign - seek the elements that have the most familiarity and focus on how they’re related to the foreign elements. This relationship focused approach provides new pathways for knowledge acquisition and perspective. When constructing life or career plans, identify the things that are likely to be unpredictable or volatile and figure out how to encapsulate them. Focus on the touch points that are critical and prepare for the underlying implementation to change. Emphasize composition by bringing together resources in ways that leverage their individual capabilities to accomplish bigger and better things together rather than relying on hierarchical dependencies - it’s more adaptable. Think about the interfaces and abstractions. Work to craft the shape of what’s important and be open to myriad ways to accomplish an acceptable result. This requires being present in the current iteration and taking in all the environment variables in their current state.
- Paraphrased from Head First Design Patterns↩