"Survival Guide for the All-in-One Developer: Beyond Code"
Tags: programming, career, beginners, computerscience
Published: 2023-07-06 22:16:35

### **Introduction:**

"Life is very simple, but we insist on making it complicated" - Seneca.

Does that ring a bell? Let me adjust it a bit for this post: "Software development is simple, but we insist on making it complicated". Well, let's not be so radical, it certainly has its difficulties and challenges. But, as I mentioned in the previous post, before we start coding and try to build the next revolutionary algorithm with complex data structures, the latest architectures, and even a chatbot like the GPT ones, we first need to see the big picture. It adds more value to prepare solutions starting with a change of focus. During my journey through university, I had an "eureka" moment when I changed my way of thinking. I began to see my daily actions as a "while" loop, my personal decisions as an "if", and remembering someone's birthday as a pointer in my head that usually points to nothing, hahaha! A first, and crucial mindset shift. Seeing things as a series of steps was a great asset to solve university tasks. However, in the last semesters, I had another "eureka", an engineer-flavored "eureka". I shifted my mindset from seeing everything as instructions to seeing things as part of something bigger, something bigger where the initial edge is the problem or challenge at hand. Then, what are the needs to be met? Then, how can I break down this problem or situation into smaller parts? The next step might be, is there a pattern in this situation, something that repeats itself? Either in user behavior or in recurrent themes in data. After asking these questions, we can say we made a general abstraction of the problem, eliminating unnecessary things and focusing on what really adds value. And now, with this mindset and focus, we can put our programming skills into action and boom! develop an algorithm. But, what is computational thinking?

In an opinion column published in the March 2006 issue of Communications of the ACM magazine, Jeannette Wing claimed: "*[Computational Thinking]… involves solving problems, designing systems, and understanding **[human behavior](https://es.wikipedia.org/wiki/Comportamiento_humano)**, based on the fundamental concepts of computer science. Computational thinking includes a wide variety of mental tools that reflect the breadth of the computing field…[in addition] it represents an attitude and universal skills that all individuals, not just computer scientists, should learn and use*" (2006, p. 33).**[1](https://es.wikipedia.org/wiki/Pensamiento_computacional#cite_note-1)** - extract from Wikipedia with all the links hahaha (**https://es.wikipedia.org/wiki/Pensamiento_computacional**)

So, what is computational thinking? I like how Jeannette defined it: computational thinking involves solving problems, designing systems, and understanding the user. A good solution takes into account these three things, always. But enough of preambles, it's time to dive into computational thinking. As always, I introduce myself: my name is Martín. It's an honor that you give me a few minutes of your time to share these ideas with you. Remember that the comments box is open, perro ("dog" in Spanish, used here as a friendly, casual term). I'll be happy to answer. Iguanas ranas (literally "iguanas frogs", it's a playful Mexican phrase with no direct translation but it's used to wrap up conversations or signal a transition), I leave you my social networks in case you want to contact me and continue this conversation. Now, let's get to it!

### **Chapter Two: Computational Thinking in Software Development**

In life, almost everything can be seen as a problem. We just need to change the perspective to find a solution. When we focus solely on code, there are two possible approaches. One is to think about indentation, about functionality itself, about coding style, about how the program works just for the task we are doing. But, what happens if we change the chip? What happens if, instead of just thinking about the code, we think about the repercussions of the solution? Does the algorithm have a good runtime? Does it need to have it? What is more important for the user about this code solution? How what I'm doing can make it difficult for other collaborators or those who are going to follow up at some point? How will we test that the solution works (not just to pass the ticket but also in the future when the system changes, because everything changes, cuate ("dude" in English, used in Mexican Spanish as a friendly term))? What programming practices can we apply to the solution to make it easier to maintain, improve performance, among other things? This second approach is closer to the definition of computational thinking. Now, how can we apply computational thinking? For that, let's delve a little deeper into each of the three parts that compose it.

### **Problem Solving:**

Listen carefully, camarada (comrade), here we're not just talking about a concept, but a key skill. Like all skills, it improves with practice. Let's start by understanding problem-solving in a broad sense, as it is present in the day-to-day life of every person on this blue planet. Problem-solving is a mental process that involves discovering, analyzing, and solving problems. The ultimate goal is to overcome obstacles and find a solution. But not just any solution, we seek the best possible one within our **current knowledge**. Why is it in bold? Well, because always, but always, there are better ways to do something, and sometimes, the best solution depends on the situation, on urgency, and, oh yeah, on the dreaded technical debt. Within the context of computational thinking, this process becomes a little more structured and systematic. A great practice in computing, which is totally extrapolable to other fields, is to break down a problem into smaller, more manageable parts, instead of confronting the original problem head-on. We seek to identify patterns, abstract irrelevant details, and design a series of steps or actions to solve it. In summary, we must decompose the problem, recognize patterns, make an abstraction, and generate algorithms.

### **System Design:**

Now, let's dive into system design within the context of computational thinking. System design is the process of defining the architecture, components, modules, interfaces, and data for a system in order to meet certain requirements. It's a crucial part of software development, because without good design, the system could be inefficient, hard to maintain, or even fail to meet user requirements. Here comes the importance of principles such as modularity, scalability, and efficiency, among others. When we design a system in a modular way, it's easier to understand, maintain, and extend. If we consider scalability from the beginning, our system will be able to handle growth in the future. And of course, we're always looking for efficiency in terms of resource use and performance.

### **Understanding the User:**

Last but not least, there is understanding the user in the context of computational thinking. This is a fundamental aspect of software development. Without a clear understanding of the user and their needs, we might end up building software that is not useful or that is not used as expected. That's why it's crucial to adopt strategies to better understand the user, such as user research, usability testing, creating personas, and many other methods. By understanding the user, we can design and build software that truly meets their needs and expectations.

### **Benefits of Computational Thinking:**

Finally, let's talk about the benefits of applying computational thinking to software development. These benefits may include creating more robust, scalable, and maintainable software, as well as the ability to better adapt to changes in system requirements.

### **Final Words:**

Thank you for joining me until here. I know this post wasn't so technical, but more focused on the engineering of our field. I believe it's crucial to take a step back and review the basics of our profession. Having a solid foundation allows us to keep learning and equips us with the initial abilities to identify problems and outline the steps to solve them. We can often fall into arrogance and believe our solution is the best. It's okay to feel proud, but as always, it's important to stay humble and review the decisions we made. Designing, executing, and analyzing our solutions is and will be our daily bread to take one step closer to our goal.

I was eager to talk about this topic, as I believe it's extremely important for those in a situation like mine to adopt this computational mindset. I encourage you to keep researching and reading more posts that delve specifically into each part. I decided not to go into detail about algorithms, as there are many other excellent posts that can help you learn or review that part.

To wrap up, it's essential to reiterate the importance of computational thinking in software development. **As developers, we are more than just code scribes. We are problem solvers, system designers, and above all, we are perpetual students in a field that's always changing and evolving.**

So, let's go, with documentation in hand, and a piece of paper, let's get to solving problems!

email: jesusmartinloera@gmail.com 
Linkedin: https://www.linkedin.com/in/martinloera/