ในฐานข้อมูลดั้งเดิมฉันจะทราบได้อย่างรวดเร็วว่ามีการใช้อะไรและสิ่งใดไม่ได้

ฉันได้รับการขอให้ประเมินสิ่งที่ดูเหมือนว่าเป็นรหัสฐานแบบดั้งเดิมที่มีความสำคัญในฐานะที่เป็นสารตั้งต้นในการทำสัญญาในการรักษารหัสฐานนั้น

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

โครงสร้างเว็บไซต์ตามที่เห็นจากภายในสู่ภายนอกเป็นสิ่งที่ไม่เป็นระเบียบ มีโฟลเดอร์ที่ต่อท้าย "_OLD" และ "_DELETE" วางอยู่ทั่วทุกที่ หลาย ๆ โฟลเดอร์ปรากฏว่าไม่มีจุดประสงค์หรือมีชื่อที่คลุมเครือมาก อาจมีสคริปต์เก่าและไม่ได้ใช้งานจำนวนหนึ่งวางอยู่แม้ในโฟลเดอร์ที่ถูกกฎหมาย ไม่เพียงแค่นั้น แต่ยังมีหลายส่วนของรหัสที่หมดอายุอย่างไม่ต้องสงสัยแม้ในสคริปต์การดำเนินการเป็นอย่างอื่น (ข้อกังวลเร่งด่วนน้อยกว่า)

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

วิธีเดียวที่จะนึกถึงการเข้าไปใน codebase คือการเริ่มต้นที่รูทของไซต์และอย่างช้า ๆ แต่ต้องไปตามสคริปต์ที่เชื่อมโยง ... และมีแนวโน้มที่จะใช้งานหลายร้อยครั้งและอีกหลายร้อยที่ไม่ใช่ เนื่องจากส่วนใหญ่ของเว็บไซต์อยู่ใน Flash นี่เป็นเรื่องที่ไม่ซับซ้อนเพราะโดยเฉพาะอย่างยิ่งในแอปพลิเคชัน Flash รุ่นเก่าลิงก์ไปยังสคริปต์อื่น ๆ อาจถูกฝังในไบนารี (.FLAs) มากกว่าในไฟล์ข้อความ (.AS / ActionScript)

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

เนื่องจากสิ่งที่คุณถูกขอให้ทำคือให้ข้อมูลสำหรับลูกค้าของคุณในการเขียนข้อเสนอที่เหมาะสมไปยังไคลเอนต์อื่น (เจ้าของรหัสฝันร้าย) สำหรับการทำงานกับรหัสนั้นฉันจะออกไปข้างนอก แขนขาและบอกว่าคุณจะไม่ทำการทดสอบหรือปรับโครงสร้างใหม่หรืออะไรก็ตามในบรรทัดเหล่านั้น ณ จุดนี้ คุณอาจมีเวลาสั้นมากในการประเมินคร่าวๆ คำตอบของฉันขึ้นอยู่กับประสบการณ์ของฉันในสถานการณ์เดียวกันดังนั้นหากการตีความของฉันไม่ถูกต้องเพียงแค่ละเว้นทุกสิ่งที่ตามมา

• ใช้เครื่องมือสไปเดอร์เพื่อรับทราบว่ามีหน้าอะไรบ้างและมีอะไรเข้ามาบ้าง แม้แต่เครื่องมือ linkchecker พื้นฐาน - ไม่ใช่เครื่องมือ "สไปเดอร์เพื่อวัตถุประสงค์ในการตรวจสอบ" โดยเฉพาะ - จะมีประโยชน์ในเรื่องนี้
• ทำสเปรดชีตการตรวจสอบ / สินค้าคงคลังขั้นพื้นฐาน นี่อาจเป็นเรื่องง่ายเพียงแค่รายการไฟล์และเวลาที่แก้ไขครั้งล่าสุดจัดเรียงโดยไดเรกทอรี สิ่งนี้จะช่วยให้คุณเข้าใจขอบเขตและเมื่อคุณไปยังไดเรกทอรีเช่น _OLD และ _DELETE คุณสามารถจดบันทึกขนาดใหญ่ได้ว่าก) การประเมินของคุณขึ้นอยู่กับสิ่งที่ไม่ได้อยู่ในไดเรกทอรีเหล่านั้น b) การมีอยู่ของไดเรกทอรีเหล่านั้นและศักยภาพสำหรับ cruft / ฝันร้ายซ่อนพิสูจน์ถึงปัญหาลึกที่ควรนำมาใช้ในการเสนอราคาของลูกค้าของคุณในทางใดทางหนึ่ง คุณไม่ต้องใช้เวลาหนึ่งพันล้านปีในการแจกแจงปัญหาที่อาจเกิดขึ้นใน _OLD หรือ _DELETE ข้อมูลจะป้อนเข้าสู่การเสนอราคาในที่สุด
• เนื่องจากคุณกำลังตรวจสอบสิ่งที่ดูเหมือนแอพพลิเคชั่นบนเว็บทั้งหมดแม้แต่เครื่องมือวิเคราะห์บันทึกมาตรฐานก็จะเป็นเพื่อนของคุณ คุณจะสามารถเพิ่มลงในสเปรดชีตได้บ้าง "นี่อยู่ใน 10 อันดับแรกของสคริปต์ที่เข้าถึง" หรือบางส่วน แม้ว่าสคริปต์จะถูกฝังอยู่ในไฟล์ Flash และดังนั้นจึงไม่สามารถสไปเดอร์ได้มีความเป็นไปได้สูงที่สคริปต์เหล่านี้จะถูกเข้าถึงผ่าน POST หรือ GET และจะแสดงในบันทึกของเซิร์ฟเวอร์ หากคุณรู้ว่าคุณมีสคริปต์ที่เข้าถึงสูง 10 สคริปต์ไม่ใช่ 100 (หรือในทางกลับกัน) สิ่งนี้จะช่วยให้คุณมีความคิดที่ดีว่างานบำรุงรักษาจะเป็นอย่างไร

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

ฉันขอแนะนำให้ปรับโครงสร้างซอร์สโค้ดที่มีอยู่ใหม่ (ซึ่งต่างจากการเขียนซ้ำ) โดยใช้รูปแบบที่พบในหนังสือ " การทำงานอย่างมีประสิทธิภาพด้วยรหัสมรดก "

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

การอ่านหนังสือทำให้ฉันมีความรู้สึกที่แท้จริงว่า "เราไม่ได้อยู่คนเดียว" ... พวกเราหลายคนหรือบางทีพวกเราทุกคนกำลังทำงานกับฐานรหัสที่ซับซ้อนซึ่งยากต่อการจัดการ เทคนิคต่าง ๆ ที่ระบุไว้ในหนังสือเล่มนี้ให้ความหวังกับฉันเป็นอย่างมากและฉันสามารถนำไปประยุกต์ใช้ได้เกือบจะทันที

โพสต์บล็อกของ Joel Spolsky ทำหน้าที่ได้ดีในการอธิบายว่าทำไมมันจึงดีที่สุดที่จะรักษาฐานรหัสที่มีอยู่เดิมให้ใช้งานซึ่งต่างจากการเริ่มต้นจากศูนย์ ฉันเลือกคำพูดจากบทความที่สรุปมันขึ้นมา แต่มันเป็นการอ่านที่ยอดเยี่ยม

“ มีเหตุผลเล็กน้อยที่โปรแกรมเมอร์ต้องการทิ้งรหัสและเริ่มต้นใหม่อยู่เสมอเหตุผลก็คือพวกเขาคิดว่ารหัสเดิมนั้นเป็นระเบียบและนี่คือการสังเกตที่น่าสนใจ: พวกเขาอาจผิด รหัสเป็นระเบียบเป็นเพราะกฎสำคัญของการเขียนโปรแกรมพื้นฐาน:

การอ่านโค้ดทำได้ยากกว่าการเขียน "- http://www.joelonsoftware.com/articles/fog0000000069.html

ในฐานรหัส Java ทั่วไปฉันจะพิจารณาใช้เครื่องมือเช่น PMD, FindBugs หรือ Sonar จากนั้นฉันจะพยายามทำความเข้าใจกับการรายงานเครื่องมือ (รหัสที่ตายแล้วรหัสที่ไม่มีเอกสารรหัสที่ซ้ำกัน ฯลฯ )

ตามรายงานฉันจะพยายามค้นหาเลเยอร์ต่าง ๆ ของแอปพลิเคชั่น / ไซต์ (ชั้นธุรกิจ, DB, SQL, ฯลฯ )

หากเลเยอร์เป็นแบบคู่ (html ภายใน servlet, sql ภายในโค้ดจาวา) ฉันจะเริ่มต้นก่อนโดยการแยกแต่ละขั้นตอนเหล่านี้ควรแยกออกจากกันและคุณอาจกระทำเมื่อสิ้นสุดแต่ละส่วน (โดยเริ่มจากสาขาแล้วทำการผสาน) .

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

ฉันขอย้ำว่าความพยายามที่จำเป็นเพื่อให้ได้รหัสที่มีอยู่ในสถานะที่สามารถบำรุงรักษาได้นั้นจะเท่ากับหรือมากกว่าความพยายามที่จะเริ่มต้นใหม่ในการเขียนใหม่ ส่วนหนึ่งของการบำรุงรักษาสิ่งที่รู้ว่าเมื่อใด "เอาไปไว้ข้างหลังโรงเก็บแล้วยิง"

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

หมายเหตุ: ฉันให้ความสำคัญกับการใช้ฐานข้อมูลในขณะที่คุณถามเกี่ยวกับการใช้งานโค้ดเอง คำตอบยังคงใช้กับทั้งสองกรณีในทุกประเด็นที่ฉันกล่าวถึง

คุณได้ตอบคำถามของคุณเองในย่อหน้าสุดท้ายแล้ว: ดูว่ามีอะไรบ้างที่เข้าถึงได้ในขณะที่แอปพลิเคชันทำงานอยู่

1. คุณอาจต้องการทำโพรไฟล์ฐานข้อมูลและขอให้ผู้สร้างบันทึกการสืบค้นทั้งหมดสำหรับหนึ่งวัน มันจะให้ภาพรวมของวัตถุฐานข้อมูลที่ใช้มากที่สุด แต่จะไม่บอกสิ่งที่ไม่เคยใช้ นอกจากนี้คุณยังต้องระมัดระวังกับผลลัพธ์: ตัวอย่างเช่นตารางอาจใช้เฉพาะผ่านขั้นตอนการจัดเก็บ แต่เมื่อคุณดูการสืบค้นจาก profiler มันจะปรากฏขึ้นราวกับว่าตารางไม่ได้ใช้เลย

2. การตรวจสอบซอร์สโค้ดการค้นหาข้อความค้นหามีประโยชน์มากขึ้นและหลังจากรวบรวมแบบสอบถามทั้งหมดคุณสามารถมีความเข้าใจที่ดีเกี่ยวกับการใช้ฐานข้อมูลไม่ใช่ในแง่ของความถี่ (นี่คือที่ที่ profiler สะดวก) แต่ในแง่ของการใช้งาน / ไม่ ตารางที่ใช้ น่าเศร้าสำหรับ codebase ที่เขียนไม่ดี / ไม่ได้เก็บรักษาไว้เป็นเวลาหลายปีอาจเป็นเรื่องยากมากและเกิดข้อผิดพลาดได้ง่ายโดยเฉพาะอย่างยิ่งหากมีการสร้างคิวรีแบบไดนามิก (ลองนึกภาพวิธีที่ใน a selectใช้พารามิเตอร์เป็นชื่อตาราง อาจจะรู้ว่าค่าที่เป็นไปได้ของพารามิเตอร์คืออะไรโดยดูที่ซอร์สโค้ด?)

3. การวิเคราะห์แบบสแตติกและคอมไพเลอร์บางตัวอาจเปิดเผยโค้ดที่ตายแล้ว แต่ก็ไม่ได้ให้คำตอบที่คุณต้องการ

4. การวิเคราะห์ข้อมูลหรือเมตาดาต้าฐานข้อมูลสามารถเปิดเผยข้อมูลที่น่าสนใจ ยกตัวอย่างเช่นมันจะเป็นเรื่องง่ายที่จะยืนยันว่าตารางLogonAudit(uniqueidentifier LogonAuditId, datetime LogonEvent, ...)ไม่ได้ใช้อีกต่อไปถ้ามี 10 000 ระเบียนต่อวันสำหรับปี 2006-2009 และมีการบันทึกจากเดือนกันยายนไม่มี, 18 ^TH 2009 เช่นเดียวกับที่ไม่เป็นความจริงสำหรับ ตารางที่มีข้อมูลที่เยื้องส่วนใหญ่เป็นแบบอ่านอย่างเดียว

จุดสี่จุดเหล่านั้นร่วมกันจะทำให้คุณมีรายการของตารางที่ใช้ คนที่เหลืออยู่มีการใช้งานหรือไม่ คุณอาจทำการยืนยันและทดสอบพวกเขา แต่หากไม่มีการทดสอบการครอบคลุมหน่วยที่ดีมันอาจไม่ใช่เรื่องง่าย ทุกวิธี "ง่าย" ก็จะล้มเหลวเช่นกัน ตัวอย่างเช่นหากคุณมีproducts_delme_not_usedตารางคุณอาจยืนยันว่าตารางนั้นไม่ได้ใช้เลยและตรวจสอบ "products_delme_not_used" ในรหัสของคุณ นี่เป็นแง่ดี: ไม่ใช่เรื่องผิดปกติที่จะหาผู้สมัคร DailyWTF เช่นนี้ใน codebase เก่า:

// Warning: WTF code below. Read with caution, never reuse it, and don't trust
// the comments.

private IEnumerable<Product> GetProducts()
{
    // Get all the products.
    return this.GetEntities<Product>("PRODUCT");
}

private IEnumerable<T> GetEntities<T>(string tableName)
{
    // Everyone knows that SQL is case sensitive.
    tableName = tableName.ToLower();

    if (tableName == "user" || tableName == "product")
    {
        // Those tables were renamed recently in the database. Don't have time
        // to refactor the code to change the names everywhere.
        // TODO: refactor the code and remove this `if` block.
        tableName += "s";
    }

    if (this.IsDelme(tableName))
    {
        // We have some tables which are marked for deletion but are still
        // used, so we adjust their name.
        tableName = this.Delme(tableName);
    }

    return this.DoSelectQuery<T>("select top 200 * from " + tableName);
}

private bool IsDelme(string name)
{
    // Find if the table is among candidates for removal.
    List<string> names = this.Query<string>("select Names from DelmeTables");
    return names.Contains(name);
}

private string Delme(string name)
{
    // Return the new name for a table renamed for deletion.
    return string.Join("_", new [] { name, "delme", "not", "used" });
}

คุณพอจะเข้าใจได้ไหมว่ารหัสนี้ใช้products_delme_not_usedตารางจริงหรือ

ถ้าฉันเป็นคุณฉันจะ:

1. เก็บวัตถุฐานข้อมูลทั้งหมดไว้
2. ปรับแอปพลิเคชันทั้งหมดใหม่อีกครั้ง (หากคุ้มค่า)
3. จัดทำเอกสาร (ในขณะที่ refactoring) แอปพลิเคชันและโดยเฉพาะการใช้ฐานข้อมูล

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

ฟังดูคุณจำเป็นต้องได้รับข้อมูลมากพอสำหรับการสร้างคำพูดดังนั้นฉันจะให้ความสำคัญกับความพยายามนั้น

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

ใช่มันเป็นความจริงที่บางครั้งรหัสไม่ได้ใช้อีกต่อไปและมันจะทำให้แอปพลิเคชันดูใหญ่กว่าที่เป็นจริงเล็กน้อย แต่ฉันไม่คิดว่านี่จะส่งผลกระทบต่อตัวเลขมากกว่า 20% เป็นอย่างมาก ดังนั้นฉันจะไม่กังวลเกี่ยวกับส่วนนั้น

การดูซอร์สโค้ดเว็บเพจและตารางฐานข้อมูลควรช่วยให้คุณค้นพบสิ่งนี้

คุณอาจต้องการพิจารณา จำกัด จำนวนชั่วโมงต่อเดือนที่คุณจะใช้ในโครงการนี้เพื่อค่าธรรมเนียมที่กำหนดไว้ล่วงหน้าเพื่อป้องกันตัวเอง

เท่าที่ค้นพบสิ่งที่กำลังถูกใช้และไม่ได้ใช้ไม่มีวิธีที่ง่ายจริงๆ เครื่องมือวิเคราะห์รหัสอาจช่วยได้ แต่เนื่องจากคุณกำลังจัดการกับปัญหาที่ไม่ดีเช่นนี้ฉันไม่คิดว่ามีเครื่องมือใด ๆ ที่สามารถช่วยได้ สำหรับแต่ละพื้นที่คุณอาจพบเครื่องมือวิเคราะห์รหัสที่อาจช่วยได้