3.6 Calculating ProductivityProduct

3.6 Calculating Productivity
Productivity is generally measured as the labor hours required to do a unit of work.
It is such a simple concept that people tend to think of productivity as a simple
calculation. Although the calculation is simple, using the right data and properly
interpreting these data is not so easy. Proper productivity calculations must consider, for example, the unique conditions of each job and the quality of the resulting product. If you estimate the size of a new job and then use some global
productivity factor to determine the total hours required, you will generally get a
misleading result. It would be analogous to always allowing for the average
driving time when you go to the airport. With that method, you will miss a lot of
flights around rush hour and do a lot of waiting the rest of the time.
When calculating productivity, divide the size of the product produced by the
hours spent producing it. This gives the volume of product produced per hour. For
programming, for example, if you developed a 600-LOC program in 60 hours,
your productivity would be 10 LOC per hour. Although this may seem simple
enough, you face many choices for picking these size and hours measures. For
example, various combinations of the numbers used in the LOC accounting
example in Table 3.2 (see p. 44) are shown in Table 3.3. There is some basis for
3.6 Calculating Productivity 47
arguing that any one of these six numbers should be used to measure development
productivity. Assuming that you spent a total of 60 hours developing this program,
the various productivity options could differ by factors of two or more times. This
variation is caused solely by the choice you make for using the size measures. That
is why comparisons of productivity numbers between organizations or even
among individuals are rarely useful and why each developer must choose his or
her own method and use it consistently.
For most new or major enhancement projects, added plus modified product is
probably most appropriate for calculating productivity. For small modifications
to large programs, however, the issue is much more complex. The reason is that
the productivity for software modification is often much lower than for new development (Flaherty 1985). By gathering data on the time spent, the sizes of the
changes, the size of the base program, and the fraction of the base program modified, you will likely find that small changes in large programs take much more
time than either new development or large-percentage modifications of existing
programs. Study your own data and see what categories provide the best correlation with development effort. Again, the methods discussed in this book will help
you to arrive at appropriate productivity figures.
3.7 Size Counters
Although it is relatively easy to count the sizes of small programs, manually counting even small programs can be time-consuming and error-prone. For large programs, however, manual counting is impractical, making automated size counters
essential.
Counters can be designed to count the number of almost any product element
as long as the definition for that element is precise and specific. For example, a
48 Chapter 3 Measuring Software Size
TABLE 3.3 VARIATIONS IN LOC PRODUCTIVITY
Size Productivity
Productivity Option LOC LOC/Hour
Added (350+100+50) 500 8.33
Added + Modified (500+100) 600 10.00
Added + Modified + Deleted (600+200) 800 13.33
Added + Modified + Reused (600+600) 1200 20.00
Added + Modified + Deleted + Reused (1,200+200) 1400 23.33
Total Finished Product 900 15.00
LOC counter could count physical lines or logical lines. Although automatically
counting database elements can be a bit more complex, if the object model is
accessible, you can usually count selected sets of database elements.
Physical LOC Counters
The simplest type of size counter counts physical LOC. Here, you count all text
lines except comments and blank lines. A text line that has both comments and
source code is counted as one LOC.
Logical LOC Counters
Logical LOC counters work much like physical counters except that line-counter
stepping is more complex. My Object Pascal logical line counter had 939 LOC
and took me about 50 hours to develop. Don’t try to develop a logical line counter
unless you have plenty of time to do it. Although people can endlessly debate the
best way to count LOC, the details are not that important. The key is to be precise
and consistent. In my Object Pascal and C++ programs, I counted every logical
program statement. Although some may argue that counting begin and end statements is not a good idea, this is a matter of personal preference. If you could show,
however, that the time required to develop a program had a higher correlation with
LOC when begin-end pairs were counted than when they were not, that would be
a good reason to use them. This would also be the proper way to resolve almost
any size counting question.
Presently, there is no compelling evidence to support any one counting
method over any other. With good data, however, a study of the various alternatives could quickly show which, if any, would be best for your work. It may show,
as is likely, that many different approaches produce roughly equivalent results.
In that case, the selection is arbitrary. The fact that it is arbitrary, however, does
not mean that everyone should do it differently. If all of the projects in an organization used the same counting standard, they could afford to develop a single highquality automated counter for everyone to use. They would also have a much
larger volume of data to use in planning and quality analysis.
Counting Program Elements
It is often desirable to measure the sizes of various parts of large programs. For
example, if you intended to reuse some newly developed classes or procedures,
you would like to know how large each one is. As you will see in Chapter 5, such
counts can also help with size estimating.
3.7 Size Counters 49
To maintain separate counts for each class or procedure, you must determine
where each one starts and ends. Because the way to do this depends on the programming language, there is no general guideline. The counter I built for Object
Pascal recognized the keywords procedure, function, constructor, and destructor as the beginning of procedures. I found the endpoints by counting begin-end
pairs. With a little study, you can determine the indicators for the beginning and
ending points of the methods, procedures, classes, functions, or other elements for
the language you use. You can then use this definition to scan the program text and
start and stop the size counter at the appropriate points.
Using Coding Standards and Physical LOC Counters
One simple way to count logical LOC is to use a coding standard and count physical LOC, omitting comments and blanks. The idea is to write the source code with
a separate physical text line for every countable line. Then, when you count physical lines, you are also counting logical lines. To use this method, you must carefully follow a coding standard like the example shown in Table 3.4. If, at the same
50 Chapter 3 Measuring Software Size
TABLE 3.4 EXAMPLE C++ CODING STANDARD
Purpose: To guide the development of C++ programs
Program Headers Begin all programs with a descriptive header.
Header Format /*************************************************************************/
/* Program Assignment: the program number */
/* Name: your name */
/* Date: the date program development started */
/* Description: a short description of the program */
/* function */
/*************************************************************************/
Listing Contents Provide a summary of the listing contents.
Contents Example /*************************************************************************/
/* Listing Contents: */
/* Reuse instructions */
/* Modification instructions */
/* Compilation instructions */
/* Includes */
/* Class declarations: */
/* CData */
/* ASet */
/* Source code in c:classesCData.cpp: */
/* CData */
/* CData() */
/* Empty() */
/*************************************************************************/
3.7 Size Counters 51
Reuse Instructions • Describe how the program is used. Provide the declaration
format, parameter values and types, and parameter limits.
• Provide warnings of illegal values, overflow conditions, or other
conditions that could potentially result in improper operation.
Reuse Example /*************************************************************************/
/* Reuse Instructions */
/* int PrintLine(char *line_of_character) */
/* Purpose: to print string, ‘line_of_character’, on one print line */
/* Limitations: the maximum line length is LINE_LENGTH */
/* Return: 0 if printer not ready to print, else 1 */
/*************************************************************************/
Identifiers Use descriptive names for all variables, function names,
constants, and other identifiers. Avoid abbreviations or single
letter variables.
Identifier Example int number_of_students; /* This is GOOD */
float x4, j, ftave; /* These are BAD */
Comments • Document the code so that the reader can understand its
operation.
• Comments should explain both the purpose and behavior of the
code.
• Comment variable declarations to indicate their purpose.
Good Comment If (record_count > limit) /* have all the records been processed? */
Bad Comment if(record_count > limit) /* check if record_count is greater than limit */
Major Sections Precede major program sections by a block comment that
describes the processing that is done in the next section.
Example /*************************************************************************/
/* This program section will examine the contents of the array */
/* “grades” and will calculate the average grade for the class. */
/*************************************************************************/
Blank Spaces • Write programs with sufficient spacing so that they

Kết quả (Việt) 1:

3,6 tính năng suấtNăng suất thường đo bằng giờ lao động cần thiết để làm một đơn vị của công việc.Nó là như vậy đơn giản một khái niệm mà mọi người có xu hướng suy nghĩ của năng suất là một đơn giảntính toán. Mặc dù tính toán đơn giản, bằng cách sử dụng dữ liệu phù hợp và đúng cáchgiải thích những dữ liệu này không phải là dễ dàng như vậy. Thích hợp năng suất tính toán phải xem xét, ví dụ, các điều kiện duy nhất của mỗi công việc và chất lượng của các sản phẩm kết quả. Nếu bạn ước tính kích thước của một công việc mới và sau đó sử dụng một số toàn cầunăng suất yếu tố để xác định tổng số giờ yêu cầu, bạn thường sẽ nhận được mộtkết quả gây hiểu nhầm. Nó sẽ là tương tự như luôn luôn cho phép cho mức trung bìnhlái xe thời gian khi bạn đi đến sân bay. Với phương pháp đó, bạn sẽ bỏ lỡ rất nhiềuchuyến bay xung quanh thành phố giờ cao điểm và làm rất nhiều chờ đợi phần còn lại của thời gian.Khi tính năng suất, phân chia kích thước của sản phẩm được sản xuất bởi cácgiờ chi tiêu sản xuất nó. Điều này cho phép khối lượng sản phẩm được sản xuất cho giờ. Cholập trình, ví dụ, nếu bạn phát triển một chương trình 600-Lộc trong 60 giờ,năng suất của bạn sẽ là LOC 10 cho giờ. Mặc dù điều này có vẻ đơn giảnđủ, bạn phải đối mặt với nhiều sự lựa chọn để chọn các biện pháp kích thước và giờ. ChoVí dụ, các kết hợp khác nhau của những con số được sử dụng trong kế toán LộcVí dụ trong bảng 3.2 (xem trang 44) được hiển thị trong bảng 3.3. Có một số cơ sở cho3,6 tính năng suất 47tranh cãi rằng bất kỳ một trong những con số sáu nên được sử dụng để đo phát triểnnăng suất. Giả sử rằng bạn đã dành tổng cộng 60 giờ phát triển chương trình này,Các tùy chọn khác nhau của năng suất có thể khác nhau do các yếu tố của hai hay nhiều lần. Điều nàybiến thể được gây ra bởi sự lựa chọn bạn thực hiện cho việc sử dụng các biện pháp kích thước. Rằnglà lý do tại sao các so sánh năng suất số giữa các tổ chức hoặc thậm chítrong số các cá nhân hiếm khi hữu ích và lý do tại sao mỗi nhà phát triển phải lựa chọn của mình hoặcCô sở hữu phương pháp và sử dụng nó một cách nhất quán.Đối với hầu hết các dự án mới hoặc chính nâng cao, bổ sung, cộng với sửa đổi sản phẩm làcó lẽ đặt thích hợp cho việc tính toán năng suất. Để sửa đổi nhỏđể chương trình lớn, Tuy nhiên, vấn đề là phức tạp hơn. Lý do lànăng suất cho sửa đổi phần mềm thường là nhiều hơn cho phát triển mới (Flaherty 1985). Bởi thu thập dữ liệu về thời gian chi tiêu, các kích thước của cácthay đổi, kích thước của chương trình cơ bản, và các phần của chương trình cơ bản lần, có thể bạn sẽ tìm thấy rằng nhỏ thay đổi trong chương trình lớn có nhiều hơn nữathời gian hơn phát triển mới hoặc sửa đổi tỷ lệ phần trăm lớn hiện cóchương trình. Nghiên cứu dữ liệu của bạn và xem những gì thể loại cung cấp sự tương quan tốt nhất với nỗ lực phát triển. Một lần nữa, các phương pháp thảo luận trong cuốn sách này sẽ giúpbạn để đi đến con số thích hợp năng suất.3.7 đồng hồ đo kích thướcMặc dù nó là tương đối dễ dàng để đếm các kích thước của chương trình nhỏ, theo cách thủ công đếm thậm chí nhỏ chương trình có thể tốn thời gian và dễ bị lỗi. Đối với chương trình lớn, Tuy nhiên, hướng dẫn sử dụng đếm là không thực tế, làm cho đồng hồ tự động kích thướcessential.Counters can be designed to count the number of almost any product elementas long as the definition for that element is precise and specific. For example, a48 Chapter 3 Measuring Software SizeTABLE 3.3 VARIATIONS IN LOC PRODUCTIVITYSize ProductivityProductivity Option LOC LOC/HourAdded (350+100+50) 500 8.33Added + Modified (500+100) 600 10.00Added + Modified + Deleted (600+200) 800 13.33Added + Modified + Reused (600+600) 1200 20.00Added + Modified + Deleted + Reused (1,200+200) 1400 23.33Total Finished Product 900 15.00LOC counter could count physical lines or logical lines. Although automaticallycounting database elements can be a bit more complex, if the object model isaccessible, you can usually count selected sets of database elements.Physical LOC CountersThe simplest type of size counter counts physical LOC. Here, you count all textlines except comments and blank lines. A text line that has both comments andsource code is counted as one LOC.Logical LOC CountersLogical LOC counters work much like physical counters except that line-counterstepping is more complex. My Object Pascal logical line counter had 939 LOCand took me about 50 hours to develop. Don’t try to develop a logical line counterunless you have plenty of time to do it. Although people can endlessly debate thebest way to count LOC, the details are not that important. The key is to be preciseand consistent. In my Object Pascal and C++ programs, I counted every logicalprogram statement. Although some may argue that counting begin and end statements is not a good idea, this is a matter of personal preference. If you could show,however, that the time required to develop a program had a higher correlation withLOC when begin-end pairs were counted than when they were not, that would bea good reason to use them. This would also be the proper way to resolve almostany size counting question.Presently, there is no compelling evidence to support any one countingmethod over any other. With good data, however, a study of the various alternatives could quickly show which, if any, would be best for your work. It may show,as is likely, that many different approaches produce roughly equivalent results.In that case, the selection is arbitrary. The fact that it is arbitrary, however, doesnot mean that everyone should do it differently. If all of the projects in an organization used the same counting standard, they could afford to develop a single highquality automated counter for everyone to use. They would also have a muchlarger volume of data to use in planning and quality analysis.Counting Program ElementsIt is often desirable to measure the sizes of various parts of large programs. Forexample, if you intended to reuse some newly developed classes or procedures,you would like to know how large each one is. As you will see in Chapter 5, suchcounts can also help with size estimating.3.7 Size Counters 49
To maintain separate counts for each class or procedure, you must determine
where each one starts and ends. Because the way to do this depends on the programming language, there is no general guideline. The counter I built for Object
Pascal recognized the keywords procedure, function, constructor, and destructor as the beginning of procedures. I found the endpoints by counting begin-end
pairs. With a little study, you can determine the indicators for the beginning and
ending points of the methods, procedures, classes, functions, or other elements for
the language you use. You can then use this definition to scan the program text and
start and stop the size counter at the appropriate points.
Using Coding Standards and Physical LOC Counters
One simple way to count logical LOC is to use a coding standard and count physical LOC, omitting comments and blanks. The idea is to write the source code with
a separate physical text line for every countable line. Then, when you count physical lines, you are also counting logical lines. To use this method, you must carefully follow a coding standard like the example shown in Table 3.4. If, at the same
50 Chapter 3 Measuring Software Size
TABLE 3.4 EXAMPLE C++ CODING STANDARD
Purpose: To guide the development of C++ programs
Program Headers Begin all programs with a descriptive header.
Header Format /*************************************************************************/
/* Program Assignment: the program number */
/* Name: your name */
/* Date: the date program development started */
/* Description: a short description of the program */
/* function */
/*************************************************************************/
Listing Contents Provide a summary of the listing contents.
Contents Example /*************************************************************************/
/* Listing Contents: */
/* Reuse instructions */
/* Modification instructions */
/* Compilation instructions */
/* Includes */
/* Class declarations: */
/* CData */
/* ASet */
/* Source code in c:classesCData.cpp: */
/* CData */
/* CData() */
/* Empty() */
/*************************************************************************/
3.7 Size Counters 51
Reuse Instructions • Describe how the program is used. Provide the declaration
format, parameter values and types, and parameter limits.
• Provide warnings of illegal values, overflow conditions, or other
conditions that could potentially result in improper operation.
Reuse Example /*************************************************************************/
/* Reuse Instructions */
/* int PrintLine(char *line_of_character) */
/* Purpose: to print string, ‘line_of_character’, on one print line */
/* Limitations: the maximum line length is LINE_LENGTH */
/* Return: 0 if printer not ready to print, else 1 */
/*************************************************************************/
Identifiers Use descriptive names for all variables, function names,
constants, and other identifiers. Avoid abbreviations or single
letter variables.
Identifier Example int number_of_students; /* This is GOOD */
float x4, j, ftave; /* These are BAD */
Comments • Document the code so that the reader can understand its
operation.
• Comments should explain both the purpose and behavior of the
code.
• Comment variable declarations to indicate their purpose.
Good Comment If (record_count > limit) /* have all the records been processed? */
Bad Comment if(record_count > limit) /* check if record_count is greater than limit */
Major Sections Precede major program sections by a block comment that
describes the processing that is done in the next section.
Example /*************************************************************************/
/* This program section will examine the contents of the array */
/* “grades” and will calculate the average grade for the class. */
/*************************************************************************/
Blank Spaces • Write programs with sufficient spacing so that they

Kết quả (Việt) 2:

3.6 Tính Năng suất
Năng suất thường được đo bằng giờ lao động cần thiết để làm một đơn vị làm việc.
Đó là một khái niệm đơn giản như vậy mà người ta có xu hướng nghĩ về năng suất như đơn giản
tính toán. Mặc dù tính toán là đơn giản, bằng cách sử dụng dữ liệu đúng và đúng cách
diễn giải các dữ liệu không phải là dễ dàng như vậy. Tính toán năng suất đúng đắn cần phải xem xét, ví dụ, các điều kiện riêng của từng công việc và chất lượng của sản phẩm tạo ra. Nếu bạn ước tính kích thước của một công việc mới và sau đó sử dụng một số toàn cầu
yếu tố năng suất để xác định tổng số giờ cần thiết, bạn sẽ thường nhận được một
kết quả sai lệch. Nó sẽ tương tự để luôn luôn cho phép các trung bình
thời gian lái xe khi bạn đi đến sân bay. Với phương pháp này, bạn sẽ bỏ lỡ rất nhiều
chuyến bay giờ cao điểm xung quanh và làm rất nhiều chờ đợi phần còn lại của thời gian.
Khi tính toán năng suất, phân chia kích thước của sản phẩm được sản xuất bởi những
giờ làm việc sản xuất nó. Điều này tạo cho khối lượng của sản phẩm được sản xuất mỗi giờ. Đối với
chương trình, ví dụ, nếu bạn phát triển một chương trình 600-LOC trong 60 giờ,
năng suất của bạn sẽ là 10 LOC mỗi giờ. Mặc dù điều này có vẻ đơn giản
đủ, bạn phải đối mặt với nhiều sự lựa chọn để có thể chọn kích thước và giờ các biện pháp này. Ví
dụ, kết hợp khác nhau của các con số được sử dụng trong kế toán LỘC
ví dụ ở bảng 3.2 (xem tr. 44) được thể hiện trong Bảng 3.3. Có một số cơ sở cho
3.6 Tính Năng suất 47
lập luận rằng bất kỳ một trong sáu con số nên được sử dụng để đo lường sự phát triển
năng suất. Giả sử rằng bạn đã dành tổng cộng 60 giờ phát triển chương trình này,
các tùy chọn khác nhau năng suất có thể khác nhau bởi các yếu tố của hai hoặc nhiều lần. Điều này
biến thể được gây ra chỉ bởi sự lựa chọn của bạn cho việc sử dụng các biện pháp kích thước. Đó
là lý do tại sao so sánh các con số về năng suất giữa các tổ chức hay thậm chí
giữa các cá nhân hiếm khi được dùng và tại sao mỗi nhà phát triển phải lựa chọn của mình hoặc
phương pháp riêng của mình và sử dụng nó một cách nhất quán.
Đối với hầu hết các dự án nâng cao mới hay lớn, thêm cộng với sản phẩm biến đổi là
lẽ là thích hợp nhất cho việc tính toán năng suất. Để sửa đổi nhỏ
cho các chương trình lớn, tuy nhiên, vấn đề là phức tạp hơn nhiều. Lý do là
năng suất cho sửa đổi phần mềm thường thấp hơn nhiều so với sự phát triển mới (Flaherty 1985). Bằng cách thu thập dữ liệu về thời gian, kích thước của các
thay đổi, kích thước của các chương trình cơ sở, và các phần của chương trình cơ sở sửa đổi, bạn sẽ có thể tìm thấy rằng những thay đổi nhỏ trong các chương trình lớn càng mất nhiều
thời gian hơn, hoặc phát triển mới hoặc lớn sửa đổi -percentage của hiện
chương trình. Nghiên cứu dữ liệu của riêng bạn và xem những gì các loại cung cấp cho các mối tương quan tốt nhất với nỗ lực phát triển. Một lần nữa, các phương pháp thảo luận trong cuốn sách này sẽ giúp
bạn để đi đến con số suất thích hợp.
3.7 Kích đếm
Mặc dù nó là tương đối dễ dàng để đếm các kích thước của chương trình nhỏ, tay đếm ngay cả các chương trình nhỏ có thể tốn nhiều thời gian và dễ bị lỗi. Đối với các chương trình lớn, tuy nhiên, dẫn đếm là không thực tế, làm cho kích thước bộ đếm tự động
thiết yếu.
Bộ đếm có thể được thiết kế để đếm số lượng của hầu hết các yếu tố sản phẩm
miễn là định nghĩa cho phần tử đó là chính xác và cụ thể. Ví dụ, một
48 Chương 3 Đo Phần mềm Kích thước
BẢNG 3.3 BIẾN TRÊN LỘC SUẤT
Kích Năng suất
Năng suất Lựa chọn LỘC LỘC / Hour
gia tăng (350 + 100 + 50) 500 8.33
Added + Được thay đổi (500 + 100) 600 10.00
Added + Được thay đổi + Deleted ( 600 + 200) 800 13.33
Added + Được thay đổi + tái sử dụng (600 + 600) 1200 20.00
Added + Được thay đổi + Deleted + tái sử dụng (1.200 + 200) 1400 23.33
Tổng số sản phẩm hoàn thành 900 15.00
LỘC counter có thể đếm dòng vật lý hoặc đường hợp lý. Mặc dù tự động
đếm các yếu tố cơ sở dữ liệu có thể phức tạp hơn một chút, nếu mô hình đối tượng là
có thể truy cập, bạn có thể thường đếm bộ được lựa chọn của các yếu tố cơ sở dữ liệu.
LOC Physical Quầy bán hàng
Loại đơn giản nhất của kích thước counter đếm LỘC vật lý. Ở đây, bạn đếm tất cả các văn bản
dòng ngoại trừ ý kiến và dòng trống. Một dòng văn bản mà có cả ý kiến và
mã nguồn được tính là một LỘC.
Counters LỘC Logical
quầy LỘC Logical hoạt động giống như bộ đếm vật lý ngoại trừ dòng-counter
bước phức tạp hơn. Object của tôi Pascal đường hợp lý truy cập có 939 LOC
và đã cho tôi khoảng 50 giờ để phát triển. Đừng cố gắng để phát triển một dòng truy cập hợp
lý, trừ khi bạn có nhiều thời gian để làm điều đó. Mặc dù mọi người không ngừng có thể tranh luận những
cách tốt nhất để đếm LOC, các chi tiết không quan trọng lắm. Điều quan trọng là để được chính xác
và nhất quán. Trong Object Pascal của tôi và các chương trình C ++, tôi đếm từng logic
tuyên bố chương trình. Mặc dù một số có thể lập luận rằng tính bắt đầu và báo cáo cuối cùng không phải là một ý tưởng tốt, đây là một vấn đề sở thích cá nhân. Nếu bạn có thể hiển thị,
tuy nhiên, thời gian cần thiết để phát triển một chương trình đã có một mối tương quan cao với
LOC khi bắt đầu-kết thúc cặp đã được tính hơn khi chúng không được, đó sẽ là
một lý do tốt để sử dụng chúng. Đây cũng sẽ là cách thích hợp để giải quyết gần như
bất kỳ câu hỏi kích thước đếm.
Hiện nay, không có bằng chứng thuyết phục để hỗ trợ bất kỳ một đếm
phương pháp trên bất kỳ khác. Với dữ liệu tốt, tuy nhiên, một nghiên cứu của các lựa chọn thay thế khác nhau có thể nhanh chóng hiển thị, nếu có, sẽ là tốt nhất cho công việc của bạn. Nó có thể hiển thị,
như là có khả năng, có nhiều cách tiếp cận khác nhau tạo ra kết quả tương đương.
Trong trường hợp đó, việc lựa chọn là tùy ý. Thực tế là nó là tùy ý, tuy nhiên,
không có nghĩa là tất cả mọi người nên làm điều đó một cách khác nhau. Nếu tất cả các dự án trong một tổ chức sử dụng các tiêu chuẩn đếm cùng, họ có thể đủ khả năng để phát triển một cải chất lượng cao tự động truy cập duy nhất cho tất cả mọi người sử dụng. Họ cũng sẽ có một nhiều
khối lượng lớn dữ liệu để sử dụng trong việc lập kế hoạch và phân tích chất lượng.
Đếm Chương trình Elements
Nó là thường mong muốn để đo các kích thước của các bộ phận khác nhau của các chương trình lớn. Ví
dụ, nếu bạn có ý định để tái sử dụng một số các lớp học hoặc các thủ tục mới được phát triển,
bạn có muốn biết làm thế nào lớn mỗi một. Như bạn sẽ thấy trong Chương 5, chẳng hạn
tính cũng có thể giúp đỡ với kích thước dự toán.
3.7 Kích Quầy bán hàng 49
Để duy trì tính riêng cho từng lớp hoặc thủ tục, bạn phải xác định
một số nơi từng bắt đầu và kết thúc. Bởi vì cách để làm điều này phụ thuộc vào ngôn ngữ lập trình, không có hướng dẫn chung. Quầy tôi đã xây dựng cho Object
Pascal nhận các thủ tục từ khóa, chức năng, xây dựng, và destructor là sự khởi đầu của thủ tục. Tôi tìm thấy các thiết bị đầu cuối bằng cách đếm bắt đầu-kết thúc
cặp. Với một nghiên cứu nhỏ, bạn có thể xác định các chỉ số cho sự khởi đầu và
kết thúc điểm của các phương pháp, thủ tục, các lớp học, chức năng, hoặc các yếu tố khác cho
ngôn ngữ bạn sử dụng. Sau đó bạn có thể sử dụng định nghĩa này để quét các văn bản chương trình và
bắt đầu và ngừng kích thước truy cập tại các điểm thích hợp.
Sử dụng Coding tiêu chuẩn và LOC Physical Counters
Một cách đơn giản để đếm LỘC logic được sử dụng một tiêu chuẩn mã hóa và đếm LỘC vật lý, bỏ qua ý kiến và khoảng trống. Ý tưởng là để viết mã nguồn với
một dòng văn bản vật lý riêng biệt cho mỗi dòng đếm được. Sau đó, khi bạn đếm dòng vật lý, bạn cũng đếm dòng logic. Để sử dụng phương pháp này, bạn phải cẩn thận tuân theo một tiêu chuẩn mã hóa như các ví dụ thể hiện trong Bảng 3.4. Nếu, vào cùng
50 Chương 3 Phần mềm Kích thước đo
BẢNG 3.4 VÍ DỤ C ++ MÃ HÓA TIÊU CHUẨN
Mục đích: Hướng dẫn sự phát triển của chương trình C
++. Headers Chương trình bắt đầu tất cả các chương trình với một tiêu đề mô tả
tiêu đề Format / *********** ************************************************** ************ /
/ * Chương trình Chuyển nhượng: số chương trình * /
/ * Tên: Tên của bạn * /
/ * Ngày: sự phát triển chương trình ngày bắt đầu * /
/ * Mô tả: Mô tả ngắn chương trình * /
/ * chức năng * /
/ **************************************** ********************************* /
Bảng liệt kê Nội dung Cung cấp một bản tóm tắt các nội dung niêm yết.
Nội dung Ví dụ / *** ************************************************** ******************** /
/ * Bảng liệt kê Nội dung: * /
/ * Tái sử dụng hướng dẫn * /
/ * Sửa đổi hướng dẫn * /
hướng dẫn / * Compilation * /
/ * Bao gồm * /
/ * khai báo Class: * /
/ * CData * /
/ * Aset * /
code / * Source trong c: CData.cpp lớp: * /
/ * CData * /
/ * CData () * /
/ * Empty ( ) * /
/ ********************************************** *************************** /
3.7 Kích Quầy bán hàng 51
Hướng dẫn sử dụng lại • Mô tả cách thức các chương trình đang sử dụng. Cung cấp tờ khai
dạng, giá trị tham số và các loại, và giới hạn các thông số.
• Cung cấp các cảnh báo của các giá trị bất hợp pháp, điều kiện tràn, hoặc khác
điều kiện có tiềm năng có thể dẫn đến hoạt động không đúng.
Tái sử dụng Ví dụ / ************ ************************************************** *********** /
/ * Hướng dẫn sử dụng lại * /
/ * int PrintLine (char * line_of_character) * /
/ * Mục đích: để in chuỗi, 'line_of_character', trên một dòng in * /
/ * Hạn chế : chiều dài dòng tối đa là LINE_LENGTH * /
/ * Trở về: 0 nếu máy in không sẵn sàng để in, khác 1 * /
/ ************************ ************************************************* /
định danh Sử dụng tên mô tả cho tất cả các biến, tên chức năng,
các hằng số, và các định dạng khác. Tránh viết tắt hay đơn
biến thư.
Nhận dạng Ví dụ int number_of_students; / * Đây là TỐT * /
float x4, j, ftave; / * Đây là BAD * /
Nhận xét ​​• Tài liệu mã để người đọc có thể hiểu được nó
hoạt động.
• Comments nên giải thích cả hai mục đích và hành vi của các
mã.
• Thảo luận các khai báo biến để chỉ mục đích của họ.
Tốt Comment Nếu (record_count> giới hạn ) / * có tất cả các hồ sơ được xử lý? * /
Bad Comment if (record_count> giới hạn) / * kiểm tra nếu record_count là lớn hơn giới hạn * /
Phần lớn trước các phần chương trình chính của một bình luận rằng khối
mô tả việc xử lý được thực hiện trong phần tiếp theo.
Ví dụ / ***** ************************************************** ****************** /
/ * phần chương trình này sẽ kiểm tra các nội dung của mảng * /
/ * "lớp" và sẽ tính điểm trung bình cho các lớp học. * /
/ *********************************************** ************************** /
Trống Spaces • Các chương trình Write có đủ khoảng cách để họ