Software metrics are measurements o

Software metrics are measurements of aspects of your software development process. Measurement is vital to this process - without measurement you cannot understand its faults, see whether improvement can be made or know whether any changes that you have made have caused that improvement to occur. You can measure a number of different aspects for any given software project -

The amount of time that it takes you to develop
The amount of software developed
The time spent maintaining your software
The number of faults
The inherent quality of your software
We are going to concentrate on the last entry on that list - the inherent quality of your software. Apart from the amount of software developed this the only item in the list that can be assessed in an objective way from the code. The process of taking code and analysing it is called 'static analysis'. A number of metrics have been developed over the years that can give you a view of aspects of your software. The problem is that there are quite a lot of them - many of them either fully or partially duplicate others, others have the same name but may be calculated in a number of different ways, some contradict others and most of them are poorly understood by those who use them.There is a wide variety of information about these various metrics but it tends to be widely scattered and in some cases conflicting. This document aims to draw these strands together to allow you to make sensible decisions based on the results of analysis of your code by tools such as JHawk. A list of further reading is supplied at the end of this document for those who wish to learn more. Later we will try to give an overview of the most common of these metrics but first we want to look at what most of us want to achieve with metrics.

After a bit of experience in a particular language we can tell good code from bad. We can run our eyes over a piece of code and suggest improvements. But like many subjective intellectual human activities it is difficult to teach a machine to do this successfully. Look at the two samples of code below -

public static double zzz(double x, double z) {
z+=(z*x/100);
return z;
}
public static double addInterestToBalance(double interestRate, double balance) {
/* Add interest to balance */
balance+=(balance*interestRate/100);
return balance;
}
Most competent Java programmers will accept that the second example, while functionally identical to the first, is a far better piece of code. The question is - why do you think it's better? One thing is that the second piece of code is easier to read and appears to tell you what it is doing - ie. the second piece has meaningful comments and meaningful identifiers. At least you might think so - but what if you found this line in a class called ManageHeartRate -

if (heartRate < 70) stimulantDose = MedicalUtilities.addInterestToBalance(10,stimulantDose);

Does the code still make sense here? Is it the calling code that is wrong or should the method be changed to take account of the circumstances in which it is found? So a lot of the things that we view as 'good' in a piece of code are contextual. This means that we are going to be limited in what we can sensibly analyse using software.

Lets say we were to perform an anlysis of the pieces of code above - one of the things we might choose to count could be the number of comments. We would then see that there no comments in the first piece of code. However we could add a comment - say "/*HGHGHJGHJGJGHJGJGHJGJHGHJGJGJGJGJHG*/" - that would add nothing to our understanding of the code. Similarly we could measure the length of the variable names - but I could change X to XDGSADGFDS and while it would be longer it would still be meaningless.The trouble is that we can't easily tell a machine how to make the kinds of distinctions that we can make in just a single glance.

So, having seen that some things are not easy to measure objectively, what are the kinds of things that we can usefully measure by taking a piece of code, breaking it down into its constituent parts and measuring the numbers of these parts and some of their aspects? We'll take a look at the measurements that we can take at Method, Class, Package and System level. We define the System level as all of the code in the project that you choose to examine as a collective entity - i.e. if you were using JHawk it would be all the files or Eclipse projects that you selected for analysis.

ผลลัพธ์ (ไทย) 1:

ซอฟต์แวร์การวัดจะวัดด้านการพัฒนาซอฟต์แวร์ วัดมีความสำคัญต่อกระบวนการนี้ - โดยประเมิน คุณไม่เข้าใจความบกพร่อง เห็นว่า ปรับปรุงได้ หรือรู้ว่า การเปลี่ยนแปลงใด ๆ ที่คุณทำได้เกิดการปรับปรุงที่เกิดขึ้น คุณสามารถวัดจำนวนด้านต่าง ๆ สำหรับโครงการใด ๆ ซอฟต์แวร์กำหนด-ระยะเวลาที่จะพัฒนาจำนวนซอฟต์แวร์ที่พัฒนาขึ้นเวลาที่ใช้ในการรักษาซอฟต์แวร์ของคุณจำนวนข้อบกพร่องคุณภาพโดยธรรมชาติของซอฟต์แวร์ของคุณเราจะเน้นรายการสุดท้ายในรายการ - คุณภาพโดยธรรมชาติของซอฟต์แวร์ของคุณ จากจำนวนซอฟต์แวร์พัฒนานี้เพียงรายการในรายการที่สามารถประเมินในทางวัตถุประสงค์จากรหัส การใช้รหัส และวิเคราะห์มันเรียกว่า 'คงวิเคราะห์' จำนวนวัดได้รับการพัฒนาปีที่สามารถให้มุมมองด้านของซอฟต์แวร์ของคุณ ปัญหาคือ ว่า มีค่อนข้างมากของพวกเขา - มากของพวกเขาทั้งหมด หรือบางส่วนซ้ำคนอื่น คนอื่นมีชื่อเดียวกัน แต่อาจคำนวณจำนวนวิธีที่แตกต่าง บางอย่างขัดแย้งกับผู้อื่น และส่วนใหญ่จะมีความเข้าใจผู้ใช้งานมีความหลากหลายของข้อมูลเกี่ยวกับวัดต่าง ๆ เหล่านี้ แต่ก็มีแนวโน้มจะกระจายอยู่อย่างกว้างขวางและ ในบางกรณีที่ขัดแย้งกัน เอกสารนี้มีวัตถุประสงค์เพื่อวาด strands เหล่านี้เข้าด้วยกันเพื่อช่วยให้คุณตัดสินใจที่เหมาะสมตามผลการวิเคราะห์ของรหัสของคุณ ด้วยเครื่องมือเช่น JHawk ต่าง ๆ อ่านเพิ่มเติม มาที่ท้ายเอกสารนี้สำหรับผู้ที่ต้องการเรียนรู้เพิ่มเติม ต่อไปเราจะพยายามให้ภาพรวมของบ่อยที่สุดของวัดนี้แต่ก่อนที่เราต้องดูอะไรมากที่สุดของเราต้อง มีการวัดหลังจากที่บิตของประสบการณ์เฉพาะภาษา เราสามารถบอกรหัสดีจากเลว เราสามารถทับตาชิ้นส่วนของรหัส และแนะนำปรับปรุง แต่เช่นกิจกรรมมากมายตามอัตวิสัยปัญญามนุษย์ ก็ยากที่จะสอนเครื่องไม่สำเร็จ ดูตัวอย่างที่สองของรหัสด้านล่าง-{สาธารณะคงคู่ zzz (คู่ x, z คู่) z += (z * x/100); กลับ z}สาธารณะคงคู่ addInterestToBalance (สองคู่ interestRate ดุล) { / * เพิ่มดอกเบี้ยดุล * / ดุล+= (ดุล * interestRate/100); คืนสมดุล}โปรแกรมเมอร์จาวามีอำนาจมากที่สุดจะยอมรับว่า ตัวอย่างที่สอง ในขณะที่ฟังก์ชันเหมือนกับครั้งแรก เป็นดีรหัส คำถามคือ - ทำไมคุณคิดว่า มันดีกว่า สิ่งหนึ่งคือ ชิ้นที่สองของรหัสในการอ่าน และดูเหมือนจะ บอกว่า ทำอะไรอยู่ - ie ชิ้นที่สองมีความเห็นความหมายและตัวบ่งชี้มีความหมาย ที่ คุณอาจคิดอย่างนั้น - แต่ถ้าคุณพบบรรทัดนี้ในชั้นเรียนเรียกว่า ManageHeartRate- ถ้า (heartRate < 70) stimulantDose = MedicalUtilities.addInterestToBalance(10,stimulantDose) รหัสไม่ยังคงเหมาะสมที่นี่ มันเป็นรหัสการเรียกที่ไม่ถูกต้อง หรือควรวิธีการเปลี่ยนไปใช้บัญชีของสถานการณ์ที่จะพบหรือไม่ ดัง มากในสิ่งที่เรามองเป็น 'ดี' ในรหัส มีบริบท หมายความ ว่า เรากำลังจะถูกจำกัดในสิ่งที่เราสามารถเลยใช้ซอฟต์แวร์วิเคราะห์กล่าวว่าเราได้ทำการ anlysis ชิ้นรหัสข้างต้น - หนึ่งในสิ่งที่เราอาจเลือกที่จะนับให้สามารถจำนวนความคิดเห็น เราจะดูว่าไม่มีความเห็นในชิ้นแรกของรหัส อย่างไรก็ตาม เราสามารถเพิ่มข้อคิดเห็น - พูด " / * HGHGHJGHJGJGHJGJGHJGJHGHJGJGJGJGJHG * / " -ที่จะเพิ่มอะไรให้เราเข้าใจรหัสได้ ในทำนองเดียวกัน เราสามารถวัดความยาวของชื่อตัวแปร - แต่ฉันไม่สามารถเปลี่ยน X XDGSADGFDS และในขณะที่มันจะยาว มันยังจะออกปัญหาคือ ว่า เราไม่ได้บอกเครื่องวิธีการสร้างชนิดของความที่เราสามารถทำได้ในเพียงคร่าว ๆ เดี่ยวดังนั้น มีเห็นสิ่งไม่ง่ายต่อการวัดเป็นรูปธรรรม บ้างชนิดของสิ่งที่เรา usefully สามารถวัด โดยใช้ชิ้นส่วนของรหัส แบ่งมันออกเป็นส่วนของส่วนประกอบต่าง ๆ ของวัดหมายเลขชิ้นส่วนเหล่านี้และบางด้านของพวกเขา เราจะทำวัดที่เราสามารถนำวิธี คลาส แพคเกจ และระบบระดับ เรากำหนดระดับระบบเป็นรหัสโครงการที่คุณต้องการตรวจสอบเป็นเอนทิตีรวมทั้งหมด - เช่นถ้าคุณใช้ JHawk มันจะแฟ้มหรือโครงการอุปราคาที่คุณเลือกสำหรับการวิเคราะห์

ผลลัพธ์ (ไทย) 3:

ตัวชี้วัดในด้านของซอฟต์แวร์การวัดกระบวนการพัฒนาซอฟต์แวร์ของคุณ วัด มีความสําคัญต่อกระบวนการนี้ โดยไม่มีการวัดที่คุณไม่สามารถเข้าใจมันผิด เห็นว่า การปรับปรุงสามารถทำได้ หรือ ทราบว่า การเปลี่ยนแปลงใด ๆที่คุณได้ทำที่ทำให้การพัฒนาเกิดขึ้น คุณสามารถวัดจำนวนของแง่มุมที่แตกต่างกันใด ๆ -

โครงการซอฟต์แวร์ปริมาณของเวลาที่ใช้ในการพัฒนาซอฟต์แวร์ที่พัฒนา

จำนวนเวลาที่ใช้รักษาซอฟต์แวร์ของคุณ

จำนวนข้อบกพร่องโดยธรรมชาติคุณภาพ
ซอฟต์แวร์ของคุณ เราจะมีสมาธิในรายการสุดท้ายในรายการ - คุณภาพที่แท้จริงของซอฟต์แวร์ของคุณนอกเหนือจากจำนวนของซอฟต์แวร์ที่พัฒนาขึ้นนี้รายการเฉพาะในรายการที่สามารถประเมินในวัตถุประสงค์ทางจากรหัส กระบวนการของการรหัสและวิเคราะห์เรียกว่า ' สถิตการวิเคราะห์ ' จำนวนวัดที่ได้รับการพัฒนามากกว่าปีที่ผ่านมา ที่สามารถให้คุณมีมุมมองในด้านของซอฟต์แวร์ของคุณปัญหาคือว่ามีค่อนข้างมากของพวกเขา -- มากของพวกเขาให้ทั้งหมด หรือบางส่วนซ้ำกับคนอื่น ๆที่มีชื่อเดียวกันแต่อาจจะคำนวณในหลายวิธีที่แตกต่างกันบางขัดแย้งกับผู้อื่น และส่วนใหญ่ของพวกเขาจะไม่ค่อยเข้าใจ โดยผู้ที่ใช้พวกเขามีความหลากหลายของข้อมูลเกี่ยวกับวัดต่าง ๆ เหล่านี้ แต่ก็มีแนวโน้มที่จะมีฝนฟ้าคะนองเป็นแห่งๆ และในบางกรณีที่ขัดแย้งกัน เอกสารนี้มีวัตถุประสงค์เพื่อวาดเส้นเหล่านี้เข้าด้วยกันเพื่อให้คุณสามารถทำให้การตัดสินใจที่เหมาะสมขึ้นอยู่กับผลลัพธ์ของการวิเคราะห์ของรหัสของคุณด้วยเครื่องมือเช่น jhawk . รายชื่อหนังสืออ่านเพิ่มเติมให้ที่ส่วนท้ายของเอกสารนี้สำหรับผู้ที่ต้องการเรียนรู้เพิ่มเติมต่อมาเราก็พยายามที่จะให้ภาพรวมของที่พบมากที่สุดของตัวชี้วัดเหล่านี้ แต่ก่อนที่เราต้องการดูว่าส่วนใหญ่ของเราต้องการที่จะบรรลุกับวัด

หลังจากที่บิตของประสบการณ์ในภาษาหนึ่ง เราสามารถบอกรหัสที่ดีจากที่ไม่ดี เราสามารถเรียกใช้ดวงตาของเราผ่านชิ้นส่วนของรหัส และเสนอแนะการปรับปรุงแต่ชอบหลายกลุ่มกิจกรรมทางปัญญาของมนุษย์เป็นเรื่องยากที่จะสอนให้เครื่องจักรนี้ เรียบร้อยแล้ว ดู 2 ตัวอย่างของรหัสด้านล่าง -

สาธารณะสถิตคู่ ( Double X ดับเบิ้ล Zzz Z ) {
Z = ( Z * x / 100 ) ;
ผลตอบแทน z ;
}
สาธารณะสถิตคู่ ( คู่ addinteresttobalance ดำเนินสมดุลคู่ ) {
/ * * /
เพิ่มความสนใจให้สมดุล สมดุล = ( สมดุล * ดำเนิน / 100 ) ;

ยอดกลับไป}
เชี่ยวชาญมากที่สุด Java โปรแกรมเมอร์จะยอมรับว่า 2 ตัวอย่าง ขณะที่การทำงานเหมือนครั้งแรก เป็นชิ้นที่ดีของรหัส คำถามคือทำไมคุณคิดว่ามันจะดีกว่า ? สิ่งหนึ่งคือว่า ชิ้นที่สองของรหัสที่ง่ายต่อการอ่าน และจะปรากฏขึ้นที่จะบอกคุณในสิ่งที่มันทำ คือ ชิ้นที่สองมีความเห็นที่มีความหมายและระบุความหมายอย่างน้อยคุณอาจจะคิดอย่างนั้น แต่ถ้าคุณพบว่าบรรทัดนี้ในระดับที่เรียกว่า manageheartrate -

ถ้า ( หัวใจ < 70 ) stimulantdose = medicalutilities . addinteresttobalance ( 10 , stimulantdose ) ;

ไม่รหัส ยังให้ความรู้สึกที่นี่ มันเรียกรหัสที่ไม่ถูกต้อง หรือ ควรวิธีถูกเปลี่ยนไปใช้บัญชีของสถานการณ์ที่พบ ?ดังนั้นมากของสิ่งที่เราดูเป็น ' ดี ' ในชิ้นส่วนของรหัสเป็นบริบท นี่หมายความว่า เรากำลังจะถูก จำกัด ในสิ่งที่เราได้เป็นตุเป็นตะ วิเคราะห์โดยใช้ซอฟต์แวร์ .

ช่วยบอกเราได้แสดงการวิเคราะห์ชิ้นส่วนของรหัสข้างต้น - สิ่งหนึ่งที่เราอาจเลือกที่จะนับได้จำนวนของความคิดเห็น เราก็จะพบว่า ไม่มีความคิดเห็นในชิ้นแรกของรหัสอย่างไรก็ตามเราสามารถเพิ่มความคิดเห็น - พูดว่า " / * * / hghghjghjgjghjgjghjgjhghjgjgjgjgjhg " ซึ่งจะเพิ่มอะไรเพื่อความเข้าใจของเรารหัส ในทำนองเดียวกัน เราสามารถวัดความยาวของตัวแปรชื่อ - แต่ฉันสามารถเปลี่ยน X เพื่อ xdgsadgfds และในขณะที่มันอาจจะยาว มันก็จะไม่มีความหมายปัญหาคือ เราไม่สามารถบอกได้อย่างง่ายดายเครื่องวิธีการสร้างชนิดของความแตกต่างที่เราสามารถทำได้ในเพียงเดียวรวดเร็ว

ดังนั้น เมื่อเห็นว่าบางเรื่องไม่ได้ง่ายในการวัดวัตถุ , สิ่งที่ชนิดของสิ่งที่เราสามารถเป็นประโยชน์วัดโดยการใช้ชิ้นส่วนของรหัสทำลายมันลงในส่วนขององค์ประกอบและการวัดตัวเลขของชิ้นส่วนเหล่านี้และบางส่วนของด้านของพวกเขาเราจะดูที่วิธีการที่เราสามารถใช้ในการวัดระดับ , แพคเกจและระดับระบบ เรากำหนดระดับระบบทั้งหมดของรหัสในโครงการที่คุณเลือกที่จะตรวจสอบว่ามีกลุ่มองค์กร - เช่นถ้าคุณใช้ jhawk มันจะเป็นไฟล์ทั้งหมดหรือคราสโครงการที่คุณเลือกสำหรับการวิเคราะห์