Personal Framework For Software Development: Think-Note-Code
The think-note-code actually it’s my personal framework that I was used to when I want to code something both for my personal or work things. This framework I’ve been using when I want (or need) to develop through rapid software development (RAD).
What is RAD?
In general, RAD approaches to software development put less emphasis on planning and more emphasis on an adaptive process
Source: https://en.wikipedia.org/wiki/Rapid_application_development
In the past, the most common software engineers do when they are coding something are think and code. They have technical problems, they start to think, and starting to code. The coding itself is a process of “hacking” the solution when we as software engineers still need to adjust the solution including rethinking the solution through the coding process, and this solution is repeated until our solution has concrete forms.
The problem with this approach is I do not feel productive. There is no guarantee that when we are coding, it will be 100% done and safe, it can fail too and will waste so much energy, the question is, why?
It’s because when we as software engineers code, actually we are still in a “thinking” state too. Thinking about the technical solution and thinking about how to implement the solution are two different things. Yes, they have the same term of “thinking”. It will be more effective and efficient, if software engineers when they are coding, only think about how to implement the solution, not about what the solution.
The journaling system actually doesn’t have a specific relation with software engineering, it can be used for many things in our life, not just for software engineer, but also for other professions too.
The journaling system I’ve learned so far is taken from the concept of Second Brain from the famous writer, Tiago Forte in his book, Building Second Brain.
Actually I have written about this book in this publication too:
I’ve learned many things and already applied this concept to my life, and giving me a really great impact to improve myself, for examples:
- Reduce my overthinking about anything. Before I knew and applied this concept to my daily life, I was a person that too over to think about almost anything. After implementing this concept, I really able to reduce these bad habits
- Thinking and acting more effectively and efficient
- Maintain and teach me how to think positively, even in the difficult conditions
- Trust your instincts and thoughts, but also verify. Always questioning your own thoughts
- Manage incoming too much information to my head. I should be able to filter all of these information
I also have written about my thinking process:
The journaling system or the Second Brainis a method by which we can “review” our own thoughts, whatever it is. Always questioning our own thoughts. Is it necessary? Is it possible? Do I walk in the correct path? Something like this.
Whatever our own thoughts, we need to trust it but also verify it. Verify it by writing our thoughts to our journal, and reading and reviewing it. This method will help us to think more broadly not stuck on a single state or maybe a single solution. We will be able to think of multiple solutions and choose which solution well suited to our condition.
- A single problem may have multiple solutions, it depends on our condition. A solution that is well suited for us, maybe it cannot be done for others, and vice versa. There are always some parameters that we need to consider
Thinking and journaling are the recursive processes, and the expected output is a solution that needs to be implemented through our codes. So at this stage, our codes are a result of these processes. It’s different from the previous methodology, where we only think of code.
- If we are only doing these two things, it’s actually we are “journaling” too but implicitly through our coding process, and what I’ve felt from that condition is really exhausting
- When we are coding something, it should minimize the thinking process. We should know what exactly things we want to code, this way, we will work effectively and efficiently which means we will save energy
I have an example of when I applied this framework to my daily works
So this example tells about my “story” when I try to model the Erlang/Elixir Actor Model but in my Rust system. In this state, I know my “problem” or “needs” which is need to implement the actor pattern , and the screenshot above describes my “thinking process”.
This second screenshot tells the story of my journey when trying to find the solution how to implement ProcessManagement.
The result (code):
When I code this solution, I only need to think about how to implement the solution, and not think anymore about what is the solution. And because I already got the “real solution”, I know exactly the solution, what I need to do when I code is just how to implement it, it’s a different context to think.
If you’re still don’t know the exact solution for your problems that well suited for your condition, do not ever try to code anything, because it will waste your energy, and will be useless
Outro
Another good and positive impact that I’ve felt using this methodology is that I was able to work (coding) effectively and efficiently, and I was able to cut the development time almost twice as fast. I have a case that I predicted I needed to develop in six months, but “suddenly” I was able to complete it in just three months, and not just quickly, but also safely.
But please remember that our objective is not the speed of development. This condition and result (faster development) actually is a side-effect because we’re able to work effectively and efficiently. It’s just because we’re able to think clearly.
If we put the speed of development as our primary objective, what I’ve found is just bad things, whatever it is. Speed is an abstract term with abstract forms and the definition is really subjective, each person will have their own definition and parameter about the “speed”.
Rather than focus on speed, it will be better if we focus on our problems, the exact and valid problems, which means the problem exists, and then think about the solution to it, repeat the process with your journaling system, and you’ll see that you’ll be able to think objectively, effectively and efficiently.
