It's All About Attention

No. This is not a blog post about AI. However, this title could be easily confused with a famous AI paper about transformers, Attention is All You Need (https://arxiv.org/abs/1706.03762). Perhaps the machines know something we dont.

In all seriousness, attention or focus is really a prerequisite for engineers. In order to understand complex tasks, make sense of complicated systems full of technical debt and anti-patterns, and reason on vague Jira tickets, engineers need focus. Without focus, basically, it's impossible to do engineering. Time drags you down, and what should be 1-2 days turns into weeks or even months.

It's possible to get things done without really understanding what's going on. Software is about layers and layers of abstraction; nobody understands all the things in the universe. However, engineers think it's fine to move forward without solid foundations, and that's a huge mistake. IMHO, it's an attention issue.

Imagine you are driving, you dont want to hit the curbs in all the turns, you dont want to cross a red signal because it's dangerous, and you don't want to go beyond the speed limits. Some might say it's the law, but it's more than that; it's a system of safety built in when following everybody is safer.

Now think about engineering, lack of attention makes people:

• Merge PRs with tests failing: Resulting in production bugs.
• Duplicate code: Because they did not ever read the code base and dont care where to put the files, resulting in complexity and more bugs.
• Copy Code they dont understand: Thinking is okay because they need to get something done, and the result again is more complexity and bugs.

You can't go fast if you don't know what you are doing. If you want to play guitar very fast, you can't put speed ahead of fundamentals and the right techniques. First, you need to do the right things, then you can do those things fast.

It's not uncommon for engineers to feel they have been pushed against the wall for days to weeks, even if they don't ask for help. How can we avoid such bad behavior:

• Ask for help: Post your questions to other engineers, use public forums, or even ask a mentor you know.
• Do more POCS: The less you know, the worse your performance, the more POCS you need to do. If you dont master your tools, you will be extremely slow. The best way to master tools, frameworks, libraries, and languages is by doing POCs all the time.
• Always validate your understanding: People think they get it, people think they understood, but they dont. They think they know how to generalize and apply, but they do not. They believe they are following, but they are not. The best thing you can do, and should always do, is repeat and ask: 'Did I get it right?'

Attention, it's not just about paying attention to what you type on the IDE, but also how you handle errors. Did you keep repeating things over and over without understanding how things work? Usually, what happens is that people are pretty bad at troubleshooting because they don't know how things work, so how can they know how to debug it? Debugging is more than just setting breakpoints; it's about having mental models.

To have great performance, you need:

1. Attention: Focus + The right approaches
2. Master the technology (tools, libs, languages, and frameworks): POCs
3. Understand what you need to do: Asking questions, validating requirements, asking a lot of questions, and asking for what is not written.

Spending several hours without interruption is great, but just time without the right approaches does not work. Every time you are learning something new, you must know how it works, so you can create a mental model. If you don't have a good mental model, you will have a hard time predicting the future, debugging, and finding the shortest path.

I don't like silence. Bad, bad, bad things happen with silence:

• People get stuck
• Multi-tasking proliferates
• Performance goes down as. time passes
• Confusion builds up

Silence is the first step to bigger issues like Ignore Cultures. Ignoring problems, only leads to more problems. Attention problems only happens on the silence.

Anti-Learning Anti-patterns

Spending hours to learn is great. However, it does not matter how many hours you put into the effort if your approach is wrong.

Never Ever:

• Stack up things you dont understand: You don't understand Java, then you don't understand Spring, then you don't understand REST. Learn one thing at a time, ensuring you master the fundamentals correctly, before moving on to more complex structures.
• Shallow Learning: Don't click on the code, don't read the code, don't debug the code, don't search on the internet, don't make notes, and the result will be a disaster.
• Silence: Don't ask questions, dont validate requirements, don't ask for reviews, it's a good formula for a disaster.

How can we improve and get better?

• Never stay in silence: ask for help, all times.
• Never assume you understand: IF there are no questions, you are wrong; you did not understand.
• Don't be afraid to look up the code: Reading code does not bite, :-) Don't be afraid to read SDKs, Libraries, Frameworks, and even programming language code.
• Don't go too fast: Never, ever pile up things you don't understand, make sure you know something in a solid manner, and than move up to more complex concepts.
• Do more POCs: Do POCs for all languages, all libraries, all frameworks, and all features of the tools and binaries you use. All of it, why? Because you must know by heart, that will make you go faster.
• Search for corner cases: Think about what could go wrong, think about what is not written, use your crystal ball, and try to predict the future, it's not that hard.
• Don't get stuck: 15-20 min is a good time for asking for help. Can save hours to weeks of waste.
• Make sure you have focus: Does your environment help you? Do you have silence? Are you too worried about personal issues? Focus on work. Tools like Pomodoro and GTD can help.
• Don't ignore signals: Don't ignore warnings, don't ignore errors, don't ignore exceptions, don't ignore tests that are failing.
• Consider Full Screen: If you use IntelliJ, consider enabling "Zen Mode"; otherwise, ensure you are in full-screen mode and minimize distractions.
• Learn shortcuts: You should learn all shortcuts, consider plugins to help you, like Key Promoter X(IntelliJ), or at least understand the shortcuts.
• Learn something different: IF you know OOP, go Learn a FP language like Scala or Clojure, IF you know Windows, go learn Linux, If you used Ubuntu, go use another distribution. You should be forcing your-self to learn new concepts, new theories and new approaches.
• Write much more: Create a blog, make lots of notes, writing helps to increase retention and ownership.

Attention to detail is everything; it's the difference between vanilla and a killer everybody wants in their teams. Discuss it, identify what's not working, and make it work.

Cheers,

Diego Pacheco