-
Notifications
You must be signed in to change notification settings - Fork 0
/
masuhara.bib
3379 lines (3067 loc) · 251 KB
/
masuhara.bib
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
% -*- Mode: BibTeX -*-
% masuhara.bib
% papers of my work
% exception: Japanes papers (see japanese-e.bib or japanese-j.bib)
% include: strings.bib
@bachelorsthesis{masuhara92bachelors-thesis,
author = "Hidehiko Masuhara",
title = "Study on Implementation of an Object-Oriented
Concurrent Reflective Language",
howpublished = "Bachelor's Thesis, " # ISUTokyo,
school = "Department of Information Science, the University of Tokyo",
year = 1992,
keywords = {ABCL/R},
pdf = {seniorthesis.pdf},
url = {https://www.is.s.u-tokyo.ac.jp/},
month = feb,
note = {Supervisor: Akinori Yonezawa},
abstract = {Computational reflection is the computational activity of a system whose targets of computation are its own structure and its own computation. Programming languages which support reflective capabilities facilitate a modular way of describing the meta-level features such as debugging and resource management --- in conventional languages, these features were only available in an ad-hoc fashion. Operational semantics of a reflective language is usually given in terms of an infinite tower of interpreters (the so-called `reflective tower.') For actual implementation of such languages, however, the tower itself must have some finite implementation. Optimization is also necessary to reduce the overhead of the interpretation. There have been several researches on such issues with sequential reflective languages, but none on concurrent reflective languages. The study of effective implementation of concurrent reflective languages is essential. Since resource management in concurrent computing systems is more dynamic and complex compared to that in sequential systems, the use of reflective facilities for the control of such management from within the language is even more beneficial. In this research , we study the implementation of ABCL/R2, an object-oriented concurrent reflective language. The operational semantics of ABCL/R2 is given in terms of two reflective towers; in order to have finite representations of these towers, we employ `lazy creation' technique, which postpones the creation of the upper-levels until they are actually needed. We also explore optimizations, such as method compilation, for efficient execution.}
}
@InProceedings{masuhara92oopsla,
author = MasMatWatYon,
title = "Object-Oriented Concurrent Reflective Languages can
be Implemented Efficiently",
crossref = "oopsla92",
pages = "127--145",
pdf = {oopsla1992.pdf},
doi = {10.1145/141937.141948},
serialNo = "16-6",
acceptanceRatio = "31/250 (12%)",
keywords = {ABCL/R},
abstract = {Computational reflection is beneficial in concurrent computing in offering a linguistic mechanism for incorporating user-specific policies . New challenges are (1) how to implement them, and (2) how to do so efficiently. We present efficient implementation schemes for object-oriented concurrent reflective languages using our language ABCL/R2 as an example. The schemes include: efficient lazy creation of metaobjects/meta-groups, partial compilation of scripts (methods), dynamic progression, self-reification, and light-weight objects, all appropriately integrated so that the user-level semantics remain consistent with the meta-circular definition so that the full power of reflection is retained, while achieving practical efficiency. ABCL/R2 exhibits two orders of magnitude speed improvement over its predecessor, ABCL/R, and in fact compares favorably to the ABCL/1 compiler and also C + Sun LWP, neither supporting reflection.}
}
@InProceedings{masuhara93rw,
author = MasMatYon,
title = "Designing an {OO} Reflective Language for
Massively-Parallel Processors",
booktitle = OOPSLA93RW,
year = 1993,
address = WashingtonDC,
month = oct,
keywords = {ABCL/R}
}
@MastersThesis{masuhara94master-thesis,
author = "Hidehiko Masuhara",
title = "Study on a Reflective Architecture to Provide
Efficient Dynamic Resource Management for
Highly-Parallel Object-Oriented Applications",
pdf = {masterthesis.pdf},
url = {https://www.is.s.u-tokyo.ac.jp/},
school = ISGSUTokyo,
year = 1994,
keywords = {ABCL/R},
note = {Supervisor: Akinori Yonezawa},
abstract = {Recent progress in implementations of object-oriented concurrent programming languages on highly-parallel processors makes it feasible to construct large-scale parallel applications having complicated structures. Such applications can not exhibit good performance without dynamic resource management (e.g., load-balancing and object scheduling) tailored to the characteristics of the applications and/or machine architectures. Since dynamic resource management systems are usually intertwined with the language implementation, modification/extension of the management systems requires complicated programming in the low-level language. Reflective systems can provide abstractions to modify/extend the implementation-level facilities within the application-level language. This study proposes a reflective architecture of an object-oriented concurrent language for highly-parallel processors to provide resource management systems for parallel applications. To make our architecture practical, much attention is payed on balancing the trade-offs between extensibility and efficiency; we examine the requirements for realistic applications by developing resource management systems for search problems and N -body simulation, and design the architecture based on the requirements. The architecture is evaluated by experiments through a prototype system running on a parallel computer.}
}
@InProceedings{masuhara94wooc,
author = MasMatYon,
title = "Distributed Memory Reflective Architecture for High
Performance Object-Oriented Computing",
booktitle = WOOC,
year = 1994,
organization = JSSST,
address = Ootu,
month = mar,
keywords = {ABCL/R}
}
@Article{masuhara94swopp,
author = MasMatYon,
title = "An Object-Oriented Concurrent Reflective Language
for Dynamic Resource Management in Highly Parallel
Computing",
OPTjournal = IPSJSIG,
year = 1994,
journal = {IPSJ Technical Reports SIG-PRG},
OPTvolume = 94,
pdf = {prg1994.pdf},
volume = 1994,
url = {http://id.nii.ac.jp/1001/00030453/},
number = {65(1994-PRO-018)},
pages = "57--64",
month = jul,
OPTnote = "(94-PRG-18)",
keywords = {ABCL/R}
}
@InProceedings{masuhara95oopsla,
author = MasMatAsaYon,
title = "Compiling Away the Meta-Level in Object-Oriented
Concurrent Reflective Languages Using Partial
Evaluation",
crossref = "oopsla95",
doi = {10.1145/217839.217869},
pdf = {oopsla1995.pdf},
pages = "300--315",
acceptanceRatio = "28/155",
keywords = {ABCL/R},
abstract = {Meta-level programmability is beneficial for parallel/distributed object-oriented computing to improve performance, etc. The major problem, however, is interpretation overhead due to meta-circular interpretation. To solve this problem, we propose a compilation framework for object-oriented concurrent reflective languages using partial evaluation. Since traditional partial evaluators do not allow us to directly deal with meta-circular interpreters written with concurrent objects, we devised techniques such as pre-/post-processing, a new proposed preaction extension to partial evaluation in order to handle side-effects, etc. Benchmarks of a prototype compiler for our language ABCL/R3 indicate that (1) the meta-level interpretation is essentially `compiled away,' and (2) meta-level optimizations in a parallel application, running on a Fujitsu MPP AP1000, exhibits only 10--30\% overhead compared to the hand-crafted source-level optimization in a non-reflective language.}
}
@InProceedings{masuhara95imsa,
author = MasMatAsaYon,
title = "Efficient Implementation Technique for
Object-Oriented Concurrent Reflective Languages
Using Partial Evaluation",
booktitle = IMSA95,
year = 1995,
note = "Digested version of \cite{masuhara95oopsla}.",
keywords = {ABCL/R}
}
@TechReport{asai95techrep,
author = "Kenichi Asai and Hidehiko Masuhara and Satoshi
Matsuoka and Akinori Yonezawa",
title = "Partial Evaluator as a Compiler for Reflective
Languages",
pdf = {techrep1995-10.pdf},
institution = "Department of Information Science, the University of Tokyo",
year = 1995,
number = "95--10",
month = dec,
serialNo = "2-26",
annote = "Submitted to PEPM'95, but in vain.",
keywords = {Black, Scheme}
}
@InProceedings{masuhara96reflection,
author = MasMatYon,
title = "Implementing Parallel Language Constructs Using
a Reflective Object-Oriented Language",
crossref = "reflection96",
pdf = {reflection1996.pdf},
pages = "79--91",
keywords = {ABCL/R},
abstract = {To provide various parallel language constructs, extensible languages based on reflection are attractive for both implementors and users. This paper describes our proposed meta-level architecture of a concurrent object-oriented language ABCL/R3, which has the following characteristics: (1) language customization through meta-interpreters and meta-objects, (2) delegation and inheritance mechanisms facilitating modular and re-usable meta-level programming, and (3) the reflective annotations and meta-level arguments realizing separation of base- and meta-level programs. We also show that several meta-level programs that provide common parallel programming strategies, such as object replication and latency hiding, are easily implemented.}
}
@TechReport{asai96techrep,
author = "Kenichi Asai and Hidehiko Masuhara and Akinori
Yonezawa",
title = "Partial Evaluation of Call-by-value lambda-calculus
with side-effects",
institution = "Department of Information Science, the University of Tokyo",
year = 1996,
number = "96--04",
month = nov,
keywords = {Black, Scheme}
}
@InProceedings{asai97pepm,
crossref = "pepm97",
pdf = {pepm1997.pdf},
doi = {10.1145/258993.258997},
url = {https://dl.acm.org/doi/proceedings/10.1145/258993},
author = "Kenichi Asai and Hidehiko Masuhara and Akinori
Yonezawa",
title = "Partial Evaluation of Call-by-value lambda-calculus
with Side-effects",
pages = "12--21",
serialNo = "6-12",
keywords = {Black, Scheme},
abstract = {We present a framework of an online partial evaluator for a call-by-vahre A-calculus with destructiveupdatesof data structures. It properly and correctly specializes expressions that contain side-effects, while preserving pointer equality, which is an important property for programs using updates. Our partial evaluator uses a side-effect analysis to extract immutable data structures and then performs an online specialization using preactions. Once mutable and immutable data structures are separated, partial evaluation is done in such a way that accesses to immutable ones are performed at specialization time, while accesses to mutable ones are residualized. For the correct residualization of side-effecting operations, preactions are used to solve various issues, including code elimination, code duplication, and execution order preservation. The preaction mechanism also enables us to reduce expressions that were residualized when the conventional let-expression approach of Similix was used. The resulting partial evaluator is simple enough to prove its correctness. Based on the framework, we have constructed a partial evaluator for Scheme, which is powerful enough to specialize fairly complicated programs with side-effects, such as an interpreter.}
}
@InProceedings{masuhara97imsa,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Reasoning-conscious Meta-object Design of a
Reflective Concurrent Language",
booktitle = IMSA97,
year = 1997,
pages = "42--56",
organization = "ETL/IPA",
address = Tsukuba,
month = oct,
keywords = {ABCL/R}
}
Misc{masuhara97draft,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Design and Partial Evaluation of Meta-objects for a
Concurrent Reflective Language",
howpublished = "submitted for publication",
year = 1997,
month = dec,
OPTnote = "",
OPTaffil = "",
OPTkeywords = "",
OPTserialNo = "",
OPTannote = "",
keywords = {ABCL/R}
}
@InProceedings{masuhara98iwpse,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "A Reflective Approach to Support Software Evolution",
crossref = "iwpse98",
OPTbooktitle = "International Workshop on the Principles of Software
Evolution",
OPTyear = 1998,
OPTeditor = "Takuya Katamaya",
pages = "135--139",
OPTaddress = "Kyoto",
OPTmonth = apr,
keywords = {ABCL/R}
}
@InProceedings{masuhara98ecoop,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Design and Partial Evaluation of Meta-objects for a
Concurrent Reflective Language",
pdf = {ecoop1998.pdf},
doi = {10.1007/BFb0054102},
url = {http://ecoop98.vub.ac.be/},
crossref = "ecoop98",
pages = "418--439",
acceptanceRatio = "24/124 (19%)",
keywords = {ABCL/R},
abstract = {Customizable meta-objects are a powerful abstraction for extending language features and implementation mechanisms, but interpretive execution suffers from severe performance penalty. Some of this penalty can be reduced by applying partial evaluation to meta-interpreters, but partial evaluation of meta-objects in existing concurrent object-oriented languages is ineffective. This paper proposes a new meta-object design for our reflective language ABCL/R3. It yields meta-objects that can be optimized effectively using partial evaluation. The crux of the design is the separation of state-related operations from other operations, and this separation is accomplished by using reader/writer methods in our concurrent object-oriented language called Schematic. Our benchmark trials show that non-trivial programs with partially evaluated meta-objects run more than six times faster than ones that are interpreted by meta-objects. In addition, a partially evaluated program that uses a customized meta-object runs as efficiently as a program that is manually rewritten so as to have the same functionality without using meta-objects.}
}
@InProceedings{sugita98oopsla-rw,
author = "Yuuya Sugita and Hidehiko Masuhara and Kenichi
Harada and Akinori Yonezawa",
pdf = {oopsla98reflection.pdf},
title = "On-the-fly Specialization of Reflective Programs
Using Dynamic Code Generation Techniques",
crossref = "oopsla98rw",
OPTyear = 1998,
OPTeditor = "Jean-Charles Fabre and Shigeru Chiba",
OPTvolume = "98--4",
OPTseries = "Technical Report of Center for Computational
Physics, University of Tsukuba",
pages = "21--25",
OPTaddress = "Vancouver, B.C., Canada",
OPTmonth = oct,
OPTannote = "ISSN 1344-3135"
}
@PhdThesis{masuhara99phd,
pdf = {phdthesis.pdf},
doi = {10.11501/3163477},
url = {https://www.is.s.u-tokyo.ac.jp/},
author = "Hidehiko Masuhara",
title = "Architecture Design and Compilation Techniques Using
Partial Evaluation in Reflective Concurrent
Object-Oriented Languages",
school = ISGSUTokyo,
year = 1999,
OPTaddress = "",
month = jan,
OPTtype = "",
OPTnote = "",
OPTaffil = "",
OPTkeywords = "",
OPTserialNo = "",
OPTannote = "",
keywords = {ABCL/R},
note = {Supervisor: Akinori Yonezawa},
abstract = {Parallel and distributed programs often have hardware/problem specific optimizations for improving quality of the program such as efficiency and robustness. Those optimizations, unfortunately, degrade portability and re-usability as they are intertwined with the original algorithm description. Reflective languages, which provide the application programmer extensible and abstract implementation of the language, can describe such optimizations as extensions to the language. The separation of optimization descriptions gains portability and re-usability of both application programs and optimizations. However, the interpretive execution model of reflective languages imposes a large amount of performance overhead, which sometimes outweighs benefits of optimizations. Previous reflective languages prohibit some of operations being modified via reflection, so as to reduce the amount of interpretation overhead. The imperfection of this approach is that it still leaves a considerable amount of overhead, and it yields less flexible, unclear reflective architecture.
This dissertation investigates design and compilation framework of meta-interpreters and meta-objects in an object-oriented concurrent language ABCL/R3. By using partial evaluation to compile reflective programs, ABCL/R3 achieves flexible and lucid reflective architecture and efficient execution at the same time. We design full-fledged meta-interpreters by examining several concurrent programming examples. A newly proposed delegation mechanism enables to define modular and scope controlled extensions to meta-interpreters. We design meta-objects by exploiting the notion of reader/writer methods in a concurrent object-oriented language Schematic, so that they can be effectively partially evaluated. The compilation frameworks of meta-interpreters and meta-objects basically translate concurrent object definitions into a sequential program, then apply partial evaluator for a sequential language, and generates a program in a (non-reflective) concurrent object-oriented language, in which base-level and meta-level objects are collapsed to single level objects. The effciency of generated programs is demonstrated by several benchmark programs, in which our compiler exhibits performance close to non-reflective languages.}
}
@InProceedings{sekiguchi99coordination,
pdf = {coordination1999.pdf},
author = "Tatsurou Sekiguchi and Hidehiko Masuhara and Akinori
Yonezawa",
title = "A Simple Extension of {Java} Language for
Controllable Transparent Migration and Its Portable
Implementation",
doi = {10.1007/3-540-48919-3_16},
booktitle = "Proceedings of Third International Conference on
Coordination Models and Languages (COORDINATION'99)",
year = 1999,
editor = "Paolo Ciancarini and Alexander L. Wolf",
number = 1594,
series = LNCS,
pages = "211--226",
publisher = SV,
address = "Amsterdam, The Netherlands",
month = apr,
acceptanceRatio = "26/67 (39%)",
abstract = {A scheme has been developed that enables a Java program to be migrated across computers while preserving its execution state, such as the values of local variables and the dynamic extents of try-and-catch blocks. This scheme provides the programmer with flexible control of migration, including transparent migration. It is based on source-code-level transformation. The translator takes as input code a Java program written in a Java language extended with language constructs for migration, and outputs pure Java source code that uses JavaRMI. The translated code can run on any Java interpreter and can be compiled by any just-in-time compiler. We have measured some execution performance for several application programs, and found that the translated programs are only about 20\% slower than the original programs. Because migration is completely controlled by using only three language constructs added to the Java language (go , undock and migratory), the programmer can write programs to be migrated easily and succinctly. Our system is available in the public domain.}
}
InProceedings{masuhara99obpdc,
author = "Hidehiko Masuhara",
title = "An Overview of {ABCL/R3}: an Object-Oriented
Concurrent Reflective Language",
booktitle = "Proceedings of Object-Based Parallel and Distributed
Computing (OBPDC'97)",
year = 1999,
series = LNCS,
note = "since this is published as \cite{masuhara2000oopdp},
do not use this entry"
}
@InProceedings{masuhara99ptw-e,
author = "Hidehiko Masuhara and Yuuya Sugita and Akinori
Yonezawa",
title = "Optimizing Reflective Languages by Using Partial
Evaluation",
booktitle = "Program Transformation Workshop (PTW'99)",
year = 1999,
month = mar,
keywords = {ABCL/R}
}
@Misc{masuhara99javagrande,
author = "Hidehiko Masuhara",
title = "ByteCode Specialization ({BCS}):
A Run-Time Specialization Technique in {JVM} Bytecode",
howpublished = "Poster Presentation at ACM Java Grande'99",
year = 1999,
month = jun,
keywords = {Java, partial evaluation}
}
@InProceedings{masuhara99peday,
pdf = {peday99-generating.pdf},
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Generating Optimized Residual Code in Run-time
Specialization",
booktitle = "Proceedings of International Colloquium on Partial
Evaluation and Program Transformation",
year = 1999,
OPTeditor = "Robert Gl{\"u}ck and Yoshihiko Futamura",
pages = "83--102",
address = "Waseda University, Tokyo, Japan",
month = nov,
keywords = {Java, bytecode, partial evaluation},
abstract = {Run-time specialization (RTS) techniques efficiently generate specialized programs with respect to run-time values. They construct compiled native-code fragments called templates at compile-time, and generate a specialized program by merely copying the templates. The generated programs are less efficient than those generated by static partial evaluation techniques because the RTS techniques prevent many optimizations.
The proposed bytecode specialization (BCS) technique is used to generate programs in a bytecode language and then translate the generated bytecode into native code by using a just-in-time (JIT) compiler. Its advantages are (1) efficient specialization processes that are similar to those of RTS techniques, (2) efficient specialized programs thanks to optimizations by the JIT compilers, and (3) that it is independent of the source-to-bytecode and the bytecode-to-native compilers thanks to a binding-time analysis algorithm that directly handles bytecode programs.
Thus far, a BCS system has been implemented for a Java virtual machine subset. Micro-benchmarking showed that BCS with JIT compilation generates specialized programs that run more than 3-times faster than ones generated by traditional RTS techniques and that this specialization process takes less than one second.}
}
@InProceedings{yamauchi2000rm,
pdf = {rm2000.pdf},
author = "Hiroshi Yamauchi and Hidehiko Masuhara and Daisuke
Hoshina and Tatsurou Sekiguchi and Akinoni Yonezawa",
title = "Wrapping Class Libraries for Migration-Transparent
Resource Access by Using Compile-Time Reflection",
booktitle = "Workshop on Reflective Middleware (RM2000)",
year = 2000,
editor = "Gordon Blair and Roy Campbell",
pages = "19--20",
address = "New York, USA",
month = apr
}
@InCollection{masuhara2000oopdp,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "An Object-Oriented Concurrent Reflective Language
{ABCL/R3}: Its Meta-level Design and Efficient
Implementation Techniques",
booktitle = "Object-Oriented Parallel and Distributed Programming",
isbn = {2-7462-0091-0},
publisher = "HERMES Science Publications",
year = 2000,
editor = "Jean-Paul Bahsoun and Takanobu Baba and Jean-Pierre
Briot and Akinori Yonezawa",
pages = "151--165",
address = "Paris",
annote = "the published version of \cite{masuhara99obpdc},
which is planed as a conference record of OBPDC'97."
}
@InProceedings{masuhara2000ispse,
author = "Hidehiko Masuhara and Yuuya Sugita and Akinori Yonezawa",
title = "Dynamic Compilation of a Reflective Language Using
Run-Time Specialization",
booktitle = "International Symposium on Principles of Software
Evolution",
url = {http://www.jaist.ac.jp/ISPSE/},
editor = "Takuya Katayama and Tetsuo Tamai and Naoki Yonezaki",
year = 2000,
publisher = "IEEE Computer Society",
pdf = {ispse2000.pdf},
pages = "128--137",
month = nov,
abstract = {In reflective languages, application programs can customize a language system that executes the application programs. Our premise is that this customizability of reflective languages can be a basic mechanisms of software evolution. In this paper, we present a simple architecture of a reflective language that can dynamically select meta-interpreters, and a dynamic compilation scheme by using run-time specialization (RTS) techniques, which could also be useful to dynamically optimize systems with mechanisms of dynamic software evolution. Our prototype system showed that dynamically compiled reflective programs run more than four times faster than the interpreted ones, and that compilation processes are fast enough to be invoked at runtime. Compared to statically compiled programs, however, dynamically compiled ones yet have 20-30\% overheads. We also discuss this problem.},
}
@InProceedings{oiwa2001ppl,
author = "Yutaka Oiwa and Hidehiko Masuhara and Akinori Yonezawa",
title = "{DynJava}: Type Safe Dynamic Code Generation in {Java}",
url = {http://ppl.jssst.or.jp/ppl2001/programme.html},
booktitle = "JSSST Workshop on Programming and Programming
Languages (PPL2001)",
year = 2001,
editor = "Kenjiro Taura and Jacuques Garrigue",
pages = "127--138",
organization = JSSST,
month = mar,
OPTnote = ""
}
@InProceedings{masuhara2001pado2,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Run-time Bytecode Specialization: A Portable
Approach to Generating Optimized Specialized Code",
crossref = "pado2",
pages = "138--154",
acceptanceRatio = "14/30 (47%)",
note = {An extended version appears as \cite{masuhara2001ngc}.},
keywords = {Java, bytecode, partial evaluation},
pdf = {pado2.pdf},
abstract = {This paper proposes a run-time bytecode specialization (BCS) technique that analyzes programs and generates specialized programs at run-time in an intermediate language. By using an intermediate language for code generation, a back-end system can optimize the specialized programs after specialization. As the intermediate language, the system uses Java virtual machine language (JVML), which allows the system to easily achieve practical portability and to use sophisticated just-in-time compilers as its back-end. The binding-time analysis algorithm, which is based on a type system, covers a non-object-oriented subset of JVML. A specializer, which generates programs on a per-instruction basis, can perform method inlining at run-time. The performance measurement showed that a non-trivial application program specialized at run-time by BCS runs approximately 3--4 times faster than the unspecialized one. Despite the large amount of overheads at JIT compilation of specialized code, we observed that the overall performance of the application can be improved.}
}
@InCollection{masuhara2001fmbook,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "Reflection in Concurrent Object-Oriented Languages",
booktitle = "Formal Methods for Distributed Processing: An Object
Oriented Approach",
publisher = "Cambridge University Press",
year = 2001,
editor = "Howard Bowman and John Derrick",
chapter = 14,
pages = "305--325",
month = oct,
annote = "http://www.cs.ukc.ac.uk/people/staff/jd1/tc6book_web_faq",
keywords = {ABCL/R},
isbn = {9780521771849},
url = {https://www.cambridge.org/us/academic/subjects/computer-science/programming-languages-and-applied-logic/formal-methods-distributed-processing-survey-object-oriented-approaches}
}
@Article{masuhara2001ngc,
author = "Hidehiko Masuhara and Akinori Yonezawa",
title = "A Portable Approach to Dynamic Optimization in
Run-time Specialization",
journal = "Journal of New Generation Computing",
year = 2001,
volume = 20,
url = {https://link.springer.com/journal/354/20/1},
doi = {10.1007/BF03037261},
number = 1,
pages = "101--124",
pdf = {ngc2001.pdf},
month = nov,
note = "Extended from \cite{masuhara2001pado2}.",
keywords = {Java, Bytecode, Just-in-time, partial evaluation},
abstract = {This paper proposes a run-time bytecode specialization (BCS) technique that analyzes programs and generates specialized programs at run-time in an intermediate language. By using an intermediate language for code generation, a back-end system can optimize the specialized programs after specialization. The system uses Java virtual machine language (JVML) as the intermediate language, which allows the system to easily achieve practical portability and to use existing sophisticated just-in-time (JIT) compilers as its back-end. The binding-time analysis algorithm is based on a type system, and covers a non-object-oriented subset of JVML. The specializer generates programs on a per-instruction basis, and can perform method inlining at run-time. Our performance measurements show that a non-trivial application program specialized at run-time by BCS runs approximately 3--4 times faster than the unspecialized one. Despite the large overhead of JIT compilation of specialized code, we observed that the overall performance of the application can be improved.}
}
Article{affeldt2001jssst,
author = "Reynald Affeldt and Hidehiko
Masuhara and Eijiro Sumii and Akinori Yonezawa",
title = "Supporting Objects in Run-time Bytecode Specialization",
journal = CompSoft,
year = "",
OPTvolume = "",
OPTnumber = "",
OPTpages = "",
OPTmonth = "",
OPTnote = "$BEj9FCf(B; rejected",
OPTaffil = "",
OPTkeywords = "",
OPTserialNo = "",
OPTannote = ""
}
Misc{imai2001oopsla-ptdoomws,
author = "Takeo Imai and Tatsurou Sekiguchi and Hidehiko
Masuhara and Akinori Yonezawa",
title = "Dynamic Access Control of Mobile Objects by
Switching Name Spaces",
howpublished = "submitted for publication",
year = 2001,
month = sep,
annote = "OOPSLA2001 Workshop on Patterns and Techniques for
Designing Object-Oriented Mobile Wireless Systems"
}
@InProceedings{masuhara2002foal,
note = {revised version in \cite{masuhara2003cc}},
author = "Hidehiko Masuhara and Gregor Kiczales and Chris Dutchyn",
title = "Compilation Semantics of Aspect-Oriented Programs",
booktitle = "FOAL 2002 Proceedings: Foundations Of Aspect-Oriented Languages, Workshop at AOSD 2002",
pages = "17--25",
url = {http://www.eecs.ucf.edu/~leavens/FOAL/index-2002.html},
year = 2002,
editor = "Gary T. Leavens and Ron Cytron",
series = "Technical Report TR{\#}02--06, Department of Computer Science, Iowa State University",
pdf = {foal2002.pdf},
month = apr,
keywords = {AspectJ, Scheme, Aspect sandbox},
abstract = {This paper presents a semantics-based compilation framework for an aspect-oriented programming language based on its operational semantics model. Using partial evaluation, the framework can explain several issues in compilation processes, including how to find places in program text to insert aspect code and how to remove unnecessary run-time checks. It also illustrates optimization of calling-context sensitive pointcuts (cflow), implemented in real compilers.}
}
@Misc{kiczales2002aosd-tutorial,
author = "Chirs Dutchyn and Gregor Kiczales and Hidehiko Masuhara",
title = "{AOP} Language Exploration Using the Aspect Sand Box",
url = {https://modularity.info/conference/2002/sandbox.html},
howpublished = "Tutorial on 1st International Conference on
Aspect-Oriented Software Development (AOSD 2002)",
year = 2002,
month = apr,
keywords = {AspectJ, Scheme}
}
@InProceedings{affeldt2002asiapepm,
author = "Reynald Affeldt and Hidehiko Masuhara and Eijiro Sumii and Akinori Yonezawa",
OPTurl = {asia-pepm2002.ps.gz},
pdf = {asia-pepm2002.pdf},
title = "Supporting Objects in Run-time Bytecode Specialization",
doi = {10.1145/568173.568179},
booktitle = {ACM SIGPLAN ASIAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (ASIA-PEPM'02)},
OPTcrossref = {?},
pages = {50--60},
year = 2002,
editor = {Wei-Ngan Chin},
OPTvolume = {?},
OPTnumber = {?},
OPTseries = {?},
publisher = {ACM Press},
address = {Aizu, Japan},
month = sep,
keywords = {Java, just-in-time compiler},
abstract = {This paper describes a run-time specialization system for the Java language. One of the main difficulties of supporting the full Java language resides in a sound yet effective management of references to objects. This is because the specialization process may share references with the running application that executes the residual code, and because side-effects through those references by the specialization process could easily break the semantics of the running application. To cope with these difficulties, we elaborate requirements that ensure sound run-time specialization. Based on them, we design and implement a run-time specialization system for the Java language, which exhibits, for instance, approximately 20-25\% speed-up factor for a ray-tracing application.}
}
@Misc{aspectsandbox,
author = "Chris Dutchyn and Gregor Kiczales and Hidehiko Masuhara",
title = "Aspect SandBox",
howpublished = "project homepage at http://www.cs.ubc.ca/labs/spl/projects/asb.html",
year = 2002,
month = oct,
keywords = {AspectJ, Scheme}
}
@InProceedings{masuhara2003ecoop,
pdf = {ecoop2003.pdf},
slides = {ecoop2003-slides.pdf},
OPTslides = {ecoop2003-slides.pps},
author = "Hidehiko Masuhara and Gregor Kiczales",
title = "Modeling Crosscutting in Aspect-Oriented Mechanisms",
booktitle = "Proceedings of European Conference on
Object-Oriented Programming (ECOOP2003)",
url = {https://web.archive.org/web/20080315032348/http://www.st.informatik.tu-darmstadt.de:8080/ecoop/index.phtml},
doi = {10.1007/978-3-540-45070-2_2},
year = 2003,
editor = "Luca Cardelli",
volume = 2743,
series = "Lecture Notes in Computer Science",
pages = "2--28",
publisher = "Springer-Verlag",
address = "Darmstadt, Germany",
month = jul,
acceptanceRatio = "18/88 (20%)",
keywords = {AspectJ, Aspect sandbox, Scheme},
abstract = {Modeling four aspect-oriented programming mechanisms shows the way in which each supports modular crosscutting. Comparing the models produces a clear three part characterization of what is required to support crosscutting structure: a common frame of reference that two (or more) programs can use to connect with each other and each provide their semantic contribution.}
}
Misc{masuhara2002draft2,
author = "Hidehiko Masuhara and Gregor Kiczales and Chris Dutchyn",
title = "A Compilation and Optimization Model for Aspect-Oriented Programs",
howpublished = "to appear in CC2003",
keywords = {AspectJ, Aspect sandbox, Scheme}
}
@InProceedings{masuhara2003cc,
author = {Hidehiko Masuhara and Gregor Kiczales and Chris Dutchyn},
pdf = {cc2003.pdf},
title = {A Compilation and Optimization Model for Aspect-Oriented Programs},
booktitle = {Proceedings of 12th International Conference on Compiler Construction (CC2003)},
doi = {10.1007/3-540-36579-6_4},
url = {http://fileadmin.cs.lth.se/cs/Personal/Gorel_Hedin/cc03/},
pages = {46--60},
year = 2003,
volume = 2622,
series = LNCS,
annote = {http://link.springer.de/link/service/series/0558/tocs/t2622.htm},
acceptanceRatio = {21/83 (25%)},
keywords = {AspectJ, Aspect sandbox, Scheme},
abstract = {This paper presents a semantics-based compilation model for an aspect-oriented programming language based on its operational semantics. Using partial evaluation, the model can explain several issues in compilation processes, including how to find places in program text to insert aspect code and how to remove unnecessary run-time checks. It also illustrates optimization of calling-context sensitive pointcuts (cflow), implemented in real compilers.}
}
Misc{masuhara2003submitted,
author = "Hidehiko Masuhara and Kazunori Kawauchi",
title = "Dataflow Pointcut in Aspect-Oriented Programming",
howpublished = "submitted for publication; to appear as \cite{masuhara2003aplas}",
year = 2003,
month = jul,
keywords = {AspectJ, dflow}
}
@InProceedings{masuhara2003aplas,
pdf = {aplas2003.pdf},
slides = {aplas2003-talk.pdf},
author = {Hidehiko Masuhara and Kazunori Kawauchi},
title = {Dataflow Pointcut in Aspect-Oriented Programming},
doi = {10.1007/978-3-540-40018-9_8},
booktitle = {Proceedings of The First Asian Symposium on Programming Languages and Systems (APLAS'03)},
pages = {105--121},
year = 2003,
editor = {Atsushi Ohori},
volume = {2895},
series = LNCS,
address = {Beijing, China},
month = nov,
acceptanceRatio = {24/76 (32%)},
keywords = {AspectJ, dflow},
abstract = {A dataflow-based pointcut is proposed for aspect-oriented programming (AOP) languages. The pointcut specifies where aspects should be applied based on the origins of values. It is designed to be compatible with the other kinds of pointcuts in existing AOP languages. Primary application fields of the pointcut are the aspects in which flow of information is important, such as security. This paper presents the design of the pointcut with a web-application example, and its prototype implementation.}
}
@InProceedings{sakurai2004aosd,
author = "Kouhei Sakurai and Hidehiko Masuhara and Naoyasu
Ubayashi and Saeko Matsuura and Seiichi Komiya",
title = "Association Aspects",
doi = {10.1145/976270.976275},
crossref = "aosd2004",
pages = "16--25",
month = mar,
acceptanceRatio = {18% (15/83)},
keywords = {AspectJ},
pdf = {aosd2004.pdf},
abstract = {We propose a linguistic mechanism for AspectJ-like languages that concisely associates aspect instances to object groups. The mechanism, which supports association aspects, extends the per-object aspects in AspectJ by allowing an aspect instance to be associated to a group of objects, and by providing a new pointcut primitive to specify aspect instances as execution contexts of advice. With association aspects, we can straightforwardly implement crosscutting concerns that have stateful behavior related to a particular group of objects. The new pointcut primitive can more flexibly specify aspect instances when compared against previous implicit mechanisms. The comparison of execution times between the programs with association aspects and the ones with regular AspectJ aspects revealed that the association aspects exhibited almost equivalent for the medium-sized configurations.}
}
@InProceedings{kawauchi2004aosdsec,
author = "Kazunori Kawauchi and Hidehiko Masuhara",
title = "Dataflow Pointcut for Integrity Concerns",
pdf = {aosdsec2004.pdf},
booktitle = "Proceedings of AOSD Technology for Application-level Security (AOSDSEC'04)",
year = 2004,
address = "Lancaster, UK",
month = mar,
url = "https://web.archive.org/web/20050906081308/http://www.aosd.net:80/workshops/aosdsec/2004/",
keywords = {AspectJ, dflow},
abstract = {Some security concerns, such as secrecy and integrity, are sensitive to flow of information in a program execution. We proposed a new pointcut to aspect-oriented programming (AOP) languages in order to easily implement such security concerns as aspects. The pointcut identifies join points based on the origins of values, and can be used with the other kinds of pointcuts in existing AOP languages. This paper presents an example how the pointcut can be applied to an integrity concern in a web-application.}
}
@InProceedings{ubayashi2004ramse,
author = {Naoyasu Ubayashi and Hidehiko Masuhara and Tetsuo Tamai},
title = {An {AOP} Implementation Framework for Extending Join Point Models},
pdf = {ramse2004.pdf},
booktitle = {ECOOP2004 Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'04)},
pages = {71--81},
year = 2004,
address = {Oslo, Norway},
month = Jun,
url = {https://dblp.org/db/conf/ecoop/ramse2004},
abstract = {Mechanisms in AOP (aspect-oriented programming) can be characterized by a JPM (join point model). AOP is effective in unanticipated software evolution because crosscutting concerns can be added or removed without making invasive modifications on original programs. However, the effectiveness would be restricted if new crosscutting concerns cannot be described with existing JPMs. Mechanisms for extending JPMs are needed in order to address the problem. In this paper, an implementation framework for extending JPMs is proposed. Using the framework, we can introduce new kinds of JPMs or extend existing JPMs in the process of software evolution.},
}
@InProceedings{kamio2004wnasc,
pdf = {wnasc2004.pdf},
author = "Takahiro Kamio and Hidehiko Masuhara",
title = "A Value Profiler for Assisting Object-Oriented
Program Specialization",
booktitle = "Proceedings of Workshop on New Approaches to
Software Construction (WNASC 2004)",
year = 2004,
pages = "95--102",
editor = "Tetsuo Tamai",
address = "Tokyo",
month = sep,
keywords = {ASpectJ},
abstract = {We present a value profiler for object-oriented programs that counts frequencies parameters to method calls. It is aimed at identifying methods that can be optimized by program specialization techniques. By adding timestamps to objects, the profiler accurately tests equality over mutable objects on a per-method basis. Our experiments with a 64602 lines of Java program showed that the profile report can reduce effort at manually finding the target methods of optimization, which speeded the overall execution time up more than 10\%.}
}
@InProceedings{tatsuzawa2005foal,
author = {Hideaki Tatsuzawa and Hidehiko Masuhara and Akinori Yonezawa},
title = {{A}spectual {C}aml: an Aspect-Oriented Functional Language},
crossref = {foal2005},
pdf = {foal2005.pdf},
note = {An extended version appears as \cite{masuhara2005icfp}.},
pages = {39--50},
keywords = {OCaml},
abstract = {We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml. Aspectual Caml offers two AOP mechanisms, namely the pointcut and advice mechanism and the type extension mechanism, which gives similar functionality to the inter-type declarations in AspectJ. Those mechanisms are not simple adaptation of the similar mechanisms in existing AOP languages, but re-designed for common programming styles in functional languages such as type inference, polymorphic types, and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including separating a type system from a compiler of a simple language.}
}
@InProceedings{aotani2005splat,
author = {Tomoyuki Aotani and Hidehiko Masuhara},
title = {Compiling Conditional Pointcuts for User-Level Semantic Pointcuts},
pdf = {splat2005.pdf},
crossref = {splat2005},
keywords = {SCoPE, AspectJ},
abstract = {We propose a compilation framework that compiles conditional pointcuts (i.e., if pointcuts) in AspectJ for allowing the programmer to define expressive pointcuts without runtime overheads. The framework automatically finds conditional pointcuts that are static with respect to join point shadows, evaluates them at compile-time, and generates compiled code that performs no runtime tests for those pointcuts. By writing conditions that examine static properties of a program, the programmer can simulate many semantic pointcuts within current AspectJ's semantics yet without runtime overheads. Our compiler implementation identifies static conditional pointcuts by using a technique similar to the binding-time analysis in partial evaluation, and employs double-compilation scheme to guarantee the same behavior to the code generated by the existing AspectJ compilers. Our experiments confirmed that the compiler is capable of compiling several semantic pointcuts, such as the ones testing class membership (e.g., has and hasfield), testing join point location (e.g., withinstaticinitialization), matching by using regular expressions, and checking high-level coding rules (e.g., the Law of Demeter).}
}
@InProceedings{yamazaki2005wtaop,
author = "Yudai Yamazaki and Kouhei Sakurai and Saeko Matsuura
and Hidehiko Masuhara and Hiroaki Hashiura and
Seiichi Komiya",
pdf = {wtaop2005.pdf},
title = "A Unit Testing Framework for Aspects without Weaving",
booktitle = "Proceedings of Workshop on Testing Aspect-Oriented Programs (WTAOP'05)",
year = 2005,
editor = "Roger T. Alexander and Anneliese A. Andrews",
address = "Chicago, IL",
month = mar,
OPTurl = "http://www.sic.shibaura-it.ac.jp/~m105108/aspect/WTAOP/paper.pdf",
keywords = {AspectJ},
abstract = {Unit testing of aspects can verify aspects implementations of aspects against their specification. Current technique for unit testing of aspects requires to weave the aspect definition into a target program, which thus makes it difficult to write comprehensive test cases and to avoid interference from other aspects. In this paper, we propose a framework for unit testing aspects without weaving. Our framework generates testing methods from an aspect definition so that test cases can directly verify properties of aspects such as the advice behavior and pointcut matching.}
}
@InProceedings{masuhara2005icfp,
pdf = {icfp2005.pdf},
url = {https://www.icfpconference.org/archived/icfp2005/www.brics.dk/~danvy/icfp05/},
slides = {icfp2005-slides.pdf},
author = {Hidehiko Masuhara and Hideaki Tatsuzawa and Akinori Yonezawa},
title = {{A}spectual {C}aml: an Aspect-Oriented Functional Language},
note = {Extended from \cite{tatsuzawa2005foal}.},
crossref = {icfp2005},
pages = {320--330},
acceptanceRatio = {33% (26/78)},
keywords = {OCaml},
abstract = {We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in AspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including for separating descriptions of a type system from compiler descriptions.}
}
@InProceedings{ubayashi2005ase,
author = {Naoyasu Ubayashi and Hidehiko Masuhara and Tetsuo Tamai},
title = {A Parameterized Interpreter for Modeling Different {AOP} Mechanisms},
pdf = {ase2005.pdf},
booktitle = {2005 IEEE/ACM International Conference on Automated Software Engineering (ASE 2005)},
OPTcrossref = {},
OPTkey = {},
OPTpages = {194--203},
year = 2005,
OPTeditor = {},
OPTvolume = {},
OPTnumber = {},
OPTseries = {},
OPTaddress = {},
month = nov,
OPTorganization = {IEEE/ACM},
OPTpublisher = {},
OPTannote = {},
acceptanceRatio = {9.6% (28/291) for full papers},
abstract = {We present a parameterized interpreter for modeling aspect-oriented mechanisms. The interpreter takes several param- eters to cover different AOP mechanisms found in AspectJ, Hyper/J, and Demeter. The interpreter helps our understanding of the AOP mechanisms in two ways. First, its core part represents the common mechanical structure shared by different AOP mechanisms. Second, by reconstructing the existing AOP mechanisms and using parameters to configure the interpreter, we can illustrate the differences and similarities of those mechanisms clearly. This will also be helpful in rapid-prototyping a new AOP mechanism or a reflective AOP system that supports different mechanisms.}
}
@InProceedings{endo2005wnasc,
author = "Yusuke Endoh and Hidehiko Masuhara and Akinori Yonezawa",
title = "Is Join Point a Point?: a pointcut and advice mechanism
for making aspects more reusable",
pdf = {wnasc2005.pdf},
slides = {wnasc2005-slides.pdf},
booktitle = "Proceedings of Workshop on New Approaches
to Software Construction (WNASC 2005)",
year = 2005,
editor = "Tetsuo Tamai",
pages = "93--98",
month = sep,
keywords = {AspectJ, continuation}
}
@Article{sakurai2006taosd,
author = "Kouhei Sakurai and Hidehiko Masuhara and Naoyasu
Ubayashi and Saeko Matsuura and Seiichi Komiya",
pdf = {taosd2006.pdf},
title = "Design and Implementation of An Aspect Instantiation Mechanism",
year = 2006,
editor = "Awais Rashid and Mehmet Ak\c{s}it",
pages = "259--292",
journal = TAOSD,
volume = {3880/2006},
note = {Extended from \cite{sakurai2004aosd}.},
doi = {10.1007/11687061_8},
keywords = {AspectJ},
abstract = {This paper describes the design and implementation of association aspects, which are a linguistic mechanism for the AspectJ language that concisely associates aspect instances to object groups by extending the per-object aspects in AspectJ. This mechanism allows an aspect instance to be associated to a group of objects, and by providing a new pointcut primitive to specify aspect instances as execution context of advice. With association aspects, we can straightforwardly implement crosscutting concerns that have stateful behavior related to a particular group of objects. The new pointcut primitive can more flexibly specify aspect instances when compared against previous implicit mechanisms. We implemented a compiler for association aspects by modifying the AspectJ compiler, which reduces the size of data structures for keeping associations. Our benchmark tests confirm that the overheads of association aspects are reasonably small when compared against functionally equivalent aspects in pure AspectJ that manually manage associations. The expressiveness of association aspects is demonstrated through development of an integrated development environment with and without association aspects.}
}
@Misc{masuhara2005asian-aosd,
author = {Hidehiko Masuhara},
title = {Pointcut \& Advice Mechanism and Types: the case of {Aspectual Caml}},
howpublished = {Talk at the First Asian Workshop on Aspect-Oriented Software Development},
month = dec,
year = 2005,
url = {https://sites.google.com/site/aoasiaworkshop/aoasia-2005},
annote = {A pedagogical talk},
keywords = {OCaml}
}
@InProceedings{endoh2006foal,
author = {Yusuke Endoh and Hidehiko Masuhara and Akinori Yonezawa},
pdf = {foal2006.pdf},
title = {Continuation Join Points},
booktitle = {Proceedings Foundations of Aspect-Oriented Languages
Workshop (FOAL 2006) at AOSD 2006},
pages = {1--10},
year = 2006,
editor = {Curtis Clifton and Ralf L\"ammel and Gary T. Leavens},
volume = {TR {\#}06-01},
series = {Technical Report, Department of Computer Science, Iowa State University},
month = mar,
acceptanceRatio = {47% (7/15) for long+short papers},
keywords = {AspectJ},
abstract = {In AspectJ-like languages, there are several different kinds of advice declarations, which are specified by using advice modifiers such as before and after returning. This makes semantics of advice complicated and also makes advice declarations less reusable since advice modifiers are not param- eterized unlike pointcuts. We propose a simpler join point model and an experimental AOP language called PitJ. The proposed join point model has only one kind of advice, but has finer grained join points. Even though we unified different kinds of advice into one, the resulted language is sufficiently expressive to cover typical advice usages in AspectJ, and has improved advice reusability by allowing pointcuts, rather than advice modifiers, to specify when advice body runs. Along with the language design, this paper gives a formalization of the join point model in a continuation-passing style (CPS).}
}
@misc{hanemann2006diku-ist,
author = "Jan Hannemann and Hidehiko Masuhara",
title = "Aspect Mining using Structural Program Properties",
howpublished = "A talk at The Second DIKU-IST Joint Workshop on Foundations of Software",
year = 2006,
address = "Kanagawa, Japan",
month = apr,
date = "2006-4-22",
OPTnote = "a talk",
keywords = {AspectJ}
}
@InProceedings{masuhara2006adi,
pdf = {adi06.pdf},
author = masuhara # AND # aotani,
title = "Issues on Observing Aspect Effects from Expressive Pointcuts",
booktitle = "Proceedings of Workshop on Aspects, Dependencies and Interactions (ADI'06)",
year = 2006,
series = "Technical Report COMP-001-2006, Lancaster University Computing Department",
pages = "53--61",
month = jul,
keywords = {AspectJ},
abstract = {This paper discusses issues on interactions of aspects with expressive pointcuts. Since expressive pointcuts specify join points based on the results of program analysis, they should be carefully designed in order to analyze effects of aspects and their precedence correctly. We show examples in which aspects with expressive pointcuts interact, and point out the required properties to those pointcuts for correct aspect interaction. We also briefly present our approach to satisfy those properties in our SCoPE compiler, which supports expressive pointcuts within AspectJ language.}
}
@InProceedings{masuhara2006aplas,
author = masuhara # AND # "Yusuke Endoh and Akinori Yonezawa",
pdf = {aplas2006.pdf},
title = "A Fine-Grained Join Point Model for More Reusable Aspects",
pages = "131--147",
crossref = {aplas2006},
doi = "10.1007/11924661_8",
OPTurl = "10.1007/11924661_8",
acceptanceRatio = {31% (22/70)},
keywords = {AspectJ, continuation},
abstract = {We propose a new join point model for aspect-oriented programming (AOP) languages. In most AOP languages including AspectJ, a join point is a time interval of an action in execution. While those languages are widely accepted, they have problems in aspects reusability, and awkwardness when designing advanced features such as tracematches. Our proposed join point model, namely the point-in-time join point model redefines join points as the moments both at the beginning and end of actions. Those finer-grained join points enable us to design AOP languages with better reusability and flexibility of aspects. In this paper, we designed an AspectJ-like language based on the point-in-time model. We also give a denotational semantics of a simplified language in a continuation passing style, and demonstrate that we can straightforwardly model advanced language features such as exception handling and cflow pointcuts.}
}
@InProceedings{aotani2007aosd,
author = aotani # AND # masuhara,
pdf = {aosd2007.pdf},
title = "{SCoPE}: an {AspectJ} Compiler for Supporting User-Defined Analysis-Based Pointcuts",
crossref = "aosd2007",
pages = "161--172",
doi = "10.1145/1218563.1218582",
abstract = {This paper proposes an approach called SCoPE, which supports user-defined analysis-based pointcuts in aspect-oriented programming (AOP) languages. The advantage of our approach is better integration with existing AOP languages than previous approaches. Instead of extending the language, SCoPE allows the programmer to write a pointcut that analyzes a program by using a conditional (if) pointcut with introspective reflection libraries. A compilation scheme automatically eliminates runtime tests for such a pointcut. The approach also makes effects of aspects visible to the analysis, which is essential for determining proper aspect interactions. We implemented a SCoPE compiler for the AspectJ language on top of the AspectBench compiler using a backpatching technique. The implementation efficiently finds analysis-based pointcuts, and generates woven code without runtime tests for those pointcuts. Our benchmark tests with JHotDraw and other programs showed that SCoPE compiles programs with less than 1\% compile-time overhead, and generates a program that is as efficient as an equivalent program that uses merely static pointcuts.},
}
@InProceedings{aotani2007foal,
pdf = {foal2007.pdf},
author = aotani # AND # masuhara,
title = "Towards A Type System for Rejecting Never-Matching Pointcut Compositions",
url = {http://www.eecs.ucf.edu/~leavens/FOAL/index-2007.shtml},
crossref = "foal2007",
pages = "23--26",
keywords = {AspectJ},
abstract = {Pointcuts in the current AspectJ family of languages are loosely checked because the languages allow compositions of pointcuts that never match any join points, which developers are unlikely to intend, for example, \verb|set(* *)&&get(* *)|. We formalize the problem by defining well-formedness of pointcuts and design a novel type system for assuring well-formedness. The type of pointcuts is encoded by using record, union and the bottom types.}
}
@InProceedings{sakurai2007late,
author = sakurai # AND # masuhara,
title = "Test-based Pointcuts: A Robust Pointcut Mechanism Based on Unit Test Cases for Software Evolution",
crossref = "late2007",
keywords = {AspectJ},
pdf = {late2007.pdf},
abstract = {This paper proposes test-based pointcuts, a new aspect-oriented
programming language construct that uses unit test cases as interface of crosscutting concerns. A test-based pointcut primarily specifies a set of test cases associated to a program. At execution time, it matches the join points that have the same execution history to the one of the specified test cases. The test-based approach improves pointcut definitions in two respects. First, test-based pointcuts are less fragile with respect to program changes because rather than directly relying on type and operation names in a program, they indirectly specify join points through unit test cases, which are easier to be kept up-to-date. Second, test-based pointcuts can discriminate execution histories without requiring to specify detailed execution steps, as they use test cases as abstractions of execution histories. With the abstractions, the second respect contributes to the first respect. We designed and implemented the test-based pointcuts as an extension to AspectJ, and confirmed, through an case study, test-based pointcuts are more robust against evolution when used for a practical application program.}
}
@Misc{masuhara2007aplas-poster,
author = masuhara,
title = "Relaxing Type Restrictions of Around Advice in Aspect-Oriented Programming",
howpublished = "Poster presentation at APLAS 2007",
crossref = "aplas2007",
poster = {aplas2007poster.pdf},
note = "poster presentation",
keywords = {AspectJ},
pdf = {aplas2007abstract.pdf}
}
@Misc{masuhara2008msra-nlp-poster,
author = masuhara # AND # watanabe,
title = {Spontaneous Source Code Recommendation Tool based on Text Search Techniques},
howpublished = {Poster presentation at Microsoft Research Asia (MSRA) Regional Workshop on Web-Scale Natural Language Processing },
month = feb,
year = 2008,
pdf = {msranlp2008.pdf},
location={Daedeok, Korea},
keywords = {Selene, Eclipse}
}
@InProceedings{sakurai2008aosd,
author = sakurai # AND # masuhara,
pdf = {aosd2008.pdf},
title = "Test-Based Pointcuts for Robust and Fine-Grained Join Point Specification",
crossref = "aosd2008",
pages = {96--107},
doi= {10.1145/1353482.1353494},
keywords = {AspectJ},
abstract = {We propose test-based pointcuts, a novel pointcut mechanism for AspectJ-like aspect-oriented programming languages. The idea behind the test-based pointcuts is to specify join points through unit test cases associated with the target program. The test-based pointcuts improve robustness and precision of pointcut languages. The test-based pointcuts are more robust against software evolution because they do not directly rely on identifier names in a target program. The test-based pointcuts are more precise because they can distinguish fine grained execution histories including conditional branches by comparing the runtime execution histories with recorded for ones of the unit test cases. This paper presents design and implementation of the test-based pointcuts as an extension of an AspectJ compiler. We evaluated robustness and runtime efficiency of test-based pointcuts through case studies that applied test-based pointcuts to several versions of practical application programs.}
}
@Misc{aotani2008aosd-poster,
author = aotani # AND # masuhara,
title = {{SCoPE}: an {AspectJ} compiler for developing intuitive and robust aspects by using program analysis},
howpublished = {Poster presentation at AOSD.08},
month = apr,
year = 2008,
date = {2008-4-1}
}
@InProceedings{masuhara2008adi,
author = masuhara,
title = {On Type Restriction of Around Advice and Aspect Interference},
booktitle = {Proceedings of the 3rd International Workshop on Aspects, Dependencies and Interactions (ADI'08)},
year = 2008,
location = {Paphos, Cyprus},
month = jul,
url = {https://web.archive.org/web/20080723204002/http://gateway.comp.lancs.ac.uk/computing/aosd-europe//adi08},
pdf = {adi2008.pdf},
keywords = {AspectJ},
abstract = {Statically typed AOP languages restrict application of around advice only to the join points that have conforming types. Though the restriction guarantees type safety, it can prohibit application of advice that is useful, yet does not cause runtime type errors. To this problem, we present a novel weaving mechanism, called the type relaxed weaving, that allows such advice applications while preserving type safety. This paper discusses language design issues to support the type relaxed weaving in AOP languages.}
}
@Misc{masuhara2008ramse,
author = masuhara,
title = {Towards Right Abstraction Mechanisms for Crosscutting Concerns},
howpublished = {Workshop on
Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'08)},
month = jul,
year = 2008,
note = {Keynote talk},
pdf = {ramse2008.pdf},
keywords = {AspectJ},
url = {http://homes.dico.unimi.it/~cazzola/RAM-SE08.html},
date = {2008-7-7}
}
@Misc{masuhara2008grace,
author = masuhara,
title = {An Abstraction Mechanism for Aspect-Oriented Programming Based on Test Cases''},
url = {http://grace-center.jp/2008/12/2173},
howpublished = {Talk at the 12th GRACE Seminar},
month = dec,
year = 2008,
slides = {grace-seminar-dec-2008.pdf},
location = {National Instutite of Informatics}}
@Misc{aotani2009aosd-poster,
author = aotani # AND # masuhara,
title = {Optimizing Dynamic Pointcuts by using {SCoPE}},
howpublished = {Poster presentation at AOSD.09},
keywords = {AspectJ, Java},
month = mar,
year = 2009}
Misc{marletta2009ramse,
author = {Daniele Marletta} # AND # masuhara # AND # {Emiliano Tramontana},
title = {Finding Scattered Code on {Globus} Toolkit},
howpublished = {submitted to RAM-SE'09 (rejected)},
month = may,
year = 2009,
abstract = {Currently, research efforts aim at identifying whether a
concern is scattered among modules implementing some
existing software systems. This paper investigates
the scattered code within the implementation of
Globus Toolkit, the widespread middleware providing
support for Grid computing. The core
functionalities of Globus Toolkit are implemented as
a big number of C source files. The analysis of
Globus Toolkit has shown that calls to functions
handling output, errors, synchronisation and memory
have the highest values of fan-in and are the most
scattered.}
}
@InProceedings{appeltauer2009cop,
author = {Malte Appeltauer and Robert Hirschfeld} # AND # masuhara,
title = {Improving the Development of
Context-dependent {Java} Applications},
booktitle = {Proceedings of the Intenational workshop on
Context-Oriented Programming (COP'09)},
pages = {article no.~5},
doi = {10.1145/1562112.1562117},
pdf = {cop2009.pdf},
year = 2009,
address = {Genoa, Italy},
month = {7 } # jul,