+ Method Shells: avoiding conflicts on destructive class - - PowerPoint PPT Presentation

▶
method shells avoiding conflicts on destructive class
SMART_READER_LITE
LIVE PREVIEW

+ Method Shells: avoiding conflicts on destructive class - - PowerPoint PPT Presentation

Feb 12, 2023 266 likes •451 views

+ Method Shells: avoiding conflicts on destructive class extensions by implicit context switches ! Wakana Takeshita and Shigeru Chiba The University of Tokyo ! + Application and Software ! 2

slide-1
SLIDE 1

+

Method ¡Shells: ¡avoiding ¡conflicts ¡on ¡destructive ¡ class ¡extensions ¡by ¡implicit ¡context ¡switches !

Wakana Takeshita and Shigeru Chiba The University of Tokyo !

slide-2
SLIDE 2

+Application ¡and ¡Software !

n Modern applications

are built on top of existing libraries

n but often not as they

are

n Need to modify the

libraries

2 !

l1: HTML renderer ! l2: web browser ! l3: HTML viewer ! Application !

slide-3
SLIDE 3

+ Mechanisms ¡for ¡modular ¡customization !

n Ruby’s openclass n AspectJ’s aspect

n [‘01 Kiczales et al.]

n GluonJ

n [’10 Chiba et al.]

n Classboxes

n [’10 Bergel et al.]

n etc…

3 !

l1: HTML renderer class Webpage{ } void popup(HTML text){ // show a popup window } ! void onClick(Mouse m){ URL url = m.getURL(); popup(url); … } ! l2: web browser !

revise Webpage{ } !

void popup(HTML text){ warning(“disabled”); } ! Example in GluonJ ! Redefine !

slide-4
SLIDE 4

+Destructive ¡Class ¡Extensions !

n A mechanism for writing

  • nly differences in a

separate source file without rewriting existing code

n for adding new methods to

existing classes, and

n for redefining existing

methods

n Modularization of

modifications

n Dividing the work !

4 !

l2: web browser ! ! l1: HTML renderer ! another file !

  • riginal

definitions ! Destructive class extensions !

  • riginal file !

Redefine !

slide-5
SLIDE 5

+Problem ¡Caused ¡by ¡Conflicts ¡of ¡ Modifications !

5 !

l1: HTML renderer ! l2: web browser ! l3: HTML viewer !

Application !

void popup(HTML text){ // show a popup window } ! void popup(HTML text){ warning(“disabled”); } !

Which a definition is applied? !

Application ! void check(File f) { … new Webpage().popup(…); …} !

slide-6
SLIDE 6

+Solution !

n Switch the applied destructive class extensions

depending on the program’s context

n How to define the context?

n by using two types of import n one context = a set of boxes connected by arrows !

!

6 !

l1: HTML renderer ! l2: web browser ! l3: HTML viewer ! Application ! void popup(HTML text){ // show a popup window } ! void popup(HTML text){ warning(“disabled”); } ! void check(File f) { … new Webpage().popup(…); …} !

slide-7
SLIDE 7

+Solution !

n Switch the applied destructive class extensions

depending on the program’s context

n How to define the context?

n by using two types of import n one context = a set of boxes connected by arrows !

!

7 !

l1: HTML renderer ! l2: web browser ! l3: HTML viewer ! Application ! void popup(HTML text){ // show a popup window } ! void popup(HTML text){ warning(“disabled”); } ! void check(File f) { … new Webpage().popup(…); …} !

slide-8
SLIDE 8

+Proposal: ¡Method ¡Shells !

n a module system for avoiding conflicts

by switching a set of revisers to fit execution contexts during runtime.

n The context is defined by two

declarations

n Link: for switching the contexts n Include: for sharing the contexts. !

8 !

l2: webBrowser !

methodshell browser; //include and link declarations include renderer; //declarations revise Webpage{ } !

void popup(HTML text){ warning(“disabled”); } !

n module: methodshell

n contains two

declarations, class declarations and destructive class extensions !

slide-9
SLIDE 9

+Include ¡declarations !

n Used when to revise other methodshells n Share the same context

9 !

l2: webBrowser ! methodshell browser; include renderer; revise Webpage{ } ! void popup(HTML text){ warning(“disabled”); } ! methodshell viewer; include renderer; class Viewer{ } revise Webpage{ } void check(File f) { … new Webpage().popup(…); …} ! Border getBorder() { // return a decorated window border } !

include link context1 context2

methodshell viewer; include renderer; class Viewer{ } revise Webpage{ } void check(File f) { … new Webpage().popup(…); …} ! Border getBorder() { // return a decorated window border } ! l1: HTML renderer methodshell renderer; class Webpage{ } void popup(HTML text){ // show a popup window } ! void onClick(Mouse m){ … popup(url); … } ! l3: HTML viewer ! l3: HTML viewer !

slide-10
SLIDE 10

+

n When the method in the linked methodshell is called, the current

context switches to the context containing the called method.

10 !

l2: webBrowser ! methodshell browser; include renderer; revise Webpage{ } ! void popup(HTML text){ warning(“disabled”); } ! Application ! methodshell application; include browser; link viewer; main(){ new Viewer().check(…); new Webpage().popup();

include link context1 context2

Link ¡declarations !

void check(File f) { … new Webpage().popup(…); …} ! Border getBorder() { // return a decorated window border } !

l3: HTML viewer !

methodshell viewer; include renderer; class Viewer{ } revise Webpage{ } void check(File f) { … new Webpage().popup(…); …} ! Border getBorder() { // return a decorated window border } ! l3: HTML viewer ! methodshell viewer; include renderer; class Viewer{ } revise Webpage{ } void check(File f) { … new Webpage().popup(…); …} ! Border getBorder() { // return a decorated window border } ! method call !

slide-11
SLIDE 11

+An ¡Entire ¡Picture !

11 !

browser methodshell !

viewer methodshell !

application methodshell ! viewer methodshell ! renderer methodshell void popup(HTML text){ // show a popup window } ! void popup(HTML text){ warning(“disabled”); } ! void check(File f) { … new Webpage().popup(…); …} ! main(){ new Webpage().popup(); new Viewer.check(…); }

include link context1 context2

void popup(HTML text){ // show a popup window } ! void check(File f) { … new Webpage().popup(…); …} !

slide-12
SLIDE 12

+

12 !

Semantics !

slide-13
SLIDE 13

+Method ¡Lookup !

  • 1. Search the linked

methodshell

  • 2. Search the

current context

  • 3. Search the global

context !

13 !

renderer methodshell ! browser methodshell ! viewer methodshell ! application methodshell ! application2 methodshell ! method call ! 1 ! 2 ! 3 ! 4 ! 5 !

include link context1 context2

slide-14
SLIDE 14

+A ¡Technique ¡for ¡Implementation !

n To reduce runtime penalty

n by transforming unique method names and

method bodies to fit them at compile time

14 !

application methodshell ! … main(){ … new Webpage().popup(…); … } … browser methodshell ! revise Webpage{ } ! void popup(HTML text){ warning(“disabled”); } ! method call ! void popup_browser(HTML text){ warning(“disabled”); } ! … main(){ … new Webpage().popup_browser(…); … } …

Modified at compile time !

slide-15
SLIDE 15

+Related ¡Work !

n Context-oriented Programming[’08 Robert

H, et al.]

n Applied method declarations are changes by the

current context

n Classboxes[’05 Alexandre B, et al.] n Ruby’s refinements

n controlling the scope of destructive class

extensions.

n NewSpeak[‘10 Bracha G, et al.]

n All class names are virtual n Provide a mechanism corresponding to include

declarations !

15 !

slide-16
SLIDE 16

+Conclusion !

n Demand to modify the existing code

n There are some mechanisms that make it easy

to add and redefine methods

n Proposal: Method Shells

n a module system for switching applied

definitions by context switches

n Link and include declarations

16 !

slide-17
SLIDE 17

+Related ¡Work !

n NewSpeak[‘10 Bracha G, et al.]

n All class names are virtual n Provide a mechanism corresponding to

include declarations

n Method Shelter

n Our previous study !

17 !