今日推荐开源项目：《Git 的生动形象学习法 learnGitBranching》传送门：GitHub链接
推荐理由：如果你是 Git 的初学者，现在还在对各种命令搞不清楚，那么这个项目就是一个不可错过的好教程。不同于普通的 Git 教程，它在右边提供了一个可视的板块可以让你更轻松的理解自己的所作所为究竟改变了什么，生动形象简单方便，你可以选择跟着它提供的教程一步步走，当你熟练之后也可以直接打开沙盒模式随意的输入命令来观察，不管怎么说，对于 Git 的初学者这会是一个好选择。
今日推荐英文原文：《How Can I Maximise my Software Team’s Productivity?》作者：Rizwan Iqbal
How Can I Maximise my Software Team’s Productivity?
Often resembling an endless treadmill of balancing the interests of man and machine in the name of the abstract ideal of ‘’Results’’, the task of maximising a software team’s productivity preoccupies many engineering managers’ minds. Between ensuring that developers are completing their tasks efficiently and to a high standard, while considering the essential human element of considering how a software team consists of a team of individuals who must be kept in a happy and peaceful state of mind, it isn’t simple at the best of times.
Engineering Managers must keep close at heart the needs to understand how to repay technical debt in a timely manner, whether their engineers are productive, how to overcome obstacles so that they can do their jobs as easily as possible, the matter of ensuring quality work and how to perform weekly 1:1s with their developers. To help them balance between these various and often contradictory elements, a dependable strategy can be instrumental in helping them ensure that none of these factors slip through the net in the day-to-day activity of a software team.
This involves a careful, ergonomic balancing of the drive for hard, factual achievement in a scope of objective data and soft, subjective human nature, where an optimum system of exchange and feedback creates a sparkling golden balance where developers’ efforts feed into fruitful maintenance and expansion of a codebase.
Measuring Developer Throughput
Counting as the first key measure of productivity, engineering managers commonly refer to a calculation of developer throughput as a means of judging their current degree of productivity, and so as a way of understanding how far they could improve beyond this level. As a reading that defines the amount of logic added over a week, calculated as effort and delta logic points divided by the total number of working hours, throughput indicates how effectively developers’ time converts to results in the codebase.
Amongst all this comes the considerations of ensuring that developers integrate thorough documentation to their workflow, ensuring that future development has a greater chance of happening seamlessly. Such increases readability for those new to the company and enables them a positive level of throughput from the outset. Measuring throughput also allows the manager to identify and mentor struggling engineers with a lower throughput, where tools can help to indicate where they’re perhaps needing some assistance with a certain skill-set; with java, typescript, and so on. Addressing these issues can be a simple, single step to unblocking an obstacle to productivity.
Of course, speed comes with a greater quantity of commits, with stale branches resulting in merge conflicts and delayed productivity. In striving for maximised productivity, it’s important to have a team commit often, and understand the importance of each commit after it’s merged to a branch.
However, speed shouldn’t come at the expense of quality, and it’s equally important for managers to have processes in place that make it easier to write and test code accurately, even while working at speed. Developers shouldn’t be tempted to compromise on the sophistication of their code in order to commit work more quickly, and measuring code coverage enables managers to understand whether the standard is slipping, or whether the developers’ efforts continue to sustain an overall measure of improvement. However, code coverage shouldn’t be an absolute measure unless enforced through code reviews.
Team Churn & Being Human
Although a software developer’s work sits on a computer and happens through a screen, it’s important to remember that all teams consist of human individuals where each person has their own methods of approaching work and understanding the concepts within. Applying a team churn metric indicates the degree of procrastination present in the team, by showing how much time sits between engineers first being presented with a task and their completion of the work set and measuring activity on the project over time. This is an area where the appropriate tools can be of huge assistance to engineering managers for seeing how their workforce are coping with the demand, by visualising the dynamic between specific applications or projects and the teams and analysing this relationship according to a series of performance metrics.
However, maximising a software team’s productivity ultimately rests upon applying intuitive, careful human judgement to accurate data readings, and it’s essential to remember that numbers don’t necessarily speak the truth on behalf of subjective individuals, and the best engineering managers excel from an ability to engage and interact with every member of a team. A high amount of time spent on a task may simply indicate a high degree of difficulty from the complexity of the code, or a backlog of undocumented work. While accurate metric readings for developer throughput and team churn support informed evaluations on the manager’s behalf, it’s always essential to combine this degree of sensitive intuition with objective data.
Once the evaluations have been made and the manager has defined the appropriate sites for improvement, what remains is integrating fresh goals and objectives at the heart of the team and encouraging the fluid communication and collaboration that promotes progress for the group of engineers. By looking at where skills could be matched with metrics — such as, assigning an engineer with strong readings in tackling complex code to an area of the codebase with high complexity, — and preparing training scenarios with developing resources in mind, managers can steer their team to maximising their productivity with a careful balance between human and metrical elements. Human behaviour shifts and changes, as does that of a codebase, and considering a team as dynamic and capitalising upon the potential for positive change by identifying key areas of focus can sit as the bottom line for a software team’s success.
Interested in finding out more? Head to Seerene.me to uncover more pearls of wisdom on transforming the efficiency of a software team.