DYNAMIC REDUCTION OF TIME COSTS ON IT-PROJECT BY FORMING TEAMS OF COMPATIBLE PROGRAMMERS Текст научной статьи по специальности «Компьютерные и информационные науки»

АЛГОРИТМИЗАЦИЯ И ПРОГРАММИРОВАНИЕ ALGORITHMIC AND PROGRAMMING

УДК 004.4-004.9

А. А. Prihozhy

Belarusian National Technical University

DYNAMIC REDUCTION OF TIME COSTS ON IT-PROJECT BY FORMING TEAMS OF COMPATIBLE PROGRAMMERS

The combinatorial problem of forming programming teams has been studied in several works. The proposed techniques and algorithms for solving the problem account for various aspects and parameters of the software development process and programming teams' operation. The problem is NP-hard in general case. Accounting for compatibility of programmers leads to forming teams with increased efficiency of operation which reduces IT-project time costs. Our previous work researched how the compatibility of programmers influences the overall runtime of teams. This paper proposes a more accurate dynamic model of calculating the programmers' time costs changes during forming teams. At each adding of a programmer to a team, the model recalculates the time costs of the programmers and teams accounting for their compatibility. The advanced dynamic optimization algorithm of stepwise pairwise merging of teams be developed in the paper aims to reduce the time costs of the project the programmers are working on. The created software and conducted computational experiments have shown the reduction in project time costs by tens of percent for large sets of programmers.

Keywords: programmer, project, time costs, compatibility of programmers, forming teams, optimization.

For citation: Prihozhy А. А. Dynamic reduction of time costs on IT-project by forming teams of compatible programmers. Proceedings of BSTU, issue 3, Physics and Mathematics. Informatics, 2024, no. 1 (278), pp. 70-76.

DOI: 10.52065/2520-6141-2024-278-11.

А. А. Прихожий

Белорусский национальный технический университет

ДИНАМИЧЕСКОЕ СОКРАЩЕНИЕ ЗАТРАТ ВРЕМЕНИ НА ИТ-ПРОЕКТ ПУТЕМ ФОРМИРОВАНИЯ КОМАНД СОВМЕСТИМЫХ ПРОГРАММИСТОВ

Комбинаторная задача формирования команд программистов изучалась в ряде работ. Предложенные методы и алгоритмы решения задачи учитывают различные аспекты и параметры процесса разработки программного обеспечения и работы команд программистов. В общем случае задача является NP-трудной. Учет совместимости программистов приводит к формированию команд с повышенной эффективностью работы, что значительно сокращает временные затраты на ИТ-проект. Наши предыдущие работы исследовали, как совместимость программистов влияет на общее время работы команд. В данной работе предлагается более точная динамическая модель расчета изменения временных затрат программистов в процессе формировании команд. При каждом добавлении программиста в команду модель пересчитывает временные затраты программистов и команд с учетом их совместимости. Разработанный в статье алгоритм динамической оптимизации путем пошагового попарного слияния команд направлен на снижение временных затрат на проект, над которым работают программисты. Созданное программное обеспечение и проведенные вычислительные эксперименты показали снижение временных затрат на проект на десятки процентов при большом количестве участников проекта.

Ключевые слова: программист, проект, временные затраты, совместимость программистов, формирование команд, оптимизация.

Для цитирования: Прихожий А. А. Динамическое сокращение затрат времени на ИТ-проект путем формирования команд совместимых программистов // Труды БГТУ. Сер. 3. Физико-математические науки и информатика. 2024. № 1 (278). С. 70-76 (In English).

DOI: 10.52065/2520-6141-2024-278-11.

Introduction. The problem of forming programming teams and managing projects has been studied in works [1-10]. The problem is combinatorial and NP-hard in general case. Therefore, exact and heuristic algorithms have been developed for solving it for various objective functions and constraints. Work [11] has considered how the compatibility of programmers influences the overall runtime of teams and how the influence of programmers on each other can be used for reducing the project time costs. A matrix of compatibility of programmers has been proposed and a greedy algorithm of stepwise pairwise merge of teams has been developed at the aim of solving the problem of forming teams. The algorithm analyses and exploits programmers' compatibility to find the number, size and staff of the teams reducing the overall runtime.

In this paper, we propose a more accurate dynamic model of calculating changes in the time costs of programmers during forming teams, propose and implement an advanced optimization dynamic algorithm of stepwise pairwise merge of programming teams.

Main part. Let P = [p\, ...,p„] be a set of n programmers working on an IT project. Vector t = = (t1, ... ti, ... tn) describes the programmers' basic time costs, which do not include interaction costs within team.

Let G = {g\...gk} be a set of teams the programmers are allocated to. If programmers are in a same team, their time costs must be corrected depending on the compatibility of programmers. Matrix dP represents corrections (%) of the programmers' costs. In matrix principal diagonal, dPi,i = ti. For programmers i and j, dPij (dPj,,) shows how programmer i j) influences on tj (ti). Values dPij and dPj,i can be negative and positive. Four combinations are possible: 1) dPij < 0 and dP},i < 0; 2) dPj > 0 and dP,i > 0; 3) dPij < 0 and dP,t > 0; 4) dPij > 0 and dPj,t < 0. The first combination is the most preferable since the time costs of both programmers are reduced.

In work [11], the changes in the programmers' time costs are calculated with dTij = tj ■ dPij / 100 before allocating the programmers to a team and then are summed. A drawback of the approach is that for significant changes of programmers' time costs the overall costs can become negative. In this paper, we develop more accurate model for estimating the time costs changes. Every adding of a programmer to a team causes the recalculation of the costs using matrix TP.

TP =

T d,

1,2

d.

1,n

d-

2,1

T2

d

2,n

dn,1 dn,2

T

Initially, Ti = ti, i = 1.n. The non-diagonal element di,j = 100 ■ dPj,i is a positive or negative share of Tj that is added to Tj if programmers i and j are

included in a same team: Tj = Tj + Tj ■ dij. According to the model, adding a new programmer to a team immediately changes the time costs of all programmers belonging to the team. The positive value of dij makes larger the Tj costs, and the negative value makes them smaller. To reduce the time costs of team g, programmers with negative dij should be included in the team first.

Theorem 1. Let u = u\...ug be an order of including programmers in team g. The overall time costs T(g) of the programmers of team g is determined by (1).

i \

T (g) = I

p=u1 ■■

TP ■ n (1+j)

j =u1..u|g V j * p

(1)

Proof. Let's prove by induction that the time costs of programmer p from team hk = {u1.uk}, k < |g| are determined by equation

T^h) = tp ■ n (1 + j). j=u1 ...uk

j*p (2)

Base case. Let a team of two programmers (shown in Fig. 1 by dark cells of matrix TPk-1) be h2 = {u1, u2}. Then programmer u2 influences on the time costs of programmer u1 and, therefore,

Similarly,

T (u1, h2) = TUi-(1 + d„2,„1)

T(u2,h2) = Tu2-(1 + duiu2)

The time costs of programmer j = u3.uk who establishes a separate team are Tj.

Induction step. Suppose (2) holds for hk-1 = = {u1...uk-1} as shown by dark cells of dimension (k- 1)x(k- 1) in Fig. 2 describing matrix TP2 for two teams. The costs of programmer uk who is not in team hk-1 are Tuk. If uk is added to hk-1, a team hk is established (filled block of dimension kxk in Fig. 3). Programmer uk gets influence on the time costs of each of programmers u1. uk-1. Therefore, their time costs are multiplied by factors (1 + duk,u\), ... , (1 + duk,uk-1) respectively, which is compliant with (2). In their turn, all the programmers get influence on the time costs of programmer uk with factor (1 + du1,uk) ■ ... ■ (1 + duk-1,uk). As a result, the time costs of programmer uk are determined by (2).

The elements of principal diagonal of matrix TP1 shown in Fig. 3 prove that the time costs of all programmers included in a team are calculated with (2), and at k = |g| and hk = g, the overall sum of the programmers' time costs is equal to T(g) defined by (1). The theorem is proved.

Corollary 1. The value of T(g) defined by (1) does not depend on the order of including programmers in team g.

Tpk-i _

Tux • (1 + du2,u1)

U2 ,ui

Ufc ,U]

T

U2

U1,U2 • (1 + d

U1 ,U2 ^

U1 ,Uk

U2 ,Uk

Ufc ,U2

uk

Fig. 1. Matrix TPk-2 of time costs of k programmers included in k - 1 teams (two programmers are in the first team)

TP2 =

'Ti • n (1 + dj u)

ui,uk-i

j =u2-uk-1

uk-1,u1

Tuk-1 ^ n (1 + j-1)

u1,uk

uk-1.uk

uk u

j =u1...uk-2 d

uk ,uk-1

Tu

uk

Fig. 2. Matrix TP2 of time costs of k programmers included in 2 teams (k - 1 programmer are in the first team)

TP1 =

Tu1 • n (1 + dj,u1)

u1.uk-1

j =u2-uk

uk-1.u1

uk ,u1

••• T

uk-1

n (1

j =u1uk, J *uk-1 d

uk ,uk-1

+

j .uk-

-1)

u1 ,uk

uk-1.uk

Tuk • n (1 + dj,k

J =u2-uk-1

Fig. 3. Matrix TP1 of time costs of k programmers included in single team

Proof. Let u be a permutation that determines the order of including the programmers in team g. Let's reorder the programmers listed in u to obtain a permutation v such that vj = j, j = 1.. .|g|. To do this, we find element uk = j and exchange it with element uj for j = 1.. .|g|. According to (2), the exchange does not change the value of T(p, g) for the elements of matrix TPus principal diagonal (Fig. 3) since the multiplication operation used in expression (1 + du1,p) • ... • (1 + dukp) is commutative and associative. Any permutation of the programmers can be replaced with v, therefore all of them yield the same value of T(p, g). The corollary is proved.

Corollary 1 allows to rewrite (1) as

( \

T (g) = I

peg

Tp

•n(1+j)

jeg

j * P

(3)

If djp is negative, then (1 + dj,p) < 1, therefore, T(p, g) is decreased. If djp is positive, then (1 + djp) > 1, therefore, T(p, g) is increased. The value of T(p, g) is smaller if the larger number of negative elements d, p are in the matrix.

The overall time costs of teams of set G are

TG = I geGT (g).

(4)

If Q is a set of all possible partitioning of set P of programmers into a set G of teams, the combinatorial optimization problem we solve is

rrL

min T

GeQ.

(5)

In the paper, we propose a dynamic greedy algorithm to solve (5) heuristically for large sets of programmers. Unlikely to [11], the algorithm recalculates time costs of programmers at every step of pairwise merge of teams.

The dynamic greedy algorithm of stepwise pair-wise merge of teams (DGAMT) is described by Algorithm 1. The set P of programmers, vector t of programmers' basic time costs and matrix TP of pairwise changes of programmers' time costs are its inputs. The set G of teams and the overall time costs TG are its outputs. DGAMT is derived from Theorem 1 and Corollary 1.

Performing initialization, the algorithm allocates each programmer pi to team {pi}. The teams' overall time costs TG are the sum of ti, i = 1...n. Each element of two-dimensional array AT is initialized by calculating a difference between T(g' u g") and T(g') + T(g") where g' and g" are teams-candidates for merging.

Algorithm 1: Dynamic greedy algorithm of stepwise pairwise merge of teams (DGAMT)

Input: A set P = {p1, ..pn} of programmers Input: A vector t = (ft...4) of programmers' basic time costs

Input: A matrix TP[nxn] of programmers' pairwise

time costs changes Output: A set G of programming teams Output: A runtime Time(G) of programming teams

G ^ 0 T° ^ 0 go ^ true for i ^ 1 to n do

gt ^ {p,} T(g) ^ t(p) ^ t, G ^ G u {gi} TG ^ TG + ti for g' e G do

BestC(g').team ^ undefined BestC(g')AT ^ ™ for g" e G do

T(g' u g") ^ TeamRuntime(P, t(p), TP, g', g") AT(g',g") ^ T(g' ug") - T(g') - T(g") AT(g", g') ^ AT(g', g") if BestC(g').AT > AT(g', g") then BestC(g').AT ^ AT(g', g") BestC(g').team ^ g" while (go) do go ^ false

g' ^SelectBestPairOfTeams(G, BestC) if BestC(g').AT < 0 then go ^ true

g" ^ BestC(g').team g ^ g' u g"

t ^ UpdateProgrammerCosts(P, t, TP, g', g")

T(g) ^ T(g') + T(g") + BestC(g').AT

G ^ (G \ {g', g"}) u {g}

TG ^ TG + BestC(g').AT

BestC(g).team ^ undefined

BestC(g).AT ^ ™

for g# e G \ {g} do

T(g u g#) ^ TeamRuntime(P, t(p), TP, g, g#) AT(g, g#) ^ T(g u g#) - T(g) - T(g#) AT(g#, g) ^ AT(g, g#) if BestC(g).AT > AT(g, g#) then BestC(g).AT ^ AT(g, g#) BestC(g).team ^ g# if BestC(g#).AT > AT(g#, g) then BestC(g#).AT ^ AT(g#, g) BestC(g#).team ^ g return G, Time(G)

Algorithm 2: Calculating time costs of team formed by merging a pair of selected teams (TeamRuntime)

Input: A set P = {p1, ..p„} of programmers Input: A vector t(p) = (t(p>1)... t(p„)) of programmers'

time costs in IT project Input: A matrix TP[nxn] of pairwise changes of programmers' time costs

Input: Teams g and g" selected for merging Output: Time costs T(g' u g") of union of two teams T(g' u g") ^ 0 for v e g' do t*(v) ^ t(v) for u e g" do

t*(v) ^ t*(v) ■ (1 + TP(u, v)) T(g' u g") = T(g' u g") + t*(v) for v e g" do t*(v) ^ t(v) for u eg' do

t*(v) ^ t*(v) ■ (1 + TP(u, v)) T(g' u g") = T(g' u g") + t*(v) return T(g' ug")

Each element BestC(g') of vector BestC is initialized with BestC(g').team which is paired with g' and has maximal reduction BestC(g').AT of time costs. Function TeamRuntime (Algorithm 2) calculates the time costs T(g) of team that is a result of merging g = g' u g". At every iteration of the while loop, DGAMT calls function SelectBestPairOf-Teams to choose a pair of teams g' and g" whose element in AT is minimal. If all elements of AT are not negative, the process of merging is over. Otherwise, the set G of teams is reconstructed: teams g' and g" are removed from G and team g = g' u g" is added to G. The time costs for each p, g and G are calculated using (2), (3) and (4).

Algorithm 3: Calculating time costs of programmers of two teams to be merged (UpdateProgrammerCosts)

Input: A set P = {p1, ..p„} of programmers Input: A vector t(p) = (t(p1)... t(p„)) of time costs Input: A matrix TP[nxn] of pairwise changes of programmers' time costs Input: Teams g and g" of programmers to be merged Output: An updated vector t(p) of time costs for v e g' do for u e g" do

t(v) ^ t(v) ■ (1 + TP(u, v)) for v e g" do for u e g' do

t(v) ^ t(v) ■ (1 + TP(u, v)) return t(p)

For new team g and for each another team g#e G, the value of AT(g, g#) is calculated. This may cause updating elements of vector BestC .Function UpdateProgrammerCosts (Algorithm 3) updates using (2) the time costs of programmers from teams g' and g" that are intended to be merged.

Example. Let P = {p1...ps} be a set of eight programmers. Vector t = (93, 15, 47, 45, 79, 92,

67, 64) describes basic time costs of the programmers in a project. Fig. 4 gives matrix dP of programmers' pairwise time costs changes (%). The overall time costs of eight teams (one programmer per team) are 502.0. The overall time costs of the single team (it contains eight programmers) are 469.1 (6.6% less). Fig. 5 describes step 1 of DGAMT s operation.

The rows and columns of matrix AT correspond to eight teams of set G = {{pi}, {^2}, {ps}, {p4>, {ps}, {p6}, {p7}, {p8}}. Element AT,, = T({p,, p}) -- T({p,}) - T({p,}), i, j = 1...8, i 4 j, is calculated using (3). Elements of vector t are in principal diagonal of AT. The A and team elements of components

of vector BestC's are in the right column (Fig. 5). Since BestC(1).A and BestC(8).A have a minimum value of - 13.22, teams {pi} and {p8} are selected for merging at step 2. Fig. 6 describes step 2 of DGAMT. Teams {pi} and {p8} are merged to {pi, p8}. The overall number of teams is reduced to seven. DGAMT removes two rows and two columns from matrix AT corresponding to teams {pi} and {p8} and adds one row and one column for the new team {pi, p8}. Observing column BestC, we see that teams {p7} and {pi, p8} give a maximum reduction - i4.99 of the time costs. They are selected for merging at step 3.

Fig. 4. Example matrix dP of programmers' pairwise time costs changes (%) after including in a same team

AT-

1 2 3 Teams 4 5 6 7 8 Programmers BestC A team

1 93 2.70 -6.82 -7.95 -0.17 12.09 -8.45 -13.22 {1} -13.22 8

2 2.70 15 -0.55 2.54 -2.30 -7.13 2.23 -2.64 {2} -7.13 6

3 -6.82 -0.55 47 -1.41 1.73 6.20 -3.48 2.39 {3} -6.82 1

4 -7.95 2.54 -1.41 45 -9.51 -1.77 4.78 -2.91 {4} -9.51 5

5 -0.17 -2.30 1.73 -9.51 79 9.17 -4.62 3.42 {5} -9.51 4

6 12.09 -7.13 6.20 -1.77 9.17 92 6.52 -6.30 {6} -7.13 2

7 -8.45 2.23 -3.48 4.78 -4.62 6.52 67 -7 {7} -8.45 1

8 -13.22 -2.64 2.39 -2.91 3.42 -6.30 -7.46 64 {8} -13.22 1

Fig. 5. Step i of merging a pair of teams from G = {{i}, {2}, {3}, {4}, {5}, {6}, {7}, {8}} by DGAMT

A T =

1 2 3 Teams 4 5 6 7 Programmers BestC A team

15.0 -0.55 2.54 -2.30 -7.13 2.23 0.12 {2} -7.13 5

-0.55 47.0 -1.41 1.73 6.20 -3.48 -4.35 {3} -4.35 7

2.54 -1.41 45.0 -9.51 -1.77 4.78 -10.06 {4} -10.06 7

-2.30 1.73 -9.51 79.0 9.17 -4.62 3.05 {5} -9.51 3

-7.13 6.20 -1.77 9.17 92.0 6.52 5.52 {6} -7.13 1

2.23 -3.48 4.78 -4.62 6.52 67.0 -14.99 {7} -14.99 7

0.12 -4.35 -10.06 3.05 5.52 -14.99 143.8 {1.8} -14.99 6

Fig. 6. Step 2 of merging a pair of teams from G = {{2}, {3}, {4}, {5}, {6}, {7}, {i, 8}} by DGAMT

Fig. 7. Comparison of time costs (%) of single team with costs of one-programmer teams (triangles) and comparison of time costs (%) of dynamic greedy teams with costs of single team (diamonds) vs. programmer count

Stepwise merge of teams by DGAMT at seven steps

Step Team count Teams Overall time costs Pair of teams merged Time costs reduction

1 8 {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8} 502.0 {1} and {8} -13.22

2 7 {2}, {3}, {4}, {5}, {6}, {7}, {1, 8} 488.8 {7} and {1, 8} -14.99

3 6 {2}, {3}, {4}, {5}, {6}, {1, 7, 8} 473.8 {4} and {5} -9.51

4 5 {2}, {3}, {4, 5}, {6}, {1, 7, 8} 464.3 {3} and {1, 7, 8} -7.32

5 4 {2}, {4, 5}, {6}, {1, 3, 7, 8} 457.0 {2} and {6} -7.13

6 3 {4, 5}, {2, 6}, {1, 3, 7, 8} 449.8 {4, 5} and {1, 3, 7, 8} -5.00

7 2 {2, 6}, {1, 3, 4, 5, 7, 8} 444.8 - 24.45

20.00

10.00

■40.00

- -•- - Single / Separate, % —Ét— Greedy/ Single, %

Table briefly describes 7 steps of DGAMT s operation. The time costs have been monotonically reduced. At step 7, the minimum time costs reduction became positive, therefore, the merge is over. Finally, DGAMT has obtained two teams having the overall time costs of 444.8 (that is 11.4% less than the costs of eight initial teams).

Results. We have implemented DGAMT in the C++ language using Visual Studio 2022 under OS Windows 10. Experiments have been conducted on Intel Core i7-10700 CPU processor using various P, t and dP. Fig. 7 compares the overall time costs of one-programmer teams, single teams and dynamic greedy teams obtained by DGAMT for sets of 10 to 100 programmers. Vector t and matrix dP (average value of element is 5%) were unique for each set of programmers. The time costs of single team differed

from those of one-programmer teams by - 6.17% to 12.65% depending on the compatibility of programmers. DGAMT have yielded greedy teams having time costs -11.75% to -29.88% lower against single teams.

Conclusion. In the paper, we have proposed an accurate model of calculating the IT project time costs which accounts for compatibility of programmers and updates the programmers' time costs at each adding of a programmer to a team. We have used the model for reducing the overall time costs by means of finding an appropriate number of teams, size, and staff of each team. The dynamic greedy algorithm of stepwise pairwise merge of teams realizes the model and shows high accuracy and efficiency while forming programming teams for working on an IT project.

References

1. Rachlin, J. N., Goodwin, R. T., Murthy, S., Akkiraju, R., Wu, F., Kumaran, S., Das, R. A-Teams: An Agent Architecture for Optimization and Decision-Support. In: Müller, J. P., Rao, A. S., Singh, M. P. (eds).

Intelligent Agents V: Agents Theories, Architectures, and Languages. ATAL, 1998. Lecture Notes in Computer Science. Berlin; Heidelberg, Springer, 1999, vol. 1555, pp. 1-15.

2. Britto R., Neto P. S., Rabelo R., Ayala W. and Soares T. A hybrid approach to solve the agile team allocation problem. 2012 IEEE Congress on Evolutionary Computation, 2012, pp. 1-8.

3. Prihozhy A. A., Zhdanouski A. M. Genetic algorithm of allocating programmers to groups. Nauka - obra-zovaniyu, proizvodstvu, ekonomike: materialy 13-y Mezhdunarodnoy nauchno-prakticheskoy konferentsii

[Science to education, industry and economics: Proceedings of 13 th international conference. Vol. 1]. Minsk, 2015, pp. 286-287 (In Russian).

4. Gutierrez J. H., Astudillo C. A., Ballesteros-Perez P., Mora-Melia D. and Candia-Vejar A. The multiple team formation problem using sociometry. Computers and Operations Research, 2016, vol. 75, pp. 150-162.

5. Masood Z., Hoda R., Blincoe K. Exploring Workflow Mechanisms and Task Allocation Strategies in Agile Software Teams. In: Baumeister H., Lichter H., Riebisch M. (eds). Agile Processes in Software Engineering and Extreme Programming. XP 2017. Lecture Notes in Business Information Processing. Springer, 2017, vol. 283, pp. 267-273.

6. Prihozhy A. A., Zhdanouski A. M. Method of qualification estimation and optimization of professional teams of programmers. System analysis and applied information science, 2018, no. 2, pp. 4-11 (In Russian).

7. Prihozhy A. A. Exact and greedy algorithms of allocating experts to maximum set of programmer teams. System analysis and applied information science, 2022, no. 1, pp. 40-46.

8. Prihozhy A., Zhdanouski A. Genetic algorithm of optimizing the size, staff and number of professional teams of programmers. Open Semantic Technologies for Intelligent Systems, Minsk, BSUIR Publ., 2019, pp. 305-310.

9. Prihozhy A. A., Zhdanouski A. M. Genetic algorithm of optimizing the qualification of programmer teams. System analysis and applied information science, 2020, no. 4, pp. 31-38.

10. Prihozhy A. A. Optimization of data allocation in hierarchical memory for blocked shortest paths algorithms. System analysis and applied information science, 2021, no. 3, pp. 40-50.

11 . Prihozhy А. А. Optimization of programming teams on compatibility of programmers. Trudy BGTU [Proceedings of BSTU], issue 3, Physics and Mathematics. Informatics, 2023, no 2 (272), pp. 104-110.

Список литературы

1. A-Teams: An Agent Architecture for Optimization and Decision-Support / J. N. Rachlin [et al.] // Intelligent Agents V: Agents Theories, Architectures, and Languages, ATAL 1998: Lecture Notes in Computer Science / J. P. Müller, A. S. Rao, M. P. Singh (eds). Berlin; Heidelberg: Springer. 1999. Vol. 1555. P. 1-15.

2. A hybrid approach to solve the agile team allocation problem / R. Britto [et al.] // 2012 IEEE Congress on Evolutionary Computation. 2012. P. 1-8.

3. Прихожий А. А., Ждановский А. М. Генетический алгоритм разбиения коллектива программистов на группы // Наука - образованию, производству, экономике: материалы 13-й Междунар. науч.-практ. конф. Минск, 2015. Т. 1. С. 286-287.

4. The multiple team formation problem using sociometry / J. H. Gutierrez [et al.] // Computers and Operations Research. 2016. Vol. 75. P. 150-162.

5. Masood Z., Hoda R., Blincoe K. Exploring Workflow Mechanisms and Task Allocation Strategies in Agile Software Teams // Agile Processes in Software Engineering and Extreme Programming. XP 2017: Lecture Notes in Business Information Processing / H. Baumeister, H. Lichter, M. Riebisch (eds). Springer, 2017. Vol. 283. P. 267-273.

6. Прихожий А. А., Ждановский А. М. Метод оценки квалификации и оптимизация состава профессиональных групп программистов // Системный анализ и прикладная информатика. 2018. № 2. С. 4-11.

7. Prihozhy A. A. Exact and greedy algorithms of allocating experts to maximum set of programmer teams // System analysis and applied information science. 2022. No. 1. P. 40-46.

8. Prihozhy A., Zhdanouski A. Genetic algorithm of optimizing the size, staff and number of professional teams of programmers // Open Semantic Technologies for Intelligent Systems. Minsk, BSUIR, 2019. P. 305-310.

9. Prihozhy A. A., Zhdanouski A. M. Genetic algorithm of optimizing the qualification of programmer teams // System analysis and applied information science. 2020. No. 4. P. 31-38.

10. Prihozhy A. A. Optimization of data allocation in hierarchical memory for blocked shortest paths algorithms // System analysis and applied information science. 2021. No. 3. P. 40-50.

11. Prihozhy A. A. Optimization of programming teams on compatibility of programmers // Труды БГТУ. Сер. 3, Физико-математические науки и информатика. 2023. № 2 (272). С. 104-110.

Information about the author

Prihozhy Anatoly Alexievich - DSc (Engineering), Professor, Professor, the Department of Computer and System Software. Belarusian National Technical University (65, Nezalezhnasti Ave., 220013, Minsk, Republic of Belarus). E-mail: prihozhy@yahoo.com

Информация об авторе

Прихожий Анатолий Алексеевич — доктор технических наук, профессор, профессор кафедры программного обеспечения информационных систем и технологий. Белорусский национальный технический университет (220013, г. Минск, пр. Независимости 65, Республика Беларусь). E-mail: prihozhy@yahoo.com

Received 07.12.2023