Monday , July 22 2019
Home / Uncategorized / A manual on personal performance – 7pace Blog

A manual on personal performance – 7pace Blog



There is a big difference between writing code is be a great programmer.

Writing code is the output and almost anyone can learn the basics of syntax and formatting. But what makes someone an expert developer? It's much more than just understanding the basics, of course. It is the mastery of the fundamental concepts and logic that make it capable of it. But to be great, there must also be a way to measure, evaluate and improve that performance.

While there are a multitude of ways to learn the basics of coding, developing support skills can sometimes be much more difficult. There is no simple online course that can teach you how to collaborate better with your team.

And there is no single way to improve your cognitive or problem-solving skills.

So, how exactly do developers go from able to good? From good to big?

This manual is designed to be a guide to the performance of developers: how to understand it, measure it and improve it.

Our Microsoft ALM Ranger range

To help us, we've contacted the Microsoft ALM Rangers to get information on developer performance, measurement and growth.

  • Gerson Dias, Consultant at Lambda 3
  • Etienne "ET" Tremblay, Senior ALM Consultant at Imaginet
  • Ken Muse, Wintellect Consulting Director
  • Niel Zeeman, owner of Team Foundation Consulting
  • Richard Hundhausen, Scrum Trainer professional at Accentient
  • Josh Garverick, Senior Cloud Architect at Willis Towers Watson
  • Jesse Houwing, Trainer, Coach and Tinkerer at Xpirit

Chapter 1: Mindset

The well-known 10,000-hour principle, popularized by Malcolm Gladwell, illustrates an important lesson for developers. (For those unfamiliar, the rule states that it takes 10,000 hours of deliberate practice to become a world class for any particular skill or activity.)

It takes extreme dedication to become a master in nothing– And the programming is not different.

Of course, there are some innate abilities that can give certain programmers an edge over their colleagues. And others could struggle to grab the bases. But the barrier for most engineers trying to move from good to big is not genetics or luck.

It is dedication, it is passion.

To become a "rockstar" engineer (shudder), one must not only be intelligent and capable. You must want it. You must be willing to dedicate a whole bunch of time and energy to becoming masterful.

Gerson Dias shares his thoughts. "Knowledge and experience come with time and raw talent is nothing without passion," he says.

"If you have a passion for what you are doing, you will be productive and you will have excellent performance, because you are putting your energy into it [into it]. Of course, it is difficult to find a job that you can say: "I really like to build it!" But it is important to have your "spiritual bonds", even just thinking: "Ok, I hate this, but while nothing gets better, I will do it because [I need to support] my family and my skills will improve. & # 39; "
-Gerson Dias

And you must be deliberate in your approach. Nobody becomes an accidental master of anything. We need a focused effort and a clear vision of what we want to achieve.

So it takes a plan for how to reach that mark.

Now this does not mean it's all or nothing. There is room for programmers at all levels, from beginners to experts. And it does not take 10,000 hours just to move a little bit. But it is important to understand the fundamental gap that exists between the majority and the truly extraordinary.

In addition to the dedication and passion for craftsmanship, the engineering mindset is also a hallmark of those who manage to solve problems of all kinds.

This is typically defined by its 8 main characteristics.

While some developers may be predisposed to having these characteristics, this does not mean that the engineering mindset is completely predetermined. It can be learned and developed consciously over time.

To develop the ability to assess and solve problems, a way is needed to measure and evaluate this performance.

If not, how do you know if you've improved?

Chapter 2: Performance Measurement

Before talking how to improve, we must define what it means to improve.

First of all, what makes someone a good developer?

Almost all the people I've talked to for this guide agree that the performance is both subjective is relative. This means that there is no single definitive way to measure performance (there are many ways not to measure it, but it is not useful) and there is no static scale where you can compare the performance between two developers or teams.

In other words: The best way to evaluate a developer's performance is to measure their growth over time.

"Measuring your skills means reflecting on each version and trying to find ways to be more efficient and effective in the future,"Explained Ken Muse."If you continue to evaluate your progress and make changes, your performance will improve."

If you want to become a better runner, what would you do?

You probably start to set a goal and develop a plan. But how do you know if you are making progress towards your goal?

Measure your skills.

It's time to run, trace the distance and compare the speed. The same is true here.

Whether it is the number of story points completed within an iteration or the quality of the written code, it should be measured as a continuous trend over a defined period. If your score was 10, your goal should be 11.

As with the ride, the process is this:

  1. Define a way to measure your performance
  2. Measure your performance
  3. Establish a goal
  4. Continue measuring and comparing performance over time
  5. Identify and test new strategies to improve performance
  6. Once you reach your goal, repeat

Are you becoming objectively better, faster or more efficient?

This is the main reason why we support monitoring of time between software teams. Not because it's a great way to make developers fit and make sure they're hitting their arbitrary odds, but because it gives developers themselves –individuals-A simple and universal way to measure and compare your skills.

Muse summarized it by saying "Understanding the time required to complete a development cycle and perfecting those cycles can be a valuable way for a team to improve collectively and individually."

If it took you 50 hours of work to complete 12 points in the last month, then your goal should be that same job in less time for this month.

Of course, many people I spoke to for this guide did not support time tracking. And how many companies have implemented time tracking is not a good way to help developers manage their time and skills.

Of course, it's fair to say that using time as a performance measure is not right in every scenario.

However, regardless of the benchmark used, it is necessary to define a KPI: an objective and consistent way of measuring and evaluating your performance as a developer. The metric (s) you ultimately use is up to you, but you decide only on those that can be measured and compared in an easy and consistent way.

Richard Hundhausen explained his thoughts on this subject. "If the team decides (without any external influence) that they want to keep track of time for any reason (again, not because someone or some policy outside the team requires it), then they should do it " he wrote in an email "Because one of Scrum's rules is to let the team decide how they want to work."

Chapter 3: mastery of the foundations

Understanding the fundamentals of each particular skill is the most essential step towards mastery.

Consider chess. Before anyone can become a Grandmaster, they must first understand the basics of the game. Not only do they need to know how the bishop moves across the board, but they also include openings, positions and tactics.

For developers, there are two basic categories that are fundamental to mastery:

  1. Fundamentals of engineering
  2. Fundamentals of language / framework

The first set is universal for almost all types of programming. It is about understanding the underlying structures, processes and structures for effective planning.

In the second set, we look more at specific specialized bases specific to certain languages ​​or frameworks that are used within a certain context. Programmers may not be experts in all languages ​​or frameworks, but having a solid foundation can often make it easier to gather new technologies.

For our purposes, we want to focus on engineering basics.

What does it include?

Things like:

  1. algorithms
  2. Abstraction
  3. Isolation
  4. Data banks

Although these Look different in different languages ​​/ structures / paradigms, the fundamental logic is relatively static.

It may be tempting to think that if you are already able to write a functional code you must already know the basics. But do you really understand all the basic science?

I can build a pendulum in my garage. But that does not mean that I understand physics.

Even competent engineers sometimes lack a true understanding of why and how things work in bloody details: they only know which keys to press in which order to make it happen. The interesting paradox is that these fundamental principles actually become more important later in your career and as your work becomes more complex and far from the basics of writing and understanding the code on a screen.

This means that many developers spend years, even decades, without really understanding the fundamentals.

But in the end, they hit a wall.

As problems become more complex as you try to grow and become a better engineer, you must master these fundamental concepts.

Otherwise, they will eventually become a barrier to your development. So you have to be willing to spend some time on this fundamental part of the trade. As with anything, this means carving out time for deliberate and focused training.

Chapter 4: Exercises for improvement

The fundamentals are very basic.

But, knowing the underlying components of the programming! = Being a good engineer.

"I think we are in a continuous learning sector and if you are not learning you will not be performing," said Etienne Tremblay. "I think if they can sincerely say they have learned something (not superficially), then they should be happy."

Programming is basically a problem-solving exercise. It is about collecting data, understanding the context and formulating the best possible solution. Probably the most important part of developing any problem-solving skills is pattern repetition and recognition.

It takes practice

"Learn, learn, learn, read books, try new things, fail and try again Stay up-to-date on the latest technologies, watch conference videos (they're free.) I can not stress how things change so fast in our industry, if not you are learning you will be left behind. "
– Etienne Tremblay

The more cases you encounter, the more context you have for how to solve each subsequent problem. You've found more problems and developed more solutions, which gives you more knowledge to draw from in the future.

So, how can developers apply this mechanics to improve their individual skills?

Practicing a widespread and focused thought

It may seem unlikely that you can somehow train your brain to be a better engineer.

But there may be some scientifically supported ways to make it happen.

One is simply practicing the types to think that they are important for solving problems. And, perhaps more importantly, to practice our ability to move from one type of thinking to another in order to find better and more easily solutions.

In general, we have two types of thinking that are implemented when solving problems or learning new things.

  1. Targeted thinking
  2. Widespread thought

With concentrated thought, we focus on a particular problem or question and actively seek to arrive at a solution. With widespread thought, we let the idea hatch into some sort of latent or passive thought mode, we do not actively focus on it, but it remains somewhere in the back of our mind and we continue to look for solutions or schemes .

When it comes to improving your skills as a developer, it turns out that both of these types of thinking are important. Some problems can be solved by pure will and concentration; but others could simply require more time and contemplation.

Practicing it is rather simple, actually.

You can easily alternate the two types of thinking.

First: start by focusing deeply on something you are trying to do or solve.

Take a moment to turn it over and think through different solutions. Focus on the problem, examine the different elements and weigh down different options and considerations.

So, after having internalized the idea and the context, go and do something else.

Let the question stay in the back of your head, but deal with another task that will take your mind off and allow you to use widespread thought.

This simple two-step cycle is a fundamental process for solving problems. And, even if you do not know it, you'll often apply the same kind of system when you try to solve problems during your career. We often call this "incubating" a solution or taking a break from the problem in question.

However, it is a practiced strategy. Apply it to different problems you are trying to solve, strengthen your skills and solidify it as an approach to solve difficult problems.

Create collateral projects

Not only are parallel projects often an indicator of passion and guidance, but they have wider benefits for you as a developer.

The Latist Sehgal wrote an article explaining the importance of collateral projects. He outlines these benefits:

  1. It teaches you to add value (not just writing code)
  2. It pushes you to act
  3. Improve concentration
  4. Awards perseverance
  5. It makes you more empathetic

The main difference for side projects compared to a day's work is that you are exposed to multiple perspectives.

Rather than simply being a developer as part of a team, you become a project manager, a CTO and maybe even a CEO.

By wearing these different hats and without any external pressure, you are able to better grasp the context of projects and products. Get out of your role to understand the bigger picture and use it to make better decisions.

Read the code of other people

Can you imagine that authors like Hemingway or Steinbeck would have been fantastic if they had not read the works of other great authors before them?

Obviously not.

We learn and grow, in large part, by consuming the work of others.

While sometimes it may feel a little bit abstract considering your work outside the context in which you created it, analyzing the work of another person gives you the opportunity to get out of the code and try to deconstruct and understand the thought in a new way.

Take the time to work with several team members to review or analyze the work of others.

It is not necessary to make it a formal process, necessarily. But, just taking the time to examine and consider the thought behind someone else's code or structure, you can inspire new ideas or push yourself to improve your skills.

Chapter 5: Solidify Knowledge

Learning is great. But preserving and applying knowledge is indeed what is important.

It can often be difficult to take something you have learned and recall it later when it is time to use that knowledge.

There are some tricks and strategies that will help you consolidate the knowledge you have learned and identify opportunities to apply these learnings in the future.

Use interleaving to learn new concepts

The idea behind the interleaving is rather simple. Studies have found that people are able to learn and recall new concepts better if they mix what they are learning, alternating some different concepts or practices.

While time-blocking can be effective for developer productivity, the concept of interleaving can actually be better for learning and recall.

One study found that students performed 25% improvement in a surprise test when they learned with interleaving techniques compared to colleagues who learned in traditional blocks. But, more surprisingly, those students were much more able to recall the test material later.

Students who originally learned through interleaving were 76% better when they performed a test one month later.

Therefore, interleaving seems to be of help in short-term learning and improvement of long-term preservation. While you are learning new things or trying out new techniques, you may want to mix more concepts and learn them together in an alternate pattern.

Teach what you have learned to others

For many, the best way to learn is to teach.

If you understand a complex problem enough to explain it to someone else, it is much more likely that you can apply that knowledge significantly.

This is also supported by a lot of science. In particular, the forgetfulness curve explains how information is lost over time. If no active effort is made to maintain that knowledge, it will slowly disappear from your memory.

Furthermore, science has shown that the practice of active recall of knowledge can increase recovery and memory by more than 100%.

Teaching is, of course, an exercise that encourages and requires that knowledge be actively recalled, explained and applied.

So, teaching what you learn can be a fundamental strategy to keep new knowledge and improve your ability to remember and apply that knowledge to your work later.

As developers improve their skills, it is often helpful for them to consolidate that knowledge by sharing with others. Or through formalized teaching or coaching, or through the informal tutoring of other teammates.

Chapter 6: Teamwork

At the end of the day, an individual's skills or knowledge will only play a small role in the result of the whole team.

Being the smartest person in the room will not make you a great developer unless you use this knowledge and promote people around you.

"We do not want heroes on the team", wrote Hundhausen, "Unless those heroes do not share their knowledge, they associate, respect others and do not control and control work".

Josh Garverick said even more explicitly.

"Nobody wants to work with an asshole who does not want to learn anything" He said.

Teamwork and collaboration Equally important like the ability to write elegant code or solve difficult problems. In reality, it could actually be more important to have a working team of any other person to be a particularly performing developer.

Application development is a team sport. Period. Point.

Of course, there may be mythical stories floating around individual developers who have done a titanic task of creating programs on their own. And this is fantastic for them.

But it's not the real world, and it's not a sustainable way of building software.

As you progress through your career, you will work with (and you could embody) many different types of developers. And to do your job well, you'll have to learn how to go through different personalities and work more effectively with these different types of people.

More importantly, diversity can help you grow as a person and also improve your team in solving problems.

But "being good at working in the team" is a bit too abstract. How do we evaluate and improve our skills and collaborations, discussions and give / receive feedback?

According to a 2012 MIT study, the following features are important for building a successful team:

  • Equal contribution from each member of the team
  • The team shares a lot of energy
  • Team members communicate directly with each other
  • The team conducts back-channel conversations
  • Members explore the outside world and report their findings to the team

Understanding your strengths (and weaknesses)

As an individual within a team, it may seem that your role in facilitating teamwork is limited. But you can take steps to become a better team player, which is just as important as a leader or manager who facilitates teamwork from the top to the bottom.

  1. Understand and communicate your strengths
  2. Understand and communicate your weaknesses
  3. Understand the strengths and weaknesses of others in your team

This is not easy. It requires you to be vulnerable and to honestly evaluate yourself and ask your peers to do the same.

But it's not an excuse to ignore it.

Every person on your team should be aware of their abilities and have an understanding of how they are able to complement each other. If your weaknesses are the algorithms, the best way to do it Improve on that weakness is understanding who is better than you and actively working with them to develop your skills.

You can do it only if you are open and honest, communicating clearly with the rest of the team.

Define your role

Secondly, you should consider how your strengths or weaknesses define your role within the team structure.

Are you the one that is considered reliable and efficient? Or are you the out-of-the-box thinker who pushes the team to explore new ideas? Whatever your final role, you need to consider how it plays a role in the overall dynamics of the team and how you can play that role in a way that helps you get better results.

Ted Bauer published an article on teamwork and outlined 4 types of people within a team.

As you underline, sometimes you need troublemakers to push forward.

But it is up to the person in that role to understand when it makes sense to make trouble, how to choose and choose their battles. If you are, within your team, the one who is inclined to push for change or progress, then you have to do it selectively.

Otherwise, you quickly slip into the "Jerk" territory and rather than guide progress, you will quickly prevent it.

Chapter 7: Development of the context

In addition to being just a skilled programmer, the most effective software developers have a broad understanding of the context in which they operate.

What does it mean?

It means that the software is not created in a vacuum.

Robust developers understand that there are institutional considerations that go beyond simply writing the functional code and verifying user stories in the backlog.

The software was created to serve a purpose. It works in a particular set of conditions, within a specific budget range and for users with a certain level of knowledge or skill.

In other words, software is not just software. It is ultimately a solution for something.

Going beyond understanding the basics of programming and being a competent or effective developer, there is another level of performance that comes from a broader understanding of the application lifecycle.

This understanding of the user, the constraints and the context allows experienced developers to make smarter and more effective decisions on how to solve problems.

It is easy for competent developers to spend the entire career head-down, writing and verifying the code. They can be a great teammate and a precious resource.

But, to level up, you have to look beyond what's on the screen.

To improve your skills – and your value – as a developer, you should strive to reduce the daily monotony of code writing and ask because.

Get the context and understanding of how decisions are made and how they will impact your work. But, do not do it just for selfish reasons, do it because you want to be included in that decision making process and better understand the purpose and importance of what you do.

Chapter 7: Additional Resources

While this guide intends to include many ideas and strategies to improve your skills as a developer, the heart of it all is learning.

She is constantly looking for new knowledge and ideas and therefore finds ways to apply new knowledge in everyday work.

In this spirit, there are many other resources to consider while looking for ways to improve and grow your skills and your career. Here are some recommended by the Microsoft ALM Rangers we talked to during the development of this guide.

Web sites and publications

Books


Source link

Leave a Reply

Your email address will not be published.