9CONCLUSIONS ANDFUTUREWORKImplement

9CONCLUSIONS ANDFUTUREWORK
Implementing behavior-preserving program transformations is difficult, particularly at the source level. Modern
mainstream programming languages such as Java provide
many convenient idioms and syntactic sugar that make it
very hard to ensure that the transformed program has the
same behavior as the input program, or even that it
compiles in the first place. One particularly complex, yet
very fundamental problem is how to deal with name
binding, which is governed by a sophisticated set of lookup
and access control rules.
In this paper, we have introducedJL, a representation of
Java programs that abstracts away from the details of name
lookup and access control, instead providing a view of the
program in which references to declared entities appear
locked: They only change when explicitly rebound by the
refactoring, and otherwise keep their original binding. We
have shown that refactorings become much more robust
and powerful when formulated at the level ofJL.
In order for JLto be usable, we need translations from
Java to JL and vice versa. We have shown how such a
translation can be achieved with the help of a reference
construction function and accessibility constraints: The
former constructs references that bind to a target declaration, and the latter determine how declared accessibilities
have to be adjusted to satisfy access control rules. We have
implemented these translations and put them to work by
implementing several refactorings on top of them. To
evaluate our implementation, we have systematically
applied two of these refactorings to a large body of realworld Java applications, showing that our tool is able to
perform transformations that are beyond the scope of
popular refactoring engines.
As our work shows, the name binding and accessibility
rules of Java are highly complex and full of sometimes
surprising quirks. On the one hand, this complexity gives the
programmer a lot of flexibility in reusing names and
omitting qualifiers such asthiswherever possible. On the
other hand, this flexibility strikes back as a degraded
capability of statically detecting logical programming errors,
and makes it easy to introduce errors when changing the
program, for instance by a refactoring. A language designed
for ease of refactoring would have much simpler binding
rules at the price of reduced freedom in choosing names.
There are, of course, many other problems besides
naming and accessibility that refactoring engines have to
handle and whichJL does not solve. Examples include
control and data flow properties that have to be preserved
during method extraction [33] or synchronization of shared
data in concurrent programs [34]. In our experience,
however, these issues are largely orthogonal to naming
and can be dealt with separately

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

9CONCLUSIONS ANDFUTUREWORKThực hiện bảo quản hành vi chương trình biến đổi là khó khăn, đặc biệt là ở mức mã nguồn. Hiện đạichính ngôn ngữ như Java cung cấpnhiều thành ngữ thuận tiện và cú pháp đường mà làm cho nórất khó để đảm bảo rằng chương trình chuyển đổi có cácCác hành vi tương tự như chương trình đầu vào, hoặc thậm chí nóbiên dịch ở nơi đầu tiên. Một trong những đặc biệt là phức tạp, đượcvấn đề rất cơ bản là làm thế nào để đối phó với tênràng buộc, mà được quản lý bởi bộ tinh vi tra cứuvà truy cập kiểm soát quy tắc.Trong bài này, chúng tôi đã introducedJL, một đại diện củaChương trình Java đó tóm tắt đi từ các chi tiết của têntra cứu và truy cập kiểm soát, thay vào đó cung cấp một cái nhìn của cácchương trình trong đó các tham chiếu đến tuyên bố thực thể xuất hiệnkhóa: họ chỉ thay đổi khi một cách rõ ràng phục hồi bởi cácrefactoring, và nếu không giữ của ràng buộc ban đầu. Chúng tôiđã chỉ ra rằng refactorings trở thành nhiều hơn nữa mạnh mẽvà mạnh mẽ khi xây dựng tại ofJL cấp.Theo thứ tự cho JLto được sử dụng được, chúng tôi cần các bản dịch từJava để JL và ngược lại. Chúng tôi đã chỉ ra như thế nào như mộtbản dịch có thể đạt được với sự giúp đỡ của một tài liệu tham khảoxây dựng chức năng và khả năng tiếp cận những hạn chế: Cáccũ xây dựng tài liệu tham khảo liên kết với một tuyên bố mục tiêu, và sau đó xác định như thế nào tuyên bố accessibilitiesphải được điều chỉnh để đáp ứng các quy tắc kiểm soát truy cập. Chúng tôi cóthực hiện các bản dịch và đặt chúng để làm việc bằngthực hiện một số refactorings trên đầu trang của họ. Đểđánh giá thực hiện của chúng tôi, chúng tôi đã có hệ thốngáp dụng hai trong số các refactorings cho một cơ thể lớn của các ứng dụng Java realworld, Đang hiển thị rằng công cụ của chúng tôi có thểthực hiện các phép biến đổi vượt ra ngoài phạm vi củađộng cơ refactoring phổ biến.Như chúng tôi cho thấy công việc, tên ràng buộc và khả năng tiếp cậnCác quy định của Java là rất phức tạp và đầy đủ của đôi khiquirks đáng ngạc nhiên. Một mặt, phức tạp này cung cấp cho cáclập trình viên rất nhiều sự linh hoạt trong sử dụng lại tên vàbỏ qua vòng loại như vậy asthiswherever có thể. Trên cácmặt khác, tính linh hoạt này tấn công trở lại như một đây bị suy thoáikhả năng tĩnh phát hiện lỗi lập trình hợp lý,và làm cho nó dễ dàng để giới thiệu lỗi khi thay đổi cácchương trình, ví dụ bởi một refactoring. Một ngôn ngữ thiết kếđể dễ refactoring sẽ có nhiều liên kết đơn giảnquy tắc với mức giảm tự do trong việc lựa chọn tên.Có là, tất nhiên, nhiều vấn đề khác bên cạnhĐặt tên và khả năng tiếp cận phải refactoring động cơxử lý và whichJL không giải quyết. Ví dụ bao gồmkiểm soát và dữ liệu dòng chảy tài sản đó phải được bảo quảntrong phương pháp khai thác [33] hoặc đồng bộ hoá của chia sẻdữ liệu trong chương trình đồng thời [34]. Theo kinh nghiệm của chúng tôi,Tuy nhiên, những vấn đề này phần lớn trực giao để đặt tênvà có thể được xử lý với một cách riêng biệt

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

9CONCLUSIONS ANDFUTUREWORK
thực hiện chương trình chuyển đổi hành vi bảo quản là rất khó, đặc biệt là ở cấp nguồn. Modern
ngôn ngữ lập trình thông thường như Java cung cấp
nhiều thành ngữ thuận tiện và cú pháp đường mà làm cho nó
rất khó để đảm bảo rằng các chương trình chuyển đổi có
hành vi tương tự như các chương trình đầu vào, hoặc thậm chí là nó
biên dịch ở nơi đầu tiên. Một đặc biệt phức tạp, tuy nhiên
vấn đề rất cơ bản là làm thế nào để đối phó với tên
ràng buộc, mà được quy định bởi một tập hợp phức tạp của việc tìm kiếm
và truy cập các quy tắc kiểm soát.
Trong bài báo này, chúng tôi có introducedJL, một đại diện của
chương trình Java mà tóm tắt đi từ các chi tiết của tên
tra cứu và kiểm soát truy cập, thay vì cung cấp một cái nhìn của các
chương trình mà trong đó tài liệu tham khảo cho các đối tượng khai báo xuất hiện
đã bị khóa, Họ chỉ thay đổi khi tăng trở lại một cách rõ ràng bởi sự
tái cấu trúc, và nếu không giữ nguyên ràng buộc của họ. Chúng tôi
đã chỉ ra rằng tái cấu trúc trở nên mạnh mẽ hơn nhiều
và mạnh mẽ khi xây dựng ở cấp ofJL.
Để cho JLto được sử dụng, chúng ta cần bản dịch từ
Java để JL và ngược lại. Chúng tôi đã cho thấy làm thế nào một ví dụ
dịch thuật có thể đạt được với sự giúp đỡ của một tài liệu tham khảo
chức năng xây dựng và hạn chế khả năng tiếp cận: Các
cấu trúc tài liệu tham khảo trước đó liên kết với một tuyên bố mục tiêu, và sau này xác định cách bố Accessibility
phải được điều chỉnh để đáp ứng các quy tắc kiểm soát truy cập. Chúng tôi đã
thực hiện các bản dịch này và đặt chúng để làm việc bằng cách
thực hiện một số phép tái cấu trúc trên đầu trang của họ. Để
đánh giá việc thực hiện của chúng tôi, chúng tôi đã có hệ thống
áp dụng hai trong số các phép tái cấu trúc cho một cơ quan lớn của các ứng dụng Java RealWorld, cho thấy rằng công cụ của chúng tôi có khả năng
thực hiện các phép biến đổi đó là vượt ra ngoài phạm vi của
động cơ refactoring phổ biến.
Khi chương trình làm việc của chúng tôi, các tên ràng buộc và khả năng tiếp cận
các quy tắc của Java là rất phức tạp và đầy đôi khi
đôi mà đáng ngạc nhiên. Một mặt, sự phức tạp này cung cấp cho các
lập trình viên rất nhiều tính linh hoạt trong sử dụng lại tên và
bỏ qua vòng loại như asthiswherever có thể. Trên
Mặt khác, sự linh hoạt này tấn công trở lại như một xuống cấp
khả năng phát hiện các lỗi lập trình logic tĩnh,
và làm cho nó dễ dàng để giới thiệu các lỗi khi thay đổi các
chương trình, ví dụ bằng một cấu trúc lại. Một ngôn ngữ được thiết kế
để dễ refactoring sẽ có ràng buộc đơn giản hơn nhiều
quy tắc với giá giảm sự tự do trong việc lựa chọn tên.
Có, tất nhiên, nhiều vấn đề khác ngoài việc
đặt tên và khả năng tiếp cận mà refactoring động cơ phải
xử lý và whichJL không giải quyết. Ví dụ như
kiểm soát và lưu lượng dữ liệu tài sản đó phải được bảo quản
trong phương pháp khai thác [33] hoặc đồng bộ hóa của chia sẻ
dữ liệu trong chương trình đồng thời [34]. Theo kinh nghiệm của chúng tôi,
tuy nhiên, những vấn đề này phần lớn là trực giao để đặt tên
và có thể được xử lý một cách riêng biệt