Skip to main content

Some small observations about working in a team

As we approach the first official delivery of the automated laboratory system on which I have been working on for the past couple of years with my colleagues I realized some important conclusions about working in a team.

I realized now that all of us from my team have kind of grown together over the past couple of years. All those challenging situations, funny moments and hard work have brought us together without us even knowing. When I first started in this team, we were all quite different and initially kind of cold to each other. Especially my boss but I think that is expected since he is in a delicate position and so I understand him.

But as we worked more and more together, we kind of slowly started opening up. I realized then that it's not enough just to be colleagues in order for a team to work. You actually need to see everyone as a bit of a friend. Why you ask me? Because only then you will feel free to collaborate with other people to work together on something. I noticed that when there were 2 codependent tasks and you gave them to people that weren't that close, a lot of miscommunication happened which caused those 2 tasks not to meet the requirements. And it's pretty simple, those 2 persons didn't see themselves as friends and were reluctant to communicate to each other the issues that arouse. In the end, each person fixed the issues that arouse in their own way and imagined that the other person came up with the same idea. So the feature which they worked on, didn't work at all as expected and another task had to be made to resolve the conflicting solutions to issues between the previous 2 tasks.

And I noticed that there is a lot more to a team than meets the eye. You might think that if all the team members are on the same page and come up with the same ideas then that's a good thing. Well, it's kind of wrong. If everyone on a team has the same ideas then there are fewer overall ideas in the team. In the complex world of software development you need as many ideas as possible because of the wide range of problems that we have to solve. So in a team you should have as many people with different ideas as you can. But the problem is that 2 people with very different ideas will find it harder to communicate to one another because they aren't exactly on the same page. If their ideas are so different they will spend more time explaining their ideas to each other. Ideally there should always be some sort of friction in a team in order to produce good ideas. You should have enough diversity in a team while retaining good communication between members.

In time a team tends to become more homogenous. This means that communication between members improves but the number of ideas dwindle. I think this is why in big companies with many teams it is actually encouraged to swap members between teams.

Comments

Popular posts from this blog

Some software development common sense ideas

 I haven't really written here in a long time so it's time to write some new things. These are just some random common sense things that seemed to short to write about individually but seem really interesting and useful to me or other people 1. There is nothing fixed in software development, all things vary by circumstances and time Remember the documentation that didn't seem that important when you started the project, well after a couple of years one the application has grown and become really complicated, no one actually knows everything about the application anymore. So now you really need that documentation. What happens if you suddenly need much more people to develop the application because of some explosive growth? Without documentation, new developers will just look at the application like they look at a painting. This actually happened to me. Maybe in the beginning of a project, a technology really helped you a lot but as the project grew, it started making things...

Some things which are often blindly applied and followed by developers which are not always good

This is probably one of the most controversial things that I have written so far but I am just tired of hearing about these things and discussing these things. Other developers that I know share part of my feelings. I would rather hear more about how people built things, overcame challenges or what new interesting ideas and concepts they implemented. Those things are really interesting and innovative, not hearing about the same theoretical things over and over again. I can just read and learn those things from 100 sources on the internet. Firstly, one of the most discussed and promoted things is agile/scrum development. I think I have been through 5-8 workshops about agile development methodology. And each time, some things differed. There is no 100% standard approach to this. Everyone uses their own version of this development methodology and seem to argue a lot that their approach is right and everyone else is doing it wrong. You go to an interview, this will be one of the first 10 t...

Protected variations in software engineering explained and extended beyond the common usages

While digging through some standard programming principles like low coupling and high cohesion I stumbled upon the fact that they are part of a larger series of principles called "GRASP" principles. After reading a bit about them, they seem just as important if not more important than the "SOLID" principles And one particular principle from that series stuck with me: protected variations. According to this principle, variations and changes in parts of the application should be contained only in them and not trigger further changes in the application. In general terms points of inflection should be established between the parts that change and the rest of the application which act like a boundary and stop additional changes from propagating to the rest of the application. For example, one of the most common parts that might change in an application, is the data access and storage methods. For example instead of using direct sql to read and write to a database, an...