Forem: MartinLoera

"Survival Guide for the All-in-One Developer: Beyond Code"

MartinLoera — Thu, 06 Jul 2023 22:16:35 +0000

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, 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** - 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/

"Survival Guide for the All-in-One Developer: Conquering the New Job”

MartinLoera — Wed, 28 Jun 2023 17:10:35 +0000

Introduction:

¡Ay, chihuahua! (Mexican expression of surprise or shock) That's how I felt on my first day at my new job as a software developer. After spending a year as an intern, where, to be honest, we were seen more as ornaments than resources, I suddenly found myself in a position where I not only had to develop and maintain mobile applications, but also work on backends, web clients, Python scripts for Raspberry Pi, maintain servers, guard databases as if they were my offspring and, to top it all off, design the next system in Figma. Yes, many responsibilities for one person and a very tough challenge for someone with a junior profile.

Faced with this panorama, I chose the only possible route: to accept my skills and my limitations, and start learning. That's how the idea for this blog was born: "The Survival Guide for the All-in-One Developer". I must be honest, a position where one person must take care of everything is not the ideal situation for any company, and it is also not the most attractive job offer for a recent graduate. Even so, I see it as a unique opportunity to learn and get a panoramic view of how systems work today.

So here I am, ready to share my journey and the lessons learned along the way. My name is Martín and this is my corner. I am open to any comments, suggestions or constructive contributions that can help us all grow. My social networks will be at the end, for those who want to contact me or simply want to join this adventure. As a final note, my native language is Spanish, so if you notice any peculiarities in my English, now you know why! Now, let's get started!

Chapter 1: Conquering the new job

Step 1: Accept your new job and your ignorance

First of all, let's be humble. We must be so when giving comments, when receiving criticism and also when accepting what we know and what we don't. As the new engineer in charge of the systems, it is vital that from the beginning they know what your skills are and where you need to improve.

If you are taking over a project already in production, here are some tips to overcome the "curve of terror".

First, ask to be shown how the system works. Identify the end users and interact with them to learn how they use the application. This will not only allow you to understand the needs that the system solves, but will also give you an idea of the system's behavior.
Second, stick your head in the bucket with water, or in other words, dive in to read and understand the code. It is not necessary for you to spend a thousand years trying to memorize line by line, file by file. As I read in a book, "think fast, think slow", to go to the specific first you have to start with the general. So, take the repository and when you open it, it will ask you the following questions:

For a client (whether it's a mobile, desktop, browser application or a website):

Ask yourself: What programming language is it? How is the project's folder and file organization structured? What architecture is used in the project? Are there packages in the project? If so, look for documentation about them.

And don't forget the Frontend:

The Frontend is the part that users see and interact with. So it's important to do it right. Are the best practices for accessibility followed? How is responsiveness handled? How is performance managed? How are errors and exceptions handled?

If it's what we call a backend, we can ask ourselves these questions
- What programming language is it?
- What is the structure of the project's folder and file organization?
- What architecture is used in the project?
- What external packages do we use, do we use a framework? If so, get to work and learn how it works.
- Does it use databases? If so, what type of database is it, SQL or NoSQL? How do I make queries to the database? Migration and that, how does it work?
- And where does the app live? On its own server? In the cloud? Which Cloud? How often is that paid for? What is the configuration of our server's hardware? What operating system does it use? How do I add domains, applications, open ports, etc?
Beyond the questions already mentioned, it is essential to understand how security is handled. Are authentication tokens used? How are passwords and sensitive information handled? Also, how are tests managed. Are unit, integration, performance tests carried out? And if they are not done, it is a good time to implement them or consider implementing them.

If it's a mobile application:
- Is it Android or iOS?
- Was it developed with programming languages or noCode tool? Is it a native app? Is it transpiled? Is it a PWA? Is it a web app turned into a mobile app with Ionic? Phew, nowadays there are thousands of ways to make a mobile app, so it's important to realize what it's made with or what we will make one with, always taking into account the system's requirements.
- How is the file organization structured?
  
  I emphasize this a lot, because simply by taking a quick look we can realize several little things about the app's behavior, and also the difficulty of maintaining it in the long term.
- What architecture does it use?
- Do we use external packages, if so which ones?
- Do we already have memberships to publish in stores?
- Do we have a Mac or a way to compile to iOS?
- How to make documentation so that app stores don't reject you?
We need to understand the particularities of each platform. If it's Android, is Java, Kotlin or both used? If it's iOS, is Objective-C, Swift or both used? Here you can also look for design patterns and check if the best practices are being followed. How is compatibility with different versions of the operating system and different screen sizes handled?

Regarding design files:
- Does it use a design system?
- What are the system's assets?
- Who are the system's users?
- Is it fully responsive? Is it for mobile? What type of client is it for?
- Do we have the brand manual at hand?
- Does this thing have animations?
- Is the prototype already made? Is it necessary to have it?
- Is it low, medium or high fidelity?
- What is the flow?
Are the design guidelines of Material Design, Human Interface Guidelines followed or is it a totally customized design? How are colors, fonts, images handled? How is localization for different languages and regions handled? What's up with UX?

Finally, for Raspberry Pi:

Is Raspbian, Ubuntu, or some other operating system used? Is Python, C++, or some other programming language used? How are interactions with hardware components handled? How is security and software update managed?

Step 2: Set Priorities and Plan Work Effectively

If a flood of tasks falls on you, don'tbe scared. Here the key is organization. Prioritize tasks based on their urgency and importance. Remember, urgent is not the same as important. Urgent is what your boss screams at you, important is what really adds value to your work. Don't forget about deadlines and be realistic when estimating how long each task will take.

Step 3: Learn about Existing Processes and Systems in the Company

Each company has its own way of doing things. When you arrive at a new job, it's vital that you familiarize yourself with the existing systems and processes. This will not only help you integrate faster, but it will also give you a better idea of how you can contribute and improve the existing system.

Step 4: Communicate Effectively with Other Departments and External Collaborators

We're not alone in this, chavo (Mexican slang for "guy" or "dude"). Having good communication with other departments and external collaborators is essential. Whether it's to coordinate tasks, request information or simply to keep everyone on the same page, good communication can save you a lot of headaches.

Step 5: Identify and Solve Complex Technical Problems

As you are the only one responsible for the systems, you will have to deal with technical problems. Don't be scared, each problem is an opportunity to learn. Don't give up at the first obstacle, research, learn and solve.

Step 6: Perform Administrative Tasks and Project Management

Yes, a developer's job is not limited to programming. You will have to manage budgets, meet deadlines and ensure the quality of work. For this, I recommend that you familiarize yourself with some project management methodology, such as Scrum or Kanban.

Step 7: Stay Updated on New Technologies and Trends

Our field is constantly updated. Never stop learning. Stay up to date with the latest technologies and trends. This will allow you to contribute innovative ideas and keep your company at the forefront.

Step 8: Ensure Data Security and Privacy

Data security is vital in our digital age. Make sure you comply with all security and privacy regulations. Remember, a mistake in this aspect can cost your company dearly.

Step 9: Create a Positive and Collaborative Work Culture

Working in a positive and collaborative environment fosters creativity and improves productivity. Promote mutual help, respect and diversity in your team. A united team is a winning team.

Step 10: Make Decisions Autonomously and Take Responsibility for the Results

As the only one responsible, you will have to make important decisions. Don't be scared, trust your judgment, but also consult it with another colleague if you don't have much experience.

Final Words

With these tips, I promise you will feel much more comfortable in your new job. Never forget that the key is humility and the willingness to constantly learn. In this field, there is always something new to learn and that is part of the beauty of our profession. So, cheer up and always move forward.

Instagram: @martinoerae

Email: jesusmartinloera@gmail.com

Forem: MartinLoera

"Survival Guide for the All-in-One Developer: Beyond Code"

Introduction:

Chapter Two: Computational Thinking in Software Development

Problem Solving:

System Design:

Understanding the User:

Benefits of Computational Thinking:

Final Words:

"Survival Guide for the All-in-One Developer: Conquering the New Job”

Introduction:

Chapter 1: Conquering the new job

Step 1: Accept your new job and your ignorance

For a client (whether it's a mobile, desktop, browser application or a website):

And don't forget the Frontend:

If it's what we call a backend, we can ask ourselves these questions

If it's a mobile application:

Regarding design files:

Finally, for Raspberry Pi:

Step 2: Set Priorities and Plan Work Effectively

Step 3: Learn about Existing Processes and Systems in the Company

Step 4: Communicate Effectively with Other Departments and External Collaborators

Step 5: Identify and Solve Complex Technical Problems

Step 6: Perform Administrative Tasks and Project Management

Step 7: Stay Updated on New Technologies and Trends

Step 8: Ensure Data Security and Privacy

Step 9: Create a Positive and Collaborative Work Culture

Step 10: Make Decisions Autonomously and Take Responsibility for the Results

Final Words