Làm thế nào để đọc hàng ngàn dòng mã mà không cần bất kỳ tài liệu nào? [đóng cửa]

Trước đây tôi đã tìm kiếm một điều khiển TimeLine tốt cho một dự án WPF. Tôi đã tìm thấy một câu trả lời trong Đây hướng dẫn tôi đến dự án CodePlex này .

Bây giờ tôi muốn thay đổi mã để đáp ứng nhu cầu văn hóa của tôi. Nhưng có một số không phù hợp!

Câu hỏi của tôi là:

Làm thế nào bạn tương tác với hàng ngàn dòng mã như vậy?

BIÊN TẬP:

Bất kỳ phím tắt sẽ là tuyệt vời!

Bạn thêm ý kiến ​​vào mã nguồn khi bạn đã hiểu nó đủ để có thể làm như vậy. Tái cấu trúc những bình luận này một cách mạnh mẽ khi bạn hiểu ngày càng nhiều.

1. Bước qua mã
2. Đổi tên khi cần
3. Tái cấu trúc khi cần thiết
4. Lặp lại cho đến khi bạn hoàn toàn hiểu

... Và mã sẽ cảm ơn bạn vì điều đó. ;-)

Thực hiện một hành động, gỡ lỗi (lặp đi lặp lại) mã để tìm cách thực hiện hành động đó. Viết cùng một ngôn ngữ đơn giản để hiểu rõ hơn!

Một cái gì đó mà Joel Spolsky đã viết cách trở lại khi trên blog của anh ấy (không thể tìm thấy bài báo bây giờ) thực sự mắc kẹt với tôi về điều này:

Ông nói làm thế nào mã không phải là ngôn ngữ tự nhiên của con người, nhưng là lập trình viên, chúng ta dễ dàng nghĩ rằng đó là và chúng ta có thể đọc nó như vậy. Do đó, rất nhiều người trong chúng ta nhìn vào mã mới và mong đợi có thể chỉ "đọc nó" và hiểu nó ngay lập tức, như thể đó là một khối văn bản bằng tiếng Anh.

Vì vậy, tôi nghĩ rằng chìa khóa là về cơ bản chỉ là chậm, có phương pháp và khoa học. Và như những người khác đã nói - bình luận nó (và thậm chí là refactor) khi bạn đi. Đừng rơi vào suy nghĩ "Tôi chỉ nên nhìn vào nó và hiểu ngay lập tức".

Ồ, và vâng, đôi khi tôi vẫn rơi vào cái bẫy này. "Làm như tôi nói, không phải như tôi làm", và tất cả những thứ đó. :)

SE-Radio đã phỏng vấn Dave Thomas về chính chủ đề này

Tập podcast này có nhiều mẹo và kỹ thuật để vào "văn hóa" của dự án và hiểu cách cư dân ban đầu sống.

Tôi đã phải làm điều này gần đây với một dự án hơn 100.000 LỘC. Ý tưởng đầu tiên của tôi là dễ dàng nhìn thấy các mẫu từ biểu đồ 100 hoặc thậm chí 1000 nút hơn từ 100.000 dòng văn bản.

Vì vậy, tôi đã dành 45 phút và viết một chương trình Python ngắn (<100LOC) để phân tích những gì tôi cần từ nó và vẽ các mối quan hệ đối tượng. Tôi đã tạo nguồn Graphviz , một ngôn ngữ thực sự dễ tạo. (Không có gì đặc biệt về Python ở đây: Ruby hoặc C # hoặc Common Lisp hoặc bất cứ điều gì cũng có thể làm điều đó.)

Trong các dự án khác, tôi đã thấy mọi người sử dụng Graphviz cho các phụ thuộc mô-đun, biểu đồ cuộc gọi, lịch sử phiên bản, tất cả các loại. Công cụ meta trực quan hóa chương trình lớn nhất từ ​​trước đến nay.

(Có thể đó là vì tôi mất biên dịch , nhưng tôi thấy nó lạ rằng khi một lập trình viên đang phải đối mặt với một vấn đề, câu trả lời dường như lúc nào cũng được, trừ khi vấn đề liên quan đến mã nguồn để một chương trình "viết một chương trình!". - )

Bước qua nó trong trình gỡ lỗi khi nó chạy, đây là cách duy nhất để hiểu một cơ sở mã mới, lớn.

Hiểu rằng thực sự không có phím tắt để mò mẫm đầy đủ. (Và nếu bạn gặp rắc rối với cụm từ đó, giáo dục của bạn đã bị lãng quên. Đó là từ "Stranger In a Strange Land", của Robert A. Heinlein.)

Đọc nó, một trang tại một thời điểm, một thói quen tại một thời điểm. Thêm ý kiến. Vẽ hình ảnh của các cấu trúc dữ liệu chính. Nhận biết các thuật toán. Rút ra kiến ​​thức trước đó.

Chống lại sự cám dỗ để quây lại trình gỡ lỗi. Khung nhìn của trình gỡ lỗi quá nhỏ: bạn nhìn thấy một dòng tại một thời điểm, nhưng bạn thực sự không thấy nơi bạn đã đến hoặc nơi bạn sẽ đến.

Bất cứ điều gì bạn làm hãy viết càng nhiều càng tốt khi bạn đi cùng để không ai có thể kết thúc ở cùng một vị trí như bạn có.

bạn cần sử dụng manh mối. có được manh mối về những gì bạn phải tìm kiếm và sử dụng rộng rãi chức năng tìm kiếm của môi trường hoặc IDE có thể đưa bạn đến phần mã mong muốn mà bạn cần thay đổi.

đọc 14 nghìn dòng mã java không có nghĩa gì cả. Chức năng tìm kiếm là cứu tinh của bạn

Những người khác nhau có cách học khác nhau, vì vậy YMMV. Điều đầu tiên tôi làm trong tình huống này là đọc toàn bộ cơ sở mã thông qua ít nhất một lần. Điều đó cho tôi một ý tưởng chung về mọi thứ ở đâu. Sau đó, tôi chọn một phần để kiểm tra chi tiết hơn. Cấu trúc dữ liệu sẽ là một nơi tốt để bắt đầu. Khi tôi có một ý tưởng chung về những gì đang diễn ra, tôi cũng làm tương tự với một phần khác của mã tương tác với phần đầu tiên. Sau khi lặp đủ, tôi có ý thức tốt về cách mã hoạt động.

Cách tốt nhất, như với tất cả các chương trình không chỉ là những đoạn mã lớn không bị lỗi, là chia nó thành nhiều phần. Đây là cả hai điều bạn nên làm trong đầu cũng như trực quan trong mã. Điều này có thể có nghĩa là thêm các bình luận táo bạo lớn hoặc ngắt nhiều dòng. Điều này giúp trong khi cuộn qua nó để xem các mảnh. Cố gắng tìm các đoạn logic của mã.

Tất nhiên, khi bạn hiểu các bit, hãy nhận xét chúng về những gì bạn biết vào thời điểm đó, có thể ghi chú về những điều bạn không hiểu.

Tôi cũng khuyên bạn không nên cố gắng hiểu toàn bộ tác phẩm ngay từ đầu. Thay vào đó hãy cố gắng hiểu những phần mà bạn cần biết ngay bây giờ và làm việc với phần còn lại sau.

Tôi sẽ bắt đầu bằng cách sử dụng Trình chỉnh sửa Leo trong chế độ @shadow với việc sử dụng tích cực các nút nhân bản . Điều này cho phép một người thêm ghi chú và nhận xét cho từng phần mã đang nghiên cứu mà không thay đổi mã và các chú thích sẽ luôn ở trong ngữ cảnh, bên cạnh mã mà nó đang nói đến. Dưới đây là một ví dụ về quy trình làm việc của các tài liệu:

Ví dụ: khi tôi sửa một lỗi trong Leo, tôi tạo một nút thông thường để thể hiện lỗi. Nút lỗi này là quan điểm của tôi về tất cả dữ liệu trong mã nguồn của Leo liên quan đến lỗi. Khi tôi phát hiện ra mã liên quan đến lỗi, tôi đã sao chép các nút của chúng và di chuyển chúng dưới nút lỗi. Tôi cũng sẽ thêm các nút thông thường như là con của nút lỗi. Các nút này chứa báo cáo lỗi ban đầu, mô tả về cách tôi sửa lỗi, dữ liệu kiểm tra hoặc bất kỳ ghi chú nào khác mà tôi có thể muốn giữ.

Khi tôi đã tạo nút lỗi, tôi chỉ tập trung vào nút đó và các con của nó. Tôi có thể kiểm tra nút lỗi và các con của nó mà không cần phải nhảy xung quanh phác thảo. Tất cả mọi thứ tôi cần là ở một nơi. Khi tôi đi xung quanh để thực sự sửa lỗi, tôi có thể làm như vậy bằng cách thay đổi bản sao. Một lần nữa, tôi không phải nhảy xung quanh phác thảo. Không quan trọng toàn bộ phác thảo lớn hay phức tạp như thế nào: Tôi chỉ đang xử lý nút lỗi và các con của nó. Trọng tâm cực kỳ hẹp này giúp việc sửa lỗi dễ dàng hơn nhiều.

Vẽ sơ đồ của nguồn: các mối quan hệ dữ liệu, các mối quan hệ chức năng, các mối quan hệ đối tượng. Xác định tổng hợp, luồng dữ liệu và luồng mã. Hình ảnh tốt hơn nhiều so với ý kiến ​​cho điều này, và có thể được tách biệt khỏi mã.

Trước khi bạn tái cấu trúc bất cứ điều gì viết bài kiểm tra. Rất nhiều bài kiểm tra. Các thử nghiệm rất cụ thể đối với các khối mã nhỏ ít nhất có thể gọi được, vì nó sẽ phụ thuộc vào cách viết lộn xộn được kế thừa của bạn.

Lợi thế của việc viết bài kiểm tra để bắt đầu là bạn cần có một số loại hiểu biết về mã trước khi bạn có thể kiểm tra nó, vì vậy mọi bài kiểm tra bạn viết sẽ hy vọng sẽ có một chút kiến ​​thức thu được. Bạn cũng có thể bình luận nặng nề các bài kiểm tra với các giả định của bạn bên cạnh các xác nhận.

Bằng cách thử nghiệm trước, bạn sẽ không gặp rủi ro khi thay đổi thứ gì đó trong mã có hiệu ứng kích thích mà bạn không thể biết. Bạn cũng sẽ có một mạng lưới an toàn khi bạn đến để cấu trúc lại mã.

Tôi sử dụng các công cụ như doxygen, để tạo ra một sơ đồ lớp tổng thể, hơn là tôi hiểu thêm về những gì mỗi lớp làm.

Sau đó, tôi nhận một số lỗi dễ dàng từ hàng đợi lỗi (trước khi người quản lý của tôi gán một lỗi khó cho tôi: P), sau đó chạy qua chức năng đó vào trình gỡ lỗi và cố gắng tạo ra một luồng dữ liệu thô hoặc mô hình dòng mã.

Ví dụ chức năng xuất trong một số phần mềm: vì vậy tôi cố gắng hiểu cách đọc dữ liệu nguồn, từ đâu trong mã (giao diện cơ sở) tôi có thể đánh giá dữ liệu được đọc chính xác bằng cách sử dụng sơ đồ dòng và mã của tôi, lớp nào chịu trách nhiệm loại xuất khẩu nào, v.v ... Tôi nghĩ rằng một nửa sự hiểu biết đã được thực hiện, một khi bạn có sơ đồ lớp và biểu đồ dòng chảy.

Tiếp cận một khiếm khuyết tầm thường, ví dụ, một NullPulumException. Tránh bất cứ điều gì liên quan đến đồng thời lúc đầu, bất cứ điều gì mà bản chất của nó sẽ liên quan đến việc hiểu rất nhiều mã cùng một lúc.

Khi bạn đã sửa một vài lỗi, có thể bạn sẽ có một ý tưởng khá hay. Làm việc cho tôi, ở mức nào.

Về cơ bản hành động để viết một mã sạch sẽ bắt đầu ngay từ thiết kế. Nếu chúng ta đang mã hóa bằng ngôn ngữ OOP với một UML, hãy chia sẻ với các đồng nghiệp và tin chắc rằng thiết kế không mơ hồ. Trong mọi trường hợp, chúng tôi các nhà phát triển nên tin chắc rằng thiết kế sẽ giải quyết vấn đề chứ không phải ambiguos.

Khi nói đến mã hóa, chúng ta phải đảm bảo rằng thiết kế đang được chuyển đổi thành mã, tức là một Thực thể thành một lớp hoặc cấu trúc, một hoạt động để hoạt động, v.v.

Và tôi đã xem qua một tờ giấy trắng http://queue.acm.org/detail.cfm?id=2063168 nói về phong cách mã hóa hoặc cách chúng ta có thể sử dụng không gian, thụt lề, biến thể phông chữ như hầu hết các IDE chúng ta có thể sử dụng để viết MUCH Mã SẠCH nơi con người chúng ta có thể hiểu nhiều như máy móc. Nó nhấn mạnh nhiều hơn vào việc viết mã nhận xét miễn phí để mã của chúng tôi sẽ xuất hiện dưới dạng các đoạn văn.